/// <summary>
/// Cria um objeto de CollisionResult.
/// </summary>
/// <param name="result">True caso houve uma colisão.</param>
/// <param name="type">True caso a colisão foi entre retângulos não rotacionados.</param>
/// <param name="intersection">A intersecção da colisão entre retângulos não rotacionados.</param>
/// <param name="polyResult">O resultado de uma colisão entre polígonos (caso os retângulos estejam rotacionados).</param>
public CollisionResult(bool result, CollisionType type, RectangleCollisionResult rectangleResult, PolygonCollisionResult polyResult)
{
HasCollided = result;
Type = type;
RectangleResult = rectangleResult;
PolygonResult = polyResult;
}
public Result(AnimatedActor source, AnimatedActor collided, GameTime gameTime, Tuple <T1, T2> boxes, RectangleCollisionResult result)
{
Source = source;
CollidedEntity = collided;
GameTime = gameTime;
Boxes = boxes;
CollisionResult = result;
}
/// <summary>
/// Verifica se os limites do ator 1 está intersectando os limites do ator 2,
/// e retorna um objeto CollisionResult para verificação do resultado.
/// </summary>
public static CollisionResult ActorCollision(Actor actor1, Actor actor2)
{
CollisionResult result = new CollisionResult
{
Type = CollisionType.None,
HasCollided = false
};
//Fazemos o cálculo simples de intersecção entre retângulos se não há rotação nos atores.
if (actor1.Transform.Rotation == 0 && actor2.Transform.Rotation == 0)
{
//Verifica se há colisão.
if (BoundsCollision(actor1.Bounds, actor2.Bounds))
{
//Cria o resultado da colisão entre retângulos.
RectangleCollisionResult rcr = new RectangleCollisionResult
{
Intersection = Rectangle.Intersect(actor1.Bounds, actor2.Bounds)
};
var ab = actor1.Bounds;
var ob = actor2.Bounds;
//O vetor de subtração a ser completado e adicionado.
rcr.Subtract = Subtract(ab, ob);
result.HasCollided = true;
result.Type = CollisionType.Rectangle;
result.RectangleResult = rcr;
}
}
//se as entidades estão rotacionadas.
else
{
PolygonCollisionResult pcr = PolygonCollision(actor1.BoundsR, actor2.BoundsR, actor1.Transform.Velocity);
if (pcr.Intersect)
{
result.HasCollided = true;
result.Type = CollisionType.Polygon;
result.PolygonResult = pcr;
}
}
return(result);
}
private void Check(AnimatedActor e, AnimatedActor o, GameTime gameTime)
{
RectangleCollisionResult result = new RectangleCollisionResult();
//Procura todos os CollisionBox da entidade
for (int i = 0; i < e.CollisionBoxes.Count; i++)
{
CollisionBox ecb = e.CollisionBoxes[i];
for (int j = 0; j < o.CollisionBoxes.Count; j++)
{
CollisionBox ocb = o.CollisionBoxes[j];
if (Collision.BoundsCollision(ecb.Bounds, ocb.Bounds))
{
result.Intersection = Rectangle.Intersect(ecb.Bounds, ocb.Bounds);
result.Subtract = Collision.Subtract(ecb.Bounds, ocb.Bounds);
ccResult.Source = entity;
ccResult.CollidedEntity = o;
ccResult.GameTime = gameTime;
ccResult.Boxes = new Tuple <CollisionBox, CollisionBox>(ecb, ocb);
ccResult.CollisionResult = result;
CxCCollision?.Invoke(ccResult);
}
}
for (int j = 0; j < o.AttackBoxes.Count; j++)
{
AttackBox oab = o.AttackBoxes[j];
if (Collision.BoundsCollision(ecb.Bounds, oab.Bounds))
{
result.Intersection = Rectangle.Intersect(ecb.Bounds, oab.Bounds);
result.Subtract = Collision.Subtract(ecb.Bounds, oab.Bounds);
caResult.Source = entity;
caResult.CollidedEntity = o;
caResult.GameTime = gameTime;
caResult.Boxes = new Tuple <CollisionBox, AttackBox>(ecb, oab);
caResult.CollisionResult = result;
CxACollision?.Invoke(caResult);
}
}
if (Collision.BoundsCollision(e.CollisionBoxes[i].Bounds, o.Bounds))
{
result.Intersection = Rectangle.Intersect(ecb.Bounds, o.Bounds);
result.Subtract = Collision.Subtract(ecb.Bounds, o.Bounds);
cbResult.Source = entity;
cbResult.CollidedEntity = o;
cbResult.GameTime = gameTime;
cbResult.Boxes = new Tuple <CollisionBox, Rectangle>(ecb, o.Bounds);
cbResult.CollisionResult = result;
CxBCollision?.Invoke(cbResult);
}
}
//Procura todos os AttackBox da entidade
for (int i = 0; i < e.AttackBoxes.Count; i++)
{
AttackBox eab = e.AttackBoxes[i];
for (int j = 0; j < o.CollisionBoxes.Count; j++)
{
CollisionBox ocb = o.CollisionBoxes[j];
if (Collision.BoundsCollision(eab.Bounds, ocb.Bounds))
{
result.Intersection = Rectangle.Intersect(eab.Bounds, ocb.Bounds);
result.Subtract = Collision.Subtract(eab.Bounds, ocb.Bounds);
caResult.Source = entity;
caResult.CollidedEntity = o;
caResult.GameTime = gameTime;
caResult.Boxes = new Tuple <CollisionBox, AttackBox>(ocb, eab);
caResult.CollisionResult = result;
CxACollision?.Invoke(caResult);
}
}
for (int j = 0; j < o.AttackBoxes.Count; j++)
{
AttackBox oab = o.AttackBoxes[j];
if (Collision.BoundsCollision(eab.Bounds, oab.Bounds))
{
result.Intersection = Rectangle.Intersect(eab.Bounds, oab.Bounds);
result.Subtract = Collision.Subtract(eab.Bounds, oab.Bounds);
aaResult.Source = entity;
aaResult.CollidedEntity = o;
aaResult.GameTime = gameTime;
aaResult.Boxes = new Tuple <AttackBox, AttackBox>(eab, oab);
aaResult.CollisionResult = result;
AxACollision?.Invoke(aaResult);
}
}
if (Collision.BoundsCollision(e.AttackBoxes[i].Bounds, o.Bounds))
{
result.Intersection = Rectangle.Intersect(eab.Bounds, o.Bounds);
result.Subtract = Collision.Subtract(eab.Bounds, o.Bounds);
abResult.Source = entity;
abResult.CollidedEntity = o;
abResult.GameTime = gameTime;
abResult.Boxes = new Tuple <AttackBox, Rectangle>(eab, o.Bounds);
abResult.CollisionResult = result;
AxBCollision?.Invoke(abResult);
}
}
}
