public void BasicTest()
{
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 0));
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetRectangle(5, 10), new SimpleDoorMode(1, 0));
var roomDescription1 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1
});
var roomDescription2 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate2
});
var mapDescription = new MapDescription <string>();
mapDescription.AddRoom("0", roomDescription1);
mapDescription.AddRoom("1", roomDescription2);
mapDescription.AddConnection("0", "1");
var mapDescriptionMapping = new MapDescriptionMapping <string>(mapDescription);
var mapping = mapDescriptionMapping.GetMapping();
Assert.That(mapDescriptionMapping.GetRoomDescription(mapping["0"]), Is.EqualTo(roomDescription1));
Assert.That(mapDescriptionMapping.GetRoomDescription(mapping["1"]), Is.EqualTo(roomDescription2));
Assert.That(mapDescriptionMapping.GetGraph().VerticesCount, Is.EqualTo(2));
Assert.That(mapDescriptionMapping.GetGraph().HasEdge(mapping["0"], mapping["1"]), Is.True);
}
public void GetRoomTemplatesDistribution_BasicTest()
{
var transformations = TransformationGrid2DHelper.GetAllTransformationsOld().ToList();
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(2), new SimpleDoorMode(1, 0), transformations);
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetSquare(4), new SimpleDoorMode(1, 0), transformations);
var roomTemplate3 = new RoomTemplate(PolygonGrid2D.GetSquare(6), new SimpleDoorMode(1, 0), transformations);
var data = new List <RoomTemplate>()
{
roomTemplate1,
roomTemplate3,
roomTemplate1,
roomTemplate1
};
var availableRoomTemplates = new List <RoomTemplate>()
{
roomTemplate1,
roomTemplate2,
roomTemplate3,
};
var distribution = entropyCalculator.GetProbabilityDistribution(data, availableRoomTemplates);
Assert.That(distribution.Count, Is.EqualTo(3));
Assert.That(distribution[roomTemplate1], Is.EqualTo(3 / 4d));
Assert.That(distribution[roomTemplate2], Is.EqualTo(0));
Assert.That(distribution[roomTemplate3], Is.EqualTo(1 / 4d));
}
public void ComputeAverageRoomTemplatesEntropy_BasicTest()
{
var transformations = TransformationGrid2DHelper.GetAllTransformationsOld().ToList();
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 0), transformations);
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetRectangle(5, 10), new SimpleDoorMode(1, 0), transformations);
var roomDescription1 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1, roomTemplate2
});
var mapDescription = new MapDescription <int>();
mapDescription.AddRoom(0, roomDescription1);
mapDescription.AddRoom(1, roomDescription1);
mapDescription.AddConnection(0, 1);
var dungeonGenerator = new DungeonGenerator <int>(mapDescription);
dungeonGenerator.InjectRandomGenerator(new Random(0));
var layouts = new List <MapLayout <int> >();
for (int i = 0; i < 10; i++)
{
layouts.Add(dungeonGenerator.GenerateLayout());
}
var entropy = entropyCalculator.ComputeAverageRoomTemplatesEntropy(mapDescription, layouts);
Assert.That(entropy, Is.GreaterThanOrEqualTo(0));
Assert.That(entropy, Is.LessThanOrEqualTo(1));
}
public void GetConfigurationSpaceOverCorridor_RoomShapesThatCannotBeCorrectlyConnected()
{
var roomShape1 = PolygonGrid2D.GetSquare(5);
var roomDoorsMode1 = new SimpleDoorMode(1, 0);
var roomShape2 = new PolygonGrid2DBuilder()
.AddPoint(0, 1)
.AddPoint(0, 2)
.AddPoint(2, 2)
.AddPoint(2, 0)
.AddPoint(1, 0)
.AddPoint(1, 1)
.Build();
var roomDoorsMode2 = new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(1, 1), new Vector2Int(0, 1)),
});
var corridor = PolygonGrid2D.GetSquare(2);
var corridorDoorsMode = new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(1, 0)),
new OrthogonalLineGrid2D(new Vector2Int(0, 2), new Vector2Int(1, 2)),
});
var configurationSpace = generator.GetConfigurationSpaceOverCorridor(roomShape2, roomDoorsMode2, roomShape1,
roomDoorsMode1, corridor, corridorDoorsMode);
Assert.That(configurationSpace.Lines.SelectMany(x => x.GetPoints()), Is.Empty);
}
public void OverlapArea_NonTouching_ReturnsZero()
{
var r1 = PolygonGrid2D.GetSquare(6);
var r2 = PolygonGrid2D.GetRectangle(2, 8);
Assert.AreEqual(0, polygonOverlap.OverlapArea(r1, new Vector2Int(0, 0), r2, new Vector2Int(7, 2)));
}
public void Run()
{
// Create square room template
var squareRoomTemplate = new RoomTemplateGrid2D(
PolygonGrid2D.GetSquare(8),
new SimpleDoorModeGrid2D(doorLength: 1, cornerDistance: 1)
);
// Create rectangle room template
var rectangleRoomTemplate = new RoomTemplateGrid2D(
PolygonGrid2D.GetRectangle(6, 10),
new SimpleDoorModeGrid2D(doorLength: 1, cornerDistance: 1)
);
// Create a room description which says that the room is not a corridor and that it can use the two room templates
var roomDescription = new RoomDescriptionGrid2D(
isCorridor: false,
roomTemplates: new List <RoomTemplateGrid2D>()
{
squareRoomTemplate, rectangleRoomTemplate
}
);
// Create an instance of the level description
var levelDescription = new LevelDescriptionGrid2D <int>();
// Add 4 rooms to the level, use the room description that we created beforehand
levelDescription.AddRoom(0, roomDescription);
levelDescription.AddRoom(1, roomDescription);
levelDescription.AddRoom(2, roomDescription);
levelDescription.AddRoom(3, roomDescription);
// Add connections between the rooms - the level graph will be a cycle with 4 vertices
levelDescription.AddConnection(0, 1);
levelDescription.AddConnection(0, 3);
levelDescription.AddConnection(1, 2);
levelDescription.AddConnection(2, 3);
// Create an instance of the generate and generate a layout
var generator = new GraphBasedGeneratorGrid2D <int>(levelDescription);
var layout = generator.GenerateLayout();
// Export the resulting layout as PNG
var drawer = new DungeonDrawer <int>();
drawer.DrawLayoutAndSave(layout, "simple_layout.png", new DungeonDrawerOptions()
{
Width = 2000,
Height = 2000,
});
var layout2 = generator.GenerateLayout();
// Export the resulting layout as PNG
drawer.DrawLayoutAndSave(layout, "simple_layout_2.png", new DungeonDrawerOptions()
{
Width = 2000,
Height = 2000,
});
}
private static List <RoomTemplate> GetRoomTemplates()
{
return(new List <RoomTemplate>()
{
new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 1)),
});
}
public void GetConfigurationSpaceOverCorridor_SquareRoomSquareCorridor()
{
var transformations = TransformationGrid2DHelper.GetAllTransformationsOld().ToList();
var basicRoomTemplate = new RoomTemplate(PolygonGrid2D.GetSquare(5), new SimpleDoorMode(1, 0), transformations);
var basicRoomTemplateInstance = generator.GetRoomTemplateInstances(basicRoomTemplate).First();
var corridorRoomTemplate = new RoomTemplate(PolygonGrid2D.GetSquare(2), new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(1, 0)),
new OrthogonalLineGrid2D(new Vector2Int(1, 0), new Vector2Int(2, 0)),
new OrthogonalLineGrid2D(new Vector2Int(0, 2), new Vector2Int(1, 2)),
new OrthogonalLineGrid2D(new Vector2Int(1, 2), new Vector2Int(2, 2)),
}), transformations);
var corridorRoomTemplateInstances = generator.GetRoomTemplateInstances(corridorRoomTemplate);
var expectedLines = new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(-7, -5), new Vector2Int(-7, 5)),
new OrthogonalLineGrid2D(new Vector2Int(7, -5), new Vector2Int(7, 5)),
new OrthogonalLineGrid2D(new Vector2Int(-5, 7), new Vector2Int(5, 7)),
new OrthogonalLineGrid2D(new Vector2Int(-5, -7), new Vector2Int(5, -7)),
};
var expectedPoints = expectedLines
.SelectMany(x => x.GetPoints())
.Distinct()
.ToList();
var configurationSpace = generator.GetConfigurationSpaceOverCorridors(basicRoomTemplateInstance,
basicRoomTemplateInstance, corridorRoomTemplateInstances);
Assert.That(configurationSpace.Lines.SelectMany(x => x.GetPoints()), Is.EquivalentTo(expectedPoints));
}
private List <RoomTemplate> GetMediumRoomTemplates()
{
var roomTemplates = new List <RoomTemplate>();
var doorMode = new SimpleDoorMode(2, 2);
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetSquare(12), doorMode, transformations, name: "Square 12x12", repeatMode: repeatMode));
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetSquare(14), doorMode, transformations, name: "Square 14x14", repeatMode: repeatMode));
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetRectangle(10, 14), doorMode, transformations, name: "Rectangle 10x14", repeatMode: repeatMode));
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetRectangle(12, 15), doorMode, transformations, name: "Rectangle 12x15", repeatMode: repeatMode));
//roomTemplates.Add(new RoomTemplate(
// new GridPolygonBuilder()
// .AddPoint(0, 0)
// .AddPoint(0, 16)
// .AddPoint(8, 16)
// .AddPoint(8, 8)
// .AddPoint(16, 8)
// .AddPoint(16, 0)
// .Build()
// , doorMode, transformations, name: "L-shape large", repeatMode: RepeatMode.NoRepeat));
if (enhanceRoomTemplates)
{
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetSquare(13), doorMode, transformations, name: "Square 13x13", repeatMode: repeatMode));
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetRectangle(10, 16), doorMode, transformations, name: "Rectangle 10x16", repeatMode: repeatMode));
}
return(roomTemplates);
}
public void SimpleMapDescriptionTest()
{
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 0), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetRectangle(5, 10), new SimpleDoorMode(1, 0), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomDescription1 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1
});
var roomDescription2 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate2
});
var mapDescription = new MapDescription <int>();
mapDescription.AddRoom(0, roomDescription1);
mapDescription.AddRoom(1, roomDescription2);
mapDescription.AddConnection(0, 1);
var dungeonGenerator = new DungeonGenerator <int>(mapDescription);
dungeonGenerator.InjectRandomGenerator(new Random(0));
var layout = dungeonGenerator.GenerateLayout();
Assert.That(layout, Is.Not.Null);
Assert.That(layout.Rooms.Count(), Is.EqualTo(2));
}
public void Generate_BasicTest()
{
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 0), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetRectangle(5, 10), new SimpleDoorMode(1, 0), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomDescription1 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1
});
var roomDescription2 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1, roomTemplate2
});
var mapDescription = new MapDescription <int>();
mapDescription.AddRoom(0, roomDescription1);
mapDescription.AddRoom(1, roomDescription2);
mapDescription.AddConnection(0, 1);
var configurationSpaces = generator.GetConfigurationSpaces <Configuration <CorridorsData> >(mapDescription);
Assert.That(configurationSpaces.GetShapesForNode(0).Count, Is.EqualTo(1));
Assert.That(configurationSpaces.GetShapesForNode(1).Count, Is.EqualTo(3));
Assert.That(configurationSpaces.GetAllShapes().Count, Is.EqualTo(3));
}
public void OverlapArea_TwoSquares()
{
var r1 = PolygonGrid2D.GetSquare(6);
var r2 = PolygonGrid2D.GetSquare(3);
Assert.AreEqual(6, polygonOverlap.OverlapArea(r1, new Vector2Int(0, 0), r2, new Vector2Int(2, -1)));
}
public void DoHaveMinimumDistance_TwoSquares()
{
var r1 = PolygonGrid2D.GetSquare(6);
var r2 = PolygonGrid2D.GetSquare(3);
Assert.IsTrue(polygonOverlap.DoHaveMinimumDistance(r1, new Vector2Int(0, 0), r2, new Vector2Int(10, 10), 4));
Assert.IsFalse(polygonOverlap.DoHaveMinimumDistance(r1, new Vector2Int(0, 0), r2, new Vector2Int(10, 10), 5));
Assert.IsFalse(polygonOverlap.DoHaveMinimumDistance(r1, new Vector2Int(0, 0), r2, new Vector2Int(3, 3), 0));
}
public void DoTouch_TwoSquares()
{
var r1 = PolygonGrid2D.GetSquare(6);
var r2 = PolygonGrid2D.GetSquare(3);
Assert.AreEqual(true, polygonOverlap.DoTouch(r1, new Vector2Int(0, 0), r2, new Vector2Int(6, 0)));
Assert.AreEqual(true, polygonOverlap.DoTouch(r1, new Vector2Int(0, 0), r2, new Vector2Int(6, -3)));
Assert.AreEqual(true, polygonOverlap.DoTouch(r1, new Vector2Int(0, 0), r2, new Vector2Int(6, -2)));
}
public void OverlapArea_PlusShapeAndSquare()
{
var p1 = GetPlusShape();
var p2 = PolygonGrid2D.GetSquare(3);
foreach (var degrees in PolygonGrid2D.PossibleRotations)
{
Assert.AreEqual(5, polygonOverlap.OverlapArea(p1.Rotate(degrees), new Vector2Int(0, 0), p2.Rotate(degrees), new Vector2Int(3, 3).RotateAroundCenter(degrees)));
}
}
public void OverlapAlongLine_Rectangles_OverlapStart2()
{
var p1 = PolygonGrid2D.GetSquare(5);
var p2 = PolygonGrid2D.GetRectangle(2, 3) + new Vector2Int(0, -3);
var line = new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(0, 10));
var result = polygonOverlap.OverlapAlongLine(p1, p2, line);
Assert.AreEqual(0, result.Count);
}
public void GetAllTransformations_ReturnsCorrectCount()
{
var square = PolygonGrid2D.GetSquare(1);
var rectangle = PolygonGrid2D.GetRectangle(1, 2);
var transformedSquares = square.GetAllTransformations();
var transformedRectangles = rectangle.GetAllTransformations();
Assert.That(transformedSquares.Count(), Is.EqualTo(8));
Assert.That(transformedRectangles.Count(), Is.EqualTo(8));
}
public void OverlapAlongLine_SquareAndL2()
{
var p1 = PolygonGrid2D.GetSquare(6);
var p2 = GetLShape();
var line = new OrthogonalLineGrid2D(new Vector2Int(3, 5), new Vector2Int(3, -2));
var result = polygonOverlap.OverlapAlongLine(p1, p2, line);
var expected = new List <Tuple <Vector2Int, bool> >()
{
Tuple.Create(new Vector2Int(3, 2), true),
};
Assert.IsTrue(expected.SequenceEqual(result));
}
public void OverlapAlongLine_Rectangles_OverlapEnd()
{
var p1 = PolygonGrid2D.GetSquare(5);
var p2 = PolygonGrid2D.GetRectangle(2, 3) + new Vector2Int(0, 8);
var line = new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(0, 10));
var result = polygonOverlap.OverlapAlongLine(p1, p2, line);
var expected = new List <Tuple <Vector2Int, bool> >()
{
Tuple.Create(new Vector2Int(0, 4), true),
};
Assert.IsTrue(expected.SequenceEqual(result));
}
public void Rotate_Square_ReturnsRotated()
{
var square = PolygonGrid2D.GetSquare(4);
var rotatedSquare = square.Rotate(180);
var expectedPoints = new List <Vector2Int>()
{
new Vector2Int(0, 0),
new Vector2Int(0, -4),
new Vector2Int(-4, -4),
new Vector2Int(-4, 0),
};
Assert.IsTrue(expectedPoints.SequenceEqual(rotatedSquare.GetPoints()));
}
public void GetRoomTemplateInstances_SquareAllTransformations_ReturnsOneInstance()
{
var roomShape = PolygonGrid2D.GetSquare(10);
var doorsMode = new SimpleDoorMode(1, 0);
var transformations = ((TransformationGrid2D[])Enum.GetValues(typeof(TransformationGrid2D))).ToList();
var roomTemplate = new RoomTemplate(roomShape, doorsMode, transformations);
var instances = generator.GetRoomTemplateInstances(roomTemplate);
Assert.That(instances.Count, Is.EqualTo(1));
Assert.That(instances[0].RoomTemplate, Is.EqualTo(roomTemplate));
Assert.That(instances[0].RoomShape, Is.EqualTo(roomShape));
Assert.That(instances[0].Transformations, Is.EquivalentTo(transformations));
}
public static List <RoomTemplate> GetRectangularRoomTemplates(Vector2Int scale)
{
var overlapScale = Math.Min(scale.X, scale.Y);
var doorMode = new SimpleDoorMode(1 * overlapScale, 0);
var transformations = TransformationGrid2DHelper.GetAllTransformationsOld().ToList();
var squareRoom = new RoomTemplate(PolygonGrid2D.GetSquare(6).Scale(scale), doorMode, transformations, name: "Square");
var rectangleRoom = new RoomTemplate(PolygonGrid2D.GetRectangle(6, 9).Scale(scale), doorMode, transformations, name: "Rectangle");
return(new List <RoomTemplate>()
{
squareRoom,
rectangleRoom,
});
}
public void DoOverlap_NonOverlappingPolygons_ReturnsFalse()
{
{
var p1 = GetLShape().Rotate(90);
var p2 = PolygonGrid2D.GetSquare(3);
Assert.IsFalse(polygonOverlap.DoOverlap(p1, new Vector2Int(0, 0), p2, new Vector2Int(0, 0)));
}
{
var p1 = GetPlusShape();
var p2 = PolygonGrid2D.GetRectangle(2, 3);
Assert.IsFalse(polygonOverlap.DoOverlap(p1, new Vector2Int(0, 0), p2, new Vector2Int(4, 4)));
}
}
public void GetConfigurationSpaceOverCorridor_SquareRoomLShapedCorridor()
{
var roomShape = PolygonGrid2D.GetSquare(5);
var roomDoorsMode = new SimpleDoorMode(1, 0);
var corridor = new PolygonGrid2DBuilder()
.AddPoint(0, 1)
.AddPoint(0, 2)
.AddPoint(2, 2)
.AddPoint(2, 0)
.AddPoint(1, 0)
.AddPoint(1, 1)
.Build();
var corridorDoorsMode = new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(0, 1), new Vector2Int(0, 2)),
new OrthogonalLineGrid2D(new Vector2Int(2, 0), new Vector2Int(1, 0)),
});
var expectedLines = new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(-6, 2), new Vector2Int(-6, 6)), // Left side
new OrthogonalLineGrid2D(new Vector2Int(-5, 2), new Vector2Int(-5, 6)),
new OrthogonalLineGrid2D(new Vector2Int(-6, 6), new Vector2Int(-2, 6)), // Top side
new OrthogonalLineGrid2D(new Vector2Int(-6, 5), new Vector2Int(-2, 5)),
new OrthogonalLineGrid2D(new Vector2Int(2, -6), new Vector2Int(6, -6)), // Bottom side
new OrthogonalLineGrid2D(new Vector2Int(2, -5), new Vector2Int(6, -5)),
new OrthogonalLineGrid2D(new Vector2Int(5, -2), new Vector2Int(5, -6)), // Right side
new OrthogonalLineGrid2D(new Vector2Int(6, -2), new Vector2Int(6, -6)),
};
var expectedPoints = expectedLines
.SelectMany(x => x.GetPoints())
.Distinct()
.ToList();
var configurationSpace = generator.GetConfigurationSpaceOverCorridor(roomShape, roomDoorsMode, roomShape,
roomDoorsMode, corridor, corridorDoorsMode);
var configurationSpacePoints = configurationSpace
.Lines
.SelectMany(x => x.GetPoints())
.ToList();
Assert.That(configurationSpacePoints, Is.EquivalentTo(expectedPoints));
}
public void DoHaveMinimumDistance_TwoPolygons()
{
var p1 = GetLShape();
var p2 = PolygonGrid2D.GetSquare(3);
foreach (var degrees in PolygonGrid2D.PossibleRotations)
{
var pr1 = p1.Rotate(degrees);
var pr2 = p2.Rotate(degrees);
var pos1 = new Vector2Int(0, 0).RotateAroundCenter(degrees);
var pos2 = new Vector2Int(6, 6).RotateAroundCenter(degrees);
Assert.IsTrue(polygonOverlap.DoHaveMinimumDistance(pr1, pos1, pr2, pos2, 3));
Assert.IsFalse(polygonOverlap.DoHaveMinimumDistance(pr1, pos1, pr2, pos2, 4));
}
}
private List <RoomTemplate> GetSmallRoomTemplates()
{
var roomTemplates = new List <RoomTemplate>();
var doorMode = new SimpleDoorMode(2, 1);
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetSquare(6), doorMode, transformations, name: "Square 6x6", repeatMode: repeatMode));
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetSquare(8), doorMode, transformations, name: "Square 8x8", repeatMode: repeatMode));
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetRectangle(6, 8), doorMode, transformations, name: "Rectangle 6x8", repeatMode: repeatMode));
if (enhanceRoomTemplates)
{
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetSquare(7), doorMode, transformations, name: "Square 7x7", repeatMode: repeatMode));
roomTemplates.Add(new RoomTemplate(PolygonGrid2D.GetRectangle(5, 7), doorMode, transformations, name: "Rectangle 5x7", repeatMode: repeatMode));
}
return(roomTemplates);
}
public void GetRoomTemplateInstances_SquareIdentity_ReturnsOneInstance()
{
var roomShape = PolygonGrid2D.GetSquare(10);
var doorsMode = new SimpleDoorMode(1, 0);
var transformations = new List <TransformationGrid2D>()
{
TransformationGrid2D.Identity
};
var roomTemplate = new RoomTemplate(roomShape, doorsMode, transformations);
var instances = generator.GetRoomTemplateInstances(roomTemplate);
Assert.That(instances.Count, Is.EqualTo(1));
Assert.That(instances[0].RoomTemplate, Is.EqualTo(roomTemplate));
Assert.That(instances[0].RoomShape, Is.EqualTo(roomShape));
Assert.That(instances[0].Transformations, Is.EquivalentTo(transformations));
}
public void DoTouch_TwoPolygons()
{
var p1 = GetLShape();
var p2 = PolygonGrid2D.GetSquare(3);
foreach (var degrees in PolygonGrid2D.PossibleRotations)
{
var pr1 = p1.Rotate(degrees);
var pr2 = p2.Rotate(degrees);
var pos1 = new Vector2Int(0, 0).RotateAroundCenter(degrees);
var pos2 = new Vector2Int(4, 3).RotateAroundCenter(degrees);
Assert.AreEqual(true, polygonOverlap.DoTouch(pr1, pos1, pr2, pos2));
Assert.AreEqual(true, polygonOverlap.DoTouch(pr1, pos1, pr2, pos2, 2));
Assert.AreEqual(false, polygonOverlap.DoTouch(pr1, pos1, pr2, pos2, 3));
}
}
private RoomDescriptionGrid2D GetBasicRoomDescription()
{
var doors = new SimpleDoorModeGrid2D(doorLength: 1, cornerDistance: 1);
var transformations = new List <TransformationGrid2D>()
{
TransformationGrid2D.Identity,
TransformationGrid2D.Rotate90
};
var squareRoom1 = new RoomTemplateGrid2D(
PolygonGrid2D.GetSquare(8),
doors,
name: "Square 8x8",
allowedTransformations: transformations
);
var squareRoom2 = new RoomTemplateGrid2D(
PolygonGrid2D.GetSquare(6),
doors,
name: "Square 6x6",
allowedTransformations: transformations
);
var rectangleRoom = new RoomTemplateGrid2D(
PolygonGrid2D.GetRectangle(6, 10),
doors,
name: "Rectangle 6x10",
allowedTransformations: transformations
);
return(new RoomDescriptionGrid2D
(
isCorridor: false,
roomTemplates: new List <RoomTemplateGrid2D>()
{
squareRoom1,
squareRoom2,
rectangleRoom
}
));
}
public void GetRoomTemplateInstances_SquareAllTransformationsOneDoor_ReturnsFourInstance()
{
var roomShape = PolygonGrid2D.GetSquare(10);
var doorsMode = new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(1, 0))
});
var transformations = TransformationGrid2DHelper.GetAllTransformationsOld().ToList();
var expectedDoorPositions = new Dictionary <TransformationGrid2D, DoorLine>()
{
{ TransformationGrid2D.Identity, new DoorLine(new OrthogonalLineGrid2D(new Vector2Int(1, 0), new Vector2Int(1, 0)), 1) },
{ TransformationGrid2D.Rotate90, new DoorLine(new OrthogonalLineGrid2D(new Vector2Int(0, 9), new Vector2Int(0, 9)), 1) },
{ TransformationGrid2D.Rotate180, new DoorLine(new OrthogonalLineGrid2D(new Vector2Int(9, 10), new Vector2Int(9, 10)), 1) },
{ TransformationGrid2D.Rotate270, new DoorLine(new OrthogonalLineGrid2D(new Vector2Int(10, 1), new Vector2Int(10, 1)), 1) },
{ TransformationGrid2D.MirrorY, new DoorLine(new OrthogonalLineGrid2D(new Vector2Int(10, 0), new Vector2Int(10, 0)), 1) },
{ TransformationGrid2D.MirrorX, new DoorLine(new OrthogonalLineGrid2D(new Vector2Int(0, 10), new Vector2Int(0, 10)), 1) },
{ TransformationGrid2D.Diagonal13, new DoorLine(new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(0, 0)), 1) },
{ TransformationGrid2D.Diagonal24, new DoorLine(new OrthogonalLineGrid2D(new Vector2Int(10, 10), new Vector2Int(10, 10)), 1) },
};
var roomTemplate = new RoomTemplate(roomShape, doorsMode, transformations);
var instances = generator.GetRoomTemplateInstances(roomTemplate);
Assert.That(instances.Count, Is.EqualTo(8));
foreach (var instance in instances)
{
Assert.That(instance.RoomShape, Is.EqualTo(roomShape));
Assert.That(instance.Transformations.Count, Is.EqualTo(1));
var transformation = instance.Transformations[0];
Assert.That(instance.DoorLines.Count, Is.EqualTo(1));
Assert.That(instance.DoorLines[0].Length, Is.EqualTo(expectedDoorPositions[transformation].Length));
Assert.That(instance.DoorLines[0].Line, Is.EqualTo(expectedDoorPositions[transformation].Line));
}
}
