private static bool checkCollisionCircleWithSide(CollisionInfo collision)
{
CollisionCircle circle = collision.obj1 as CollisionCircle;
CollisionSide side = collision.obj2 as CollisionSide;
Logger.instance.Assert(null != circle && null != side, "Collision objects incorrect data for CircleWithSide");
if ((side.P1 - circle.Center).Dot(side.DirOut) > circle.Radius)
{
return(false);
}
double distanceToLine = (intersectLine(circle.Center, side.P1, side.P2) - circle.Center).Length;
double distanceToInfinity = (side.P1 - circle.Center).Dot(side.DirOut);
if (-circle.Radius - CollisionSide.SideWidth < distanceToInfinity && distanceToInfinity < circle.Radius &&
distanceToLine <= distanceToInfinity + 1.0e-3)
{
Vector collisionPoint = circle.Center + side.DirOut * distanceToInfinity;
collision.setCollisionData(collisionPoint, side.DirOut.Negative(), side.DirOut);
return(true);
}
return(false);
}
private static HashSet <TilePos> objectTiles(ICollisionObject obj)
{
switch (obj.Type)
{
case CollisionObjectType.Circle:
CollisionCircle circle = obj as CollisionCircle;
return(tilesByPosition(circle.Center.X - circle.Radius, circle.Center.Y - circle.Radius,
circle.Center.X + circle.Radius, circle.Center.Y + circle.Radius));
case CollisionObjectType.Rect:
CollisionRect rect = obj as CollisionRect;
Vector min = new Vector(double.MaxValue);
Vector max = new Vector(double.MinValue);
foreach (Vector point in rect.Points)
{
min.set(Math.Min(point.X, min.X), Math.Min(point.Y, min.Y));
max.set(Math.Max(point.X, max.X), Math.Max(point.Y, max.Y));
}
return(tilesByPosition(min.X, min.Y, max.X, max.Y));
}
;
return(new HashSet <TilePos>());
}
///Other
private List <ICollisionObject> objectsByTilesAndEdgesInfo(Dictionary <TilePos, TileDir[]> tilesInfo)
{
CollisionRect carRect = new CollisionRect(car);
List <ICollisionObject> result = new List <ICollisionObject>();
if (null != tilesInfo)
{
foreach (TilePos pos in tilesInfo.Keys)
{
foreach (TileDir dir in tilesInfo[pos])
{
ICollisionObject obj = null;
if (dir.Correct())
{
obj = new CollisionSide(pos, dir);
}
else
{
obj = new CollisionCircle(pos, dir);
}
if (null == CollisionDetector.CheckCollision(carRect, obj))
{
result.Add(obj);
}
}
}
}
return(result);
}
private static bool checkCollisionCircleWithRect(CollisionInfo collision)
{
CollisionCircle circle = collision.obj1 as CollisionCircle;
CollisionRect rect = collision.obj2 as CollisionRect;
Logger.instance.Assert(null != circle && null != rect, "Collision objects incorrect data for CircleWithRect");
if ((circle.Center - rect.Center).Length > circle.Radius + rect.MaxRadius)
{
return(false);
}
Vector TileDir = circle.Center - rect.Center;
double distanceLength = TileDir.Dot(rect.Dir);
double distanceCross = TileDir.Cross(rect.Dir);
//inside
if (Math.Abs(distanceLength) < rect.Width * 0.5 - circle.Radius && Math.Abs(distanceCross) < rect.Height * 0.5 - circle.Radius)
{
collision.setCollisionDataForInside(circle.Center);
return(true);
}
Vector[] points = rect.Points;
Vector[] intersects = new Vector[4] {
intersectLine(circle.Center, points[0], points[1]),
intersectLine(circle.Center, points[1], points[2]),
intersectLine(circle.Center, points[2], points[3]),
intersectLine(circle.Center, points[3], points[0])
};
int minIndex = -1;
double minDistance = circle.Radius;
for (int i = 0; i < 4; i++)
{
double distance = (intersects[i] - circle.Center).Length;
if (distance < minDistance)
{
minIndex = i;
minDistance = distance;
}
}
if (-1 != minIndex)
{
Vector n1 = (circle.Center - intersects[minIndex]).Normalize();
Vector n2 = (rect.Center - intersects[minIndex]).Normalize();
collision.setCollisionData(intersects[minIndex], n1, n2);
return(true);
}
return(false);
}
private static bool checkCollisionCircleWithCircle(CollisionInfo collision)
{
CollisionCircle circle1 = collision.obj1 as CollisionCircle;
CollisionCircle circle2 = collision.obj2 as CollisionCircle;
Logger.instance.Assert(null != circle1 && null != circle2, "Collision objects incorrect data for CircleWithCircle");
Vector direction = (circle1.Center - circle2.Center);
if (direction.Length < circle1.Radius + circle2.Radius)
{
direction = direction.Normalize();
Vector collisionPoint = circle1.Center - direction * circle1.Radius;
collision.setCollisionData(collisionPoint, direction, direction.Negative());
return(true);
}
return(false);
}
