public void OverlapArea_NonTouching_ReturnsZero()
{
var r1 = GridPolygon.GetSquare(6);
var r2 = GridPolygon.GetRectangle(2, 8);
Assert.AreEqual(0, polygonOverlap.OverlapArea(r1, new IntVector2(0, 0), r2, new IntVector2(7, 2)));
}
public void OverlapArea_TwoSquares()
{
var r1 = GridPolygon.GetSquare(6);
var r2 = GridPolygon.GetSquare(3);
Assert.AreEqual(6, polygonOverlap.OverlapArea(r1, new IntVector2(0, 0), r2, new IntVector2(2, -1)));
}
public MapDescription<int> GetMapDescription()
{
var mapDescription = new MapDescription<int>();
mapDescription.SetupWithGraph(GraphsDatabase.GetExample5());
// Add room shapes
var doorMode = new OverlapMode(1, 1);
var squareRoomBig = new RoomDescription(
GridPolygon.GetSquare(8),
doorMode
);
var squareRoomSmall = new RoomDescription(
GridPolygon.GetSquare(6),
doorMode
);
var rectangleRoomBig = new RoomDescription(
GridPolygon.GetRectangle(8, 12),
doorMode
);
var rectangleRoomSmall = new RoomDescription(
GridPolygon.GetRectangle(6, 10),
doorMode
);
mapDescription.AddRoomShapes(squareRoomBig, probability: 10);
mapDescription.AddRoomShapes(squareRoomSmall);
mapDescription.AddRoomShapes(rectangleRoomBig);
mapDescription.AddRoomShapes(rectangleRoomSmall);
return mapDescription;
}
public MapDescription <int> GetMapDescription()
{
var mapDescription = new MapDescription <int>();
// Add rooms ( - you would normally use a for cycle)
mapDescription.AddRoom(0);
mapDescription.AddRoom(1);
mapDescription.AddRoom(2);
mapDescription.AddRoom(3);
// Add passages
mapDescription.AddPassage(0, 1);
mapDescription.AddPassage(0, 3);
mapDescription.AddPassage(1, 2);
mapDescription.AddPassage(2, 3);
// Add room shapes
var doorMode = new OverlapMode(1, 1);
var squareRoom = new RoomDescription(
GridPolygon.GetSquare(8),
doorMode
);
var rectangleRoom = new RoomDescription(
GridPolygon.GetRectangle(6, 10),
doorMode
);
mapDescription.AddRoomShapes(squareRoom);
mapDescription.AddRoomShapes(rectangleRoom);
return(mapDescription);
}
public void Generate_BasicTest()
{
// This test cannot check if the generated configuration spaces are valid
var mapDescription = new MapDescription <int>();
var squareRoom = new RoomDescription(GridPolygon.GetSquare(3), new OverlapMode(1, 0));
var rectangleRoom = new RoomDescription(GridPolygon.GetRectangle(4, 5), new OverlapMode(1, 1));
mapDescription.AddRoomShapes(squareRoom);
mapDescription.AddRoomShapes(rectangleRoom, probability: 0.5d);
mapDescription.AddRoom(0);
mapDescription.AddRoom(1);
mapDescription.AddPassage(0, 1);
mapDescription.AddRoomShapes(1, rectangleRoom, new List <Transformation>()
{
Transformation.Identity
});
// var configurationSpaces = generator.Generate(mapDescription);
Assert.IsTrue(false); // TODO: repair
//Assert.AreEqual(3, configurationSpaces.GetShapesForNode(0).Count);
//Assert.AreEqual(1, configurationSpaces.GetShapesForNode(1).Count);
}
public void DoTouch_TwoSquares()
{
var r1 = GridPolygon.GetSquare(6);
var r2 = GridPolygon.GetSquare(3);
Assert.AreEqual(true, polygonOverlap.DoTouch(r1, new IntVector2(0, 0), r2, new IntVector2(6, 0)));
Assert.AreEqual(false, polygonOverlap.DoTouch(r1, new IntVector2(0, 0), r2, new IntVector2(6, -3)));
Assert.AreEqual(true, polygonOverlap.DoTouch(r1, new IntVector2(0, 0), r2, new IntVector2(6, -2)));
}
public void OverlapArea_PlusShapeAndSquare()
{
var p1 = GetPlusShape();
var p2 = GridPolygon.GetSquare(3);
foreach (var degrees in GridPolygon.PossibleRotations)
{
Assert.AreEqual(5, polygonOverlap.OverlapArea(p1.Rotate(degrees), new IntVector2(0, 0), p2.Rotate(degrees), new IntVector2(3, 3).RotateAroundCenter(degrees)));
}
}
public void OverlapAlongLine_Rectangles_OverlapStart2()
{
var p1 = GridPolygon.GetSquare(5);
var p2 = GridPolygon.GetRectangle(2, 3) + new IntVector2(0, -3);
var line = new OrthogonalLine(new IntVector2(0, 0), new IntVector2(0, 10));
var result = polygonOverlap.OverlapAlongLine(p1, p2, line);
Assert.AreEqual(0, result.Count);
}
private Room <int> GetRoom(IntVector2 position, IntVector2 roomShapeOrigin, Transformation transformation, List <Transformation> transformations)
{
return(new Room <int>(0,
GridPolygon.GetSquare(10),
position,
false,
new RoomDescription(GridPolygon.GetSquare(10) + roomShapeOrigin, new OverlapMode(1, 0)),
transformation,
transformations));
}
public void GetAllTransformations_ReturnsCorrectCount()
{
var square = GridPolygon.GetSquare(1);
var rectangle = GridPolygon.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 = GridPolygon.GetSquare(6);
var p2 = GetLShape();
var line = new OrthogonalLine(new IntVector2(3, 5), new IntVector2(3, -2));
var result = polygonOverlap.OverlapAlongLine(p1, p2, line);
var expected = new List <Tuple <IntVector2, bool> >()
{
Tuple.Create(new IntVector2(3, 2), true),
};
Assert.IsTrue(expected.SequenceEqual(result));
}
public void Rotate_Square_ReturnsRotated()
{
var square = GridPolygon.GetSquare(4);
var rotatedSquare = square.Rotate(180);
var expectedPoints = new List <IntVector2>()
{
new IntVector2(0, 0),
new IntVector2(0, -4),
new IntVector2(-4, -4),
new IntVector2(-4, 0),
};
Assert.IsTrue(expectedPoints.SequenceEqual(rotatedSquare.GetPoints()));
}
public void OverlapAlongLine_Rectangles_OverlapEnd()
{
var p1 = GridPolygon.GetSquare(5);
var p2 = GridPolygon.GetRectangle(2, 3) + new IntVector2(0, 8);
var line = new OrthogonalLine(new IntVector2(0, 0), new IntVector2(0, 10));
var result = polygonOverlap.OverlapAlongLine(p1, p2, line);
var expected = new List <Tuple <IntVector2, bool> >()
{
Tuple.Create(new IntVector2(0, 4), true),
};
Assert.IsTrue(expected.SequenceEqual(result));
}
/// <summary>
/// Adds basic room shapes to a given map description.
/// </summary>
/// <typeparam name="TNode"></typeparam>
/// <param name="mapDescription"></param>
/// <param name="scale"></param>
/// <returns></returns>
public static MapDescription <TNode> AddClassicRoomShapes <TNode>(this MapDescription <TNode> mapDescription,
IntVector2 scale)
{
var overlapScale = Math.Min(scale.X, scale.Y);
var doorMode = new OverlapMode(1 * overlapScale, 0);
var squareRoom = new RoomDescription(GridPolygon.GetSquare(6).Scale(scale), doorMode);
var rectangleRoom = new RoomDescription(GridPolygon.GetRectangle(6, 9).Scale(scale), doorMode);
var room1 = new RoomDescription(
new GridPolygonBuilder()
.AddPoint(0, 0)
.AddPoint(0, 6)
.AddPoint(3, 6)
.AddPoint(3, 3)
.AddPoint(6, 3)
.AddPoint(6, 0)
.Build().Scale(scale)
, doorMode);
var room2 = new RoomDescription(
new GridPolygonBuilder()
.AddPoint(0, 0)
.AddPoint(0, 9)
.AddPoint(3, 9)
.AddPoint(3, 3)
.AddPoint(6, 3)
.AddPoint(6, 0)
.Build().Scale(scale)
, doorMode);
var room3 = new RoomDescription(
new GridPolygonBuilder()
.AddPoint(0, 0)
.AddPoint(0, 3)
.AddPoint(3, 3)
.AddPoint(3, 6)
.AddPoint(6, 6)
.AddPoint(6, 3)
.AddPoint(9, 3)
.AddPoint(9, 0)
.Build().Scale(scale)
, doorMode);
mapDescription.AddRoomShapes(squareRoom, probability: 4);
mapDescription.AddRoomShapes(rectangleRoom, probability: 2);
mapDescription.AddRoomShapes(room1);
mapDescription.AddRoomShapes(room2);
mapDescription.AddRoomShapes(room3);
return(mapDescription);
}
public void DoOverlap_OverlappingPolygons_ReturnsTrue()
{
{
var p1 = GetLShape();
var p2 = GridPolygon.GetSquare(3);
Assert.IsTrue(polygonOverlap.DoOverlap(p1, new IntVector2(0, 0), p2, new IntVector2(3, 0)));
}
{
var p1 = GetPlusShape();
var p2 = GridPolygon.GetRectangle(2, 3);
Assert.IsTrue(polygonOverlap.DoOverlap(p1, new IntVector2(0, 0), p2, new IntVector2(3, 4)));
}
}
public void DoTouch_TwoPolygons()
{
var p1 = GetLShape();
var p2 = GridPolygon.GetSquare(3);
foreach (var degrees in GridPolygon.PossibleRotations)
{
var pr1 = p1.Rotate(degrees);
var pr2 = p2.Rotate(degrees);
var pos1 = new IntVector2(0, 0).RotateAroundCenter(degrees);
var pos2 = new IntVector2(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));
}
}
public MapDescription <int> GetMapDescription()
{
var mapDescription = new MapDescription <int>();
mapDescription.SetupWithGraph(GraphsDatabase.GetExample1());
// Add room shapes
var doorMode = new OverlapMode(1, 1);
var squareRoom = new RoomDescription(
GridPolygon.GetSquare(8),
doorMode
);
var rectangleRoom = new RoomDescription(
GridPolygon.GetRectangle(6, 10),
doorMode
);
mapDescription.AddRoomShapes(squareRoom);
mapDescription.AddRoomShapes(rectangleRoom);
// Setup corridor shapes
var corridorRoom = new RoomDescription(
GridPolygon.GetSquare(1),
new SpecificPositionsMode(new List <OrthogonalLine>()
{
new OrthogonalLine(new IntVector2(0, 0), new IntVector2(1, 0)),
new OrthogonalLine(new IntVector2(0, 1), new IntVector2(1, 1))
})
);
mapDescription.AddCorridorShapes(corridorRoom);
// Enable corridors
mapDescription.SetWithCorridors(true, new List <int>()
{
1
});
return(mapDescription);
}
public void Plus_ReturnsTranslated()
{
{
var p = GridPolygon.GetSquare(3);
var amount = new IntVector2(2, 3);
var translated = p + amount;
var expected = new GridPolygon(p.GetPoints().Select(x => x + amount));
Assert.AreEqual(expected, translated);
}
{
var p = GridPolygon.GetRectangle(2, 4);
var amount = new IntVector2(-3, 5);
var translated = p + amount;
var expected = new GridPolygon(p.GetPoints().Select(x => x + amount));
Assert.AreEqual(expected, translated);
}
}
public void Scale_ReturnsScaled()
{
{
var p = GridPolygon.GetSquare(3);
var factor = new IntVector2(2, 3);
var scaled = p.Scale(factor);
var expected = GridPolygon.GetRectangle(6, 9);
Assert.AreEqual(expected, scaled);
}
{
/*var p = GridPolygon.GetRectangle(2, 4);
* var factor = new IntVector2(-3, 5);
*
* var scaled = p.Scale(factor);
* var expected = GridPolygon.GetRectangle(-6, 20);
*
* Assert.AreEqual(expected, scaled);*/
}
}
public void OverlapAlongLine_SquareAndL3()
{
var p1 = GridPolygon.GetSquare(6);
var p2 = new GridPolygonBuilder()
.AddPoint(0, 0)
.AddPoint(0, 6)
.AddPoint(6, 6)
.AddPoint(6, 3)
.AddPoint(3, 3)
.AddPoint(3, 0)
.Build();
var line = new OrthogonalLine(new IntVector2(3, 2), new IntVector2(3, -5));
var result = polygonOverlap.OverlapAlongLine(p1, p2, line);
var expected = new List <Tuple <IntVector2, bool> >()
{
Tuple.Create(new IntVector2(3, 2), true),
Tuple.Create(new IntVector2(3, -3), false),
};
Assert.IsTrue(expected.SequenceEqual(result));
}
public void GetConfigurationSpace_OverlapOne()
{
var p1 = GridPolygon.GetSquare(3);
var p2 = GridPolygon.GetSquare(5);
var configurationSpace = generator.GetConfigurationSpace(p1, new OverlapMode(1, 1), p2, new OverlapMode(1, 1));
var expectedPoints = new List <IntVector2>();
var actualPoints = configurationSpace.Lines.Select(x => x.GetPoints()).SelectMany(x => x).ToList();
{
// Top side of fixed
var points = new OrthogonalLine(new IntVector2(0, 5), new IntVector2(2, 5)).GetPoints();
expectedPoints.AddRange(points);
Assert.AreEqual(points.Count, actualPoints.Intersect(points).Count());
}
{
// Bottom side of fixed
var points = new OrthogonalLine(new IntVector2(0, -3), new IntVector2(2, -3)).GetPoints();
expectedPoints.AddRange(points);
Assert.AreEqual(points.Count, actualPoints.Intersect(points).Count());
}
{
// Right side of fixed
var points = new OrthogonalLine(new IntVector2(5, 2), new IntVector2(5, 0)).GetPoints();
expectedPoints.AddRange(points);
Assert.AreEqual(points.Count, actualPoints.Intersect(points).Count());
}
{
// Left side of fixed
var points = new OrthogonalLine(new IntVector2(-3, 0), new IntVector2(-3, 2)).GetPoints();
expectedPoints.AddRange(points);
Assert.AreEqual(points.Count, actualPoints.Intersect(points).Count());
}
Assert.AreEqual(expectedPoints.Distinct().Count(), actualPoints.Count);
}
public MapDescription<int> GetMapDescription()
{
var mapDescription = new MapDescription<int>();
mapDescription.SetupWithGraph(GraphsDatabase.GetExample2());
// Add room shapes
var doorMode = new OverlapMode(1, 1);
var squareRoom = new RoomDescription(
GridPolygon.GetSquare(8),
doorMode
);
var rectangleRoom = new RoomDescription(
GridPolygon.GetRectangle(6, 10),
doorMode
);
mapDescription.AddRoomShapes(squareRoom);
mapDescription.AddRoomShapes(rectangleRoom);
// Add boss room shape
var bossRoom = new RoomDescription(
new GridPolygonBuilder()
.AddPoint(2, 0).AddPoint(2, 1).AddPoint(1, 1).AddPoint(1, 2)
.AddPoint(0, 2).AddPoint(0, 7).AddPoint(1, 7).AddPoint(1, 8)
.AddPoint(2, 8).AddPoint(2, 9).AddPoint(7, 9).AddPoint(7, 8)
.AddPoint(8, 8).AddPoint(8, 7).AddPoint(9, 7).AddPoint(9, 2)
.AddPoint(8, 2).AddPoint(8, 1).AddPoint(7, 1).AddPoint(7, 0)
.Build().Scale(new IntVector2(2, 2)),
new OverlapMode(1, 1)
);
mapDescription.AddRoomShapes(8, bossRoom);
return mapDescription;
}