Updated CollisionHash.

Author: jordanbriere

addons/source-python/docs/source-python/source/developing/module_tutorials/listeners.rst

@@ -329,7 +329,11 @@ OnEntityCollision
 
 Called when a non-player entity is about to collide with another entity.
 
-.. note:: This listener can be extremely noisy. Use :class:`entities.collisions.CollisionHash` if you don't have dynamic conditions to test for.
+.. note::
+
+    This listener can be extremely noisy. Use :class:`entities.collisions.CollisionHash`,
+    :class:`entities.collisions.CollisionMap`, or :class:`entities.collisions.CollisionSet`
+    if you don't have dynamic conditions to test for.
 
 .. code-block:: python
 
@@ -428,7 +432,11 @@ OnPlayerCollision
 
 Called when a player is about to collide with an entity.
 
-.. note:: This listener can be extremely noisy. Use :class:`entities.collisions.CollisionHash` if you don't have dynamic conditions to test for.
+.. note::
+
+    This listener can be extremely noisy. Use :class:`entities.collisions.CollisionHash`,
+    :class:`entities.collisions.CollisionMap`, or :class:`entities.collisions.CollisionSet`
+    if you don't have dynamic conditions to test for.
 
 .. code-block:: python
 

src/core/modules/entities/entities_collisions.cpp

@@ -40,7 +40,6 @@
 // Externals.
 //-----------------------------------------------------------------------------
 extern IEngineTrace *enginetrace;
-extern IPhysics *physics;
 extern CGlobalVars *gpGlobals;
 
 
@@ -323,7 +322,10 @@ bool CCollisionManager::EnterScope(HookType_t eHookType, CHook *pHook)
 	}
 
 	scope.m_pFilter = pWrapper;
-	scope.m_nMask = nMask;
+
+	static object ContentFlags = import("engines").attr("trace").attr("ContentFlags");
+	scope.m_oMask = ContentFlags(nMask);
+
 	scope.m_bSolidContents = bSolidContents;
 	scope.m_uiIndex = uiIndex;
 	scope.m_bIsPlayer = ((CBaseEntityWrapper *)pWrapper->m_pPassEnt)->IsPlayer();
@@ -399,12 +401,9 @@ bool CCollisionManager::ShouldHitEntity(IHandleEntity *pHandleEntity, int conten
 
 		object oFilter = object(ptr((ITraceFilter *)scope.m_pFilter));
 
-		static object ContentFlags = import("engines").attr("trace").attr("ContentFlags");
-		object oMask = ContentFlags(scope.m_nMask);
-
 		FOR_EACH_VEC(pManager->m_pCollisionHooks->m_vecCallables, i) {
 			BEGIN_BOOST_PY()
-				object oResult = pManager->m_pCollisionHooks->m_vecCallables[i](oEntity, oOther, oFilter, oMask);
+				object oResult = pManager->m_pCollisionHooks->m_vecCallables[i](oEntity, oOther, oFilter, scope.m_oMask);
 				if (!oResult.is_none() && !extract<bool>(oResult)) {
 					scope.m_pCache->SetResult(uiIndex, false);
 					return false;
@@ -546,27 +545,6 @@ void CCollisionCache::SetResult(unsigned int uiIndex, bool bResult)
 //-----------------------------------------------------------------------------
 // CCollisionHash class.
 //-----------------------------------------------------------------------------
-CCollisionHash::CCollisionHash()
-{
-	m_pHash = physics->CreateObjectPairHash();
-
-	if (!m_pHash) {
-		BOOST_RAISE_EXCEPTION(
-			PyExc_RuntimeError,
-			"Failed to create a collision hash."
-		)
-	}
-}
-
-CCollisionHash::~CCollisionHash()
-{
-	if (!m_pHash) {
-		return;
-	}
-
-	physics->DestroyObjectPairHash(m_pHash);
-}
-
 void CCollisionHash::OnEntityDeleted(CBaseEntity *pEntity)
 {
 	RemovePairs(pEntity);
@@ -586,58 +564,82 @@ void CCollisionHash::AddPair(CBaseEntityWrapper *pEntity, CBaseEntityWrapper *pO
 		)
 	}
 
-	m_pHash->AddObjectPair(pEntity, pOther);
+	m_setPairs.insert(CollisionPair_t(pEntity, pOther));
 }
 
 void CCollisionHash::RemovePair(void *pObject, void *pOther)
 {
-	m_pHash->RemoveObjectPair(pObject, pOther);
+	m_setPairs.erase(CollisionPair_t(pObject, pOther));
 }
 
 void CCollisionHash::RemovePairs(void *pObject)
 {
-	m_pHash->RemoveAllPairsForObject(pObject);
+	for (CollisionPairs_t::const_iterator it = m_setPairs.begin(); it != m_setPairs.end(); ) {
+		CollisionPair_t p = *it;
+		if (p.first == pObject || p.second == pObject) {
+			m_setPairs.erase(it);
+		}
+
+		++it;
+	}
+}
+
+void CCollisionHash::Clear()
+{
+	m_setPairs.clear();
 }
 
 bool CCollisionHash::Contains(void *pObject)
 {
-	return m_pHash->IsObjectInHash(pObject);
+	for (CollisionPairs_t::const_iterator it = m_setPairs.begin(); it != m_setPairs.end(); ++it) {
+		CollisionPair_t p = *it;
+		if (p.first == pObject || p.second == pObject) {
+			return true;
+		}
+	}
+
+	return false;
 }
 
 bool CCollisionHash::HasPair(void *pObject, void *pOther)
 {
-	return m_pHash->IsObjectPairInHash(pObject, pOther);
+	return m_setPairs.find(CollisionPair_t(pObject, pOther)) != m_setPairs.end();
 }
 
-int CCollisionHash::GetCount(void *pObject)
+unsigned int CCollisionHash::GetCount(void *pObject)
 {
-	return m_pHash->GetPairCountForObject(pObject);
+	unsigned int nCount = 0;
+	for (CollisionPairs_t::const_iterator it = m_setPairs.begin(); it != m_setPairs.end(); ++it) {
+		CollisionPair_t p = *it;
+		if (p.first == pObject || p.second == pObject) {
+			++nCount;
+		}
+	}
+
+	return nCount;
 }
 
 list CCollisionHash::GetPairs(void *pObject)
 {
 	list oObjects;
-	int nCount = m_pHash->GetPairCountForObject(pObject);
-
-	if (!nCount) {
-		return oObjects;
-	}
-
-	void **ppObjects = (void **)stackalloc(nCount * sizeof(void *));
-	m_pHash->GetPairListForObject(pObject, nCount, ppObjects);
-
-	for (int i = 0; i < nCount; ++i) {
-		pObject = ppObjects[i];
-		if (!pObject) {
-			continue;
+	for (CollisionPairs_t::const_iterator it = m_setPairs.begin(); it != m_setPairs.end(); ++it) {
+		CollisionPair_t p = *it;
+		if (p.first == pObject) {
+			oObjects.append(p.second);
+		}
+		else if (p.second == pObject) {
+			oObjects.append(p.first);
 		}
-
-		oObjects.append(pObject);
 	}
 
 	return oObjects;
 }
 
+unsigned int CCollisionHash::GetSize()
+{
+	return m_setPairs.size();
+}
+
 
 //-----------------------------------------------------------------------------
 // CCollisionSet class.

src/core/modules/entities/entities_collisions.h

@@ -34,7 +34,6 @@
 #include "sp_main.h"
 #include "modules/listeners/listeners_manager.h"
 #include "modules/entities/entities_entity.h"
-#include "modules/physics/physics.h"
 #include "modules/memory/memory_hooks.h"
 
 // Boost
@@ -65,6 +64,8 @@ typedef boost::unordered_map<CHook *, CollisionHookData_t> CollisionHooksMap_t;
 typedef CBitVec<MAX_EDICTS> CollisionCache_t;
 typedef boost::unordered_map<unsigned int, CCollisionCache *> CollisionCacheMap_t;
 
+typedef std::pair<void *, void *> CollisionPair_t;
+
 
 //-----------------------------------------------------------------------------
 // CTraceFilterSimpleWrapper class.
@@ -89,7 +90,7 @@ struct CollisionScope_t
 	CTraceFilterSimpleWrapper *m_pFilter;
 	ShouldHitFunc_t m_pExtraShouldHitCheckFunction;
 	CCollisionCache *m_pCache;
-	int m_nMask;
+	object m_oMask;
 	bool m_bSolidContents;
 };
 
@@ -120,30 +121,52 @@ class ICollisionRules
 };
 
 
+//-----------------------------------------------------------------------------
+// CollisionPairs_t definition and specializations.
+//-----------------------------------------------------------------------------
+namespace boost {
+	inline std::size_t hash_value(CollisionPair_t const &p) {
+		std::size_t s = 0;
+		boost::hash_combine(s, p.first < p.second ? p.first : p.second);
+		boost::hash_combine(s, p.first < p.second ? p.second : p.first);
+		return s;
+	}
+
+	struct hash_equals {
+		inline bool operator()(const CollisionPair_t &a, const CollisionPair_t &b) const {
+			return (a.first == b.first && a.second == b.second) || (a.first == b.second && a.second == b.first); 
+		}
+	};
+}
+
+typedef boost::unordered_set<CollisionPair_t, boost::hash<CollisionPair_t>, boost::hash_equals> CollisionPairs_t;
+
+
 //-----------------------------------------------------------------------------
 // CCollisionHash class.
 //-----------------------------------------------------------------------------
 class CCollisionHash : public ICollisionRules
 {
 public:
-	CCollisionHash();
-	~CCollisionHash();
-
 	void OnEntityDeleted(CBaseEntity *pEntity);
 	bool ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther);
 
 	void AddPair(CBaseEntityWrapper *pEntity, CBaseEntityWrapper *pOther);
 	void RemovePair(void *pObject, void *pOther);
 	void RemovePairs(void *pObject);
 
+	void Clear();
+
 	bool Contains(void *pObject);
 	bool HasPair(void *pObject, void *pOther);
 
-	int GetCount(void *pObject);
+	unsigned int GetCount(void *pObject);
 	list GetPairs(void *pObject);
 
+	unsigned int GetSize();
+
 private:
-	IPhysicsObjectPairHash *m_pHash;
+	CollisionPairs_t m_setPairs;
 };
 
 

src/core/modules/entities/entities_collisions_wrap.cpp

@@ -157,12 +157,24 @@ void export_collision_hash(scope _collisions)
 		"Returns a list of all entities associated with the given entity."
 	);
 
+	CollisionHash.def(
+		"clear",
+		&CCollisionHash::Clear,
+		"Removes all elements from the hash."
+	);
+
 	// Special methods...
 	CollisionHash.def(
 		"__contains__",
 		&CCollisionHash::Contains,
 		"Returns whether the given entity is in the hash."
 	);
+
+	CollisionHash.def(
+		"__len__",
+		&CCollisionHash::GetSize,
+		"Returns the size of the collision hash."
+	);
 }