//----------------------------------------------------------------------------- // Purpose: // Input : *pHandleEntity - // contentsMask - // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CASW_Trace_Filter_Doors::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { if ( !StandardFilterRules( pHandleEntity, contentsMask ) ) return false; // Don't test if the game code tells us we should ignore this collision... CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); const CBaseEntity *pEntPass = EntityFromEntityHandle( m_pPassEnt ); // don't hurt ourself if ( pEntPass == pEntity ) return false; if ( !pEntity || pEntity->Classify() != CLASS_ASW_DOOR ) return false; CASW_Door *pDoor = assert_cast<CASW_Door*>( pEntity ); if ( !pDoor ) return false; if ( m_bRequireLockedOrSealed ) { if ( pDoor->GetSealAmount() > 0 || !pDoor->IsAutoOpen() ) { return true; } else { return false; } } return true; }
//----------------------------------------------------------------------------- // The trace filter! //----------------------------------------------------------------------------- bool CTraceFilterSimple::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { if(m_pPassEnt) { // Don't test if the game code tells us we should ignore this collision... CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); CBaseEntity *pPass = EntityFromEntityHandle( (CBaseEntity *)m_pPassEnt ); if(VFuncs::entindex(pEntity) != VFuncs::entindex(pPass)) return true; } return false; }
//----------------------------------------------------------------------------- // A standard filter to be applied to just about everything. //----------------------------------------------------------------------------- bool StandardFilterRules( IHandleEntity *pHandleEntity, int fContentsMask ) { CBaseEntity *pCollide = EntityFromEntityHandle( pHandleEntity ); // Static prop case... if ( !pCollide ) return true; SolidType_t solid = pCollide->GetSolid(); const model_t *pModel = pCollide->GetModel(); if ( ( modelinfo->GetModelType( pModel ) != mod_brush ) || (solid != SOLID_BSP && solid != SOLID_VPHYSICS) ) { if ( (fContentsMask & CONTENTS_MONSTER) == 0 ) return false; } // This code is used to cull out tests against see-thru entities if ( !(fContentsMask & CONTENTS_WINDOW) && pCollide->IsTransparent() ) return false; // FIXME: this is to skip BSP models that are entities that can be // potentially moved/deleted, similar to a monster but doors don't seem to // be flagged as monsters // FIXME: the FL_WORLDBRUSH looked promising, but it needs to be set on // everything that's actually a worldbrush and it currently isn't if ( !(fContentsMask & CONTENTS_MOVEABLE) && (pCollide->GetMoveType() == MOVETYPE_PUSH))// !(touch->flags & FL_WORLDBRUSH) ) return false; return true; }
//----------------------------------------------------------------------------- // The trace filter! //----------------------------------------------------------------------------- bool CTraceFilterSimple::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { if ( !StandardFilterRules( pHandleEntity, contentsMask ) ) return false; if ( m_pPassEnt ) { if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) ) { return false; } } // Don't test if the game code tells us we should ignore this collision... CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity ) return false; if ( !pEntity->ShouldCollide( m_collisionGroup, contentsMask ) ) return false; if ( pEntity && !g_pGameRules->ShouldCollide( m_collisionGroup, pEntity->GetCollisionGroup() ) ) return false; if ( m_pExtraShouldHitCheckFunction && (! ( m_pExtraShouldHitCheckFunction( pHandleEntity, contentsMask ) ) ) ) return false; return true; }
bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity ) return false; // Check parents against each other // NOTE: Don't let siblings/parents collide. if ( UTIL_EntityHasMatchingRootParent( m_pRootParent, pEntity ) ) return false; if ( m_checkHash ) { if ( g_EntityCollisionHash->IsObjectPairInHash( m_pEntity, pEntity ) ) return false; } #ifndef CLIENT_DLL if ( m_pEntity->IsNPC() ) { if ( NPC_CheckBrushExclude( m_pEntity, pEntity ) ) return false; } #endif return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask ); }
bool CASWTraceFilterShot::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { Assert( pHandleEntity ); if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt2 ) ) return false; CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); // don't collide with other projectiles if ( dynamic_cast<CASW_Flamer_Projectile*>( pEntity ) != NULL ) return false; if ( dynamic_cast<CASW_Extinguisher_Projectile*>( pEntity ) != NULL ) return false; if ( pEntity && pEntity->Classify() == CLASS_ASW_MARINE ) { if ( m_bSkipMarines ) return false; CASW_Marine *pMarine = assert_cast<CASW_Marine*>( pEntity ); if ( m_bSkipRollingMarines && pMarine->GetCurrentMeleeAttack() && pMarine->GetCurrentMeleeAttack()->m_nAttackID == CASW_Melee_System::s_nRollAttackID ) return false; if ( m_bSkipMarinesReflectingProjectiles && pMarine->IsReflectingProjectiles() ) return false; } if ( m_bSkipAliens && pEntity && IsAlienClass( pEntity->Classify() ) ) return false; return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask ); }
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { static const char *ppszIgnoredClasses[] = { "weapon_*", "item_*", "prop_ragdoll", "prop_dynamic", "prop_static", "prop_physics", "npc_bullseye", // Tracker 15335 }; CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); // Tracker 15335: Never impact decals against entities which are not rendering, either. if ( pEntity->IsEffectActive( EF_NODRAW ) ) return false; for ( int i = 0; i < ARRAYSIZE(ppszIgnoredClasses); i++ ) { if ( pEntity->ClassMatches( ppszIgnoredClasses[i] ) ) return false; } if ( modelinfo->GetModelType( pEntity->GetModel() ) != mod_brush ) return false; return CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask ); }
bool CTraceFilterWars::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { // Only collide with the map boundaries! CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity || !(dynamic_cast<CBaseFuncMapBoundary *>(pEntity)) ) return false; return true; }
bool CTraceFilterSkipTwoClassnames::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity || FClassnameIs( pEntity, m_pchClassname2 ) ) return false; return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask ); }
//----------------------------------------------------------------------------- // Purpose: Trace filter that ignores team mates //----------------------------------------------------------------------------- bool CTraceFilterIgnoreTeam::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity ) return false; if( pEntity->GetOwnerNumber() == m_iOwnerNumber ) return false; return CTraceFilterSimple::ShouldHitEntity(pHandleEntity, contentsMask); }
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); if ( pEntity && pEntity->IsBaseObject() ) return false; return BaseClass::ShouldHitEntity( pServerEntity, contentsMask ); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CTraceFilterLOS::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity->BlocksLOS() ) return false; return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask ); }
DETOUR_DECL_MEMBER(bool, CTraceFilterDeflection_ShouldHitEntity, IHandleEntity *pHandleEntity, int contentsMask) { if (cvar_fix.GetBool()) { CBaseEntity *pEntity = EntityFromEntityHandle(pHandleEntity); if (pEntity == nullptr) return false; if (pEntity->IsPlayer()) return false; } return DETOUR_MEMBER_CALL(CTraceFilterDeflection_ShouldHitEntity)(pHandleEntity, contentsMask); }
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); if ( pEntity->IsPlayer() && pEntity->GetTeamNumber() == m_iIgnoreTeam ) { return false; } return true; }
bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); if ( pEntity ) { if ( pEntity->IsPlayer() || pEntity->MyNPCPointer() ) return true; } return false; }
//----------------------------------------------------------------------------- // Purpose: Trace filter that only hits anything but Units and the player //----------------------------------------------------------------------------- bool CTraceFilterNoUnitsOrPlayer::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { if ( CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask ) ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity ) return NULL; return (!pEntity->IsUnit() && !pEntity->IsPlayer()); } return false; }
bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); if ( pEntity ) { if ( pEntity->IsPlayer() || pEntity->MyNPCPointer() || pEntity->m_iClassname == g_iszPhysicsPropClassname ) return true; } return false; }
bool CTraceFilterSkipEnemies::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity ) return false; CUnitBase *pUnit = pEntity->MyUnitPointer(); if( m_pUnit && pUnit && m_pUnit->IRelationType(pUnit) == D_HT ) { return false; } return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask ); }
bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); // Static prop case... if ( !pEntity ) return false; // Only impact on physics objects if ( !pEntity->VPhysicsGetObject() ) return false; return g_pGameRules->CanEntityBeUsePushed( pEntity ); }
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); if ( !pEntity ) return false; IUnit *pUnit = pEntity->GetIUnit(); if( pUnit && pUnit->AreAttacksPassable(m_pUnit) && m_pUnit->GetCommander() == NULL ) { return false; } return BaseClass::ShouldHitEntity( pServerEntity, contentsMask ); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CTraceFilterSimpleClassnameList::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity ) return false; for ( int i = 0; i < m_PassClassnames.Count(); ++i ) { if ( FClassnameIs( pEntity, m_PassClassnames[ i ] ) ) return false; } return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask ); }
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { C_BaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); if( pEntity && ( dynamic_cast<C_BaseViewModel *>( pEntity ) != NULL ) || ( dynamic_cast<C_BasePlayer *>( pEntity ) != NULL ) ) { return false; } else { return true; } }
//----------------------------------------------------------------------------- // Purpose: Trace filter that only hits anything but NPCs and the player //----------------------------------------------------------------------------- bool CTraceFilterNoNPCsOrPlayer::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { if ( CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask ) ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity ) return NULL; #ifndef CLIENT_DLL if ( pEntity->Classify() == CLASS_PLAYER_ALLY ) return false; // CS hostages are CLASS_PLAYER_ALLY but not IsNPC() #endif return (!pEntity->IsNPC() && !pEntity->IsPlayer()); } return false; }
//----------------------------------------------------------------------------- // // Shared client/server trace filter code // //----------------------------------------------------------------------------- bool PassServerEntityFilter( const IHandleEntity *pTouch, const IHandleEntity *pPass ) { if ( !pPass ) return true; if ( pTouch == pPass ) return false; const CBaseEntity *pEntTouch = EntityFromEntityHandle( pTouch ); const CBaseEntity *pEntPass = EntityFromEntityHandle( pPass ); if ( !pEntTouch || !pEntPass ) return true; // don't clip against own missiles if ( pEntTouch->GetOwnerEntity() == pEntPass ) return false; // don't clip against owner if ( pEntPass->GetOwnerEntity() == pEntTouch ) return false; return true; }
//----------------------------------------------------------------------------- // Purpose: // Input : *pHandleEntity - // contentsMask - // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CASW_Trace_Filter_Door_Crush::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { if ( !StandardFilterRules( pHandleEntity, contentsMask ) ) return false; if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) ) return false; // Don't test if the game code tells us we should ignore this collision... CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( pEntity ) { //Msg("%f CASW_Trace_Filter_Door_Crush::ShouldHitEntity %s\n", gpGlobals->curtime, pEntity->GetClassname()); if ( !pEntity->ShouldCollide( m_collisionGroup, contentsMask ) ) return false; if ( !g_pGameRules->ShouldCollide( m_collisionGroup, pEntity->GetCollisionGroup() ) ) return false; if ( pEntity->Classify() == CLASS_ASW_DOOR ) return false; if ( pEntity->m_takedamage == DAMAGE_NO ) return false; // Translate the vehicle into its driver for damage if ( pEntity->GetServerVehicle() != NULL ) { CBaseEntity *pDriver = pEntity->GetServerVehicle()->GetPassenger(); if ( pDriver != NULL ) { pEntity = pDriver; } } Vector attackDir = pEntity->WorldSpaceCenter() - m_dmgInfo->GetAttacker()->WorldSpaceCenter(); VectorNormalize( attackDir ); pEntity->TakeDamage( *m_dmgInfo ); //CalculateMeleeDamageForce( &info, attackDir, info.GetAttacker()->WorldSpaceCenter(), m_flForceScale ); return true; } return false; }
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) ) return false; CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( pEntity ) { if ( g_pGameRules->ShouldCollide( m_collisionGroupAlreadyChecked, pEntity->GetCollisionGroup() ) ) return false; if ( g_pGameRules->ShouldCollide( m_newCollisionGroup, pEntity->GetCollisionGroup() ) ) return true; } return false; }
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); if ( pEntity->IsPlayer() ) { if ( pEntity != GetPassEntity() ) { return false; } else return true; } return true; }
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { // Only skip ourselves (not things we own) if ( pHandleEntity == m_pTraceOwner ) return false; // Get the entity referenced by this handle CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( pEntity == NULL ) return false; // Handle grate entities differently if ( HasContentsGrate( pEntity ) ) { // See if it's a grabbable physics prop CPhysicsProp *pPhysProp = dynamic_cast<CPhysicsProp *>(pEntity); if ( pPhysProp != NULL ) return pPhysProp->CanBePickedUpByPhyscannon(); // See if it's a grabbable physics prop if ( FClassnameIs( pEntity, "prop_physics" ) ) { CPhysicsProp *pPhysProp = dynamic_cast<CPhysicsProp *>(pEntity); if ( pPhysProp != NULL ) return pPhysProp->CanBePickedUpByPhyscannon(); // Somehow had a classname that didn't match the class! Assert(0); } else if ( FClassnameIs( pEntity, "func_physbox" ) ) { // Must be a moveable physbox CPhysBox *pPhysBox = dynamic_cast<CPhysBox *>(pEntity); if ( pPhysBox ) return pPhysBox->CanBePickedUpByPhyscannon(); // Somehow had a classname that didn't match the class! Assert(0); } // Don't bother with any other sort of grated entity return false; } // Use the default rules return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask ); }
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) { // Test against the vehicle too? // FLASHLIGHTFIXME: how do you know that you are actually inside of the vehicle? C_BaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); if ( !pEntity ) return true; if ( ( dynamic_cast<C_BaseViewModel *>( pEntity ) != NULL ) || ( dynamic_cast<C_BasePlayer *>( pEntity ) != NULL ) || pEntity->GetCollisionGroup() == COLLISION_GROUP_DEBRIS || pEntity->GetCollisionGroup() == COLLISION_GROUP_INTERACTIVE_DEBRIS ) { return false; } return true; }
//----------------------------------------------------------------------------- // Purpose: Trace filter that only hits NPCs and the player //----------------------------------------------------------------------------- bool CTraceFilterOnlyNPCsAndPlayer::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) { if ( CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask ) ) { CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); if ( !pEntity ) return false; #ifdef CSTRIKE_DLL #ifndef CLIENT_DLL if ( pEntity->Classify() == CLASS_PLAYER_ALLY ) return true; // CS hostages are CLASS_PLAYER_ALLY but not IsNPC() #endif // !CLIENT_DLL #endif // CSTRIKE_DLL return (pEntity->IsNPC() || pEntity->IsPlayer()); } return false; }