/// <summary>
/// Determines if a collision has occurred on an Axis of one of the
/// planes parallel to the Rectangle
/// </summary>
/// <param name="theRectangle">The rectangle.</param>
/// <param name="aAxis">A axis.</param>
/// <returns>
/// <c>true</c> if [is axis collision] [the specified the rectangle]; otherwise, <c>false</c>.
/// </returns>
private bool IsAxisCollision(RotatedRectangle theRectangle, Vector2 aAxis)
{
//Project the corners of the Rectangle we are checking on to the Axis and
//get a scalar value of that project we can then use for comparison
List<int> aRectangleAScalars = new List<int>();
aRectangleAScalars.Add(GenerateScalar(theRectangle.UpperLeftCorner(), aAxis));
aRectangleAScalars.Add(GenerateScalar(theRectangle.UpperRightCorner(), aAxis));
aRectangleAScalars.Add(GenerateScalar(theRectangle.LowerLeftCorner(), aAxis));
aRectangleAScalars.Add(GenerateScalar(theRectangle.LowerRightCorner(), aAxis));
//Project the corners of the current Rectangle on to the Axis and
//get a scalar value of that project we can then use for comparison
List<int> aRectangleBScalars = new List<int>();
aRectangleBScalars.Add(GenerateScalar(UpperLeftCorner(), aAxis));
aRectangleBScalars.Add(GenerateScalar(UpperRightCorner(), aAxis));
aRectangleBScalars.Add(GenerateScalar(LowerLeftCorner(), aAxis));
aRectangleBScalars.Add(GenerateScalar(LowerRightCorner(), aAxis));
//Get the Maximum and Minium Scalar values for each of the Rectangles
int aRectangleAMinimum = aRectangleAScalars.Min();
int aRectangleAMaximum = aRectangleAScalars.Max();
int aRectangleBMinimum = aRectangleBScalars.Min();
int aRectangleBMaximum = aRectangleBScalars.Max();
//If we have overlaps between the Rectangles (i.e. Min of B is less than Max of A)
//then we are detecting a collision between the rectangles on this Axis
if (aRectangleBMinimum <= aRectangleAMaximum && aRectangleBMaximum >= aRectangleAMaximum)
{
return true;
}
else if (aRectangleAMinimum <= aRectangleBMaximum && aRectangleAMaximum >= aRectangleBMaximum)
{
return true;
}
return false;
}
/// <summary>
/// Colors the collision.
/// </summary>
/// <param name="collideColor">Color of the collide.</param>
/// <param name="projectile">The cross hair.</param>
/// <param name="npc">The NPC.</param>
/// <param name="projectilePixels">The projectile pixels.</param>
/// <param name="npcPixels">The NPC pixels.</param>
/// <returns></returns>
public static bool colorCollision(Color collideColor, RotatedRectangle projectile, RotatedRectangle npc, Color[] projectilePixels, Color[] npcPixels)
{
Rectangle Rectangle1 = _getBoundingRectangleOfRotatedRectangle(projectile.RectanglePoints);
Rectangle Rectangle2 = _getBoundingRectangleOfRotatedRectangle(npc.RectanglePoints);
int top = Math.Max(Rectangle1.Top, Rectangle2.Top);
int bottom = Math.Min(Rectangle1.Bottom, Rectangle2.Bottom);
int left = Math.Max(Rectangle1.Left, Rectangle2.Left);
int right = Math.Min(Rectangle1.Right, Rectangle2.Right);
for (int y = top; y < bottom; y++)
{
for (int x = left; x < right; x++)
{
Color colorA = projectilePixels[(x - Rectangle1.Left) + (y - Rectangle1.Top) * Rectangle1.Width];
Color colorB = npcPixels[(x - Rectangle2.Left) + (y - Rectangle2.Top) * Rectangle2.Width];
if (colorA != collideColor && colorB != collideColor)
return true;
}
}
return false;
}
/// <summary>
/// Check to see if two Rotated Rectangls have collided
/// </summary>
/// <param name="theRectangle">The rectangle.</param>
/// <returns></returns>
public bool Intersects(RotatedRectangle theRectangle)
{
//Calculate the Axis we will use to determine if a collision has occurred
//Since the objects are rectangles, we only have to generate 4 Axis (2 for
//each rectangle) since we know the other 2 on a rectangle are parallel.
List<Vector2> aRectangleAxis = new List<Vector2>();
aRectangleAxis.Add(UpperRightCorner() - UpperLeftCorner());
aRectangleAxis.Add(UpperRightCorner() - LowerRightCorner());
aRectangleAxis.Add(theRectangle.UpperLeftCorner() - theRectangle.LowerLeftCorner());
aRectangleAxis.Add(theRectangle.UpperLeftCorner() - theRectangle.UpperRightCorner());
//Cycle through all of the Axis we need to check. If a collision does not occur
//on ALL of the Axis, then a collision is NOT occurring. We can then exit out
//immediately and notify the calling function that no collision was detected. If
//a collision DOES occur on ALL of the Axis, then there is a collision occurring
//between the rotated rectangles. We know this to be true by the Seperating Axis Theorem
foreach (Vector2 aAxis in aRectangleAxis)
{
if (!IsAxisCollision(theRectangle, aAxis))
{
return false;
}
}
return true;
}
