public void TestCircleCircleCollision()
{
// Import data
var circle = Circles.Circle;
var results = CircleCircleTest.CircleCircleResults;
for (int obj = 0; obj < results.Length; obj++)
{
CollisionResult result;
//Create circle objects
CircleShape firstCircle = new CircleShape(circle[results[obj].FirstShape].Center,
circle[results[obj].FirstShape].Radius);
CircleShape secondCircle = new CircleShape(circle[results[obj].SecondShape].Center,
circle[results[obj].SecondShape].Radius);
// Transform circles
Collision.Transform firstCircleTransform =
new Collision.Transform(circle[results[obj].FirstShape].Trans,
circle[results[obj].FirstShape].Rotate);
Collision.Transform secondCircleTransform =
new Collision.Transform(circle[results[obj].SecondShape].Trans,
circle[results[obj].SecondShape].Rotate);
var testResult = firstCircle.IntersectsWith(firstCircleTransform, secondCircle,
secondCircleTransform, out result);
string err = String.Format("Circle to Circle test({0}) failed; Circle1_ID: {1}, Circle2_ID: {2}",
obj, results[obj].FirstShape, results[obj].SecondShape);
Assert.That(results[obj].Result == testResult, err);
}
}
public void TestCirclePolygonCollision()
{
// Import data
var circle = Circles.Circle;
var poly = Polygons.Poly;
var results = CirclePolyTest.CirclePolyResults;
for (int obj = 0; obj < results.Length; obj++)
{
CollisionResult result;
//Create objects
CircleShape circleShape = new CircleShape(circle[results[obj].FirstShape].Center,
circle[results[obj].FirstShape].Radius);
Collision.Transform circleTransform =
new Collision.Transform(circle[results[obj].FirstShape].Trans,
circle[results[obj].FirstShape].Rotate);
PolygonShape polShape = new PolygonShape(poly[results[obj].SecondShape].Points);
Collision.Transform polTransform =
new Collision.Transform(poly[results[obj].SecondShape].Trans,
poly[results[obj].SecondShape].Rotate);
var testResult = circleShape.IntersectsWith(circleTransform, polShape,
polTransform, out result);
string err = String.Format(
"Circle to Polygon test({0}) failed; Circle_ID: {1}, Polygon_ID: {2}",
obj, results[obj].FirstShape, results[obj].SecondShape);
Assert.That(results[obj].Result == testResult, err);
}
}
public void TestCircleRectangleCollision()
{
// Import data
var circle = Circles.Circle;
var rect = Rects.Rect;
var results = CircleRectTest.CircleRectResults;
for (int obj = 0; obj < results.Length; obj++)
{
CollisionResult result;
//Create objects
CircleShape circleShape = new CircleShape(circle[results[obj].FirstShape].Center,
circle[results[obj].FirstShape].Radius);
Collision.Transform circleTransform =
new Collision.Transform(circle[results[obj].FirstShape].Trans,
circle[results[obj].FirstShape].Rotate);
RectangleShape rectShape =
new RectangleShape(rect[results[obj].SecondShape].Center, rect[results[obj].SecondShape].Width,
rect[results[obj].SecondShape].Height);
Collision.Transform rectTransform =
new Collision.Transform(rect[results[obj].SecondShape].Trans,
rect[results[obj].SecondShape].Rotate);
var testResult = circleShape.IntersectsWith(circleTransform, rectShape,
rectTransform, out result);
string err = String.Format(
"Circle to Rectangle test({0}) failed; Circle_ID: {1}, Rectangle_ID: {2}",
obj, results[obj].FirstShape, results[obj].SecondShape);
Assert.That(results[obj].Result == testResult, err);
}
}
public void TestPolygonCircleCollision()
{
PolygonShape polyShape = new PolygonShape(new Vector2[]
{
new Vector2(2.291772f, 0.6106892f),
new Vector2(2.80672f, 1.035656f),
new Vector2(3.09072f, 1.088906f),
new Vector2(3.436845f, 0.9380314f),
new Vector2(3.556658f, 0.649594f),
new Vector2(3.525595f, 0.383344f),
new Vector2(3.290365f, 0.03150498f),
new Vector2(2.9109f, -0.288045f)
});
Collision.Transform polyTransform = new Collision.Transform(new Vector2(10.47f, -5.44f), -1.349715f);
CircleShape circleShape = new CircleShape(new Vector2(0, 0), 0.01f);
Collision.Transform circleTransform = new Collision.Transform(new Vector2(11.51633f, -8.27487f), 5.145f);
// circle and poly should collide
CollisionResult result;
Assert.That(polyShape.IntersectsWith(polyTransform, circleShape, circleTransform, out result), "PolygonCircle collision failed");
// should not collide in this case
Collision.Transform anotherCircleTransform = new Collision.Transform(new Vector2(15.51633f, -8.27487f), 5.145f);
Assert.That(!polyShape.IntersectsWith(polyTransform, circleShape, anotherCircleTransform, out result), "PolygonCircle collision failed");
}
public void TestPolygonPolygonCollision()
{
// Import data
var poly = Polygons.Poly;
var results = PolyPolyTest.PolyPolyResults;
for (int obj = 0; obj < results.Length; obj++)
{
CollisionResult result;
// Create polygon objects
PolygonShape firstPol = new PolygonShape(poly[results[obj].FirstShape].Points);
PolygonShape secondPol = new PolygonShape(poly[results[obj].SecondShape].Points);
// Transform polygons
Collision.Transform firstPolTransform =
new Collision.Transform(poly[results[obj].FirstShape].Trans,
poly[results[obj].FirstShape].Rotate);
Collision.Transform secondPolTransform =
new Collision.Transform(poly[results[obj].SecondShape].Trans,
poly[results[obj].SecondShape].Rotate);
var testResult = firstPol.IntersectsWith(firstPolTransform, secondPol,
secondPolTransform, out result);
string err = String.Format("Polygon to Polygon test({0}) failed; Polygon({1}), Polygon({2})",
obj, results[obj].FirstShape, results[obj].SecondShape);
Assert.That(results[obj].Result == testResult, err);
}
}
public void TestRectangleRectangleCollision()
{
// Import data
var rect = Rects.Rect;
var results = RectRectTest.RectRectResults;
for (int obj = 0; obj < results.Length; obj++)
{
CollisionResult result;
//Create rectangle objects
RectangleShape firstRect =
new RectangleShape(rect[results[obj].FirstShape].Center, rect[results[obj].FirstShape].Width,
rect[results[obj].FirstShape].Height);
RectangleShape secondRect =
new RectangleShape(rect[results[obj].SecondShape].Center, rect[results[obj].SecondShape].Width,
rect[results[obj].SecondShape].Height);
// Transform Rectangles
Collision.Transform firstRectTransform =
new Collision.Transform(rect[results[obj].FirstShape].Trans,
rect[results[obj].FirstShape].Rotate);
Collision.Transform secondRectTransform =
new Collision.Transform(rect[results[obj].SecondShape].Trans,
rect[results[obj].SecondShape].Rotate);
var testResult = firstRect.IntersectsWith(firstRectTransform, secondRect,
secondRectTransform, out result);
string err = String.Format(
"Rectangle to Rectangle test({0}) failed; Rectangle({1}), Rectangle({2})",
obj, results[obj].FirstShape, results[obj].SecondShape);
Assert.That(results[obj].Result == testResult, err);
}
}
public void SingleTestRectRectCollision()
{
Vector2[] firstPol =
{
new Vector2(-58.99589f, -180.19639f), new Vector2(-173.56437f, 156.44204f),
new Vector2(-116.36934f, 143.46347f),
new Vector2(85.68483f, 64.82733f), new Vector2(175.23662f, -90.592f)
};
Vector2[] secondPol =
{
new Vector2(-196.38893f, -132.43044f), new Vector2(43.23116f, 78.08958f),
new Vector2(-65.40522f, -98.55061f)
};
CollisionResult result;
//Create rectangle objects
PolygonShape firstPolShape = new PolygonShape(firstPol);
PolygonShape secondPolShape = new PolygonShape(secondPol);
// Transform Shapes
Collision.Transform firstPolTransform =
new Collision.Transform(new Vector2(152.17828f, -197.50353f), 3.57942f);
Collision.Transform secondPolTransform =
new Collision.Transform(new Vector2(-55.65048f, -119.74799f), 4.94887f);
// Make test
var testResult = firstPolShape.IntersectsWith(firstPolTransform, secondPolShape,
secondPolTransform, out result);
Assert.That(testResult, "Error Kobzar");
Console.Write("Point: {0} \n", result.Points[0]);
Console.Write("Normal: {0}", result.Normals[0]);
}
public void TestPointCircleCollision()
{
// true results
bool[] trueResults = { false, true, false, false, true };
// Points coordinates
float[] pointX = { -2.0f, 0, 2.0f, 2.0f, 0 };
float[] pointY = { -2.0f, 0, 2.0f, -2.0f, 2.0f };
//Create circle obj
CircleShape circleShape = new CircleShape(Vector2.Zero, 2.0f);
// Transform circle to x=0, y=0, r=2
Collision.Transform circleTransform = new Collision.Transform(Vector2.Zero, 0);
// Create point obj
PointShape point = new PointShape(Vector2.Zero);
//Create points and check collisions
for (var obj = 0; obj < trueResults.Length; obj++)
{
CollisionResult result;
Collision.Transform pointTranform =
new Collision.Transform(new Vector2(pointX[obj], pointY[obj]), 0);
var testResult = circleShape.IntersectsWith(circleTransform, point, pointTranform, out result);
string err = String.Format("Point to Circle test({0}) failed; Circle:(0,0,2), Point({1}, {2})",
obj, pointX[obj], pointY[obj]);
Assert.That(trueResults[obj] == testResult, err);
}
}
public void TestRectanglePolygonCollision()
{
// Import data
var rect = Rects.Rect;
var poly = Polygons.Poly;
var results = RectPolyTest.RectPolyResults;
for (int obj = 0; obj < results.Length; obj++)
{
CollisionResult result;
//Create objects
RectangleShape rectShape =
new RectangleShape(rect[results[obj].FirstShape].Center, rect[results[obj].FirstShape].Width,
rect[results[obj].FirstShape].Height);
Collision.Transform rectTransform =
new Collision.Transform(rect[results[obj].FirstShape].Trans,
rect[results[obj].FirstShape].Rotate);
PolygonShape polShape = new PolygonShape(poly[results[obj].SecondShape].Points);
Collision.Transform polTransform =
new Collision.Transform(poly[results[obj].SecondShape].Trans,
poly[results[obj].SecondShape].Rotate);
var testResult = rectShape.IntersectsWith(rectTransform, polShape,
polTransform, out result);
string err = String.Format(
"Rectangle to Polygon test({0}) failed; Rectangle_ID: {1}, Polygon_ID: {2}",
obj, results[obj].FirstShape, results[obj].SecondShape);
Assert.That(results[obj].Result == testResult, err);
}
}
public void TestPointPointCollision()
{
// true results: not touching, touching in zero, touching
bool[] trueResults = { false, true, true };
// Points coordinates for first Shape
float[] firstX = { -4.0f, 0, 7.0f };
float[] firstY = { 4.0f, 0, -1.0f };
// Points coordinates for second Shape
float[] secondX = { 2.0f, 0, 7.0f };
float[] secondY = { 2.0f, 0, -1.0f };
//Create points and check collisions
for (var obj = 0; obj < trueResults.Length; obj++)
{
CollisionResult result;
//Create point objects
PointShape firstPointShape = new PointShape(Vector2.Zero);
PointShape secondPointShape = new PointShape(Vector2.Zero);
// Transform points
Collision.Transform firstPointTransform =
new Collision.Transform(new Vector2(firstX[obj], firstY[obj]), 230 * Mathf.Deg2Rad);
Collision.Transform secondCPointTransform =
new Collision.Transform(new Vector2(secondX[obj], secondY[obj]), 22 * Mathf.Deg2Rad);
var testResult = firstPointShape.IntersectsWith(firstPointTransform, secondPointShape,
secondCPointTransform, out result);
string err = String.Format("Point to Point test({0}) failed; Point1({1}, {2}) Point2 ({3}, {4})",
obj, firstX[obj], firstY[obj], secondX[obj], secondY[obj]);
Assert.That(trueResults[obj] == testResult, err);
}
}
public void TestRaycastComplex()
{
// lines
Vector2[][] lines =
{
new[] { new Vector2(5.01675f, 21.14647f), new Vector2(9.35574f, 23.23984f) },
new[] { new Vector2(9.35574f, 23.23984f), new Vector2(5.01675f, 21.14647f) },
new[] { new Vector2(4.6742f, 12.27819f), new Vector2(18.37627f, 18.32993f) }
};
Vector2[] intrDot =
{
new Vector2(7.66f, 22.42f),
new Vector2(7.66f, 22.42f),
new Vector2(7.16f, 13.38f)
};
// Polygon points
Vector2[] rect =
{
new Vector2(6.0f, 8.0f), new Vector2(4.0f, 12.0f)
};
Vector2[] polPoints =
{
new Vector2(8.0f, 6.0f), new Vector2(14.0f, 6.0f),
new Vector2(14.0f, 2.0f), new Vector2(8.0f, 2.0f)
};
//Create Rectangles
RectangleShape rectShape = new RectangleShape(rect[0], rect[1].X, rect[1].Y);
//Create Polygons
PolygonShape polyShape = new PolygonShape(polPoints);
//Create Complex obj
IShape[] shapes = { rectShape, polyShape };
ComplexShape compShape = new ComplexShape(shapes);
Collision.Transform compTranform =
new Collision.Transform(new Vector2(5.0456f, 8.1234543f), 23.023f * Mathf.Deg2Rad);
Console.WriteLine(23.023f * Mathf.Deg2Rad);
// True fraction data
float[] trueFraction = { 0.6090305f, 0.3909697f, 0.1815236f };
for (var obj = 0; obj < lines.Length; obj++)
{
float fraction;
Vector2 normal;
bool rayCast = compShape.RayCast(compTranform, lines[obj][0], lines[obj][1], out fraction,
out normal);
Assert.That(rayCast, "RayCast to Complex test({0}) failed.", obj);
Vector2 point = lines[obj][0] + (lines[obj][1] - lines[obj][0]) * fraction;
string err = String.Format(
"Intersect RayCast to Complex test({0}) failed; Intersect: trueFraction {1} (testFraction: {2}), intrPoint({3}), testPoint {4}, normal {5}",
obj, trueFraction[obj], fraction, intrDot[obj], point, normal);
Assert.That(Mathf.FloatEquals(fraction, trueFraction[obj], 0.005f), err);
}
}
public void TestRectRectCollision()
{
// true results: not touching, intersection, touching
bool[] trueResults = { false, true, true };
// First rectangle values
Vector2[][] firstRec =
{
new[] { new Vector2(-590.333f, -23456.0f), new Vector2(99.99f, 1111.01f) },
new[] { new Vector2(-73.999f, 60.001f), new Vector2(10.012f, 109.0002f) },
new[] { new Vector2(0, 8.0f), new Vector2(4.0f, 2.0f) }
};
// Second rectangle values
Vector2[][] secondRec =
{
new[] { new Vector2(1050.009f, 907.039f), new Vector2(2.00123f, 222.33f) },
new[] { new Vector2(3.23f, 53.0101f), new Vector2(97.0301f, 3.99991f) },
new[] { new Vector2(3.0f, 8.0f), new Vector2(2.0f, 2.0f) }
};
//Turns for first and second Shapes
Vector2[] turnShape =
{
new Vector2(355.0f, 1.98765f),
new Vector2(72.909f, 22.0001f),
new Vector2(360.0f, 360.0f) //wery hard make touching by hand, so use 360°
};
for (var obj = 0; obj < trueResults.Length; obj++)
{
CollisionResult result;
//Create rectangle objects
RectangleShape firstRectShape =
new RectangleShape(Vector2.Zero, firstRec[obj][1].X, firstRec[obj][1].Y);
RectangleShape secondRectShape = new RectangleShape(Vector2.Zero, secondRec[obj][1].X,
secondRec[obj][1].Y);
// Transform Shapes
Collision.Transform firstRectTransform =
new Collision.Transform(firstRec[obj][0], turnShape[obj].X * Mathf.Deg2Rad);
Collision.Transform secondRectTransform =
new Collision.Transform(secondRec[obj][0], turnShape[obj].Y * Mathf.Deg2Rad);
// Make test
var testResult = firstRectShape.IntersectsWith(firstRectTransform, secondRectShape,
secondRectTransform, out result);
string err = String.Format(
"Rectangle to Rectangle test({0}) failed; Rect1: center({1}), size({2}x{3}){4}° - Rect2: center ({5}), size({6}x{7}){8}°",
obj, firstRec[obj][0], firstRec[obj][1].X, firstRec[obj][1].Y, turnShape[obj].X,
secondRec[obj][0], secondRec[obj][1].X, secondRec[obj][1].Y, turnShape[obj].Y);
Assert.That(trueResults[obj] == testResult, err);
}
}
public void TestCircleRectCollision()
{
RectangleShape rectShape = new RectangleShape(Vector2.Zero, 0.1f, 60.0f);
Collision.Transform rectTransform = new Collision.Transform(new Vector2(94.20413f, 7.581524f), 0.08616392f);
CircleShape circleShape = new CircleShape(new Vector2(0, 0), 1.2f);
Collision.Transform circleTransform = new Collision.Transform(new Vector2(110.7501f, 8.56217f), 0.05750136f);
// circle and rect should not collide
CollisionResult result;
Assert.That(!circleShape.IntersectsWith(circleTransform, rectShape, rectTransform, out result), "RectangleCircle collision failed");
}
public void TestCircleAABB()
{
CircleShape circleShape = new CircleShape(new Vector2(0, 20.0f), 14.577379f);
Collision.Transform circleTransform = new Collision.Transform(new Vector2(-1709.34f, 402.0f), 1.2456f);
Vector2 lb;
Vector2 ub;
circleShape.GetAABB(circleTransform, out lb, out ub);
Console.WriteLine("Circle LB: " + lb);
Assert.That(VectorEquals(lb, new Vector2(-1742.869f, 393.8125f)), "CircleShape.GetAABB() lower bound is incorrect");
Console.WriteLine("Circle UB: " + ub);
Assert.That(VectorEquals(ub, new Vector2(-1713.714f, 422.9673f)), "CircleShape.GetAABB() upper bound is incorrect");
}
public void TestPointAABB()
{
PointShape pointShape = new PointShape(new Vector2(0, 20.0f));
Collision.Transform pointTransform = new Collision.Transform(new Vector2(-1709.34f, 402.0f), 1.2456f);
Vector2 lb;
Vector2 ub;
pointShape.GetAABB(pointTransform, out lb, out ub);
Console.WriteLine("Point LB: " + lb);
Assert.That(VectorEquals(lb, new Vector2(-1728.292f, 408.3899f)), "PointShape.GetAABB() lower bound is incorrect");
Console.WriteLine("Point UB: " + ub);
Assert.That(VectorEquals(ub, new Vector2(-1728.292f, 408.3899f)), "PointShape.GetAABB() upper bound is incorrect");
}
public void TestNoneAABB()
{
NoneShape noneShape = new NoneShape();
Collision.Transform noneTransform = new Collision.Transform(new Vector2(-1709.34f, 402.0f), 1.2456f);
Vector2 lb;
Vector2 ub;
noneShape.GetAABB(noneTransform, out lb, out ub);
Console.WriteLine("None LB: " + lb);
Assert.That(lb.LengthSquared() == 0, "NoneShape.GetAABB() lower bound is incorrect");
Console.WriteLine("None UB: " + ub);
Assert.That(lb.LengthSquared() == 0, "NoneShape.GetAABB() upper bound is incorrect");
}
public void TestPointComplexCollision()
{
// true results
bool[] trueResults = { false, true, true, false };
// Points coordinates
Vector2[] points =
{
new Vector2(3.07563f, 25.33322f),
new Vector2(6.80563f, 18.67249f),
new Vector2(13.35218f, 16.38881f),
new Vector2(17.34862f, 12.54462f)
};
float[] pointTurn = { 234.12f, 12.234f, 11.11f, 66.66f, 111.111f };
// Polygon points
Vector2[] rect =
{
new Vector2(6.0f, 8.0f), new Vector2(4.0f, 12.0f)
};
Vector2[] polPoints =
{
new Vector2(8.0f, 6.0f), new Vector2(14.0f, 6.0f),
new Vector2(14.0f, 2.0f), new Vector2(8.0f, 2.0f)
};
//Create Rectangle
RectangleShape rectShape = new RectangleShape(rect[0], rect[1].X, rect[1].Y);
//Create Polygon
PolygonShape polShape = new PolygonShape(polPoints);
//Create Complex obj
IShape[] shapes = { rectShape, polShape };
ComplexShape compShape = new ComplexShape(shapes);
Collision.Transform compTranform =
new Collision.Transform(new Vector2(5.0456f, 8.1234543f), 23.023f * Mathf.Deg2Rad);
//Create points and check collisions
for (var obj = 0; obj < trueResults.Length; obj++)
{
CollisionResult result;
PointShape pointShape = new PointShape(Vector2.Zero);
Collision.Transform pointTranform =
new Collision.Transform(points[obj], pointTurn[obj] * Mathf.Deg2Rad);
var testResult = compShape.IntersectsWith(compTranform, pointShape, pointTranform, out result);
string err = String.Format("Point to Complex test({0}) failed for Point({1})", obj, points[obj]);
Assert.That(trueResults[obj] == testResult, err);
}
}
public void TestRaycastPolygon()
{
// lines
Vector2[][] lines =
{
new[] { new Vector2(-20.02394f, -5.17816f), new Vector2(-15.39518f, -10.87007f) },
new[] { new Vector2(-15.39518f, -10.87007f), new Vector2(-20.02394f, -5.17816f) },
new[] { new Vector2(-5.008571f, -5.03002f), new Vector2(-15.0059f, -25.00544f) }
};
Vector2[] intrDot =
{
new Vector2(-17.85f, -7.86f),
new Vector2(-17.85f, -7.86f),
new Vector2(-6.6701f, -8.35f)
};
Vector2[] polPoints =
{
new Vector2(-20.001f, -10.0002f), new Vector2(-15.001f, -5.0234f),
new Vector2(-10.0231f, -5.002f), new Vector2(-5.003f, -10.02234f),
new Vector2(-5.10021f, -15.0091f), new Vector2(-10.000001f, -20.00002f),
new Vector2(-15.10221f, -20.0056f), new Vector2(-20.0034f, -15.1234f)
};
// True fraction data
float[] trueFraction = { 0.4705673f, 0.5294338f, 0.1662021f };
//Create circle obj
PolygonShape polShape = new PolygonShape(polPoints);
Collision.Transform polTransform =
new Collision.Transform(new Vector2(0, 0), 0 * Mathf.Deg2Rad);
for (var obj = 0; obj < lines.Length; obj++)
{
float fraction;
Vector2 normal;
bool rayCast = polShape.RayCast(polTransform, lines[obj][0], lines[obj][1], out fraction,
out normal);
Assert.That(rayCast, "RayCast to Polygon test failed. Result {0} is incorrect", obj);
Vector2 point = lines[obj][0] + (lines[obj][1] - lines[obj][0]) * fraction;
string err =
String.Format(
"RayCast to Polygon test({0}) failed; Intersect: trueFraction {1} (testFraction: {2}), intrPoint({3}), testPoint {4}, normal {5}",
obj, trueFraction[obj], fraction, intrDot[obj], point, normal);
Assert.That(Mathf.FloatEquals(fraction, trueFraction[obj], 0.005f), err);
}
}
public void TestCircleComplexCollision()
{
// true results
bool[] trueResults = { false, true, true, true };
// Circles params: center coordiantes x,y ; radius, turn
Vector2[][] circles =
{
new[] { new Vector2(-5.10756f, 25.02873f), new Vector2(3.234f, 34.098f) },
new[] { new Vector2(4.14134f, 25.21903f), new Vector2(3.00123f, 324.081f) },
new[] { new Vector2(10.11697f, 15.05666f), new Vector2(1.892340f, 7.00098f) },
new[] { new Vector2(20.05097f, 18.25381f), new Vector2(4.1101f, 104.3398f) }
};
// Polygon points
Vector2[] rect =
{
new Vector2(6.0f, 8.0f), new Vector2(4.0f, 12.0f)
};
Vector2[] polPoints =
{
new Vector2(8.0f, 6.0f), new Vector2(14.0f, 6.0f),
new Vector2(14.0f, 2.0f), new Vector2(8.0f, 2.0f)
};
//Create Rectangle
RectangleShape rectShape = new RectangleShape(rect[0], rect[1].X, rect[1].Y);
//Create Polygon
PolygonShape polShape = new PolygonShape(polPoints);
//Create Complex obj
IShape[] shapes = { rectShape, polShape };
ComplexShape compShape = new ComplexShape(shapes);
Collision.Transform compTranform =
new Collision.Transform(new Vector2(5.0456f, 8.1234543f), 23.023f * Mathf.Deg2Rad);
//Create circles and check collisions
for (var obj = 0; obj < trueResults.Length; obj++)
{
CollisionResult result;
CircleShape circleShape = new CircleShape(Vector2.Zero, circles[obj][1].X);
Collision.Transform circleTransform =
new Collision.Transform(circles[obj][0], circles[obj][1].Y * Mathf.Deg2Rad);
var testResult = compShape.IntersectsWith(compTranform, circleShape, circleTransform, out result);
string err = String.Format("Point to Complex test({0}) failed.", obj);
Assert.That(trueResults[obj] == testResult, err);
}
}
public void TestRectAABB()
{
RectangleShape rectShape = new RectangleShape(new Vector2(0, 20.0f), 29, 3);
Collision.Transform rectTransform = new Collision.Transform(new Vector2(-1709.34f, 402.0f), 1.2456f);
Vector2 lb;
Vector2 ub;
rectShape.GetAABB(rectTransform, out lb, out ub);
Console.WriteLine("Rectangle LB: " + lb);
Assert.That(VectorEquals(lb, new Vector2(-1734.346f, 394.1706f)), "RectangleShape.GetAABB() lower bound is incorrect");
Console.WriteLine("Rectangle UB: " + ub);
Assert.That(VectorEquals(ub, new Vector2(-1722.238f, 422.6092f)), "RectangleShape.GetAABB() upper bound is incorrect");
}
public void TestComplexComplexCollision()
{
// Import data
var comp = Complexes.Comp;
var results = CompCompTest.CompCompResults;
for (int obj = 0; obj < results.Length; obj++)
{
IShape[] firstComplex = new IShape[comp[results[obj].FirstShape].PolPoints.Length];
IShape[] secondComplex = new IShape[comp[results[obj].SecondShape].PolPoints.Length];
for (int pol = 0; pol < comp[results[obj].FirstShape].PolPoints.Length; pol++)
{
firstComplex[pol] = new PolygonShape(comp[results[obj].FirstShape].PolPoints[pol]);
}
for (int pol = 0; pol < comp[results[obj].SecondShape].PolPoints.Length; pol++)
{
secondComplex[pol] = new PolygonShape(comp[results[obj].SecondShape].PolPoints[pol]);
}
// Create complex objects
ComplexShape firstComp = new ComplexShape(firstComplex);
ComplexShape secondComp = new ComplexShape(secondComplex);
// Transform complex objects
Collision.Transform firstCompTranform =
new Collision.Transform(comp[results[obj].FirstShape].Trans,
comp[results[obj].FirstShape].Rotate);
Collision.Transform secondCompTranform =
new Collision.Transform(comp[results[obj].SecondShape].Trans,
comp[results[obj].SecondShape].Rotate);
CollisionResult result;
var testResult = firstComp.IntersectsWith(firstCompTranform, secondComp, secondCompTranform,
out result);
string err = String.Format(
"Complex to Compex test({0}) failed; Complex({1}), Complex({2}) {3} {4}",
obj, results[obj].FirstShape, results[obj].SecondShape, comp[results[obj].FirstShape].Trans,
comp[results[obj].SecondShape].Rotate);
Assert.That(results[obj].Result == testResult, err);
}
}
public void TestPointPolygonCollision()
{
// true results
bool[] trueResults = { true, true, true, true, false };
// Points coordinates
Vector2[] points =
{
new Vector2(-1.23f, 0.9834f),
new Vector2(1.234f, 1.199f),
new Vector2(1.00009f, -0.999f),
new Vector2(-0.96001f, -0.86023f),
new Vector2(234.432f, 99.66f)
};
float[] pointTurn = { 234.12f, 12.234f, 11.11f, 66.66f, 111.111f };
// Polygon points
Vector2[] polPoints =
{
new Vector2(-15.30f, -4.4560f), new Vector2(-9.9910f, -5.25101f),
new Vector2(-4.99f, -10.05f), new Vector2(-5.001f, -15.081f),
new Vector2(-10.0333f, -19.8301f), new Vector2(-15.234f, -22.4598f),
new Vector2(-20.90f, -15.0f), new Vector2(-20.0123f, -10.3398f)
};
//Create circle obj
PolygonShape polShape = new PolygonShape(polPoints);
Collision.Transform polTransform =
new Collision.Transform(new Vector2(-0.0005f, 15.045f), 45.34f * Mathf.Deg2Rad);
//Create points and check collisions
for (var obj = 0; obj < trueResults.Length; obj++)
{
CollisionResult result;
PointShape pointShape = new PointShape(Vector2.Zero);
Collision.Transform pointTranform =
new Collision.Transform(points[obj], pointTurn[obj] * Mathf.Deg2Rad);
var testResult = polShape.IntersectsWith(polTransform, pointShape, pointTranform, out result);
string err = String.Format("Point to Polygon test({0}) failed. Polygon:()2.34f°, Point({1})", obj,
points[obj]);
Assert.That(trueResults[obj] == testResult, err);
}
}
public void ManualTestCircleRectangleCollision()
{
CollisionResult result;
CircleShape circleShape = new CircleShape(Vector2.Zero, 1.2f);
Collision.Transform circleTransform =
new Collision.Transform(new Vector2(110.7501f, 8.56217f), 0.05750136f);
RectangleShape rectShape =
new RectangleShape(Vector2.Zero, 0.1f, 60f);
Collision.Transform rectTransform =
new Collision.Transform(new Vector2(94.20413f, 7.581524f), 0.08616392f);
var res = circleShape.IntersectsWith(circleTransform, rectShape, rectTransform, out result);
// Console.WriteLine(res);
Assert.That(res == false, "Error on ManualTestCircleRectangleCollision. Must be false but got True");
}
public void TestComplexAABB()
{
ComplexShape complexShape = new ComplexShape(new IShape[]
{
new CircleShape(new Vector2(0, 20.0f), 14.577379f),
new RectangleShape(new Vector2(0, 20.0f), 49, 3)
});
Collision.Transform complexTransform = new Collision.Transform(new Vector2(-1709.34f, 402.0f), 1.2456f);
Vector2 lb;
Vector2 ub;
complexShape.GetAABB(complexTransform, out lb, out ub);
Console.WriteLine("Complex LB: " + lb);
Assert.That(VectorEquals(lb, new Vector2(-1742.869f, 384.6948f)), "ComplexShape.GetAABB() lower bound is incorrect");
Console.WriteLine("Complex UB: " + ub);
Assert.That(VectorEquals(ub, new Vector2(-1713.714f, 432.0851f)), "ComplexShape.GetAABB() upper bound is incorrect");
}
public void TestRaycastCircle()
{
// lines
Vector2[][] lines =
{
new[] { new Vector2(5.023f, -5.024f), new Vector2(12.04f, -9.72f) },
new[] { new Vector2(12.04f, -9.72f), new Vector2(5.023f, -5.024f) },
new[] { new Vector2(20.0001f, -4.999f), new Vector2(15.100001f, -20.0202f) }
};
Vector2[] intrDot =
{
new Vector2(10.23f, -8.51f),
new Vector2(10.23f, -8.51f),
new Vector2(19.22f, -7.33f)
};
// True fraction data
float[] trueFraction = { 0.7421412f, 0.2578588f, 0.1555718f };
//Create circle obj
CircleShape circleShape = new CircleShape(Vector2.Zero, 5.02302f);
Collision.Transform circleTransform =
new Collision.Transform(new Vector2(15.05f, -10.06f), 33.34f * Mathf.Deg2Rad);
for (var obj = 0; obj < lines.Length; obj++)
{
float fraction;
Vector2 normal;
bool rayCast = circleShape.RayCast(circleTransform, lines[obj][0], lines[obj][1], out fraction,
out normal);
Vector2 point = lines[obj][0] + (lines[obj][1] - lines[obj][0]) * fraction;
Assert.That(rayCast, "RayCast to Circle test failed. Result {0} is incorrect", obj);
string err =
String.Format(
"RayCast to Circle test({0}) failed; Intersect: trueFraction {1} (testFraction: {2}), intrPoint({3}), testPoint {4}, normal {5}",
obj, trueFraction[obj], fraction, intrDot[obj], point, normal);
Assert.That(Mathf.FloatEquals(fraction, trueFraction[obj], 0.005f), err);
}
}
public void TestComplexRectangleCollision()
{
// Import data
var comp = Complexes.Comp;
var rect = Rects.Rect;
var results = CompRectTest.CompRectResults;
for (int obj = 0; obj < results.Length; obj++)
{
IShape[] polygons = new IShape[comp[results[obj].FirstShape].PolPoints.Length];
for (int pol = 0; pol < comp[results[obj].FirstShape].PolPoints.Length; pol++)
{
polygons[pol] = new PolygonShape(comp[results[obj].FirstShape].PolPoints[pol]);
}
// Create complex objects
ComplexShape compShape = new ComplexShape(polygons);
// Transform complex objects
Collision.Transform firstCompTranform =
new Collision.Transform(comp[results[obj].FirstShape].Trans,
comp[results[obj].FirstShape].Rotate);
// Create Rectangle object
RectangleShape rectShape =
new RectangleShape(rect[results[obj].SecondShape].Center, rect[results[obj].SecondShape].Width,
rect[results[obj].SecondShape].Height);
// Transform Rectangle object
Collision.Transform rectTransform =
new Collision.Transform(rect[results[obj].SecondShape].Trans,
rect[results[obj].SecondShape].Rotate);
CollisionResult result;
var testResult = compShape.IntersectsWith(firstCompTranform, rectShape, rectTransform,
out result);
string err = String.Format("Complex to Rectangle test({0}) failed; Complex({1}), Rectangle({2})",
obj, results[obj].FirstShape, results[obj].SecondShape);
Assert.That(results[obj].Result == testResult, err);
}
}
public void TestCircleCircleCollision()
{
// true results: not touching, intersection, touching
bool[] trueResults = { false, true, true };
// Points coordinates for first Shape
float[] firstX = { -456.001f, 0, 7.00001f };
float[] firstY = { 1024.945f, 0, -1.00002f };
float[] firstRad = { 123.4056f, 2.0f, 2.0000f };
float[] firstTurn = { 36.554f, 137.2345f, 11.001f };
// Points coordinates for second Shape
float[] secondX = { 23433.7f, 2.1234f, 11.00f };
float[] secondY = { -90.12345f, -1.000001f, -1.00002f };
float[] secondRad = { 1.00001f, 2.0034f, 2.00001f };
float[] secondTurn = { 345.01f, 9.001f, 111.001f };
//Create points and check collisions
for (var obj = 0; obj < trueResults.Length; obj++)
{
CollisionResult result;
//Create circle objects
CircleShape firstCircleShape = new CircleShape(Vector2.Zero, firstRad[obj]);
CircleShape secondCircleShape = new CircleShape(Vector2.Zero, secondRad[obj]);
// Transform circles
Collision.Transform firstCircleTransform =
new Collision.Transform(new Vector2(firstX[obj], firstY[obj]),
firstTurn[obj] * Mathf.Deg2Rad);
Collision.Transform secondCircleTransform =
new Collision.Transform(new Vector2(secondX[obj], secondY[obj]),
secondTurn[obj] * Mathf.Deg2Rad);
var testResult = firstCircleShape.IntersectsWith(firstCircleTransform, secondCircleShape,
secondCircleTransform, out result);
string err = String.Format(
"Circle to Circle test({0}) failed; Circle1({1}, {2},{3}){4}° Circle2({5}, {6}, {7}){8}°", obj,
firstX[obj], firstY[obj], firstRad[obj], firstTurn[obj], secondX[obj], secondY[obj],
secondRad[obj], secondTurn[obj]);
Assert.That(trueResults[obj] == testResult, err);
}
}
public void TestComplexPolygonCollision()
{
// Import data
var comp = Complexes.Comp;
var poly = Polygons.Poly;
var results = CompPolyTest.CompPolyResults;
for (int obj = 0; obj < results.Length; obj++)
{
IShape[] polygons = new IShape[comp[results[obj].FirstShape].PolPoints.Length];
for (int pol = 0; pol < comp[results[obj].FirstShape].PolPoints.Length; pol++)
{
polygons[pol] = new PolygonShape(comp[results[obj].FirstShape].PolPoints[pol]);
}
// Create complex objects
ComplexShape compShape = new ComplexShape(polygons);
// Transform complex objects
Collision.Transform firstCompTranform =
new Collision.Transform(comp[results[obj].FirstShape].Trans,
comp[results[obj].FirstShape].Rotate);
// Create polygon objects
PolygonShape polShape = new PolygonShape(poly[results[obj].SecondShape].Points);
// Transform polygon object
Collision.Transform polTransform =
new Collision.Transform(poly[results[obj].SecondShape].Trans,
poly[results[obj].SecondShape].Rotate);
CollisionResult result;
var testResult = compShape.IntersectsWith(firstCompTranform, polShape, polTransform,
out result);
string err = String.Format("Complex to Polygon test({0}) failed; Complex({1}), Polygon({2})",
obj, results[obj].FirstShape, results[obj].SecondShape);
Assert.That(results[obj].Result == testResult, err);
}
}
public void TestCircleRayCast()
{
CircleShape circleShape = new CircleShape(new Vector2(-3.0f, 6.0f), 4.15f);
Collision.Transform circleTransform = new Collision.Transform(new Vector2(-1.05f, 0), 0.0f);
Vector2 from = new Vector2(0, -20);
Vector2 to = new Vector2(0, 6);
float fraction;
Vector2 normal;
bool rayCast = circleShape.RayCast(circleTransform, from, to, out fraction, out normal);
Assert.That(rayCast, "CircleShape.RayCast() result is incorrect");
Assert.That(Mathf.FloatEquals(fraction, 0.9635197f, 0.005f), "CircleShape.RayCast() fraction is incorrect: " + fraction);
Vector2 point = from + (to - from) * fraction;
Console.WriteLine("Connection point is at fraction {0}, point {1}, normal {2}", fraction, point, normal);
}
public void TestRaycastRectangle()
{
// lines
Vector2[][] lines =
{
new[] { new Vector2(37.39518f, 27.87007f), new Vector2(32.02394f, 22.17816f) },
new[] { new Vector2(32.02394f, 22.17816f), new Vector2(37.39518f, 27.87007f) },
new[] { new Vector2(40.66259f, 1.94544f), new Vector2(5.58571f, 33.33002f) }
};
Vector2[] intrDot =
{
new Vector2(34.6901f, 25.0f),
new Vector2(34.6901f, 25.0f),
new Vector2(31.66f, 10.0013f)
};
// True fraction data
float[] trueFraction = { 0.5039476f, 0.4960526f, 0.256666f };
//Create circle obj
RectangleShape rectShape = new RectangleShape(Vector2.Zero, 30.0f, 15.0f);
Collision.Transform rectTransform =
new Collision.Transform(new Vector2(25.03758f, 17.48668f), 0 * Mathf.Deg2Rad);
for (var obj = 0; obj < lines.Length; obj++)
{
float fraction;
Vector2 normal;
bool rayCast = rectShape.RayCast(rectTransform, lines[obj][0], lines[obj][1], out fraction,
out normal);
Assert.That(rayCast, "RayCast to Rectangle test failed. Result {0} is incorrect", obj);
var point = lines[obj][0] + (lines[obj][1] - lines[obj][0]) * fraction;
string err =
String.Format(
"RayCast to Rectangle test failed; Intersect: trueFraction {0} (testFraction: {1}), intrPoint({2}), testPoint {3}, normal {4}",
trueFraction[obj], fraction, intrDot[obj], point, normal);
Assert.That(Mathf.FloatEquals(fraction, trueFraction[obj], 0.005f), err);
}
}
