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); } }