public DoorInfo(TemplatePositioned ownerRoom, int ownerRoomIndex, int doorIndex, RoomTemplate.DoorLocation doorLocation) { OwnerRoom = ownerRoom; DoorIndexInRoom = doorIndex; OwnerRoomIndex = ownerRoomIndex; DoorLocation = doorLocation; }
private static void AddStandardDecorativeFeaturesToRoom(int level, TemplatePositioned positionedRoom, int featuresToPlace, DecorationFeatureDetails.Decoration decorationDetails) { var bridgeRouter = new RoomFilling(positionedRoom.Room); var floorPoints = RoomTemplateUtilities.GetPointsInRoomWithTerrain(positionedRoom.Room, RoomTemplateTerrain.Floor); for (int i = 0; i < featuresToPlace; i++) { var randomPoint = floorPoints.RandomElement(); floorPoints.Remove(randomPoint); if (bridgeRouter.SetSquareUnWalkableIfMaintainsConnectivity(randomPoint)) { var featureLocationInMapCoords = positionedRoom.Location + randomPoint; Game.Dungeon.AddFeatureBlocking(new Features.StandardDecorativeFeature(decorationDetails.representation, decorationDetails.colour), level, featureLocationInMapCoords, true); LogFile.Log.LogEntryDebug("Placing feature in room " + positionedRoom.RoomIndex + " at location " + featureLocationInMapCoords, LogDebugLevel.Medium); } if (floorPoints.Count() == 0) { break; } } }
public DoorInfo(TemplatePositioned ownerRoom, int ownerRoomIndex, int doorIndex, RoomTemplate.DoorLocation doorLocation) { OwnerRoom = ownerRoom; DoorIndexInRoom = doorIndex; OwnerRoomIndex = ownerRoomIndex; DoorLocation = doorLocation; }
private void AddNewDoorsToPotentialDoors(TemplatePositioned positionedRoom, int roomIndex) { //Store a reference to each potential door in the room int noDoors = positionedRoom.PotentialDoors.Count(); //var currentDoorLocations = potentialDoors.Select(d => d.MapCoords); for (int i = 0; i < noDoors; i++) { //if (!currentDoorLocations.Contains(positionedRoom.PotentialDoors[i])) potentialDoors.Add(new DoorInfo(positionedRoom, roomIndex, i, RoomTemplateUtilities.GetDoorLocation(positionedRoom.Room, i))); } }
/// <summary> /// Add the terrain to the map, overriding what was there before. /// Use with caution since may break connectivity /// Performs no checking and allows any override /// </summary> /// <param name="templateToAdd"></param> /// <returns></returns> public void UnconditionallyOverridePositionedTemplate(TemplatePositioned templateToAdd) { try { mapCache.MergeArea(templateToAdd.Location, templateToAdd.Room.terrainMap, OverrideTerrain); idCache.MergeArea(templateToAdd.Location, MakeIdArray(templateToAdd), OverrideIds); } catch (ArgumentException e) { throw new ApplicationException("Can't place room: " + e.Message); } }
public void CyclesOnSeparateLevelsCanBeReturned() { var builder = new MapInfoBuilder(); var l1ConnectivityMap = new ConnectivityMap(); //Cycle in level 1 l1ConnectivityMap.AddRoomConnection(1, 2); l1ConnectivityMap.AddRoomConnection(2, 3); l1ConnectivityMap.AddRoomConnection(3, 1); var l1RoomList = new List<TemplatePositioned>(); var room1 = new TemplatePositioned(1, 1, 0, null, 1); l1RoomList.Add(room1); l1RoomList.Add(new TemplatePositioned(1, 1, 0, null, 2)); l1RoomList.Add(new TemplatePositioned(1, 1, 0, null, 3)); var l2ConnectivityMap = new ConnectivityMap(); //Cycle in level 2 l2ConnectivityMap.AddRoomConnection(5, 6); l2ConnectivityMap.AddRoomConnection(6, 7); l2ConnectivityMap.AddRoomConnection(7, 5); var l2RoomList = new List<TemplatePositioned>(); var room5 = new TemplatePositioned(1, 1, 0, null, 5); l2RoomList.Add(room5); l2RoomList.Add(new TemplatePositioned(1, 1, 0, null, 6)); l2RoomList.Add(new TemplatePositioned(1, 1, 0, null, 7)); builder.AddConstructedLevel(0, l1ConnectivityMap, l1RoomList, new Dictionary<Connection, Point>(), 1); builder.AddConstructedLevel(1, l2ConnectivityMap, l2RoomList, new Dictionary<Connection, Point>(), new Connection(3, 5)); var mapInfo = new MapInfo(builder); var cyclesOnLevel0 = mapInfo.GetCyclesOnLevel(0).ToList(); Assert.AreEqual(1, cyclesOnLevel0.Count()); CollectionAssert.AreEquivalent(cyclesOnLevel0[0], new List<Connection>{ new Connection(1, 2), new Connection(2, 3), new Connection(3, 1) }); var cyclesOnLevel1 = mapInfo.GetCyclesOnLevel(1).ToList(); Assert.AreEqual(1, cyclesOnLevel1.Count()); CollectionAssert.AreEquivalent(cyclesOnLevel1[0], new List<Connection>{ new Connection(5, 6), new Connection(6, 7), new Connection(7, 5) }); }
public void PotentialDoorsShouldBeAvailableFromPositionedTemplate() { RoomTemplate room1 = LoadTemplateFromAssemblyFile("DDRogueTest.testdata.vaults.test4doors.room"); TemplatePositioned templatePos1 = new TemplatePositioned(11, 12, 0, room1, 0); //Doors at: (3,0),(0,1),(7,1),(3,3) List <Point> outputList = new List<Point>(); outputList.Add(new Point(14, 12)); outputList.Add(new Point(11, 13)); outputList.Add(new Point(18, 13)); outputList.Add(new Point(14, 15)); List<Point> doorList = templatePos1.PotentialDoors.ToList(); CollectionAssert.AreEqual(doorList, outputList); }
public void AddingOverlappingTemplatesWorksIfOnlyOverlapIsOnWallsAndDoors() { //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, 0, 0, room1, 0); Assert.IsTrue(mapGen.AddPositionedTemplate(templatePos2)); }
public void AddingOverlappingTemplatesWorksIfOnlyOverlapIsOnACorner() { //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(7, 3, 10, room1, 0); var addResult = mapGen.AddPositionedTemplate(templatePos2); Assert.IsTrue(addResult); }
public int PlaceRoomTemplateAtPosition(RoomTemplate roomTemplate, Point point) { var roomIndex = NextRoomIndex(); var positionedRoom = new TemplatePositioned(point.x, point.y, 0, roomTemplate, roomIndex); templates[roomIndex] = positionedRoom; bool placementSuccess = mapBuilder.AddPositionedTemplate(positionedRoom); if (!placementSuccess) { throw new ApplicationException("Can't place template at position"); } IncreaseNextRoomIndex(); AddNewDoorsToPotentialDoors(positionedRoom, roomIndex); return(roomIndex); }
public bool AddPositionedTemplate(TemplatePositioned templateToAdd) { if (!CanBePlacedWithoutOverlappingOtherTemplates(templateToAdd)) { return(false); } try { mapCache.MergeArea(templateToAdd.Location, templateToAdd.Room.terrainMap, MergeTerrain, CheckNotCompletelyOverlapping); idCache.MergeArea(templateToAdd.Location, MakeIdArray(templateToAdd), MergeIds); return(true); } catch (ArgumentException e) { throw new ApplicationException("Can't place room: " + e.Message); } }
/// <summary> /// Add the terrain to the map, overriding what was there before. /// Use with caution since may break connectivity /// </summary> /// <param name="templateToAdd"></param> /// <returns></returns> public bool OverridePositionedTemplate(TemplatePositioned templateToAdd) { if (!CanBePlacedOverlappingOtherTemplates(templateToAdd)) { return(false); } try { mapCache.MergeArea(templateToAdd.Location, templateToAdd.Room.terrainMap, OverrideFloorTerrain); idCache.MergeArea(templateToAdd.Location, MakeIdArray(templateToAdd), OverrideIds); return(true); } catch (ArgumentException e) { throw new ApplicationException("Can't place room: " + e.Message); } }
private int[,] MakeIdArray(TemplatePositioned template) { var ret = new int[template.Room.terrainMap.GetLength(0), template.Room.terrainMap.GetLength(1)]; for (int i = 0; i < template.Room.terrainMap.GetLength(0); i++) { for (int j = 0; j < template.Room.terrainMap.GetLength(1); j++) { if (template.Room.terrainMap[i, j] != RoomTemplateTerrain.Transparent) { ret[i, j] = template.RoomIndex; } else { ret[i, j] = defaultId; } } } return(ret); }
/// <summary> /// Align toAlignRoomTemplate so that a straight corridor can be drawn from baseRoom. /// Will rotate toAlignRoomTemplate if required /// </summary> public static Tuple<TemplatePositioned, Point> AlignRoomFacing(RoomTemplate toAlignRoomTemplate, int toAlignRoomIndex, TemplatePositioned baseRoom, int toAlignRoomDoorIndex, int baseRoomDoorIndex, int distanceApart) { Point toAlignDoorLocation = toAlignRoomTemplate.PotentialDoors[toAlignRoomDoorIndex].Location; Point baseDoorLocation = baseRoom.Room.PotentialDoors[baseRoomDoorIndex].Location; RoomTemplate.DoorLocation toAlignDoorLoc = GetDoorLocation(toAlignRoomTemplate, toAlignRoomDoorIndex); RoomTemplate.DoorLocation baseDoorLoc = GetDoorLocation(baseRoom.Room, baseRoomDoorIndex); RoomTemplate rotatedTemplate; Point rotatedtoAlignDoorLocation; //B is toAlignRoomTemplate //A is baseTemplate //Rotate 2 + (Bi - Ai) * 90 degree steps clockwise. int stepsToRotate = 2 + ((int)toAlignDoorLoc - (int)baseDoorLoc); if (stepsToRotate < 0) stepsToRotate += 4; if (stepsToRotate >= 4) stepsToRotate -= 4; rotatedTemplate = RotateRoomTemplate(toAlignRoomTemplate, stepsToRotate); rotatedtoAlignDoorLocation = RotateRoomPoint(toAlignRoomTemplate, toAlignDoorLocation, stepsToRotate); int xOffset = baseDoorLocation.x - rotatedtoAlignDoorLocation.x; int yOffset = baseDoorLocation.y - rotatedtoAlignDoorLocation.y; Point toAlignRoomPosition; if (baseDoorLoc == RoomTemplate.DoorLocation.Bottom) { //Vertical alignment toAlignRoomPosition = new Point(baseRoom.X + xOffset, baseRoom.Y + baseRoom.Room.Height + distanceApart - 1); } else if (baseDoorLoc == RoomTemplate.DoorLocation.Top) { toAlignRoomPosition = new Point(baseRoom.X + xOffset, baseRoom.Y - distanceApart - (rotatedTemplate.Height - 1)); } else if (baseDoorLoc == RoomTemplate.DoorLocation.Right) { //Horizontal alignment toAlignRoomPosition = new Point(baseRoom.X + baseRoom.Room.Width - 1 + distanceApart, baseRoom.Y + yOffset); } else { toAlignRoomPosition = new Point(baseRoom.X - distanceApart - (rotatedTemplate.Width - 1), baseRoom.Y + yOffset); } TemplatePositioned rotatedTemplatePosition = new TemplatePositioned(toAlignRoomPosition.x, toAlignRoomPosition.y, baseRoom.Z + 1, rotatedTemplate, toAlignRoomIndex); Point rotatedDoorLocation = new Point(toAlignRoomPosition.x + rotatedtoAlignDoorLocation.x, toAlignRoomPosition.y + rotatedtoAlignDoorLocation.y); return new Tuple<TemplatePositioned, Point>(rotatedTemplatePosition, rotatedDoorLocation); }
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 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 TemplateCantBeOverlappedUsingOverrideTemplateIfSecondTemplateTriesToReplacesNonFloorTiles() { //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); Assert.IsFalse(mapGen.OverridePositionedTemplate(templatePos2)); }
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); }
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); }
public bool CanBePlacedWithoutOverlappingOtherTemplates(TemplatePositioned template) { return(mapCache.CheckMergeArea(template.Location, template.Room.terrainMap, MergeTerrain, CheckNotCompletelyOverlapping)); }
private int[,] MakeIdArray(TemplatePositioned template) { var ret = new int[template.Room.terrainMap.GetLength(0), template.Room.terrainMap.GetLength(1)]; for (int i = 0; i < template.Room.terrainMap.GetLength(0); i++) { for (int j = 0; j < template.Room.terrainMap.GetLength(1); j++) { if (template.Room.terrainMap[i, j] != RoomTemplateTerrain.Transparent) ret[i, j] = template.RoomIndex; else ret[i, j] = defaultId; } } return ret; }
/// <summary> /// Add the terrain to the map, overriding what was there before. /// Use with caution since may break connectivity /// </summary> /// <param name="templateToAdd"></param> /// <returns></returns> public bool OverridePositionedTemplate(TemplatePositioned templateToAdd) { if (!CanBePlacedOverlappingOtherTemplates(templateToAdd)) return false; try { mapCache.MergeArea(templateToAdd.Location, templateToAdd.Room.terrainMap, OverrideFloorTerrain); idCache.MergeArea(templateToAdd.Location, MakeIdArray(templateToAdd), OverrideIds); return true; } catch (ArgumentException e) { throw new ApplicationException("Can't place room: " + e.Message); } }
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)); }
/// <summary> /// Join 2 doors with a corridor. They must be on the opposite sides of their parent rooms (for now) /// </summary> public bool JoinDoorsWithCorridor(DoorInfo firstDoor, DoorInfo secondDoor, RoomTemplate corridorTemplate) { try { if (connectionDoors.ContainsKey(new Connection(firstDoor.OwnerRoomIndex, secondDoor.OwnerRoomIndex).Ordered)) { LogFile.Log.LogEntryDebug("No allowing 2nd connection between rooms for now - revisit past 7DRL", LogDebugLevel.High); return(false); } var firstDoorLoc = RoomTemplateUtilities.GetDoorLocation(firstDoor.OwnerRoom.Room, firstDoor.DoorIndexInRoom); var secondDoorLoc = RoomTemplateUtilities.GetDoorLocation(secondDoor.OwnerRoom.Room, secondDoor.DoorIndexInRoom); var firstDoorCoord = firstDoor.MapCoords; var secondDoorCoord = secondDoor.MapCoords; var corridorTermini = RoomTemplateUtilities.CorridorTerminalPointsBetweenDoors(firstDoor.MapCoords, firstDoor.DoorLocation, secondDoor.MapCoords, secondDoor.DoorLocation); bool canDoLSharedCorridor = RoomTemplateUtilities.CanBeConnectedWithLShapedCorridor(firstDoorCoord, firstDoorLoc, secondDoorCoord, secondDoorLoc); bool canDoBendCorridor = RoomTemplateUtilities.CanBeConnectedWithBendCorridor(firstDoorCoord, firstDoorLoc, secondDoorCoord, secondDoorLoc); bool canDoStraightCorridor = RoomTemplateUtilities.CanBeConnectedWithStraightCorridor(firstDoorCoord, firstDoorLoc, secondDoorCoord, secondDoorLoc); bool areAdjacent = corridorTermini.Item1 == secondDoorCoord && corridorTermini.Item2 == firstDoorCoord; bool areOverlapping = firstDoorCoord == secondDoorCoord; if (!canDoLSharedCorridor && !canDoBendCorridor && !canDoStraightCorridor && !areAdjacent && !areOverlapping) { throw new ApplicationException("No corridor available to connect this type of door"); } if (areAdjacent || areOverlapping) { //Add a direct connection in the connectivity graph connectivityMap.AddRoomConnection(firstDoor.OwnerRoomIndex, secondDoor.OwnerRoomIndex); connectionDoors.Add(new Connection(firstDoor.OwnerRoomIndex, secondDoor.OwnerRoomIndex).Ordered, firstDoor); } else { //Create template var horizontal = false; if (firstDoorLoc == RoomTemplate.DoorLocation.Left || firstDoorLoc == RoomTemplate.DoorLocation.Right) { horizontal = true; } int xOffset = corridorTermini.Item2.x - corridorTermini.Item1.x; int yOffset = corridorTermini.Item2.y - corridorTermini.Item1.y; RoomTemplate expandedCorridor; Point corridorTerminus1InTemplate; if (canDoBendCorridor) { int transition = (int)Math.Floor(yOffset / 2.0); if (horizontal == true) { transition = (int)Math.Floor(xOffset / 2.0); } var expandedCorridorAndPoint = RoomTemplateUtilities.ExpandCorridorTemplateBend(xOffset, yOffset, transition, horizontal, corridorTemplate); expandedCorridor = expandedCorridorAndPoint.Item1; corridorTerminus1InTemplate = expandedCorridorAndPoint.Item2; } else if (canDoLSharedCorridor) { var expandedCorridorAndPoint = RoomTemplateUtilities.ExpandCorridorTemplateLShaped(xOffset, yOffset, horizontal, corridorTemplate); expandedCorridor = expandedCorridorAndPoint.Item1; corridorTerminus1InTemplate = expandedCorridorAndPoint.Item2; } else { var offsetToUse = horizontal ? xOffset : yOffset; var expandedCorridorAndPoint = RoomTemplateUtilities.ExpandCorridorTemplateStraight(offsetToUse, horizontal, corridorTemplate); expandedCorridor = expandedCorridorAndPoint.Item1; corridorTerminus1InTemplate = expandedCorridorAndPoint.Item2; } //Place corridor //Match corridor tile to location of door Point topLeftCorridor = corridorTermini.Item1 - corridorTerminus1InTemplate; var corridorRoomIndex = NextRoomIndex(); var positionedCorridor = new TemplatePositioned(topLeftCorridor.x, topLeftCorridor.y, 0, expandedCorridor, corridorRoomIndex); if (!mapBuilder.CanBePlacedWithoutOverlappingOtherTemplates(positionedCorridor)) { return(false); } //Place the corridor mapBuilder.AddPositionedTemplate(positionedCorridor); templates[corridorRoomIndex] = positionedCorridor; IncreaseNextRoomIndex(); //Add connections to the old and new rooms connectivityMap.AddRoomConnection(firstDoor.OwnerRoomIndex, corridorRoomIndex); connectivityMap.AddRoomConnection(corridorRoomIndex, secondDoor.OwnerRoomIndex); connectionDoors.Add(new Connection(firstDoor.OwnerRoomIndex, corridorRoomIndex).Ordered, firstDoor); connectionDoors.Add(new Connection(corridorRoomIndex, secondDoor.OwnerRoomIndex).Ordered, secondDoor); } //Remove both doors from the potential list potentialDoors.Remove(firstDoor); potentialDoors.Remove(secondDoor); return(true); } catch (ApplicationException ex) { LogFile.Log.LogEntryDebug("Failed to join doors: " + ex.Message, LogDebugLevel.Medium); return(false); } }
/// <summary> /// Check placement using the rules for replacing a room /// </summary> /// <param name="template"></param> /// <returns></returns> public bool CanBePlacedOverlappingOtherTemplates(TemplatePositioned template) { return(mapCache.CheckMergeArea(template.Location, template.Room.terrainMap, OverrideFloorTerrain)); }
private MapInfoBuilder GetStandardMapInfoBuilder() { var builder = new MapInfoBuilder(); var l1ConnectivityMap = new ConnectivityMap(); l1ConnectivityMap.AddRoomConnection(1, 2); l1ConnectivityMap.AddRoomConnection(2, 3); var l1RoomList = new List<TemplatePositioned>(); var room1 = new TemplatePositioned(1, 1, 0, null, 1); l1RoomList.Add(room1); l1RoomList.Add(new TemplatePositioned(1, 1, 0, null, 2)); l1RoomList.Add(new TemplatePositioned(1, 1, 0, null, 3)); var l2ConnectivityMap = new ConnectivityMap(); l2ConnectivityMap.AddRoomConnection(5, 6); l2ConnectivityMap.AddRoomConnection(6, 7); var l2RoomList = new List<TemplatePositioned>(); var room5 = new TemplatePositioned(1, 1, 0, null, 5); l2RoomList.Add(room5); l2RoomList.Add(new TemplatePositioned(1, 1, 0, null, 6)); l2RoomList.Add(new TemplatePositioned(1, 1, 0, null, 7)); var l1DoorDict = new Dictionary<Connection, Point>(); l1DoorDict.Add(new Connection(2, 3), new Point(5,5)); var l2DoorDict = new Dictionary<Connection, Point>(); l2DoorDict.Add(new Connection(5, 6), new Point(8, 8)); builder.AddConstructedLevel(0, l1ConnectivityMap, l1RoomList, l1DoorDict, 1); builder.AddConstructedLevel(1, l2ConnectivityMap, l2RoomList, l2DoorDict, new Connection(3, 5)); return builder; }
public void RoomsCanBeRetrievedByIndex() { var newTemplate = new TemplatePositioned(9, 9, 0, null, 100); var mapInfoBuilder = new MapInfoBuilder(); var templateList = new List<TemplatePositioned>(); templateList.Add(newTemplate); var map = new ConnectivityMap(); map.AddRoomConnection(new Connection(100, 101)); mapInfoBuilder.AddConstructedLevel(0, map, templateList, new Dictionary<Connection, Point>(), 100); var mapInfo = new MapInfo(mapInfoBuilder); Assert.AreEqual(new Point(9,9), mapInfo.GetRoom(100).Location); }
/// <summary> /// Place a room template aligned with an existing door. /// Returns Connection(Source = existing room or corridor to new room, Target = new room)) /// </summary> public Connection PlaceRoomTemplateAlignedWithExistingDoor(RoomTemplate roomTemplateToPlace, RoomTemplate corridorTemplate, DoorInfo existingDoor, int newRoomDoorIndex, int distanceApart) { var newRoomIndex = NextRoomIndex(); Point existingDoorLoc = existingDoor.MapCoords; Tuple <TemplatePositioned, Point> newRoomTuple = RoomTemplateUtilities.AlignRoomFacing(roomTemplateToPlace, newRoomIndex, existingDoor.OwnerRoom, newRoomDoorIndex, existingDoor.DoorIndexInRoom, distanceApart); var alignedNewRoom = newRoomTuple.Item1; var alignedDoorLocation = newRoomTuple.Item2; var alignedDoorIndex = alignedNewRoom.PotentialDoors.IndexOf(alignedDoorLocation); var alignedDoor = new DoorInfo(alignedNewRoom, newRoomIndex, alignedDoorIndex, RoomTemplateUtilities.GetDoorLocation(alignedNewRoom.Room, alignedDoorIndex)); //In order to place this successfully, we need to be able to both place the room and a connecting corridor if (!mapBuilder.CanBePlacedWithoutOverlappingOtherTemplates(alignedNewRoom)) { throw new ApplicationException("Room failed to place because overlaps existing room"); } //Increase next room for any corridor we may add IncreaseNextRoomIndex(); TemplatePositioned corridorTemplateConnectingRooms = null; Connection connectionToNewRoom = null; if (distanceApart > 1) { //Need points that are '1-in' from the doors var doorOrientation = RoomTemplateUtilities.GetDoorLocation(existingDoor.OwnerRoom.Room, existingDoor.DoorIndexInRoom); bool isHorizontal = doorOrientation == RoomTemplate.DoorLocation.Left || doorOrientation == RoomTemplate.DoorLocation.Right; var corridorTermini = RoomTemplateUtilities.CorridorTerminalPointsBetweenDoors(existingDoorLoc, existingDoor.DoorLocation, alignedDoorLocation, RoomTemplateUtilities.GetOppositeDoorLocation(existingDoor.DoorLocation)); var corridorIndex = NextRoomIndex(); if (corridorTermini.Item1 == corridorTermini.Item2) { corridorTemplateConnectingRooms = RoomTemplateUtilities.GetTemplateForSingleSpaceCorridor(corridorTermini.Item1, RoomTemplateUtilities.ArePointsOnVerticalLine(corridorTermini.Item1, corridorTermini.Item2), 0, corridorTemplate, corridorIndex); } else { corridorTemplateConnectingRooms = RoomTemplateUtilities.GetTemplateForCorridorBetweenPoints(corridorTermini.Item1, corridorTermini.Item2, 0, corridorTemplate, corridorIndex); } //Implicit guarantee that the corridor won't overlap with the new room we're about to place //(but it may overlap other previously placed rooms or corridors) if (!mapBuilder.CanBePlacedWithoutOverlappingOtherTemplates(corridorTemplateConnectingRooms)) { throw new ApplicationException("Room failed to place because corridor overlaps existing room"); } //Place the corridor mapBuilder.AddPositionedTemplate(corridorTemplateConnectingRooms); templates[corridorIndex] = corridorTemplateConnectingRooms; IncreaseNextRoomIndex(); //Add connections to the old and new rooms connectionToNewRoom = new Connection(corridorIndex, newRoomIndex); connectivityMap.AddRoomConnection(existingDoor.OwnerRoomIndex, corridorIndex); LogFile.Log.LogEntryDebug("Adding connection: " + existingDoor.OwnerRoomIndex + " to " + corridorIndex, LogDebugLevel.Medium); connectivityMap.AddRoomConnection(corridorIndex, newRoomIndex); LogFile.Log.LogEntryDebug("Adding connection: " + corridorIndex + " to " + newRoomIndex, LogDebugLevel.Medium); connectionDoors.Add(new Connection(existingDoor.OwnerRoomIndex, corridorIndex).Ordered, existingDoor); connectionDoors.Add(connectionToNewRoom.Ordered, alignedDoor); } else { //No corridor - a direct connection between the rooms connectionToNewRoom = new Connection(existingDoor.OwnerRoomIndex, newRoomIndex); connectivityMap.AddRoomConnection(existingDoor.OwnerRoomIndex, newRoomIndex); connectionDoors.Add(connectionToNewRoom.Ordered, alignedDoor); LogFile.Log.LogEntryDebug("Adding connection: " + existingDoor.OwnerRoomIndex + " to " + newRoomIndex, LogDebugLevel.Medium); } //Place the room bool successfulPlacement = mapBuilder.AddPositionedTemplate(alignedNewRoom); if (!successfulPlacement) { LogFile.Log.LogEntryDebug("Room failed to place because overlaps own corridor - bug", LogDebugLevel.High); throw new ApplicationException("Room failed to place because overlaps own corridor - bug"); } templates[newRoomIndex] = alignedNewRoom; //Add the new potential doors (excluding the one we are linked on) //Can't find a nice linq alternative int noDoors = alignedNewRoom.PotentialDoors.Count(); for (int i = 0; i < noDoors; i++) { if (alignedNewRoom.PotentialDoors[i] == alignedDoorLocation) { continue; } potentialDoors.Add(new DoorInfo(alignedNewRoom, newRoomIndex, i, RoomTemplateUtilities.GetDoorLocation(alignedNewRoom.Room, i))); } //If successful, remove the candidate door from the list potentialDoors.Remove(existingDoor); return(connectionToNewRoom); }
public void TestOverlappingSolidRoomsReturnFalseWhenTestedForOverlap() { //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(0, 0, 10, room1, 0); Assert.IsFalse(mapGen.CanBePlacedWithoutOverlappingOtherTemplates(templatePos2)); }
/// <summary> /// Check placement using the rules for replacing a room /// </summary> /// <param name="template"></param> /// <returns></returns> public bool CanBePlacedOverlappingOtherTemplates(TemplatePositioned template) { return mapCache.CheckMergeArea(template.Location, template.Room.terrainMap, OverrideFloorTerrain); }
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 MapContainsCorrectIdOnTwoNonOverlappingRooms() { //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); TemplatePositioned templatePos2 = new TemplatePositioned(8, 0, 10, room1, 2); mapGen.AddPositionedTemplate(templatePos2); Map outputMap = mapGen.MergeTemplatesIntoMap(GetStandardTerrainMapping()); Assert.IsTrue(outputMap.roomIdMap[0, 0] == 1); Assert.IsTrue(outputMap.roomIdMap[8, 0] == 2); }
/// <summary> /// Return a new template with terrain set to all Transparent /// </summary> public static TemplatePositioned TransparentTemplate(TemplatePositioned templateToReplace) { var newTerrain = new RoomTemplateTerrain [templateToReplace.Room.Width, templateToReplace.Room.Height]; for (int i = 0; i < templateToReplace.Room.Width; i++) { for (int j = 0; j < templateToReplace.Room.Height; j++) { newTerrain[i, j] = RoomTemplateTerrain.Transparent; } } return new TemplatePositioned(templateToReplace.X, templateToReplace.Y, templateToReplace.Z, new RoomTemplate(newTerrain), templateToReplace.RoomIndex); }
public void MapContainsDefaultIdForTransparentPartsOfRoom() { //Load sample template 8x4 Assembly _assembly = Assembly.GetExecutingAssembly(); Stream roomFileStream = _assembly.GetManifestResourceStream("DDRogueTest.testdata.vaults.testtransparent1.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] == TemplatedMapBuilder.defaultId); Assert.IsTrue(outputMap.roomIdMap[1, 1] == 12); }
/// <summary> /// Align toAlignRoomTemplate so that it matches the alignment of baseRoom and the target doors overlap /// </summary> public static Tuple<TemplatePositioned, Point> AlignRoomOverlapping(RoomTemplate toAlignRoomTemplate, int toAlignRoomIndex, TemplatePositioned baseRoom, int toAlignRoomDoorIndex, int baseRoomDoorIndex) { Point toAlignDoorLocation = toAlignRoomTemplate.PotentialDoors[toAlignRoomDoorIndex].Location; Point baseDoorLocation = baseRoom.Room.PotentialDoors[baseRoomDoorIndex].Location; RoomTemplate.DoorLocation toAlignDoorLoc = GetDoorLocation(toAlignRoomTemplate, toAlignRoomDoorIndex); RoomTemplate.DoorLocation baseDoorLoc = GetDoorLocation(baseRoom.Room, baseRoomDoorIndex); RoomTemplate rotatedTemplate; Point rotatedtoAlignDoorLocation; //B is toAlignRoomTemplate //A is baseTemplate //Rotate 2 + (Bi - Ai) * 90 degree steps clockwise. int stepsToRotate = ((int)toAlignDoorLoc - (int)baseDoorLoc); if (stepsToRotate < 0) stepsToRotate += 4; if (stepsToRotate >= 4) stepsToRotate -= 4; rotatedTemplate = RotateRoomTemplate(toAlignRoomTemplate, stepsToRotate); rotatedtoAlignDoorLocation = RotateRoomPoint(toAlignRoomTemplate, toAlignDoorLocation, stepsToRotate); int xOffset = baseDoorLocation.x - rotatedtoAlignDoorLocation.x; int yOffset = baseDoorLocation.y - rotatedtoAlignDoorLocation.y; Point toAlignRoomPosition = new Point(baseRoom.X + xOffset, baseRoom.Y + yOffset); TemplatePositioned rotatedTemplatePosition = new TemplatePositioned(toAlignRoomPosition.x, toAlignRoomPosition.y, baseRoom.Z + 1, rotatedTemplate, toAlignRoomIndex); Point rotatedDoorLocation = new Point(toAlignRoomPosition.x + rotatedtoAlignDoorLocation.x, toAlignRoomPosition.y + rotatedtoAlignDoorLocation.y); return new Tuple<TemplatePositioned, Point>(rotatedTemplatePosition, rotatedDoorLocation); }
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)); }
public bool CanBePlacedWithoutOverlappingOtherTemplates(TemplatePositioned template) { return mapCache.CheckMergeArea(template.Location, template.Room.terrainMap, MergeTerrain, CheckNotCompletelyOverlapping); }
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)); }
/// <summary> /// Add the terrain to the map, overriding what was there before. /// Use with caution since may break connectivity /// Performs no checking and allows any override /// </summary> /// <param name="templateToAdd"></param> /// <returns></returns> public void UnconditionallyOverridePositionedTemplate(TemplatePositioned templateToAdd) { try { mapCache.MergeArea(templateToAdd.Location, templateToAdd.Room.terrainMap, OverrideTerrain); idCache.MergeArea(templateToAdd.Location, MakeIdArray(templateToAdd), OverrideIds); } catch (ArgumentException e) { throw new ApplicationException("Can't place room: " + e.Message); } }
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)); }
public bool AddPositionedTemplate(TemplatePositioned templateToAdd) { if (!CanBePlacedWithoutOverlappingOtherTemplates(templateToAdd)) return false; try { mapCache.MergeArea(templateToAdd.Location, templateToAdd.Room.terrainMap, MergeTerrain, CheckNotCompletelyOverlapping); idCache.MergeArea(templateToAdd.Location, MakeIdArray(templateToAdd), MergeIds); return true; } catch (ArgumentException e) { throw new ApplicationException("Can't place room: " + e.Message); } }
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)); }