protected MoveResponse ResolveAllCollisions(ICollisionComponent source)
{
MoveResponse response = new MoveResponse();
//As long as at least one collision occurred attempt to resolve it.
//And, of course, only resolve collisions if we're supposed to!
if (higherPriorityCollisionList.Count > 0)
{
correctionVectors.Clear();
for (int i = 0; i < tempCollisionList.Count; i++)
{
var vector = GetCorrectionVector(source, tempCollisionList[i]);
correctionVectors.Add(vector);
//Notify of a collision
NotifyCollision(source, tempCollisionList[i], vector);
}
//Now determine the direction for the X and Y axis.
CorrectionVector2 directions = GetDirections(correctionVectors);
//Correct the movement of this object if we're supposed to
if (ResolveCollisions)
{
CorrectMovement(source, tempCollisionList, directions);
//Mark this object as having moved and put it back into the QuadTree.
response.moved = true;
}
}
return(response);
}
/// <summary>
/// Requests that the CollidableGameObject be moved to the location where its ProjectedBoundingBox currently resides.
/// </summary>
/// <param name="objectToMove">The IGameObject to be moved.</param>
/// <returns>A MoveResponse object providing information related to the movement.</returns>
protected MoveResponse RequestMove(ICollisionComponent objectToMove)
{
MoveResponse response = new MoveResponse(false);
HandleObjectMovement(objectToMove);
return(response);
}
/// <summary>
/// Resolves all collisions against the source ICollidable object.
/// </summary>
/// <param name="source">The source ICollidable object that has moved and requires collision testing.</param>
protected MoveResponse HandleObjectMovement(ICollisionComponent source)
{
tempCollisionList.Clear();
higherPriorityCollisionList.Clear();
lowerPriorityCollisionList.Clear();
resolvedCollisions.Clear();
finalCorrectionVector = new CorrectionVector2();
MoveResponse response = new MoveResponse();
collisionTree.GetCollidingWith(source, ref tempCollisionList);
while (tempCollisionList.Count > 0)
{
if (source.Solid)
{
for (int i = 0; i < tempCollisionList.Count; i++)
{
ICollisionComponent currObject = tempCollisionList[i];
//Check if the object we are colliding with has a priority greater than ours.
//If so, then add it to the list of collisions we need to resolve!
//We will also consider objects with the same priority so long as both of use are flagged as being able to collide with
//objects of the same priority.
if (currObject.Solid)
{
if (currObject.CollisionPriority > source.CollisionPriority ||
(
(currObject.CollisionPriority == source.CollisionPriority)))
{
higherPriorityCollisionList.Add(currObject);
}
//If we've collided with anything of lower priority then we need to push IT out of the way.
else if (currObject.CollisionPriority < source.CollisionPriority)
{
lowerPriorityCollisionList.Add(currObject);
}
}
}
}
//Now let's resolve those collisions!
ResolveAllCollisions(source);
//Resolve all of the individual collisions that we are pushing away.
for (int j = 0; j < lowerPriorityCollisionList.Count; j++)
{
ResolveIndividualCollision(source, lowerPriorityCollisionList[j]);
}
//Notify all the ICollisionComponents that they have collided with something.
//for (int j = 0; j < tempCollisionList.Count; j++)
//{
// if (collisionEvents.ContainsKey(source.Parent.GUID) && collisionEvents[source.Parent.GUID] != null)
// collisionEvents[source.Parent.GUID](source, tempCollisionList[j], finalCorrectionVector);
// if (collisionEvents.ContainsKey(tempCollisionList[j].Parent.GUID) && collisionEvents[tempCollisionList[j].Parent.GUID] != null)
// collisionEvents[tempCollisionList[j].Parent.GUID](tempCollisionList[j], source, finalCorrectionVector);
// }
tempCollisionList.Clear();
higherPriorityCollisionList.Clear();
lowerPriorityCollisionList.Clear();
//Only check again if we're resolving collisions!
if (ResolveCollisions)
{
collisionTree.GetCollidingWith(source, ref tempCollisionList);
}
}
return response;
}
protected MoveResponse ResolveAllCollisions(ICollisionComponent source)
{
MoveResponse response = new MoveResponse();
//As long as at least one collision occurred attempt to resolve it.
//And, of course, only resolve collisions if we're supposed to!
if (higherPriorityCollisionList.Count > 0)
{
correctionVectors.Clear();
for (int i = 0; i < tempCollisionList.Count; i++)
{
var vector = GetCorrectionVector(source, tempCollisionList[i]);
correctionVectors.Add(vector);
//Notify of a collision
NotifyCollision(source, tempCollisionList[i], vector);
}
//Now determine the direction for the X and Y axis.
CorrectionVector2 directions = GetDirections(correctionVectors);
//Correct the movement of this object if we're supposed to
if (ResolveCollisions)
{
CorrectMovement(source, tempCollisionList, directions);
//Mark this object as having moved and put it back into the QuadTree.
response.moved = true;
}
}
return response;
}
/// <summary>
/// Requests that the CollidableGameObject be moved to the location where its ProjectedBoundingBox currently resides.
/// </summary>
/// <param name="objectToMove">The IGameObject to be moved.</param>
/// <returns>A MoveResponse object providing information related to the movement.</returns>
protected MoveResponse RequestMove(ICollisionComponent objectToMove)
{
MoveResponse response = new MoveResponse(false);
HandleObjectMovement(objectToMove);
return response;
}
/// <summary>
/// Resolves all collisions against the source ICollidable object.
/// </summary>
/// <param name="source">The source ICollidable object that has moved and requires collision testing.</param>
protected MoveResponse HandleObjectMovement(ICollisionComponent source)
{
tempCollisionList.Clear();
higherPriorityCollisionList.Clear();
lowerPriorityCollisionList.Clear();
resolvedCollisions.Clear();
finalCorrectionVector = new CorrectionVector2();
MoveResponse response = new MoveResponse();
collisionTree.GetCollidingWith(source, ref tempCollisionList);
while (tempCollisionList.Count > 0)
{
if (source.Solid)
{
for (int i = 0; i < tempCollisionList.Count; i++)
{
ICollisionComponent currObject = tempCollisionList[i];
//Check if the object we are colliding with has a priority greater than ours.
//If so, then add it to the list of collisions we need to resolve!
//We will also consider objects with the same priority so long as both of use are flagged as being able to collide with
//objects of the same priority.
if (currObject.Solid)
{
if (currObject.CollisionPriority > source.CollisionPriority ||
(
(currObject.CollisionPriority == source.CollisionPriority)))
{
higherPriorityCollisionList.Add(currObject);
}
//If we've collided with anything of lower priority then we need to push IT out of the way.
else if (currObject.CollisionPriority < source.CollisionPriority)
{
lowerPriorityCollisionList.Add(currObject);
}
}
}
}
//Now let's resolve those collisions!
ResolveAllCollisions(source);
//Resolve all of the individual collisions that we are pushing away.
for (int j = 0; j < lowerPriorityCollisionList.Count; j++)
{
ResolveIndividualCollision(source, lowerPriorityCollisionList[j]);
}
//Notify all the ICollisionComponents that they have collided with something.
//for (int j = 0; j < tempCollisionList.Count; j++)
//{
// if (collisionEvents.ContainsKey(source.Parent.GUID) && collisionEvents[source.Parent.GUID] != null)
// collisionEvents[source.Parent.GUID](source, tempCollisionList[j], finalCorrectionVector);
// if (collisionEvents.ContainsKey(tempCollisionList[j].Parent.GUID) && collisionEvents[tempCollisionList[j].Parent.GUID] != null)
// collisionEvents[tempCollisionList[j].Parent.GUID](tempCollisionList[j], source, finalCorrectionVector);
// }
tempCollisionList.Clear();
higherPriorityCollisionList.Clear();
lowerPriorityCollisionList.Clear();
//Only check again if we're resolving collisions!
if (ResolveCollisions)
{
collisionTree.GetCollidingWith(source, ref tempCollisionList);
}
}
return(response);
}
