场景管理：四叉树算法C++实现

简单实现了游戏中场景管理用到的四叉树算法

代码结构：

• object.h，object.cpp被管理的对象类
• quad_tree_node.h，quad_tree_node.cpp四叉树类
• main.cpp程序入口

object.h

/*
//被管理的对象类
*/
#pragma once
class Object
{
public:
	Object(float _x,float _y,float _width,float _height);
	~Object();
public:
	//对象的属性，例如坐标和长宽，以左上角为锚点
	float x;
	float y;
	float width;
	float height;
};

object.cpp

#include "object.h"


Object::Object(float _x,float _y,float _width,float _height):
	x(_x),
	y(_y),
	width(_width),
	height(_height)
{
}
Object::~Object()
{
}

quad_tree_node.h

/*
//四叉树节点类，用头节点代表四叉树
//坐标系坐上角为原点，左往右为x轴递增，上往下y轴递增
//本四叉树的策略是：1，插入时动态分配节点和删除节点，不是满树；2，当矩形区域完全包含某个节点时才获取或剔除；3，对象放在完全包含它的区域节点内，非根节点也存储对象
*/
#pragma once
#include <list>

//四叉树类型枚举
enum QuadType
{
	ROOT,         //根
	UP_RIGHT,     //象限Ⅰ
	UP_LEFT,      //象限Ⅱ
	BOTTOM_LEFT,  //象限Ⅲ
	BOTTOM_RIGHT  //象限Ⅳ
};

template <typename T>
class QuadTreeNode
{
public:
	QuadTreeNode(float _x,float _y,float _width,float _height,int _level,int _maxLevel,QuadType _quadType,QuadTreeNode *_parent);
	~QuadTreeNode();
public:
	void InsertObject(T *object); //插入对象
	std::list<T *> GetObjectsAt(float px,float py,float w,float h); //查询对象,获得一片区域里的对象链表，此处只考虑完全包含的
	void RemoveObjectsAt(float px,float py,float w,float h); //删除对象，删除一片区域里的对象和节点，此处只考虑完全包含的

private:
	bool IsContain(float px,float py,float w,float h,T *object) const; //判断某个区域是否包含某对象
	bool IsContain(float px,float py,float w,float h,QuadTreeNode<T> *quadTreeNode) const; //重载，判断某个区域是否包含某个节点
private:
	std::list<T *> objects; //节点数据队列
	//父、子节点，分四个象限
	QuadTreeNode *parent;
	QuadTreeNode *upRightNode;
	QuadTreeNode *upLeftNode;
	QuadTreeNode *bottomLeftNode;
	QuadTreeNode *bottomRightNode;
	//节点类型
	QuadType quadType;
	//坐标和长宽属性，左上角为锚点
	float x;
	float y;
	float width;
	float height;

	int level; //当前深度
	int maxLevel; //最大深度
};

quad_tree_node.cpp

#include "quad_tree_node.h"

template <typename T>
QuadTreeNode<T>::QuadTreeNode(
	float _x,float _y,float _width,float _height,
	int _level,int _maxLevel,
	QuadType _quadType,
	QuadTreeNode *_parent):
	x(_x),
	y(_y),
	width(_width),
	height(_height),
	level(_level),
	maxLevel(_maxLevel),
	quadType(_quadType)
{
	parent=_parent;
	upRightNode=nullptr;
	bottomLeftNode=nullptr;
	bottomRightNode=nullptr;
}

template <typename T>
QuadTreeNode<T>::~QuadTreeNode()
{
	if(level==maxLevel)
		return;
	//如果不是叶子节点，就销毁子节点
	parent=nullptr;

}

template <typename T>
bool QuadTreeNode<T>::IsContain(float px,float py,float w,float h,T *object) const 
{
	if(object->x>=px
		&&object->x+object->width<=px+w
		&&object->y>=py
		&&object->y+object->height<=py+h)
		return true;
	return false;
}

template <typename T>
bool QuadTreeNode<T>::IsContain(float px,float py,float w,float h,QuadTreeNode<T> *quadTreeNode) const
{
	if(quadTreeNode->x>=px
		&&quadTreeNode->x+quadTreeNode->width<=px+w
		&&quadTreeNode->y>=py
		&&quadTreeNode->y+quadTreeNode->height<=py+h)
		return true;
	return false;
}

template <typename T>
void QuadTreeNode<T>::InsertObject(T *object)
{
	//如果是叶子节点，则存在叶子节点
	if(level==maxLevel)
	{
		objects.push_back(object);
		return;
	}
	
	//非叶子节点，如果下层节点可以包含该对象，则递归构建子节点并插入对象,边构建边插入
	if(IsContain(x+width/2,y,width/2,height/2,object))
	{
		if(!upRightNode) //避免重复创建覆盖掉原来的节点
			upRightNode=new QuadTreeNode(x+width/2,y,width/2,height/2,level+1,maxLevel,UP_RIGHT,this);//如果没有子节点就创建子节点，parent节点是当前节点
		upRightNode->InsertObject(object);
		return;
	}
	else if(IsContain(x,y,width/2,height/2,object))
	{
		if(!upLeftNode)
			upLeftNode=new QuadTreeNode(x,y,width/2,height/2,level+1,maxLevel,UP_LEFT,this);
		upLeftNode->InsertObject(object);
		return;
	}
	else if(IsContain(x,y+height/2,width/2,height/2,object))
	{
		if(!bottomLeftNode)
			bottomLeftNode=new QuadTreeNode(x,y+height/2,width/2,height/2,level+1,maxLevel,BOTTOM_LEFT,this);
		bottomLeftNode->InsertObject(object);
		return;
	}
	else if(IsContain(x+width/2,y+height/2,width/2,height/2,object))
	{
		if(!bottomRightNode)
			bottomRightNode=new QuadTreeNode(x+width/2,y+height/2,width/2,height/2,level+1,maxLevel,BOTTOM_RIGHT,this);
		bottomRightNode->InsertObject(object);
		return;
	}
	//下层节点不能完全包含改对象，则插入到当前非叶子节点
	//这个判断也可以省去
	if(IsContain(x,y,width,height,object))
		objects.push_back(object);
}

template <typename T>
std::list<T *> QuadTreeNode<T>::GetObjectsAt(float px,float py,float w,float h)
{
	std::list<T *> resObjects;
	//如果当前节点完全被包含，把当前节点存的对象放到列表末尾,空链表也行
	if(IsContain(px,py,w,h,this))
	{
		resObjects.insert(resObjects.end(),objects.begin(),objects.end());
		//最后一层
		if(level==maxLevel)
			return resObjects;
	}

	//如果有下层节点就把下层节点包含的对象加进来
	if(upRightNode)
	{
		std::list<T *> upRightChild;
		upRightChild=upRightNode->GetObjectsAt(px,py,w,h);
		resObjects.insert(resObjects.end(),upRightChild.begin(),upRightChild.end());
	}		
	if(upLeftNode)
	{
		std::list<T *> upLeftChild;
		upLeftChild=upLeftNode->GetObjectsAt(px,py,w,h);
		resObjects.insert(resObjects.end(),upLeftChild.begin(),upLeftChild.end());
	}	
	if(bottomLeftNode)
	{
		std::list<T *> bottomLeftChild;
		bottomLeftChild=bottomLeftNode->GetObjectsAt(px,py,w,h);
		resObjects.insert(resObjects.end(),bottomLeftChild.begin(),bottomLeftChild.end());
	}
	if(bottomRightNode)
	{
		std::list<T *> bottomRightChild;
		bottomRightChild=bottomRightNode->GetObjectsAt(px,py,w,h);
		resObjects.insert(resObjects.end(),bottomRightChild.begin(),bottomRightChild.end());
	}
	return resObjects;
}

template <typename T>
void QuadTreeNode<T>::RemoveObjectsAt(float px,float py,float w,float h)
{
	//如果本层节点被包含则删除本层节点的对象
	//这个判断主要是对根节点起作用，其他子节点实际在上层都做了判断
	if(IsContain(px,py,w,h,this))
	{
		//清除本节点层的对象
		objects.clear();
		//最后一层
		if(level==maxLevel)
			return;

	}
	//如果有子节点且被包含就销毁子节点，注意别产生野指针
	//其实只要上层被包含了，下层肯定被包含，代码还需改进
	if(upRightNode&&IsContain(px,py,w,h,upRightNode))
	{
		upRightNode->RemoveObjectsAt(px,py,w,h);
		delete upRightNode;
		upRightNode=nullptr;

	}
	if(upLeftNode&&IsContain(px,py,w,h,upLeftNode))
	{
		upLeftNode->RemoveObjectsAt(px,py,w,h);
		delete upLeftNode;
		upLeftNode=nullptr;

	}
	if(bottomLeftNode&&IsContain(px,py,w,h,bottomLeftNode))
	{
		bottomLeftNode->RemoveObjectsAt(px,py,w,h);
		delete bottomLeftNode;
		bottomLeftNode=nullptr;

	}
	if(bottomRightNode&&IsContain(px,py,w,h,bottomRightNode))
	{
		bottomRightNode->RemoveObjectsAt(px,py,w,h);
		delete bottomRightNode;
		bottomRightNode=nullptr;
	}
}

main.cpp

#include <iostream>
#include <queue>
#include "object.h"
#include "quad_tree_node.h"
#include "quad_tree_node.cpp"

using namespace std;


int main(int argc,char *argv[])
{
	QuadTreeNode<Object> *quadTree=new QuadTreeNode<Object>(0,0,200,200,1,3,ROOT,nullptr);

	quadTree->InsertObject(new Object(50,50,100,100));
	quadTree->InsertObject(new Object(25,25,50,50));
	quadTree->InsertObject(new Object(62.5,12.5,25,25));
	quadTree->InsertObject(new Object(62.5,62.5,25,25));
	quadTree->InsertObject(new Object(63.5,63.6,25,25));
	quadTree->InsertObject(new Object(125,25,50,50));
	quadTree->InsertObject(new Object(112.5,62.5,25,25));

	quadTree->RemoveObjectsAt(100,0,110,110);
	list<Object *> resObjects=quadTree->GetObjectsAt(0,0,200,200);
	cout<<resObjects.size()<<endl;
	for(auto &t:resObjects)
		cout<<t->x<<' '<<t->y<<' '<<t->width<<' '<<t->height<<endl;
	delete quadTree;
	system("pause");
	return 0;
}