public QuadTree(int x, int y, int width, int height)
{
mRootNode = new QuadNode(new Rectangle(x, y, width, height));
mRootNode.getSetID = 1;
AddToNodePopulus(mRootNode);
}
/// <summary>
/// Should be implemented for an Adaptive QuadTree design
/// </summary>
public void CheckNodes(IQuadNode node)
{
CheckChildNodes(node);
//IDictionary<string, ICollidable> passMe = new Dictionary<string, ICollidable>();
//IList<IEntity> values = GetChildObjects(mRootNode);
//foreach (IEntity entityRef in values)
//{
// if (entityRef.getSetID != "Player1" && entityRef is Wall)
// {
// passMe.Add(entityRef.getSetID, (ICollidable)entityRef);
// }
//}
//CollisionM.getInstance.BreakStaticHitboxes();
//CollisionM.getInstance.SetUpStaticHitboxes(passMe);
//IDictionary<string, ICollidable> passMe = new Dictionary<string, ICollidable>();
//foreach (ICollidable c in objectToNodeLookup.Keys)
//{
// if (c.getSetID == "Player1")
// {
// passMe.Concat(objectToNodeLookup[c].getSetParent.getContents);
// break;
// }
//}
//CollisionM.getInstance.BreakStaticHitboxes();
//CollisionM.getInstance.SetUpStaticHitboxes(passMe);
}
public QuadTree(Rectangle pBounds)
{
mRootNode = new QuadNode(pBounds);
mRootNode.getSetID = 1;
AddToNodePopulus(mRootNode);
}
/// <summary>
/// Clears all of the contents inside the IQuadNode
/// </summary>
/// <param name="node">IQuadNode to be wiped</param>
public void ClearObjectsFromNode(IQuadNode node)
{
List <IEntity> quadObjects = new List <IEntity>(node.getContents.Values);
foreach (IEntity quadObject in quadObjects)
{
RemoveObjectFromNode(quadObject);
}
}
/// <summary>
/// Splits a IQuadNode into 4 more QuadNodes
/// </summary>
/// <param name="node">IQuadNode to split</param>
public void SplitNode(IQuadNode node)
{
node.Split();
foreach (IQuadNode child in node.getChildNodes.Values)
{
child.getSetParent = node;
AddToNodePopulus(child);
}
}
/// <summary>
/// Adds an IEntity object to a IQuadNode's contents dictionary
/// </summary>
/// <param name="node">IQuadNode which object will be added to</param>
/// <param name="e">IEntity object to be added</param>
public void AddObjectToNode(IQuadNode node, IEntity e)
{
node.getContents.Add(e.getSetID, e);
objectToNodeLookup.Add(e, node);
if (e is ICollidable)
{
ICollidable c = (ICollidable)e;
c.BoundsChanged += new EventHandler(quadObject_BoundsChanged);
}
}
private void CheckChildNodes(IQuadNode node)
{
if (node.getContentsCount <= mMaxObjectsPerLeaf)
{
// Move child objects into this node, and delete sub nodes
IList <IEntity> subChildObjects = GetChildObjects(node);
foreach (IEntity childObject in subChildObjects)
{
if (!node.getContents.Values.Contains(childObject) && node.getSetID != 1)
{
RemoveObjectFromNode(childObject);
AddObjectToNode(node, childObject);
}
}
if (node.getSetParent != null)
{
//CheckChildNodes(node.getSetParent);
CheckNodes(node.getSetParent);
}
else
{
// Its the root node, see if we're down to one quadrant, with none in local storage - if so, ditch the other three
int numQuadrantsWithObjects = 0;
IQuadNode nodeWithObjects = null;
foreach (IQuadNode childNode in node.getChildNodes.Values)
{
if (childNode != null && childNode.getContentsCount > 0)
{
numQuadrantsWithObjects++;
nodeWithObjects = childNode;
if (numQuadrantsWithObjects > 1)
{
break;
}
}
}
if (numQuadrantsWithObjects == 1)
{
foreach (IQuadNode childNode in node.getChildNodes.Values)
{
if (childNode != nodeWithObjects)
{
childNode.getSetParent = null;
}
}
mRootNode = nodeWithObjects;
}
}
}
}
public void ClearQuadTree()
{
foreach (IQuadNode node in mAllNodes.Values)
{
node.getContents.Clear();
}
objectToNodeLookup.Clear();
mRootNode = mAllNodes[1];
mAllNodes.Clear();
AddToNodePopulus(mRootNode);
//objectToNodeLookup.Clear();
}
public void Insert(IEntity quadObject)
{
bool containsObject = false;
//mRootNode = mAllNodes[1];
while (!containsObject)
{
if (mRootNode.getSetParent != null)
{
foreach (IQuadNode qn in mRootNode.getSetParent.getChildNodes.Values)
{
mRootNode = qn;
if (quadObject is ICollidable)
{
ICollidable c = (ICollidable)quadObject;
c.SetUpHitbox();
if (mRootNode.getBounds.Contains(c.getSetHitbox))
{
containsObject = true;
break;
}
}
// Object is not ICollidable
else
{
if (mRootNode.getBounds.Contains(quadObject.getSetPointLocation))
{
containsObject = true;
break;
}
}
}
}
else
{
containsObject = true;
}
if (!containsObject)
{
mRootNode = mRootNode.getSetParent;
}
}
InsertObjectToNode(quadObject, mRootNode);
}
/// <summary>
/// Removes an IEntity object from a IQuadNode's contents dictionary
/// </summary>
/// <param name="e">IEntity object to be removed</param>
public void RemoveObjectFromNode(IEntity e)
{
IQuadNode node = objectToNodeLookup[e];
node.getContents.Remove(e.getSetID);
objectToNodeLookup.Remove(e);
if (e is ICollidable && e.getSetName == "Player")
{
ICollidable c = (ICollidable)e;
c.BoundsChanged -= new EventHandler(quadObject_BoundsChanged);
}
}
public void quadObject_BoundsChanged(object sender, EventArgs e)
{
ICollidable quadObject = sender as ICollidable;
if (!objectToNodeLookup[quadObject].getBounds.Intersects(quadObject.getSetHitbox))
{
RemoveObjectFromNode(quadObject);
Insert(quadObject);
mRootNode = objectToNodeLookup[quadObject];
Console.WriteLine("Change bounds to this node: " + mRootNode.getSetID);
BoundsHaveChanged(quadObject, mRootNode);
}
}
private List <IEntity> GetChildObjects(IQuadNode node)
{
List <IEntity> results = new List <IEntity>();
results.AddRange(node.getContents.Values);
foreach (IQuadNode childNode in node.getChildNodes.Values)
{
if (childNode != null)
{
results.AddRange(GetChildObjects(childNode));
}
}
return(results);
}
public void BoundsHaveChanged(IEntity quadObject, IQuadNode node)
{
IDictionary <string, ICollidable> passMe = new Dictionary <string, ICollidable>();
List <IEntity> values = GetChildObjects(mRootNode);
foreach (IEntity entityRef in values)
{
if (entityRef.getSetID != "Player1" && (entityRef is IStructure || entityRef is ISmartObject))
{
passMe.Add(entityRef.getSetID, (ICollidable)entityRef);
}
}
//CollisionM.getInstance.BreakStaticHitboxes();
//CollisionM.getInstance.SetUpStaticHitboxes(passMe);
CollisionM.getInstance.getSetDictionary = passMe;
}
private void ContentsHasChanged(IQuadNode node)
{
IDictionary <string, ICollidable> passMe = new Dictionary <string, ICollidable>();
List <IEntity> values = GetChildObjects(node);
foreach (IEntity entityRef in values)
{
if (entityRef.getSetID != "Player1" && (entityRef is IStructure || entityRef is ISmartObject))
{
passMe.Add(entityRef.getSetID, (ICollidable)entityRef);
}
}
//CollisionM.getInstance.ResetStaticHitboxes();
//CollisionM.getInstance.SetUpStaticHitboxes(passMe);
CollisionM.getInstance.getSetDictionary = passMe;
CollisionM.getInstance.ResetStaticHitboxes();
}
public void Remove(IEntity quadObject)
{
if (!objectToNodeLookup.ContainsKey(quadObject))
{
throw new KeyNotFoundException("QuadObject not found in dictionary for removal");
}
IQuadNode containingNode = objectToNodeLookup[quadObject];
RemoveObjectFromNode(quadObject);
if (containingNode.getSetParent != null)
{
//CheckNodes(containingNode.getSetParent);
}
ContentsHasChanged(containingNode);
}
/// <summary>
/// Adds the IQuadNode node to the dictionary which contains all of the nodes in the tree
/// </summary>
/// <param name="node">IQuadNode to add</param>
public void AddToNodePopulus(IQuadNode node)
{
mAllNodes.Add(node.getSetID, node);
}
/// <summary>
/// Checks for whether it needs to split a QuadNode and cleans up contents lists
/// </summary>
/// <param name="e">IEntity to be inserted</param>
/// <param name="node">IQuadNode which object will be inserted to</param>
public void InsertObjectToNode(IEntity e, IQuadNode node)
{
ICollidable c;
if (node.getChildNodes.Count == 0 && node.getContents.Count + 1 > mMaxObjectsPerLeaf)
{
SplitNode(node);
List <IEntity> childObjects = new List <IEntity>(node.getContents.Values);
List <IEntity> childrenToRelocate = new List <IEntity>();
foreach (IEntity childObject in childObjects)
{
foreach (IQuadNode childNode in node.getChildNodes.Values)
{
if (childNode == null)
{
continue;
}
if (childObject is ICollidable)
{
c = (ICollidable)childObject;
if (childNode.getBounds.Contains(c.getSetHitbox))
{
childrenToRelocate.Add(childObject);
break;
}
}
// If object is a floor
else
{
if (childNode.getBounds.Contains(childObject.getSetPointLocation))
{
childrenToRelocate.Add(childObject);
break;
}
}
}
}
foreach (IEntity childObject in childrenToRelocate)
{
RemoveObjectFromNode(childObject);
InsertObjectToNode(childObject, node);
}
}
foreach (IQuadNode childNode in node.getChildNodes.Values)
{
if (childNode != null)
{
if (e is ICollidable)
{
c = (ICollidable)e;
if (childNode.getBounds.Contains(c.getSetHitbox))
{
InsertObjectToNode(e, childNode);
return;
}
}
// If object is a floor
else
{
if (childNode.getBounds.Contains(e.getSetLocation))
{
InsertObjectToNode(e, childNode);
return;
}
}
}
}
AddObjectToNode(node, e);
}
