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 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 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 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 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 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 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 TestCirclePolygonCollision()
{
// Circles params: center coordiantes x,y ; radius, turn
Vector2[][] circles =
{
new[] { new Vector2(5.0f, 5.0f), new Vector2(2.0f, 34.098f) },
new[] { new Vector2(-6.0f, 6.0f), new Vector2(3.0f, 324.081f) },
new[] { new Vector2(-8.0f, -7.0f), new Vector2(4.0f, 7.00098f) },
new[] { new Vector2(10.0f, -8.0f), new Vector2(5.0f, 104.3398f) }
};
//Not intersect polygon coordinates
Vector2[][] freePol =
{
new[]
{
new Vector2(10.3123f, 12.5321f), new Vector2(13.1701f, 15.15001f),
new Vector2(16.76001f, 15.15001f), new Vector2(18.8001f, 13.5701f),
new Vector2(17.031f, 11.091f), new Vector2(13.1001f, 11.5001f)
},
new[]
{
new Vector2(-13.3209f, 12.00192f), new Vector2(-17.812f, 12.8202f),
new Vector2(-16.4001f, 17.5001f)
},
new[]
{
new Vector2(-15.013f, -14.980001f), new Vector2(-15.1001f, -18.5001f),
new Vector2(-18.1001f, -18.5001f), new Vector2(-18.007f, -14.1230f)
},
new[]
{
new Vector2(20.0012f, -4.9001f), new Vector2(26.034f, -5.000009f),
new Vector2(23.1001f, -6.5001f), new Vector2(20.1001f, -7.5001f)
}
};
// Intersect polygon coordinates
Vector2[][] intrPol =
{
new[]
{
new Vector2(1.03123f, 5.0321f), new Vector2(3.0701f, 7.99501f),
new Vector2(7.06001f, 8.25001f), new Vector2(8.95001f, 5.02701f),
new Vector2(7.031f, 2.1191f), new Vector2(2.93001f, 2.12901f)
},
new[]
{
new Vector2(-4.0909f, 5.07192f), new Vector2(-8.0412f, 5.0202f),
new Vector2(-5.94001f, 8.0201f)
},
new[]
{
new Vector2(-7.013f, -1.080001f), new Vector2(-4.1301f, -7.91001f),
new Vector2(-7.1001f, -13.95001f), new Vector2(-10.007f, -7.91230f)
},
new[]
{
new Vector2(1.8812f, -7.8601f), new Vector2(9.951001f, -7.8001f),
new Vector2(10.1001f, -10.5001f), new Vector2(8.1601f, -11.85001f),
new Vector2(6.034f, -12.00009f)
}
};
// Center coordiantes for free/intr polygons
Vector2[][] polTrans =
{
new[] { new Vector2(140.234f, 2345.76f), new Vector2(0.0345f, 0.1065f) },
new[] { new Vector2(-220.0f, 330.0f), new Vector2(0.0044f, 0.00765f) },
new[] { new Vector2(-2222.0f, -1222.0f), new Vector2(0.10001f, 0.9089f) },
new[] { new Vector2(544.0f, -998.0f), new Vector2(0.5544f, 0.77f) }
};
// Turns for free/intr polygons
float[] freeTurn = { 37.304f, 124.303f, 322.022f, 266.6666f };
float[] intrTurn = { 6.6001f, 6.6f, 32.546f, 4.012f };
//Create circles and check collisions
for (var obj = 0; obj < circles.Length; obj++)
{
//Work vals
CollisionResult result;
// Circle objects: circles[obj][0] - coords, circles[obj][1][0] - radius, circles[obj][1][1] - turn
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);
//Create free polygons objects: freePol[obj] - coord, freeTurn[obj] - turn, polTrans[obj][0] - centr
PolygonShape freePolShape = new PolygonShape(freePol[obj]);
Collision.Transform freePolTransform =
new Collision.Transform(polTrans[obj][0], freeTurn[obj] * Mathf.Deg2Rad);
//Create free polygons objects: intrPol[obj] - coor, freeTurn[obj] - turn, polTrans[obj][1] - centr
PolygonShape intrPolShape = new PolygonShape(intrPol[obj]);
Collision.Transform intrPolTransform =
new Collision.Transform(polTrans[obj][1], intrTurn[obj] * Mathf.Deg2Rad);
// Make free test
var freeResult =
circleShape.IntersectsWith(circleTransform, freePolShape, freePolTransform, out result);
// Make Intersection test
var intrResult =
circleShape.IntersectsWith(circleTransform, intrPolShape, intrPolTransform, out result);
// Generate error messages
string freeErr = String.Format("Not interssept for Circle to Polygon test({0}) failed", obj);
string intrErr = String.Format("Interssept for Circle to Polygon test({0}) failed", obj);
// Assert results
Assert.That(freeResult == false, freeErr);
Assert.That(intrResult, intrErr);
}
}
public void TestCircleRectangleCollision()
{
// Circles params: center coordiantes x,y ; radius, turn
Vector2[][] circles =
{
new[] { new Vector2(5.0f, 5.0f), new Vector2(2.0f, 34.098f) },
new[] { new Vector2(-6.0f, 6.0f), new Vector2(3.0f, 324.081f) },
new[] { new Vector2(-8.0f, -7.0f), new Vector2(4.0f, 7.00098f) },
new[] { new Vector2(10.0f, -8.0f), new Vector2(5.0f, 104.3398f) }
};
//Not intersect rectangle coordinates
Vector2[][] freeRec =
{
new[] { new Vector2(2.023f, 3.00009f), new Vector2(130.0099f, 9900.019f) },
new[] { new Vector2(102.999f, 60.0017f), new Vector2(-210.012f, 109.0002f) },
new[] { new Vector2(534.001f, 12.0001f), new Vector2(-1024.99f, -634.091f) },
new[] { new Vector2(2.09343f, 2.02321f), new Vector2(99.99f, 100.1f) }
};
// Intersect rectangle coordinates
Vector2[][] intrRec =
{
new[] { new Vector2(6.0123f, 6.0321f), new Vector2(5.0001f, 5.0001f) },
new[] { new Vector2(2.0009f, 2.00192f), new Vector2(-6.012f, 6.2202f) },
new[] { new Vector2(7.013f, 1.980001f), new Vector2(-6.007f, -7.1230f) },
new[] { new Vector2(4.0012f, 4.1001f), new Vector2(6.034f, -8.000009f) }
};
// Turns for first/second rect's
Vector2[] turnRec =
{
new Vector2(27.304f, 0.0001f),
new Vector2(124.303f, 66.6f),
new Vector2(322.022f, 132.546f),
new Vector2(66.6666f, 12.012f)
};
//Create circles and check collisions
for (var obj = 0; obj < circles.Length; obj++)
{
//Work vals
CollisionResult result;
// Circle objects: circles[obj][0] - coords, circles[obj][1][0] - radius, circles[obj][1][1] - turn
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);
//Create free rectangle objects: freeRec[obj][0] - width/heigth, freeRec[obj][1] - coordinates
//Create intersect rectangle objects: intrRec[obj][0] - width/heigth, intrRec[obj][1] - coordinates
// Turns for Shapes turnRec[obj][0-1]
// Free Rect
RectangleShape freeRectShape =
new RectangleShape(Vector2.Zero, freeRec[obj][0].X, freeRec[obj][0].Y);
Collision.Transform freeRectTransform =
new Collision.Transform(freeRec[obj][1], turnRec[obj].X * Mathf.Deg2Rad);
//Intersection Rect
RectangleShape intrRectShape =
new RectangleShape(Vector2.Zero, intrRec[obj][0].X, intrRec[obj][0].Y);
Collision.Transform intrdRectTransform =
new Collision.Transform(intrRec[obj][1], turnRec[obj].Y * Mathf.Deg2Rad);
// Make free test
var freeResult = circleShape.IntersectsWith(circleTransform, freeRectShape,
freeRectTransform, out result);
// Make Intersection test
var intrResult = circleShape.IntersectsWith(circleTransform, intrRectShape,
intrdRectTransform, out result);
// Generate error messages
string freeErr =
String.Format(
"Circle to Rectangle test failed; Circle({0})R:({1}) {2}° and freeRect({3} : {4}){5}°",
circles[obj][0], circles[obj][1].X, circles[obj][1].Y, freeRec[obj][0], freeRec[obj][1],
turnRec[obj].X);
string intrErr = String.Format(
"Circle to Rectangle Interssept failed; Circle({0})R:({1}) {2}° and intrRect({3} : {4}){5}°",
circles[obj][0], circles[obj][1].X, circles[obj][1].Y, intrRec[obj][0], intrRec[obj][1],
turnRec[obj].Y);
// Assert results
Assert.That(freeResult == false, freeErr);
Assert.That(intrResult, intrErr);
}
}
