surfacedata_t* C_ASW_Alien::GetGroundSurface()
{
//
// Find the name of the material that lies beneath the player.
//
Vector start, end;
VectorCopy( GetAbsOrigin(), start );
VectorCopy( start, end );
// Straight down
end.z -= 38; // was 64
// Fill in default values, just in case.
Ray_t ray;
ray.Init( start, end, GetCollideable()->OBBMins(), GetCollideable()->OBBMaxs() );
trace_t trace;
UTIL_TraceRay( ray, MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NPC, &trace );
if ( trace.fraction == 1.0f )
return NULL; // no ground
return physprops->GetSurfaceData( trace.surface.surfaceProps );
}
//-----------------------------------------------------------------------------
// Purpose: Test for portals inside our volume when we switch on, and forcibly rotate them
//-----------------------------------------------------------------------------
void CFuncPortalOrientation::OnActivate( void )
{
if ( !GetCollideable() || m_bDisabled )
return;
int iPortalCount = CProp_Portal_Shared::AllPortals.Count();
if( iPortalCount != 0 )
{
CProp_Portal **pPortals = CProp_Portal_Shared::AllPortals.Base();
for( int i = 0; i != iPortalCount; ++i )
{
CProp_Portal *pTempPortal = pPortals[i];
if( IsOBBIntersectingOBB( pTempPortal->GetAbsOrigin(), pTempPortal->GetAbsAngles(), CProp_Portal_Shared::vLocalMins, CProp_Portal_Shared::vLocalMaxs,
GetAbsOrigin(), GetCollideable()->GetCollisionAngles(), GetCollideable()->OBBMins(), GetCollideable()->OBBMaxs() ) )
{
QAngle angNewAngles;
if ( m_bMatchLinkedAngles )
{
CProp_Portal* pLinked = pTempPortal->m_hLinkedPortal.Get();
if ( !pLinked )
return;
angNewAngles = pTempPortal->m_hLinkedPortal->GetAbsAngles();
}
else
{
angNewAngles = m_vecAnglesToFace;
}
pTempPortal->PlacePortal( pTempPortal->GetAbsOrigin(), angNewAngles, PORTAL_ANALOG_SUCCESS_NO_BUMP );
}
}
}
}
void C_Func_Dust::AttemptSpawnNewParticle()
{
// Find a random spot inside our bmodel.
static int nTests=10;
for( int iTest=0; iTest < nTests; iTest++ )
{
Vector vPercent = RandomVector( 0, 1 );
Vector vTest = WorldAlignMins() + (WorldAlignMaxs() - WorldAlignMins()) * vPercent;
int contents = enginetrace->GetPointContents_Collideable( GetCollideable(), vTest );
if( contents & CONTENTS_SOLID )
{
CFuncDustParticle *pParticle = (CFuncDustParticle*)m_Effect.AddParticle( 10, m_hMaterial, vTest );
if( pParticle )
{
pParticle->m_vVelocity = RandomVector( -m_SpeedMax, m_SpeedMax );
pParticle->m_vVelocity.z -= m_FallSpeed;
pParticle->m_flLifetime = 0;
pParticle->m_flDieTime = RemapVal( rand(), 0, RAND_MAX, m_LifetimeMin, m_LifetimeMax );
if( m_DustFlags & DUSTFLAGS_SCALEMOTES )
pParticle->m_flSize = RemapVal( rand(), 0, RAND_MAX, m_flSizeMin/10000.0f, m_flSizeMax/10000.0f );
else
pParticle->m_flSize = RemapVal( rand(), 0, RAND_MAX, m_flSizeMin, m_flSizeMax );
pParticle->m_Color = m_Color;
}
break;
}
}
}
bool CFuncBulletShield::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace )
{
// ignore unless a shot
if ((mask & MASK_SHOT) == MASK_SHOT)
{
// use obb collision
ICollideable *pCol = GetCollideable();
Assert(pCol);
return IntersectRayWithOBB(ray,pCol->GetCollisionOrigin(),pCol->GetCollisionAngles(),
pCol->OBBMins(),pCol->OBBMaxs(),1.0f,&trace);
/*
const model_t *pModel = this->GetCollisionModel();
if ( pModel && pModel->type == mod_brush )
{
int nModelIndex = this->GetCollisionModelIndex();
cmodel_t *pCModel = CM_InlineModelNumber( nModelIndex - 1 );
int nHeadNode = pCModel->headnode;
CM_TransformedBoxTrace( ray, nHeadNode, fMask, this->GetCollisionOrigin(), this->GetCollisionAngles(), *pTrace );
return true;
}
return false;
*/
// return BaseClass::TestCollision( ray, mask, trace );
}
else
return false;
}
void C_Func_Dust::AttemptSpawnNewParticle()
{
// Find a random spot inside our bmodel.
static int nTests=10;
for( int iTest=0; iTest < nTests; iTest++ )
{
Vector vPercent = RandomVector( 0, 1 );
double x = rand() % 6000-3000;
double y = rand() % 6000-3000;
double z = rand() % 600;
double x_distance = (x);
double y_distance = y;
double distance = sqrt((x_distance*x_distance) + (y_distance*y_distance));
int now = gpGlobals->curtime;
//Vector vTest = WorldAlignMins() + (WorldAlignMaxs() - WorldAlignMins()) * vPercent;
Vector vTest = Vector(x,y,z);
int contents = enginetrace->GetPointContents_Collideable( GetCollideable(), vTest );
if( contents & CONTENTS_SOLID )
{
PMaterialHandle my_hMaterial = m_Effect.GetPMaterial( "particle/particle_smokegrenade1" );;
CFuncDustParticle *pParticle = (CFuncDustParticle*)m_Effect.AddParticle( 10, my_hMaterial, vTest );
if( pParticle )
{
pParticle->m_vVelocity = RandomVector( -m_SpeedMax, m_SpeedMax );
pParticle->m_vVelocity.z -= m_FallSpeed;
pParticle->m_flLifetime = 0;
pParticle->m_flDieTime = RemapVal( rand(), 0, RAND_MAX, m_LifetimeMin, m_LifetimeMax );
if( m_DustFlags & DUSTFLAGS_SCALEMOTES )
pParticle->m_flSize = RemapVal( rand(), 0, RAND_MAX, m_flSizeMin/10000.0f, m_flSizeMax/10000.0f );
else
pParticle->m_flSize = RemapVal( rand(), 0, RAND_MAX, m_flSizeMin, m_flSizeMax );
pParticle->m_Color = m_Color;
}
break;
}
}
}
void CFunc_LiquidPortal::Think( void )
{
if( m_bFillInProgress )
{
if( gpGlobals->curtime < m_fFillEndTime )
{
float fInterp = ((gpGlobals->curtime - m_fFillStartTime) / (m_fFillEndTime - m_fFillStartTime));
Vector vMins, vMaxs;
GetCollideable()->WorldSpaceSurroundingBounds( &vMins, &vMaxs );
vMaxs.z = vMins.z + ((vMaxs.z - vMins.z) * fInterp);
for( int i = m_hLeftToTeleportThisFill.Count(); --i >= 0; )
{
CBaseEntity *pEntity = m_hLeftToTeleportThisFill[i].Get();
if( pEntity == NULL )
continue;
Vector vEntMins, vEntMaxs;
pEntity->GetCollideable()->WorldSpaceSurroundingBounds( &vEntMins, &vEntMaxs );
if( vEntMaxs.z <= vMaxs.z )
{
TeleportImmersedEntity( pEntity );
m_hLeftToTeleportThisFill.FastRemove( i );
}
}
SetNextThink( gpGlobals->curtime + TICK_INTERVAL );
}
else
{
//teleport everything that's left in the list
for( int i = m_hLeftToTeleportThisFill.Count(); --i >= 0; )
{
TeleportImmersedEntity( m_hLeftToTeleportThisFill[i].Get() );
}
m_hLeftToTeleportThisFill.RemoveAll();
m_bFillInProgress = false;
}
}
}
//-----------------------------------------------------------------------------
// Main entry point for clipping rays to entities
//-----------------------------------------------------------------------------
void CEngineTrace::ClipRayToEntity( const Ray_t &ray, unsigned int fMask, IHandleEntity *pEntity, trace_t *pTrace )
{
ClipRayToCollideable( ray, fMask, GetCollideable(pEntity), pTrace );
}
