Added CollisionMap.

Author: jordanbriere

addons/source-python/packages/source-python/entities/collisions.py

@@ -18,6 +18,7 @@
 #   Entities
 from _entities._collisions import CollisionHash
 from _entities._collisions import CollisionManager
+from _entities._collisions import CollisionMap
 from _entities._collisions import CollisionRules
 from _entities._collisions import CollisionSet
 from _entities._collisions import collision_manager
@@ -30,6 +31,7 @@
     'CollisionHash',
     'CollisionHook',
     'CollisionManager',
+    'CollisionMap',
     'CollisionRules',
     'CollisionSet',
     'collision_manager',

src/core/modules/entities/entities_collisions.cpp

@@ -501,8 +501,12 @@ CCollisionCache *CCollisionManager::GetCache(unsigned int uiIndex)
 //-----------------------------------------------------------------------------
 // ICollisionRules class.
 //-----------------------------------------------------------------------------
-ICollisionRules::ICollisionRules()
+ICollisionRules::ICollisionRules(bool bRegister)
 {
+	if (!bRegister) {
+		return;
+	}
+
 	static CCollisionManager *pManager = GetCollisionManager();
 	pManager->RegisterRules(this);
 }
@@ -638,6 +642,18 @@ list CCollisionHash::GetPairs(void *pObject)
 //-----------------------------------------------------------------------------
 // CCollisionSet class.
 //-----------------------------------------------------------------------------
+CCollisionSet::CCollisionSet():
+	ICollisionRules()
+{
+
+}
+
+CCollisionSet::CCollisionSet(bool bRegister):
+	ICollisionRules(bRegister)
+{
+
+}
+
 void CCollisionSet::Add(CBaseEntityWrapper *pEntity)
 {
 	if (Contains(pEntity)) {
@@ -703,6 +719,89 @@ bool CCollisionSet::ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther)
 };
 
 
+//-----------------------------------------------------------------------------
+// CCollisionMap class.
+//-----------------------------------------------------------------------------
+boost::shared_ptr<CCollisionSet> CCollisionMap::Find(CBaseEntityWrapper *pEntity)
+{
+	boost::shared_ptr<CCollisionSet> spSet;
+	spSet = m_mapSets[pEntity];
+
+	if (!get_pointer(spSet)) {
+		if (!pEntity->IsNetworked()) {
+			BOOST_RAISE_EXCEPTION(
+				PyExc_ValueError,
+				"Given entity is not networked."
+			)
+		}
+
+		spSet = boost::shared_ptr<CCollisionSet>(new CCollisionSet(false));
+		m_mapSets[pEntity] = spSet;
+	}
+
+	return spSet;
+}
+
+void CCollisionMap::Remove(void *pObject)
+{
+	m_mapSets.erase(pObject);
+}
+
+void CCollisionMap::Clear()
+{
+	m_mapSets.clear();
+}
+
+bool CCollisionMap::Contains(void *pObject)
+{
+	return m_mapSets.find(pObject) != m_mapSets.end();
+}
+
+unsigned int CCollisionMap::GetSize()
+{
+	return m_mapSets.size();
+}
+
+bool CCollisionMap::HasElements()
+{
+	return !m_mapSets.empty();
+}
+
+object CCollisionMap::Iterate()
+{
+	list oElements;
+
+	if (HasElements()) {
+		for (boost::unordered_map<void *, boost::shared_ptr<CCollisionSet> >::const_iterator it = m_mapSets.begin();
+				it != m_mapSets.end(); it++) {
+			oElements.append(make_tuple(object(it->first), object(it->second)));
+		}
+	}
+
+	return oElements.attr("__iter__")();
+}
+
+void CCollisionMap::OnEntityDeleted(CBaseEntity *pEntity)
+{
+	for (boost::unordered_map<void *, boost::shared_ptr<CCollisionSet> >::const_iterator it = m_mapSets.begin();
+			it != m_mapSets.end(); it++) {
+		it->second->OnEntityDeleted(pEntity);
+	}
+
+	Remove(pEntity);
+}
+
+bool CCollisionMap::ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther)
+{
+	CCollisionSet *pSet = get_pointer(m_mapSets[pEntity]);
+	if (!pSet) {
+		return true;
+	}
+
+	return !pSet->Contains(pOther);
+}
+
+
 //-----------------------------------------------------------------------------
 // CCollisionListenerManager class.
 //-----------------------------------------------------------------------------

src/core/modules/entities/entities_collisions.h

@@ -110,7 +110,7 @@ struct CollisionHookData_t
 class ICollisionRules
 {
 public:
-	ICollisionRules();
+	ICollisionRules(bool bRegister = true);
 	virtual ~ICollisionRules();
 
 	virtual void OnEntityDeleted(CBaseEntity *pEntity) = 0;
@@ -153,6 +153,9 @@ class CCollisionHash : public ICollisionRules
 class CCollisionSet : public ICollisionRules
 {
 public:
+	CCollisionSet();
+	CCollisionSet(bool bRegister);
+
 	void Add(CBaseEntityWrapper *pEntity);
 	void Remove(void *pObject);
 	void Clear(void *pObject);
@@ -171,6 +174,31 @@ class CCollisionSet : public ICollisionRules
 };
 
 
+//-----------------------------------------------------------------------------
+// CCollisionMap class.
+//-----------------------------------------------------------------------------
+class CCollisionMap: public ICollisionRules
+{
+public:
+	void OnEntityDeleted(CBaseEntity *pEntity);
+	bool ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther);
+
+	boost::shared_ptr<CCollisionSet> Find(CBaseEntityWrapper *pEntity);
+
+	void Remove(void *pObject);
+	void Clear();
+
+	bool Contains(void *pObject);
+	unsigned int GetSize();
+	bool HasElements();
+
+	object Iterate();
+
+private:
+	boost::unordered_map<void *, boost::shared_ptr<CCollisionSet> > m_mapSets;
+};
+
+
 //-----------------------------------------------------------------------------
 // CCollisionCache class.
 //-----------------------------------------------------------------------------

src/core/modules/entities/entities_collisions_wrap.cpp

@@ -39,6 +39,7 @@ static void export_collision_manager(scope);
 static void export_collision_rules(scope);
 static void export_collision_hash(scope);
 static void export_collision_set(scope);
+static void export_collision_map(scope);
 
 
 //-----------------------------------------------------------------------------
@@ -50,6 +51,7 @@ DECLARE_SP_SUBMODULE(_entities, _collisions)
 	export_collision_rules(_collisions);
 	export_collision_hash(_collisions);
 	export_collision_set(_collisions);
+	export_collision_map(_collisions);
 }
 
 
@@ -169,7 +171,7 @@ void export_collision_hash(scope _collisions)
 //-----------------------------------------------------------------------------
 void export_collision_set(scope _collisions)
 {
-	class_<CCollisionSet, bases<ICollisionRules> > CollisionSet(
+	class_<CCollisionSet, boost::shared_ptr<CCollisionSet>, bases<ICollisionRules> > CollisionSet(
 		"CollisionSet",
 		"Collision rules where contained elements never collide with anything."
 	);
@@ -218,3 +220,59 @@ void export_collision_set(scope _collisions)
 		"Returns the amount of elements contained in the set."
 	);
 }
+
+
+//-----------------------------------------------------------------------------
+// Exports CCollisionMap.
+//-----------------------------------------------------------------------------
+void export_collision_map(scope _collisions)
+{
+	class_<CCollisionMap, bases<ICollisionRules> > CollisionMap(
+		"CollisionMap",
+		"Collision rules that overrides one-way collisions."
+	);
+
+	// Methods...
+	CollisionMap.def(
+		"clear",
+		&CCollisionMap::Clear,
+		"Removes all elements from the map."
+	);
+
+	// Special methods...
+	CollisionMap.def(
+		"__getitem__",
+		&CCollisionMap::Find,
+		"Returns the collision set associated with the given entity."
+	);
+
+	CollisionMap.def(
+		"__delitem__",
+		&CCollisionMap::Remove,
+		"Removes the collision set associated with the given entity."
+	);
+
+	CollisionMap.def(
+		"__bool__",
+		&CCollisionMap::HasElements,
+		"Returns whether the map is empty or not."
+	);
+
+	CollisionMap.def(
+		"__contains__",
+		&CCollisionMap::Contains,
+		"Returns whether the given element is in the map or not."
+	);
+
+	CollisionMap.def(
+		"__len__",
+		&CCollisionMap::GetSize,
+		"Returns the amount of elements contained in the map."
+	);
+
+	CollisionMap.def(
+		"__iter__",
+		&CCollisionMap::Iterate,
+		"Iterates over all elements contained in the map."
+	);
+}