bool C_DynamicProp::TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )
{
if ( IsSolidFlagSet(FSOLID_NOT_SOLID) )
{
// if this entity is marked non-solid and custom test it must have bone followers
if ( IsSolidFlagSet( FSOLID_CUSTOMBOXTEST ) && IsSolidFlagSet( FSOLID_CUSTOMRAYTEST ))
{
return TestBoneFollowers( ray, fContentsMask, tr );
}
}
return BaseClass::TestCollision( ray, fContentsMask, tr );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CFuncRotating::CreateVPhysics( void )
{
if ( !IsSolidFlagSet( FSOLID_NOT_SOLID ))
{
VPhysicsInitShadow( false, false );
}
return true;
}
bool CRotDoor::CreateVPhysics()
{
if ( !IsSolidFlagSet( FSOLID_NOT_SOLID ) )
{
VPhysicsInitShadow( false, false );
}
return true;
}
//-----------------------------------------------------------------------------
// Updates the spatial partition
//-----------------------------------------------------------------------------
void CCollisionProperty::UpdateServerPartitionMask( )
{
#ifndef CLIENT_DLL
SpatialPartitionHandle_t handle = GetPartitionHandle();
if ( handle == PARTITION_INVALID_HANDLE )
return;
// Remove it from whatever lists it may be in at the moment
// We'll re-add it below if we need to.
partition->Remove( handle );
// Don't bother with deleted things
if ( !m_pOuter->edict() )
return;
// don't add the world
if ( m_pOuter->entindex() == 0 )
return;
// Make sure it's in the list of all entities
bool bIsSolid = IsSolid() || IsSolidFlagSet(FSOLID_TRIGGER);
if ( bIsSolid || m_pOuter->IsEFlagSet(EFL_USE_PARTITION_WHEN_NOT_SOLID) )
{
partition->Insert( PARTITION_ENGINE_NON_STATIC_EDICTS, handle );
}
if ( !bIsSolid )
return;
// Insert it into the appropriate lists.
// We have to continually reinsert it because its solid type may have changed
SpatialPartitionListMask_t mask = 0;
if ( !IsSolidFlagSet(FSOLID_NOT_SOLID) )
{
mask |= PARTITION_ENGINE_SOLID_EDICTS;
}
if ( IsSolidFlagSet(FSOLID_TRIGGER) )
{
mask |= PARTITION_ENGINE_TRIGGER_EDICTS;
}
Assert( mask != 0 );
partition->Insert( mask, handle );
#endif
}
void CTripmineGrenade::BeamBreakThink( void )
{
// See if I can go solid yet (has dropper moved out of way?)
if (IsSolidFlagSet( FSOLID_NOT_SOLID ))
{
trace_t tr;
Vector vUpBit = GetAbsOrigin();
vUpBit.z += 5.0;
UTIL_TraceEntity( this, GetAbsOrigin(), vUpBit, MASK_SHOT, &tr );
if ( !tr.startsolid && (tr.fraction == 1.0) )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
}
trace_t tr;
// NOT MASK_SHOT because we want only simple hit boxes
UTIL_TraceLine( GetAbsOrigin(), m_vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
// ALERT( at_console, "%f : %f\n", tr.flFraction, m_flBeamLength );
// respawn detect.
if ( !m_pBeam )
{
MakeBeam( );
if ( tr.m_pEnt )
m_hOwner = tr.m_pEnt; // reset owner too
}
CBaseEntity *pEntity = tr.m_pEnt;
CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pEntity );
bool bAttachMoved = false;
if ( m_bAttached && m_hAttachEntity.Get() != NULL )
{
if ( m_hAttachEntity.Get()->GetAbsOrigin() != m_vAttachedPosition )
bAttachMoved = true;
}
// Also blow up if the attached entity goes away, ie: a crate
if (pBCC || fabs( m_flBeamLength - tr.fraction ) > 0.001 || ( m_bAttached && m_hAttachEntity.Get() == NULL) || bAttachMoved )
{
m_iHealth = 0;
if (m_pConstraint)
m_pConstraint->Deactivate();
Event_Killed( CTakeDamageInfo( (CBaseEntity*)m_hOwner, this, 100, GIB_NORMAL ) );
return;
}
SetNextThink( gpGlobals->curtime + 0.05f );
}
void CHL2MP_Player::State_PreThink_OBSERVER_MODE()
{
// Make sure nobody has changed any of our state.
// Assert( GetMoveType() == MOVETYPE_FLY );
Assert( m_takedamage == DAMAGE_NO );
Assert( IsSolidFlagSet( FSOLID_NOT_SOLID ) );
// Assert( IsEffectActive( EF_NODRAW ) );
// Must be dead.
Assert( m_lifeState == LIFE_DEAD );
Assert( pl.deadflag );
}
void CTripwireGrenade::RopeBreakThink( void )
{
// See if I can go solid yet (has dropper moved out of way?)
if (IsSolidFlagSet(FSOLID_NOT_SOLID))
{
trace_t tr;
Vector vUpBit = GetAbsOrigin();
vUpBit.z += 5.0;
UTIL_TraceEntity( this, GetAbsOrigin(), vUpBit, MASK_SHOT, &tr );
if ( !tr.startsolid && (tr.fraction == 1.0) )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
}
// Check if rope had gotten beyond it's max length
float flRopeLength = (GetAbsOrigin()-m_pHook->GetAbsOrigin()).Length();
if (flRopeLength > TGRENADE_MAX_ROPE_LEN)
{
// Shoot missiles at hook
m_iHealth = 0;
BreakRope();
m_vTargetPos = m_pHook->GetAbsOrigin();
CrossProduct ( m_vecDir, Vector(0,0,1), m_vTargetOffset );
m_vTargetOffset *=TGRENADE_MISSILE_OFFSET;
SetThink(FireThink);
FireThink();
}
// Check to see if can see hook
// NOT MASK_SHOT because we want only simple hit boxes
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), m_pHook->GetAbsOrigin(), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
// If can't see hook
CBaseEntity *pEntity = tr.m_pEnt;
if (tr.fraction != 1.0 && pEntity != m_pHook)
{
// Shoot missiles at place where rope was intersected
m_iHealth = 0;
BreakRope();
m_vTargetPos = tr.endpos;
CrossProduct ( m_vecDir, Vector(0,0,1), m_vTargetOffset );
m_vTargetOffset *=TGRENADE_MISSILE_OFFSET;
SetThink(FireThink);
FireThink();
return;
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
const matrix3x4_t *CCollisionProperty::GetRootParentToWorldTransform() const
{
if ( IsSolidFlagSet( FSOLID_ROOT_PARENT_ALIGNED ) )
{
CBaseEntity *pEntity = m_pOuter->GetRootMoveParent();
Assert(pEntity);
if ( pEntity )
{
return &pEntity->CollisionProp()->CollisionToWorldTransform();
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Check for untouch
//-----------------------------------------------------------------------------
void CCollisionProperty::CheckForUntouch()
{
#ifndef CLIENT_DLL
if ( !IsSolid() && !IsSolidFlagSet(FSOLID_TRIGGER))
{
// If this ent's touch list isn't empty, it's transitioning to not solid
if ( m_pOuter->IsCurrentlyTouching() )
{
// mark ent so that at the end of frame it will check to
// see if it's no longer touching ents
m_pOuter->SetCheckUntouch( true );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Does not change the entities velocity at all
// Input : push -
// Output : trace_t
//-----------------------------------------------------------------------------
void C_BaseEntity::PhysicsCheckSweep( const Vector& vecAbsStart, const Vector &vecAbsDelta, trace_t *pTrace )
{
unsigned int mask = PhysicsSolidMaskForEntity();
Vector vecAbsEnd;
VectorAdd( vecAbsStart, vecAbsDelta, vecAbsEnd );
// Set collision type
if ( !IsSolid() || IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
{
// don't collide with monsters
mask &= ~CONTENTS_MONSTER;
}
Physics_TraceHull( this, vecAbsStart, vecAbsEnd, WorldAlignMins(), WorldAlignMaxs(), mask, pTrace );
}
void CTripmineGrenade::BeamBreakThink( void )
{
// See if I can go solid yet (has dropper moved out of way?)
if (IsSolidFlagSet( FSOLID_NOT_SOLID ))
{
trace_t tr;
Vector vUpBit = GetAbsOrigin();
vUpBit.z += 5.0;
UTIL_TraceEntity( this, GetAbsOrigin(), vUpBit, MASK_SHOT, &tr );
if ( !tr.startsolid && (tr.fraction == 1.0) )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
}
trace_t tr;
// NOT MASK_SHOT because we want only simple hit boxes
UTIL_TraceLine( GetAbsOrigin(), m_vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
// ALERT( at_console, "%f : %f\n", tr.flFraction, m_flBeamLength );
// respawn detect.
if ( !m_pBeam )
{
MakeBeam( );
if ( tr.m_pEnt )
m_hOwner = tr.m_pEnt; // reset owner too
}
CBaseEntity *pEntity = tr.m_pEnt;
CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pEntity );
if (pBCC && pBCC->GetTeamNumber() != m_nTeam && pBCC->m_floatCloakFactor < 1.0f)
//if (pBCC || fabs( m_flBeamLength - tr.fraction ) > 0.001)
{
m_iHealth = 0;
Event_Killed( CTakeDamageInfo( (CBaseEntity*)m_hOwner, this, 100, GIB_NORMAL ) );
return;
}
SetNextThink( gpGlobals->curtime + 0.05f );
}
bool CCollisionProperty::ShouldTouchTrigger( int triggerSolidFlags ) const
{
// debris only touches certain triggers
if ( GetCollisionGroup() == COLLISION_GROUP_DEBRIS )
{
if ( triggerSolidFlags & FSOLID_TRIGGER_TOUCH_DEBRIS )
return true;
return false;
}
// triggers don't touch other triggers (might be solid to other ents as well as trigger)
if ( IsSolidFlagSet( FSOLID_TRIGGER ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Updates the spatial partition
//-----------------------------------------------------------------------------
void CCollisionProperty::UpdatePartition( )
{
if ( m_pOuter->IsEFlagSet( EFL_DIRTY_SPATIAL_PARTITION ) )
{
m_pOuter->RemoveEFlags( EFL_DIRTY_SPATIAL_PARTITION );
#ifndef CLIENT_DLL
Assert( m_pOuter->entindex() != 0 );
// Don't bother with deleted things
if ( !m_pOuter->edict() )
return;
if ( GetPartitionHandle() == PARTITION_INVALID_HANDLE )
{
CreatePartitionHandle();
UpdateServerPartitionMask();
}
#else
if ( GetPartitionHandle() == PARTITION_INVALID_HANDLE )
return;
#endif
// We don't need to bother if it's not a trigger or solid
if ( IsSolid() || IsSolidFlagSet( FSOLID_TRIGGER ) || m_pOuter->IsEFlagSet( EFL_USE_PARTITION_WHEN_NOT_SOLID ) )
{
// Bloat a little bit...
if ( BoundingRadius() != 0.0f )
{
Vector vecSurroundMins, vecSurroundMaxs;
WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs );
vecSurroundMins -= Vector( 1, 1, 1 );
vecSurroundMaxs += Vector( 1, 1, 1 );
partition->ElementMoved( GetPartitionHandle(), vecSurroundMins, vecSurroundMaxs );
}
else
{
partition->ElementMoved( GetPartitionHandle(), GetCollisionOrigin(), GetCollisionOrigin() );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CFuncMoveLinear::CreateVPhysics( void )
{
if ( !FClassnameIs( this, "func_water_analog" ) )
{
//normal door
if ( !IsSolidFlagSet( FSOLID_NOT_SOLID ) )
{
VPhysicsInitShadow( false, false );
}
}
else
{
// special contents
AddSolidFlags( FSOLID_VOLUME_CONTENTS );
//SETBITS( m_spawnflags, SF_DOOR_SILENT ); // water is silent for now
IPhysicsObject *pPhysics = VPhysicsInitShadow( false, false );
fluidparams_t fluid;
Assert( CollisionProp()->GetCollisionAngles() == vec3_angle );
fluid.damping = 0.01f;
fluid.surfacePlane[0] = 0;
fluid.surfacePlane[1] = 0;
fluid.surfacePlane[2] = 1;
fluid.surfacePlane[3] = CollisionProp()->GetCollisionOrigin().z + CollisionProp()->OBBMaxs().z - 1;
fluid.currentVelocity.Init(0,0,0);
fluid.torqueFactor = 0.1f;
fluid.viscosityFactor = 0.01f;
fluid.pGameData = static_cast<void *>(this);
//FIXME: Currently there's no way to specify that you want slime
fluid.contents = CONTENTS_WATER;
m_pFluidController = physenv->CreateFluidController( pPhysics, &fluid );
}
return true;
}
//-----------------------------------------------------------------------------
// Expand trigger bounds..
//-----------------------------------------------------------------------------
void CCollisionProperty::ComputeVPhysicsSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
{
bool bSetBounds = false;
IPhysicsObject *pPhysicsObject = GetOuter()->VPhysicsGetObject();
if ( pPhysicsObject )
{
if ( pPhysicsObject->GetCollide() )
{
physcollision->CollideGetAABB( pVecWorldMins, pVecWorldMaxs,
pPhysicsObject->GetCollide(), GetCollisionOrigin(), GetCollisionAngles() );
bSetBounds = true;
}
else if ( pPhysicsObject->GetSphereRadius( ) )
{
float flRadius = pPhysicsObject->GetSphereRadius( );
Vector vecExtents( flRadius, flRadius, flRadius );
VectorSubtract( GetCollisionOrigin(), vecExtents, *pVecWorldMins );
VectorAdd( GetCollisionOrigin(), vecExtents, *pVecWorldMaxs );
bSetBounds = true;
}
}
if ( !bSetBounds )
{
*pVecWorldMins = GetCollisionOrigin();
*pVecWorldMaxs = *pVecWorldMins;
}
// Also, lets expand for the trigger bounds also
if ( IsSolidFlagSet( FSOLID_USE_TRIGGER_BOUNDS ) )
{
Vector vecWorldTriggerMins, vecWorldTriggerMaxs;
WorldSpaceTriggerBounds( &vecWorldTriggerMins, &vecWorldTriggerMaxs );
VectorMin( vecWorldTriggerMins, *pVecWorldMins, *pVecWorldMins );
VectorMax( vecWorldTriggerMaxs, *pVecWorldMaxs, *pVecWorldMaxs );
}
}
bool CFuncWallToggle::IsOn( void )
{
if ( IsSolidFlagSet( FSOLID_NOT_SOLID ) )
return false;
return true;
}
