private void CheckCollisions()
{
Collision collision = null;
Collision maxCollision = null;
float maxDepth = float.MinValue;
foreach (var component in map.Components)
{
collision = CollisionManager.CheckCollision(component.Body, lukesProjectile.Body);
if (collision != null)
{
if (collision.Depth > maxDepth)
{
maxDepth = collision.Depth;
maxCollision = collision;
}
}
}
if (maxCollision != null)
{
lukesProjectile.Position = lukesProjectile.Position + maxCollision.Normal * maxCollision.Depth;
lukesProjectile.Velocity = GetNewVelocity(lukesProjectile.Velocity, maxCollision);
}
}
private bool CheckCollision(Vector2f a, Vector2f b)
{
var p1 = body.Transform.TransformPoint(body.GetPoint(0));
var p2 = body.Transform.TransformPoint(body.GetPoint(1));
var p3 = body.Transform.TransformPoint(body.GetPoint(2));
var p4 = body.Transform.TransformPoint(body.GetPoint(3));
return
(CollisionManager.CheckCollision(a, b, p1, p2) != null ||
CollisionManager.CheckCollision(a, b, p2, p3) != null ||
CollisionManager.CheckCollision(a, b, p3, p4) != null ||
CollisionManager.CheckCollision(a, b, p4, p1) != null);
}
private float[] CheckCollisions(Car car)
{
var colliding = new HashSet <Vertex[]>();
var rayCollisions = new float[7] {
1, 1, 1, 1, 1, 1, 1
};
for (int i = 0; i < car.GetRays.Length; i++)
{
var ray = car.GetRays[i];
var p2 = ray[0].Position;
var p3 = ray[1].Position;
foreach (var line in lineSegments)
{
var p0 = line[0].Position;
var p1 = line[1].Position;
var collisionPoint = CollisionManager.CheckCollision(p0, p1, p2, p3);
if (collisionPoint != null)
{
ray[0].Color = Color.Red;
ray[1].Color = Color.Red;
colliding.Add(ray);
var rayLength = Math.Pow(p2.X - p3.X, 2) + Math.Pow(p2.Y - p3.Y, 2);
var hitLength = Math.Pow(p2.X - collisionPoint.Value.X, 2) + Math.Pow(p2.Y - collisionPoint.Value.Y, 2);
var hitDistance = (float)(hitLength / rayLength);
if (hitDistance < rayCollisions[i])
{
rayCollisions[i] = hitDistance;
car.CollisionPoints[i].Position = collisionPoint.Value;
}
}
}
if (ray[0].Color != Color.Red)
{
car.CollisionPoints[i].Position = new Vector2f();
}
}
foreach (var ray in car.GetRays.Where(r => !colliding.Contains(r)))
{
ray[0].Color = Color.Green;
ray[1].Color = Color.Green;
}
return(rayCollisions);
}
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
// TODO: Add your update logic here
// Intro menu
intro(gameTime);
if (collisionManager.IsCollisionWithExit)
{
level = lv2;
}
// Scrolling backgrounds
foreach (Scrolling scrolling in level.ScrollingLayer)
{
if (scrolling.rectangle.X + scrolling.texture.Width <= 0)
{
scrolling.rectangle.X = 3200;
}
}
foreach (CollisionTiles tile in level.CollisionTiles)
{
camera.Update(hero.Position, level.Width, level.Height);
collisionManager.UpdateCollision(hero.CollisionRectangle, tile.Rectangle, level.Width, level.Height, hero);
collisionManager.LevelCollision(hero.CollisionRectangle, tile.Rectangle, tile.texture, hero);
}
if (level.Enemies != null)
{
foreach (Enemy enemy in level.Enemies)
{
enemy.Update(hero);
collisionWithEnemy.Handle(collisionManager, hero);
collisionManager.CheckCollision(hero.CollisionRectangle, enemy.CollisionRectangle);
}
}
base.Update(gameTime);
}
public void Run()
{
for (int a = 0; a < filter.Components1.Length; a++)
{
var collisionComponentA = filter.Components1[a];
if (collisionComponentA == null)
{
break;
}
collisionComponentA.LifeTime += TimeTracker.Time.FrameTime;
if (collisionComponentA.Cooldown > collisionComponentA.LifeTime)
{
continue;
}
for (int b = a + 1; b < filter.Components1.Length; b++)
{
var collisionComponentB = filter.Components1[b];
if (collisionComponentB == null || collisionComponentB.Body == null)
{
break;
}
if (collisionComponentB.Cooldown > collisionComponentB.LifeTime)
{
continue;
}
var collision = CollisionManager.CheckCollision(collisionComponentA, collisionComponentB);
if (collision != null)
{
collision.EntityA = filter.Entities[a];
collision.EntityB = filter.Entities[b];
ProcessCollision(collision);
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="raycasts"></param>
/// <param name="map"></param>
/// <returns>A list of normalised collision distances, and the collidion points themselves.</returns>
public static (float[], Vector2f?[]) GetRaycastCollisions(List <LineSegment> raycasts, List <LineSegment> map)
{
var colliding = new HashSet <LineSegment>();
var collisionPoints = new Vector2f?[raycasts.Count];
var collisionDistances = new float[raycasts.Count()];
for (int i = 0; i < raycasts.Count; i++)
{
collisionDistances[i] = 1;
}
for (int i = 0; i < raycasts.Count; i++)
{
var ray = raycasts[i];
var p2 = ray.Start;
var p3 = ray.End;
foreach (var line in map)
{
var p0 = line.Start;
var p1 = line.End;
var collisionPoint = CollisionManager.CheckCollision(p0, p1, p2, p3);
if (collisionPoint != null)
{
colliding.Add(ray);
var rayLength = Math.Pow(p2.X - p3.X, 2) + Math.Pow(p2.Y - p3.Y, 2);
var hitLength = Math.Pow(p2.X - collisionPoint.Value.X, 2) + Math.Pow(p2.Y - collisionPoint.Value.Y, 2);
var hitDistance = (float)(hitLength / rayLength);
if (hitDistance < collisionDistances[i])
{
collisionDistances[i] = hitDistance;
collisionPoints[i] = collisionPoint;
}
}
}
}
return(collisionDistances, collisionPoints);
}
