Added CollisionSet.

Some minors fixes to make potential physics support easier.

Author: jordanbriere

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

@@ -19,6 +19,7 @@
 from _entities._collisions import CollisionHash
 from _entities._collisions import CollisionManager
 from _entities._collisions import CollisionRules
+from _entities._collisions import CollisionSet
 from _entities._collisions import collision_manager
 
 
@@ -30,6 +31,7 @@
     'CollisionHook',
     'CollisionManager',
     'CollisionRules',
+    'CollisionSet',
     'collision_manager',
 ]
 

src/core/modules/entities/entities_collisions.cpp

@@ -160,7 +160,7 @@ void CCollisionManager::OnNetworkedEntityCreated(object oEntity)
 void CCollisionManager::OnNetworkedEntityDeleted(CBaseEntity *pEntity)
 {
 	FOR_EACH_VEC(m_vecRules, i) {
-		m_vecRules[i]->OnEntityDeleted((void *)pEntity);
+		m_vecRules[i]->OnEntityDeleted(pEntity);
 	}
 }
 
@@ -422,14 +422,14 @@ bool CCollisionManager::ShouldHitEntity(IHandleEntity *pHandleEntity, int conten
 	}
 
 	FOR_EACH_VEC(pManager->m_vecRules, i) {
-		if (!pManager->m_vecRules[i]->ShouldHitEntity((void *)scope.m_pFilter->m_pPassEnt, (void *)pHandleEntity)) {
+		if (!pManager->m_vecRules[i]->ShouldHitEntity((CBaseEntity *)scope.m_pFilter->m_pPassEnt, (CBaseEntity *)pHandleEntity)) {
 			scope.m_pCache->SetResult(uiIndex, false);
 			return false;
 		}
 	}
 
 	if (scope.m_bIsPlayer) {
-		static CPlayerCollisionListenerManager *OnPlayerCollision = GetOnPlayerCollisionListenerManager();
+		static CCollisionListenerManager *OnPlayerCollision = GetOnPlayerCollisionListenerManager();
 		if (!OnPlayerCollision->GetCount()) {
 			scope.m_pCache->SetResult(uiIndex, true);
 			return true;
@@ -451,7 +451,7 @@ bool CCollisionManager::ShouldHitEntity(IHandleEntity *pHandleEntity, int conten
 		return true;
 	}
 
-	static CEntityCollisionListenerManager *OnEntityCollision = GetOnEntityCollisionListenerManager();
+	static CCollisionListenerManager *OnEntityCollision = GetOnEntityCollisionListenerManager();
 	if (!OnEntityCollision->GetCount()) {
 		scope.m_pCache->SetResult(uiIndex, true);
 		return true;
@@ -563,78 +563,146 @@ CCollisionHash::~CCollisionHash()
 	physics->DestroyObjectPairHash(m_pHash);
 }
 
-void CCollisionHash::OnEntityDeleted(void *pEntity)
+void CCollisionHash::OnEntityDeleted(CBaseEntity *pEntity)
 {
 	RemovePairs(pEntity);
 }
 
-bool CCollisionHash::ShouldHitEntity(void *pEntity, void *pOther)
+bool CCollisionHash::ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther)
 {
 	return !HasPair(pEntity, pOther);
 }
 
-void CCollisionHash::AddPair(void *pEntity, void *pOther)
+void CCollisionHash::AddPair(CBaseEntityWrapper *pEntity, CBaseEntityWrapper *pOther)
 {
-	if (!IsValidNetworkedEntityPointer(pEntity) || !IsValidNetworkedEntityPointer(pOther)) {
+	if (!pEntity->IsNetworked() || !pOther->IsNetworked()) {
 		BOOST_RAISE_EXCEPTION(
 			PyExc_ValueError,
-			"Given entity pointer invalid or not networked."
+			"Given entity is not networked."
 		)
 	}
 
 	m_pHash->AddObjectPair(pEntity, pOther);
 }
 
-void CCollisionHash::RemovePair(void *pEntity, void *pOther)
+void CCollisionHash::RemovePair(void *pObject, void *pOther)
 {
-	m_pHash->RemoveObjectPair(pEntity, pOther);
+	m_pHash->RemoveObjectPair(pObject, pOther);
 }
 
-void CCollisionHash::RemovePairs(void *pEntity)
+void CCollisionHash::RemovePairs(void *pObject)
 {
-	m_pHash->RemoveAllPairsForObject(pEntity);
+	m_pHash->RemoveAllPairsForObject(pObject);
 }
 
-bool CCollisionHash::Contains(void *pEntity)
+bool CCollisionHash::Contains(void *pObject)
 {
-	return m_pHash->IsObjectInHash(pEntity);
+	return m_pHash->IsObjectInHash(pObject);
 }
 
-bool CCollisionHash::HasPair(void *pEntity, void *pOther)
+bool CCollisionHash::HasPair(void *pObject, void *pOther)
 {
-	return m_pHash->IsObjectPairInHash(pEntity, pOther);
+	return m_pHash->IsObjectPairInHash(pObject, pOther);
 }
 
-int CCollisionHash::GetCount(void *pEntity)
+int CCollisionHash::GetCount(void *pObject)
 {
-	return m_pHash->GetPairCountForObject(pEntity);
+	return m_pHash->GetPairCountForObject(pObject);
 }
 
-list CCollisionHash::GetPairs(void *pEntity)
+list CCollisionHash::GetPairs(void *pObject)
 {
-	list oEntities;
-	int nCount = m_pHash->GetPairCountForObject(pEntity);
+	list oObjects;
+	int nCount = m_pHash->GetPairCountForObject(pObject);
 
 	if (!nCount) {
-		return oEntities;
+		return oObjects;
 	}
 
-	void **ppEntities = (void **)stackalloc(nCount * sizeof(void *));
-	m_pHash->GetPairListForObject(pEntity, nCount, ppEntities);
+	void **ppObjects = (void **)stackalloc(nCount * sizeof(void *));
+	m_pHash->GetPairListForObject(pObject, nCount, ppObjects);
 
 	for (int i = 0; i < nCount; ++i) {
-		pEntity = ppEntities[i];
-		if (!pEntity) {
+		pObject = ppObjects[i];
+		if (!pObject) {
 			continue;
 		}
 
-		oEntities.append(pEntity);
+		oObjects.append(pObject);
 	}
 
-	return oEntities;
+	return oObjects;
 }
 
 
+//-----------------------------------------------------------------------------
+// CCollisionSet class.
+//-----------------------------------------------------------------------------
+void CCollisionSet::Add(CBaseEntityWrapper *pEntity)
+{
+	if (Contains(pEntity)) {
+		return;
+	}
+
+	if (!pEntity->IsNetworked()) {
+		BOOST_RAISE_EXCEPTION(
+			PyExc_ValueError,
+			"Given entity is not networked."
+		)
+	}
+
+	m_pSet.insert(pEntity);
+}
+
+void CCollisionSet::Remove(void *pObject)
+{
+	m_pSet.erase(pObject);
+}
+
+bool CCollisionSet::Contains(void *pObject)
+{
+	return m_pSet.find(pObject) != m_pSet.end();
+}
+
+void CCollisionSet::Clear(void *pObject)
+{
+	m_pSet.clear();
+}
+
+unsigned int CCollisionSet::GetSize()
+{
+	return m_pSet.size();
+}
+
+bool CCollisionSet::HasElements()
+{
+	return !m_pSet.empty();
+}
+
+object CCollisionSet::Iterate()
+{
+	list oElements;
+
+	if (HasElements()) {
+		for (boost::unordered_set<void *>::const_iterator it = m_pSet.begin(); it != m_pSet.end(); it++) {
+			oElements.append(*it);
+		}
+	}
+
+	return oElements.attr("__iter__")();
+}
+
+void CCollisionSet::OnEntityDeleted(CBaseEntity *pEntity)
+{
+	Remove(pEntity);
+};
+
+bool CCollisionSet::ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther)
+{
+	return !(Contains(pEntity) || Contains(pOther));
+};
+
+
 //-----------------------------------------------------------------------------
 // CCollisionListenerManager class.
 //-----------------------------------------------------------------------------
@@ -682,20 +750,16 @@ bool CCollisionListenerManager::CallCallbacks(object oEntity, object oOther)
 
 
 //-----------------------------------------------------------------------------
-// CEntityCollisionListenerManager singleton accessor.
+// Singleton accessors.
 //-----------------------------------------------------------------------------
-static CEntityCollisionListenerManager s_OnEntityCollision;
-CEntityCollisionListenerManager *GetOnEntityCollisionListenerManager()
+static CCollisionListenerManager s_OnEntityCollision;
+CCollisionListenerManager *GetOnEntityCollisionListenerManager()
 {
 	return &s_OnEntityCollision;
 }
 
-
-//-----------------------------------------------------------------------------
-// CPlayerCollisionListenerManager singleton accessor.
-//-----------------------------------------------------------------------------
-static CPlayerCollisionListenerManager s_OnPlayerCollision;
-CPlayerCollisionListenerManager *GetOnPlayerCollisionListenerManager()
+static CCollisionListenerManager s_OnPlayerCollision;
+CCollisionListenerManager *GetOnPlayerCollisionListenerManager()
 {
 	return &s_OnPlayerCollision;
 }

src/core/modules/entities/entities_collisions.h

@@ -113,8 +113,8 @@ class ICollisionRules
 	ICollisionRules();
 	virtual ~ICollisionRules();
 
-	virtual void OnEntityDeleted(void *pEntity) = 0;
-	virtual bool ShouldHitEntity(void *pEntity, void *pOther) = 0;
+	virtual void OnEntityDeleted(CBaseEntity *pEntity) = 0;
+	virtual bool ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther) = 0;
 
 	virtual void UnloadInstance();
 };
@@ -129,24 +129,48 @@ class CCollisionHash : public ICollisionRules
 	CCollisionHash();
 	~CCollisionHash();
 
-	void OnEntityDeleted(void *pEntity);
-	bool ShouldHitEntity(void *pEntity, void *pOther);
+	void OnEntityDeleted(CBaseEntity *pEntity);
+	bool ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther);
 
-	void AddPair(void *pEntity, void *pOther);
-	void RemovePair(void *pEntity, void *pOther);
-	void RemovePairs(void *pEntity);
+	void AddPair(CBaseEntityWrapper *pEntity, CBaseEntityWrapper *pOther);
+	void RemovePair(void *pObject, void *pOther);
+	void RemovePairs(void *pObject);
 
-	bool Contains(void *pEntity);
-	bool HasPair(void *pEntity, void *pOther);
+	bool Contains(void *pObject);
+	bool HasPair(void *pObject, void *pOther);
 
-	int GetCount(void *pEntity);
-	list GetPairs(void *pEntity);
+	int GetCount(void *pObject);
+	list GetPairs(void *pObject);
 
 private:
 	IPhysicsObjectPairHash *m_pHash;
 };
 
 
+//-----------------------------------------------------------------------------
+// CCollisionSet class.
+//-----------------------------------------------------------------------------
+class CCollisionSet : public ICollisionRules
+{
+public:
+	void Add(CBaseEntityWrapper *pEntity);
+	void Remove(void *pObject);
+	void Clear(void *pObject);
+
+	bool Contains(void *pObject);
+	unsigned int GetSize();
+	bool HasElements();
+
+	object Iterate();
+
+	void OnEntityDeleted(CBaseEntity *pEntity);
+	bool ShouldHitEntity(CBaseEntity *pEntity, CBaseEntity *pOther);
+
+private:
+	boost::unordered_set<void *> m_pSet;
+};
+
+
 //-----------------------------------------------------------------------------
 // CCollisionCache class.
 //-----------------------------------------------------------------------------
@@ -245,29 +269,9 @@ class CCollisionListenerManager : public CListenerManager
 	bool m_bInitialized;
 };
 
-
-//-----------------------------------------------------------------------------
-// CEntityCollisionListenerManager class.
-//-----------------------------------------------------------------------------
-class CEntityCollisionListenerManager: public CCollisionListenerManager
-{
-
-};
-
-// Singleton accessor.
-CEntityCollisionListenerManager *GetOnEntityCollisionListenerManager();
-
-
-//-----------------------------------------------------------------------------
-// CPlayerCollisionListenerManager class.
-//-----------------------------------------------------------------------------
-class CPlayerCollisionListenerManager: public CCollisionListenerManager
-{
-
-};
-
-// Singleton accessor.
-CPlayerCollisionListenerManager *GetOnPlayerCollisionListenerManager();
+// Singleton accessors.
+CCollisionListenerManager *GetOnPlayerCollisionListenerManager();
+CCollisionListenerManager *GetOnEntityCollisionListenerManager();
 
 
 #endif // _ENTITIES_COLLISIONS_H