public override bool Check(PCar car)
{
CollisionRect carRect = new CollisionRect(car);
List <CollisionInfo> collisions = CollisionDetector.CheckCollision(carRect, collisionObjects);
if (!collisions.HasCollision())
{
return(false);
}
foreach (CollisionInfo info in collisions)
{
if (!info.CollisionDeletected)
{
continue;
}
Vector normal = info.NormalObj1;
if (car.Dir.Dot(normal) > -1.0e-2)
{
continue;
}
checkInfo = new Tuple <Vector, Vector>(info.Point, normal);
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 checkCollisionRectWithRect(CollisionInfo collision)
{
CollisionRect rect1 = collision.obj1 as CollisionRect;
CollisionRect rect2 = collision.obj2 as CollisionRect;
Logger.instance.Assert(null != rect1 && null != rect2, "Collision objects incorrect data for RectWithRect");
return(false);
}
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 checkCollisionRectWithSide(CollisionInfo collision)
{
CollisionRect rect = collision.obj1 as CollisionRect;
CollisionSide side = collision.obj2 as CollisionSide;
Logger.instance.Assert(null != rect && null != side, "Collision objects incorrect data for RectWithSide");
if ((side.P1 - rect.Center).Dot(side.DirOut) > rect.MaxRadius)
{
return(false);
}
Vector[] points = rect.Points;
Vector[] intersects = new Vector[4] {
intersectLine(points[0], side.P1, side.P2),
intersectLine(points[1], side.P1, side.P2),
intersectLine(points[2], side.P1, side.P2),
intersectLine(points[3], side.P1, side.P2),
};
double[] distances = new double[4] {
(side.P1 - points[0]).Dot(side.DirOut),
(side.P1 - points[1]).Dot(side.DirOut),
(side.P1 - points[2]).Dot(side.DirOut),
(side.P1 - points[3]).Dot(side.DirOut)
};
for (int i = 0; i < 4; i++)
{
double distanceToLine = (points[i] - intersects[i]).Length;
if (-CollisionSide.SideWidth < distances[i] && distances[i] < 0 && distanceToLine <= Math.Abs(distances[i]) + 1.0e-3)
{
collision.setCollisionData(intersects[i], side.DirOut.Negative(), side.DirOut);
return(true);
}
}
return(false);
}