Beispiel #1
0
        public void TemplateCanBeOverlappedUsingOverrideTemplateIfSecondTemplateOnlyReplacesNonFloorTiles()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testalignmentroom3.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            Stream       overlapFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testoverlap.room");
            RoomTemplate room2             = RoomTemplateLoader.LoadTemplateFromFile(overlapFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            //Base
            TemplatePositioned templatePos1 = new TemplatePositioned(5, 5, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            //Overlap in smaller room
            TemplatePositioned templatePos2 = new TemplatePositioned(5, 6, 0, room2, 0);

            mapGen.OverridePositionedTemplate(templatePos2);

            Map outputMap = mapGen.MergeTemplatesIntoMap(GetStandardTerrainMapping());

            Assert.AreEqual(MapTerrain.ClosedDoor, outputMap.mapSquares[0, 2].Terrain);
            Assert.AreEqual(MapTerrain.ClosedDoor, outputMap.mapSquares[3, 2].Terrain);
        }
Beispiel #2
0
        public void TemplateCanBeOverlappedUsingUnconditionallyOverrideTemplateWhenTerrainTypesDontMatch()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.test4doors.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            Stream       overlapFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testoverlap.room");
            RoomTemplate room2             = RoomTemplateLoader.LoadTemplateFromFile(overlapFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            //Base
            TemplatePositioned templatePos1 = new TemplatePositioned(5, 5, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            //Overlap in smaller room
            TemplatePositioned templatePos2 = new TemplatePositioned(5, 5, 0, room2, 0);

            mapGen.UnconditionallyOverridePositionedTemplate(templatePos2);

            Map outputMap = mapGen.MergeTemplatesIntoMap(GetStandardTerrainMapping());

            Assert.AreEqual(MapTerrain.Wall, outputMap.mapSquares[3, 0].Terrain);
            Assert.AreEqual(MapTerrain.ClosedDoor, outputMap.mapSquares[0, 1].Terrain);
        }
Beispiel #3
0
        public void AddingOverlappingTemplatesWorksIfOverlapIsTransparent()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testsolid1.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            //Start
            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            //End
            TemplatePositioned templatePos2 = new TemplatePositioned(-10, 20, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos2);

            //Middle
            TemplatePositioned templatePos3 = new TemplatePositioned(-8, 30, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos3);

            //Corridor from start - end that overlaps middle
            var expandedCorridorAndPoint = RoomTemplateUtilities.ExpandCorridorTemplateLShaped(6, 28, true, corridor1);
            var positionedCorridor       = new TemplatePositioned(-2, 4, 0, expandedCorridorAndPoint.Item1, 3);

            Assert.IsTrue(mapGen.AddPositionedTemplate(positionedCorridor));
        }
        public void RoomTemplatesCanBeRetrievedById()
        {
            RoomTemplate room1 = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            var room1Id = mapGen.PlaceRoomTemplateAtPosition(room1, new Point(-5, -5));
            TemplatePositioned roomTemplate = mapGen.GetRoomTemplateById(room1Id);

            Assert.AreEqual(new Point(-5, -5), roomTemplate.Location);
        }
        public void RoomTemplateMayBeRetrievedAfterAddingRoom()
        {
            //Load sample template 8x4
            RoomTemplate room1 = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));

            Assert.AreEqual(room1, mapGen.GetRoomTemplatesInWorldCoords()[0].Room);
        }
Beispiel #6
0
        public void TestAddTemplateOnTopWorksWithNoExistingTemplates()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testsolid1.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 0);

            Assert.IsTrue(mapGen.AddPositionedTemplate(templatePos1));
        }
        public void AligningARoomWithNoCorridorReturnsTheConnectionToTheNewRoom()
        {
            //Load sample template 8x4
            RoomTemplate room1 = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate room2 = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            Assert.AreEqual(new Connection(0, 1),
                            mapGen.PlaceRoomTemplateAlignedWithExistingDoor(room2, null, mapGen.PotentialDoors[0], 0, 0));
        }
Beispiel #8
0
        public void RoomsWithOverlapOnTransparentBoundariesCanBeAdded()
        {
            RoomTemplate room1 = LoadTemplateFromAssemblyFile("DDRogueTest.testdata.vaults.testsolid1.room");

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            TemplatePositioned templatePos2 = new TemplatePositioned(9, 0, 1, room1, 0);

            Assert.IsTrue(mapGen.AddPositionedTemplate(templatePos2));
        }
Beispiel #9
0
        public void RoomsAtHighXWhichMergeShouldntOverlap()
        {
            RoomTemplate room1 = LoadTemplateFromAssemblyFile("DDRogueTest.testdata.vaults.testsolid1.room");

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(20, 20, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            TemplatePositioned templatePos2 = new TemplatePositioned(21, 21, 1, room1, 0);

            Assert.IsFalse(mapGen.AddPositionedTemplate(templatePos2));
        }
Beispiel #10
0
        public void RoomsCanBePlacedAtPresetZUsingAddPositionedTemplate()
        {
            //Load sample template 8x4
            RoomTemplate room1 = LoadTemplateFromAssemblyFile("DDRogueTest.testdata.vaults.testsolid1.room");

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            TemplatePositioned templatePos2 = new TemplatePositioned(8, 0, 0, room1, 0);

            Assert.IsTrue(mapGen.AddPositionedTemplate(templatePos2));
        }
        public void AligningOverlappingRoomsOnADoorRemovesBothDoors()
        {
            //Load sample template 8x4
            RoomTemplate room1     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate room2     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");
            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            mapGen.PlaceRoomTemplateAlignedWithExistingDoor(room2, null, mapGen.PotentialDoors[0], 0, 0);

            Assert.AreEqual(0, mapGen.PotentialDoors.Count);
        }
        public void RoomCantBeReplacedWithLargeRooms()
        {
            //Load sample template 8x4
            RoomTemplate baseRoom   = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate joinedRoom = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");

            RoomTemplate replacementRoom = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testoverlap3.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(baseRoom, new Point(0, 0));
            mapGen.PlaceRoomTemplateAlignedWithExistingDoor(joinedRoom, null, mapGen.PotentialDoors[0], 0, 0);

            Assert.IsFalse(mapGen.ReplaceRoomTemplate(0, new Connection(0, 1), replacementRoom, 0));
        }
        public void AddingTwoAlignedRoomsGiveTwoConnectedNodeGraph()
        {
            //Load sample template 8x4
            RoomTemplate room1 = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate room2 = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            mapGen.PlaceRoomTemplateAlignedWithExistingDoor(room2, null, mapGen.PotentialDoors[0], 0, 1);

            var connectivityMap = mapGen.ConnectivityMap;
            var allConnections  = connectivityMap.GetAllConnections().ToList();

            CollectionAssert.AreEquivalent(new List <Connection>(new Connection[] { new Connection(0, 1) }), allConnections);
        }
        public void ConnectingDoorBetweenTwoOverlappingRoomsCanBeIdentified()
        {
            //Load sample template 8x4
            RoomTemplate room1     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate room2     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");
            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            mapGen.PlaceRoomTemplateAlignedWithExistingDoor(room2, null, mapGen.PotentialDoors[0], 0, 0);

            var connectingDoor = mapGen.GetDoorForConnection(new Connection(0, 1));

            Assert.AreEqual(new Point(4, 3), connectingDoor.MapCoords);
        }
        public void TemplatesCanBeReturnedInMapCoords()
        {
            //Load sample template 8x4
            RoomTemplate room1     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate room2     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");
            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(-5, -5));
            mapGen.PlaceRoomTemplateAtPosition(room2, new Point(5, 10));

            var roomTemplatesInWorldCoords = mapGen.GetRoomTemplatesInWorldCoords();

            Assert.AreEqual(new Point(10, 15), roomTemplatesInWorldCoords[1].Location);
        }
Beispiel #16
0
        public void TestNonOverlappingSolidRoomsCanBeCheckedToBeAllowedToBePlaced()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testsolid1.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            TemplatePositioned templatePos2 = new TemplatePositioned(8, 0, 10, room1, 0);

            Assert.IsTrue(mapGen.CanBePlacedWithoutOverlappingOtherTemplates(templatePos2));
        }
        public void PotentialDoorsAreRemovedAfterRoomsAreConnectedByPlacingSideToSide()
        {
            //Load sample template 8x4
            RoomTemplate room1     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate room2     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");
            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            mapGen.PlaceRoomTemplateAtPosition(room2, new Point(3, 4));

            bool corridorPlacement = mapGen.JoinDoorsWithCorridor(mapGen.PotentialDoors[0], mapGen.PotentialDoors[1], corridor1);

            Assert.AreEqual(0, mapGen.PotentialDoors.Count);
        }
Beispiel #18
0
        public void MapContainsCorrectIdOnSingleRoom()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testsolid1.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 12);

            mapGen.AddPositionedTemplate(templatePos1);

            Map outputMap = mapGen.MergeTemplatesIntoMap(GetStandardTerrainMapping());

            Assert.IsTrue(outputMap.roomIdMap[0, 0] == 12);
        }
Beispiel #19
0
        public void TemplateCanBeOverlappedByItself()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testalignmentroom3.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            //Base
            TemplatePositioned templatePos1 = new TemplatePositioned(5, 5, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            //Overlap the same room as a limit test
            Assert.IsTrue(mapGen.OverridePositionedTemplate(templatePos1));
        }
Beispiel #20
0
        public void RoomsWhichOverlapOnFloorWallCantBeAdded()
        {
            //Completely overlapping rooms cause problems with door removal etc. so they can't be allowed
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testsolid1.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            TemplatePositioned templatePos2 = new TemplatePositioned(1, 0, 10, room1, 0);

            Assert.IsFalse(mapGen.AddPositionedTemplate(templatePos2));
        }
        public void RoomTemplateMayBeRetrievedAfterAddingCorridor()
        {
            //Load sample template 8x4
            RoomTemplate room1     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate room2     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");
            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            mapGen.PlaceRoomTemplateAtPosition(room2, new Point(-7, 8));

            bool corridorPlacement = mapGen.JoinDoorsWithCorridor(mapGen.PotentialDoors[0], mapGen.PotentialDoors[1], corridor1);

            //We are only testing that the corridor exists, where it is is tested elsewhere
            Assert.AreNotEqual(null, mapGen.GetRoomTemplatesInWorldCoords()[2].Room);
        }
Beispiel #22
0
        public void AddingOverlappingTemplatesWorksIfTwoRowOverlapWithOneRowWall()
        {
            //Completely overlapping rooms cause problems with door removal etc. so they can't be allowed
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testsolid1.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            TemplatePositioned templatePos2 = new TemplatePositioned(6, 2, 10, room1, 0);
            var addResult = mapGen.AddPositionedTemplate(templatePos2);

            Assert.IsFalse(addResult);
        }
Beispiel #23
0
        public void TerrainAtPointCanBeOverriden()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testsolid1.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 1);

            mapGen.AddPositionedTemplate(templatePos1);

            mapGen.AddOverrideTerrain(new Point(0, 0), RoomTemplateTerrain.Floor);

            Map outputMap = mapGen.MergeTemplatesIntoMap(GetStandardTerrainMapping());

            Assert.AreEqual(MapTerrain.Empty, outputMap.mapSquares[0, 0].Terrain);
        }
        public void ConnectingDoorsBetweenTwoRoomsJoinedWithACorridorButAdjacentCanBeIdentified()
        {
            //Load sample template 8x4
            RoomTemplate room1     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom3.room");
            RoomTemplate room2     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom4.room");
            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            mapGen.PlaceRoomTemplateAtPosition(room2, new Point(-7, 1));

            bool corridorPlacement = mapGen.JoinDoorsWithCorridor(mapGen.PotentialDoors[0], mapGen.PotentialDoors[1], corridor1);

            var room1ToRoom2Door = mapGen.GetDoorForConnection(new Connection(0, 1));

            Assert.AreEqual(new Point(0, 2), room1ToRoom2Door.MapCoords);
        }
        public void RoomReplacedWithSmallRoomsCantThenBeMadeLargeAgain()
        {
            //Load sample template 8x4
            RoomTemplate baseRoom   = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate joinedRoom = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");

            RoomTemplate replacementRoom = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testoverlap2.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(baseRoom, new Point(0, 0));
            mapGen.PlaceRoomTemplateAlignedWithExistingDoor(joinedRoom, null, mapGen.PotentialDoors[0], 0, 0);

            mapGen.ReplaceRoomTemplate(0, new Connection(0, 1), replacementRoom, 0);

            //Here we use the knowledge that we deleted index 0, so the new replacement room is at index 1
            Assert.IsFalse(mapGen.ReplaceRoomTemplate(0, new Connection(0, 1), baseRoom, 0));
        }
        public void CorrectPotentialDoorsAreRemovedAfterMultiDoorsRoomsAreConnectedByACorridor()
        {
            //Load sample template 8x4
            RoomTemplate room1     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.test4doors.room");
            RoomTemplate room2     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.test2doors.room");
            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            mapGen.PlaceRoomTemplateAlignedWithExistingDoor(room2, null, mapGen.PotentialDoors[3], 1, 1);

            var expectedDoors = new List <Point>(new Point[] { new Point(3, 0), new Point(0, 1), new Point(7, 1),
                                                               new Point(6, 6) });
            var actualDoors = mapGen.PotentialDoors.Select(d => d.MapCoords);

            CollectionAssert.AreEquivalent(expectedDoors.ToList(), actualDoors.ToList());
        }
Beispiel #27
0
        public void AddingOverlappingTemplatesDoesntWorkIfOOverlapBetweenWallAndDoor()
        {
            //Load sample template 8x4
            Assembly     _assembly      = Assembly.GetExecutingAssembly();
            Stream       roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.test4doors.room");
            RoomTemplate room1          = RoomTemplateLoader.LoadTemplateFromFile(roomFileStream, StandardTemplateMapping.terrainMapping);

            TemplatedMapBuilder mapGen = new TemplatedMapBuilder();

            //Base
            TemplatePositioned templatePos1 = new TemplatePositioned(0, 0, 0, room1, 0);

            mapGen.AddPositionedTemplate(templatePos1);

            //Overlapping by wall and door only
            TemplatePositioned templatePos2 = new TemplatePositioned(7, 1, 0, room1, 0);

            Assert.IsFalse(mapGen.AddPositionedTemplate(templatePos2));
        }
        public void UnconnectedDoorsCanBeReplacedWithOtherTerrain()
        {
            //With 4 doors
            RoomTemplate room1 = LoadTemplateFromFile("DDRogueTest.testdata.vaults.test4doors.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));

            mapGen.ReplaceUnconnectedDoorsWithTerrain(RoomTemplateTerrain.Wall);

            //Check the doors are walls when merged
            var map = mapBuilder.MergeTemplatesIntoMap(GetStandardTerrainMapping());

            Assert.AreEqual(map.mapSquares[0, 3].Terrain, MapTerrain.Wall);
            Assert.AreEqual(map.mapSquares[7, 1].Terrain, MapTerrain.Wall);
            Assert.AreEqual(map.mapSquares[7, 0].Terrain, MapTerrain.Wall);
            Assert.AreEqual(map.mapSquares[3, 3].Terrain, MapTerrain.Wall);
        }
        public void AddingSideToSideRoomsGivesConnectedNodeGraph()
        {
            //Load sample template 8x4
            RoomTemplate room1     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate room2     = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");
            RoomTemplate corridor1 = LoadTemplateFromFileRogueBasin("RogueBasin.bin.Debug.vaults.corridortemplate3x1.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(room1, new Point(0, 0));
            mapGen.PlaceRoomTemplateAtPosition(room2, new Point(3, 4));

            bool corridorPlacement = mapGen.JoinDoorsWithCorridor(mapGen.PotentialDoors[0], mapGen.PotentialDoors[1], corridor1);

            var connectivityMap = mapGen.ConnectivityMap;
            var allConnections  = connectivityMap.GetAllConnections().Select(c => c.Ordered).ToList();

            CollectionAssert.AreEquivalent(new List <Connection>(new Connection[] { new Connection(0, 1) }), allConnections);
        }
        public void ExcessAreaFromReplacedRoomsAreRemovedWhenSmallerRoomReplacesThem()
        {
            //Load sample template 8x4
            RoomTemplate baseRoom   = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom1.room");
            RoomTemplate joinedRoom = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testalignmentroom2.room");

            RoomTemplate replacementRoom = LoadTemplateFromFile("DDRogueTest.testdata.vaults.testoverlap2.room");

            TemplatedMapBuilder   mapBuilder = new TemplatedMapBuilder();
            TemplatedMapGenerator mapGen     = new TemplatedMapGenerator(mapBuilder);

            mapGen.PlaceRoomTemplateAtPosition(baseRoom, new Point(0, 0));
            mapGen.PlaceRoomTemplateAlignedWithExistingDoor(joinedRoom, null, mapGen.PotentialDoors[0], 0, 0);

            mapGen.ReplaceRoomTemplate(0, new Connection(0, 1), replacementRoom, 0);

            var map = mapBuilder.MergeTemplatesIntoMap(GetStandardTerrainMapping());

            Assert.AreEqual(MapTerrain.Void, map.mapSquares[0, 0].Terrain);
        }