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 );
}
//-----------------------------------------------------------------------------
// 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 CTraceFilterSkipTwoEntities::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
Assert( pHandleEntity );
if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt2 ) )
return false;
return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask );
}
//-----------------------------------------------------------------------------
// 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 *pHandleEntity, int contentsMask )
{
if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) )
return false;
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( pEntity )
{
if ( pEntity == m_pPassEnt2 )
return false;
if ( pEntity->GetCollisionGroup() == TF_COLLISIONGROUP_GRENADES )
return false;
if ( pEntity->GetCollisionGroup() == TFCOLLISION_GROUP_ROCKETS )
return false;
if ( pEntity->GetCollisionGroup() == COLLISION_GROUP_DEBRIS )
return false;
if ( pEntity->GetCollisionGroup() == COLLISION_GROUP_NONE )
return false;
return true;
}
return true;
}
void CGETKnife::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
// Call the baseclass first so we don't interfere with the normal running of things
BaseClass::VPhysicsCollision( index, pEvent );
// Grab what we hit
CBaseEntity *pOther = pEvent->pEntities[!index];
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS) )
return;
if ( !PassServerEntityFilter( this, pOther) )
return;
if ( !g_pGameRules->ShouldCollide( GetCollisionGroup(), pOther->GetCollisionGroup() ) )
return;
trace_t tr;
CollisionEventToTrace( index, pEvent, tr );
Vector vecAiming = pEvent->preVelocity[index];
VectorNormalize( vecAiming );
if ( pOther->m_takedamage != DAMAGE_NO && (pOther->IsPlayer() || pOther->IsNPC()) )
{
ClearMultiDamage();
CTakeDamageInfo dmgInfo( this, GetOwnerEntity(), GetDamage(), DMG_SLASH | DMG_NEVERGIB );
CalculateMeleeDamageForce( &dmgInfo, vecAiming, tr.endpos, TKNIFE_FORCE_SCALE );
dmgInfo.SetDamagePosition( tr.endpos );
if ( this->GetOwnerEntity() && this->GetOwnerEntity()->IsPlayer() )
{
CBasePlayer *pPlayer = ToBasePlayer( this->GetOwnerEntity() );
dmgInfo.SetWeapon( pPlayer->Weapon_OwnsThisType( "weapon_throwing_knife" ) );
}
pOther->DispatchTraceAttack( dmgInfo, vecAiming, &tr );
ApplyMultiDamage();
PhysCallbackSetVelocity( pEvent->pObjects[index], vec3_origin );
SetTouch( NULL );
SetThink( NULL );
PhysCallbackRemove( this->NetworkProp() );
}
else
{
if ( pOther->IsWorld() )
{
// We hit the world, we have to check if this is sky
trace_t tr2;
Vector origin;
pEvent->pInternalData->GetContactPoint( origin );
UTIL_TraceLine( origin, origin + (vecAiming * 4), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr2 );
if ( tr2.surface.flags & SURF_SKY )
{
// We hit sky, remove us NOW
SetTouch( NULL );
SetThink( NULL );
PhysCallbackRemove( this->NetworkProp() );
return;
}
}
m_bInAir = false;
CollisionProp()->UseTriggerBounds( true, 24 );
g_PostSimulationQueue.QueueCall( this, &CBaseEntity::SetOwnerEntity, (CBaseEntity*)NULL );
// const CBaseEntity *host = te->GetSuppressHost();
// te->SetSuppressHost( NULL );
// StopParticleEffects( this );
// te->SetSuppressHost( (CBaseEntity*)host );
SetTouch( &CGETKnife::PickupTouch );
SetThink( &CGETKnife::RemoveThink );
g_PostSimulationQueue.QueueCall(this, &CBaseEntity::SetCollisionGroup, COLLISION_GROUP_DROPPEDWEAPON);
SetNextThink( gpGlobals->curtime + 10.0f );
}
}
void CGETKnife::DamageTouch( CBaseEntity *pOther )
{
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS) )
return;
if ( !PassServerEntityFilter( this, pOther) )
return;
if ( !g_pGameRules->ShouldCollide( GetCollisionGroup(), pOther->GetCollisionGroup() ) )
return;
if (!pOther->IsPlayer() && !pOther->IsNPC())
return;
Vector vecAiming;
VPhysicsGetObject()->GetVelocity( &vecAiming, NULL );
VectorNormalize( vecAiming );
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + (vecAiming * 24), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
// We didn't hit the player again with our damage cast. Do a cast to the player's center to get a proper hit.
if (tr.m_pEnt != pOther)
{
Vector TargetVec = pOther->GetAbsOrigin();
TargetVec.z = min(GetAbsOrigin().z, pOther->EyePosition().z); //Make sure we don't cast over their head.
UTIL_TraceLine(GetAbsOrigin(), pOther->GetAbsOrigin(), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
}
// TEMPORARY DEBUGGING PURPOSES
// DebugDrawLine( tr.startpos, tr.endpos, 0, 255, 0, true, 5.0f );
// debugoverlay->AddSweptBoxOverlay( tr.startpos, tr.endpos, CollisionProp()->OBBMins(), CollisionProp()->OBBMaxs(), GetAbsAngles(), 0, 0, 255, 100, 5.0f );
// END TEMPORARY
// If our target can take damage and the trace actually hit our target
if ( pOther->m_takedamage != DAMAGE_NO && tr.fraction < 1.0f && tr.m_pEnt == pOther )
{
ClearMultiDamage();
CTakeDamageInfo dmgInfo( this, GetOwnerEntity(), GetDamage(), DMG_SLASH | DMG_NEVERGIB );
CalculateMeleeDamageForce( &dmgInfo, vecAiming, tr.endpos, TKNIFE_FORCE_SCALE );
dmgInfo.SetDamagePosition( tr.endpos );
if ( this->GetOwnerEntity() && this->GetOwnerEntity()->IsPlayer() )
{
CBasePlayer *pPlayer = ToBasePlayer( this->GetOwnerEntity() );
dmgInfo.SetWeapon( pPlayer->Weapon_OwnsThisType( "weapon_knife_throwing" ) );
}
pOther->DispatchTraceAttack( dmgInfo, vecAiming, &tr );
ApplyMultiDamage();
SetAbsVelocity( vec3_origin );
SetTouch( NULL );
SetThink( NULL );
PhysCallbackRemove( this->NetworkProp() );
}
}
