//-----------------------------------------------------------------------------
// Purpose: Checks collisions against other entities
//-----------------------------------------------------------------------------
void CTFFlameEntity::CheckCollision( CBaseEntity *pOther, bool *pbHitWorld )
{
*pbHitWorld = false;
// if we've already burnt this entity, don't do more damage, so skip even checking for collision with the entity
int iIndex = m_hEntitiesBurnt.Find( pOther );
if ( iIndex != m_hEntitiesBurnt.InvalidIndex() )
return;
// Do a bounding box check against the entity
Vector vecMins, vecMaxs;
pOther->GetCollideable()->WorldSpaceSurroundingBounds( &vecMins, &vecMaxs );
CBaseTrace trace;
Ray_t ray;
float flFractionLeftSolid;
ray.Init( m_vecPrevPos, GetAbsOrigin(), WorldAlignMins(), WorldAlignMaxs() );
if ( IntersectRayWithBox( ray, vecMins, vecMaxs, 0.0, &trace, &flFractionLeftSolid ) )
{
// if bounding box check passes, check player hitboxes
trace_t trHitbox;
trace_t trWorld;
bool bTested = pOther->GetCollideable()->TestHitboxes( ray, MASK_SOLID | CONTENTS_HITBOX, trHitbox );
if ( !bTested || !trHitbox.DidHit() )
return;
// now, let's see if the flame visual could have actually hit this player. Trace backward from the
// point of impact to where the flame was fired, see if we hit anything. Since the point of impact was
// determined using the flame's bounding box and we're just doing a ray test here, we extend the
// start point out by the radius of the box.
Vector vDir = ray.m_Delta;
vDir.NormalizeInPlace();
UTIL_TraceLine( GetAbsOrigin() + vDir * WorldAlignMaxs().x, m_vecInitialPos, MASK_SOLID, this, COLLISION_GROUP_DEBRIS, &trWorld );
if ( tf_debug_flamethrower.GetInt() )
{
NDebugOverlay::Line( trWorld.startpos, trWorld.endpos, 0, 255, 0, true, 3.0f );
}
if ( trWorld.fraction == 1.0 )
{
// if there is nothing solid in the way, damage the entity
OnCollide( pOther );
}
else
{
// we hit the world, remove ourselves
*pbHitWorld = true;
UTIL_Remove( this );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Do not test against hit boxes, but against the bounding box.
// Much cheaper and we don't really need hitboxes for hl2wars.
//-----------------------------------------------------------------------------
bool CUnitBase::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )
{
#if 1
if( unit_cheaphitboxtest.GetBool() == false )
return BaseClass::TestHitboxes( ray, fContentsMask, tr );
CStudioHdr *pStudioHdr = GetModelPtr( );
if (!pStudioHdr)
return false;
Ray_t ray2 = ray;
Vector start = GetAbsOrigin() - ray.m_Start;
ray2.Init(start, start+ray.m_Delta);
IntersectRayWithBox(ray2, WorldAlignMins(), WorldAlignMaxs(), 0.0f, &tr);
if ( tr.DidHit() )
{
tr.surface.name = "**studio**";
tr.surface.flags = SURF_HITBOX;
tr.surface.surfaceProps = VPhysicsGetObject() ? VPhysicsGetObject()->GetMaterialIndex() : 0;
//NDebugOverlay::SweptBox(ray.m_Start, tr.endpos, -Vector(32, 32, 32), Vector(32, 32, 32), GetAbsAngles(), 255, 0, 0, 255, 1.0f);
return true;
}
return false;
#else
return BaseClass::TestHitboxes( ray, fContentsMask, tr );
#endif // 0
}
void CBaseTurret::Deploy(void)
{
SetNextThink( gpGlobals->curtime + 0.1f );
StudioFrameAdvance( );
if ( m_Activity != ACT_TURRET_OPEN )
{
m_iOn = 1;
SetActivity( (Activity)ACT_TURRET_OPEN );
EmitSound( "NPC_Turret.Deploy" );
m_OnDeploy.FireOutput(NULL, this);
}
if (m_fSequenceFinished)
{
Vector curmins, curmaxs;
curmins = WorldAlignMins();
curmaxs = WorldAlignMaxs();
curmaxs.z = m_iDeployHeight;
curmins.z = -m_iDeployHeight;
SetCollisionBounds( curmins, curmaxs );
Relink();
SetActivity( (Activity)ACT_TURRET_OPEN_IDLE );
m_flPlaybackRate = 0;
SetThink(SearchThink);
}
m_flLastSight = gpGlobals->curtime + m_flMaxWait;
}
void CRopeKeyframe::UpdateBBox( bool bForceRelink )
{
Vector v1, v2;
Vector vMin, vMax;
if ( GetEndPointPos( 0, v1 ) )
{
if ( GetEndPointPos( 1, v2 ) )
{
VectorMin( v1, v2, vMin );
VectorMax( v1, v2, vMax );
// Set our bounds to enclose both endpoints and relink.
vMin -= GetAbsOrigin();
vMax -= GetAbsOrigin();
}
else
{
vMin = vMax = v1 - GetAbsOrigin();
}
}
else
{
vMin = vMax = Vector( 0, 0, 0 );
}
if ( WorldAlignMins() != vMin || WorldAlignMaxs() != vMax )
{
UTIL_SetSize( this, vMin, vMax );
}
}
void C_FuncSmokeVolume::OnDataChanged( DataUpdateType_t updateType )
{
m_MinColor[0] = ( 1.0f / 255.0f ) * m_Color1.r;
m_MinColor[1] = ( 1.0f / 255.0f ) * m_Color1.g;
m_MinColor[2] = ( 1.0f / 255.0f ) * m_Color1.b;
m_MaxColor[0] = ( 1.0f / 255.0f ) * m_Color2.r;
m_MaxColor[1] = ( 1.0f / 255.0f ) * m_Color2.g;
m_MaxColor[2] = ( 1.0f / 255.0f ) * m_Color2.b;
m_ParticleRadius = m_ParticleDrawWidth * 0.5f;
m_SpacingRadius = m_ParticleSpacingDistance * 0.5f;
// Warning( "m_Density: %f\n", m_Density );
// Warning( "m_MovementSpeed: %f\n", m_MovementSpeed );
if(updateType == DATA_UPDATE_CREATED)
{
Vector size = WorldAlignMaxs() - WorldAlignMins();
m_xCount = 0.5f + ( size.x / ( m_SpacingRadius * 2.0f ) );
m_yCount = 0.5f + ( size.y / ( m_SpacingRadius * 2.0f ) );
m_zCount = 0.5f + ( size.z / ( m_SpacingRadius * 2.0f ) );
m_CurrentDensity = m_Density;
delete [] m_pSmokeParticleInfos;
m_pSmokeParticleInfos = new SmokeParticleInfo[m_xCount * m_yCount * m_zCount];
Start( &g_ParticleMgr, NULL );
}
BaseClass::OnDataChanged( updateType );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_Bug_Warrior::Spawn( void )
{
Precache();
SetModel( BUG_WARRIOR_MODEL );
SetHullType(HULL_WIDE_HUMAN);//HULL_WIDE_SHORT;
SetHullSizeNormal();
SetDefaultEyeOffset();
SetViewOffset( (WorldAlignMins() + WorldAlignMaxs()) * 0.5 ); // See from my center
SetDistLook( 1024.0 );
SetNavType(NAV_GROUND);
m_NPCState = NPC_STATE_NONE;
SetBloodColor( BLOOD_COLOR_YELLOW );
m_iHealth = npc_bug_warrior_health.GetFloat();
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetMoveType( MOVETYPE_STEP );
m_iszPatrolPathName = NULL_STRING;
// Only do this if a squadname appears in the entity
if ( m_SquadName != NULL_STRING )
{
CapabilitiesAdd( bits_CAP_SQUAD );
}
CapabilitiesAdd( bits_CAP_MOVE_GROUND | bits_CAP_INNATE_MELEE_ATTACK1 );
NPCInit();
BaseClass::Spawn();
}
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;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_Bug_Builder::Spawn( void )
{
Precache();
SetModel( BUG_BUILDER_MODEL );
SetHullType(HULL_TINY);
SetHullSizeNormal();
SetDefaultEyeOffset();
SetViewOffset( (WorldAlignMins() + WorldAlignMaxs()) * 0.5 ); // See from my center
SetDistLook( 1024.0 );
m_flNextDawdle = 0;
SetNavType(NAV_GROUND);
m_NPCState = NPC_STATE_NONE;
SetBloodColor( BLOOD_COLOR_YELLOW );
m_iHealth = npc_bug_builder_health.GetFloat();
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetMoveType( MOVETYPE_STEP );
CapabilitiesAdd( bits_CAP_MOVE_GROUND );
NPCInit();
BaseClass::Spawn();
}
//=========================================================
// SetEyePosition
//
// queries the units's model for $eyeposition and copies
// that vector to the npc's m_vDefaultEyeOffset and m_vecViewOffset
//
//=========================================================
void CUnitBase::SetDefaultEyeOffset( Vector *pCustomOfset )
{
if( pCustomOfset )
{
m_vDefaultEyeOffset = *pCustomOfset;
}
else if ( GetModelPtr() )
{
GetEyePosition( GetModelPtr(), m_vDefaultEyeOffset );
if ( m_vDefaultEyeOffset == vec3_origin )
{
//if ( Classify() != CLASS_NONE )
{
DevMsg( "WARNING: %s(%s) has no eye offset in .qc!\n", GetClassname(), STRING(GetModelName()) );
}
VectorAdd( WorldAlignMins(), WorldAlignMaxs(), m_vDefaultEyeOffset );
m_vDefaultEyeOffset *= 0.75;
}
}
else
m_vDefaultEyeOffset = vec3_origin;
// Clamp to values in dt
m_vDefaultEyeOffset.x = Max<float>( Min<float>( m_vDefaultEyeOffset.x, 256.0f ), -256.0 );
m_vDefaultEyeOffset.y = Max<float>( Min<float>( m_vDefaultEyeOffset.y, 256.0f ), -256.0 );
m_vDefaultEyeOffset.z = Max<float>( Min<float>( m_vDefaultEyeOffset.z, 1024.0f ), -1.0f );
#ifndef CLIENT_DLL
SetViewOffset( m_vDefaultEyeOffset );
#endif // CLIENT_DLL
}
void CNPC_Ichthyosaur::DragVictim( float moveDist )
{
Vector mins, maxs;
float width;
mins = WorldAlignMins();
maxs = WorldAlignMaxs();
width = ( maxs.y - mins.y ) * 0.5f;
Vector forward, up;
GetVectors( &forward, NULL, &up );
Vector newPos = GetAbsOrigin() + ( (forward+(up*0.25f)) * ( moveDist + width + DRAG_OFFSET ) );
trace_t tr;
AI_TraceEntity( this, m_pVictim->GetAbsOrigin(), newPos, MASK_NPCSOLID, &tr );
if ( ( tr.fraction == 1.0f ) && ( tr.m_pEnt != this ) )
{
UTIL_SetOrigin( m_pVictim, tr.endpos );
}
else
{
ReleaseVictim();
}
}
//-----------------------------------------------------------------------------
// Purpose: custom code to fix collision errors
//-----------------------------------------------------------------------------
bool CBaseHelicopter::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace )
{
// Let normal hitbox code handle rays
if ( mask & CONTENTS_HITBOX )
return BaseClass::TestCollision( ray, mask, trace );
return TestCollisionBox( ray, mask, trace, WorldAlignMins() + GetAbsOrigin(), WorldAlignMaxs() + GetAbsOrigin() );
}
//=========================================================
// Retire - stop being active
//=========================================================
void CNPC_BaseTurret::Retire(void)
{
// make the turret level
m_vecGoalAngles.x = 0;
m_vecGoalAngles.y = m_flStartYaw;
SetNextThink( gpGlobals->curtime + 0.1 );
StudioFrameAdvance( );
EyeOff( );
if (!MoveTurret())
{
if (m_iSpin)
{
SpinDownCall();
}
else if (GetSequence() != TURRET_ANIM_RETIRE)
{
SetTurretAnim(TURRET_ANIM_RETIRE);
CPASAttenuationFilter filter( this );
EmitSound( filter, entindex(), "Turret.Undeploy" );
m_OnDeactivate.FireOutput(this, this);
}
//else if (IsSequenceFinished())
else if( GetSequence() == TURRET_ANIM_RETIRE && GetCycle() <= 0.0 )
{
m_iOn = 0;
m_flLastSight = 0;
//SetTurretAnim(TURRET_ANIM_NONE);
Vector curmins, curmaxs;
curmins = WorldAlignMins();
curmaxs = WorldAlignMaxs();
curmaxs.z = m_iRetractHeight;
curmins.z = -m_iRetractHeight;
SetCollisionBounds( curmins, curmaxs );
if (m_iAutoStart)
{
SetThink(&CNPC_BaseTurret::AutoSearchThink);
SetNextThink( gpGlobals->curtime + 0.1 );
}
else
{
SetThink( &CBaseEntity::SUB_DoNothing );
}
}
}
else
{
SetTurretAnim(TURRET_ANIM_SPIN);
}
}
virtual void SetObjectCollisionBox( void )
{
SetAbsMins( GetAbsOrigin() + WorldAlignMins() );
SetAbsMaxs( GetAbsOrigin() + WorldAlignMaxs() );
// Extend our bounding box downwards the length of the tongue
Vector vecAbsMins = GetAbsMins();
vecAbsMins.z -= m_flAltitude;
SetAbsMins( vecAbsMins );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFVehicle::GetPassengerExitPoint( CBasePlayer *pPlayer, int nRole, Vector *pAbsPosition, QAngle *pAbsAngles )
{
// Deal with vehicles built on other vehicles
CBaseTFVehicle *pParentVehicle = dynamic_cast<CBaseTFVehicle*>(GetMoveParent());
if (pParentVehicle)
{
int nParentVehicleRole = pParentVehicle->GetChildVehicleRole( this );
if (nParentVehicleRole >= 0)
{
pParentVehicle->GetPassengerExitPoint( pPlayer, nParentVehicleRole, pAbsPosition, pAbsAngles );
return;
}
}
// Deal with vehicles build on objects
IHasBuildPoints *pMount = dynamic_cast<IHasBuildPoints*>(GetMoveParent());
if (pMount)
{
int nBuildPoint = pMount->FindObjectOnBuildPoint( this );
if (nBuildPoint >= 0)
{
pMount->GetExitPoint( pPlayer, nBuildPoint, pAbsPosition, pAbsAngles );
return;
}
}
Vector vNewPos;
GetInitialPassengerExitPoint( nRole, pAbsPosition, pAbsAngles );
if ( EntityPlacementTest(pPlayer, *pAbsPosition, vNewPos, true) )
{
*pAbsPosition = vNewPos;
return;
}
// Find the first valid exit point
for( int iExitPoint = 0; iExitPoint < m_nMaxPassengers; ++iExitPoint )
{
if (iExitPoint == nRole)
continue;
GetInitialPassengerExitPoint( iExitPoint, pAbsPosition, pAbsAngles );
if ( EntityPlacementTest(pPlayer, *pAbsPosition, vNewPos, true) )
{
*pAbsPosition = vNewPos;
return;
}
}
// Worst case, we will be returning the vehicle's origin + 50z here
*pAbsPosition = GetAbsOrigin();
pAbsPosition->z = WorldAlignMaxs()[2] + 150.0f;
}
void CBaseTurret::Retire(void)
{
// make the turret level
m_vecGoalAngles = GetAngles( );
SetNextThink( gpGlobals->curtime + 0.1f );
StudioFrameAdvance( );
EyeOff( );
if ( m_Activity != ACT_TURRET_CLOSE )
{
SetActivity( (Activity)ACT_TURRET_OPEN_IDLE );
if (!MoveTurret())
{
SetActivity( (Activity)ACT_TURRET_CLOSE );
EmitSound( "NPC_Turret.Retire" );
m_OnRetire.FireOutput(NULL, this);
}
}
else if (m_fSequenceFinished)
{
m_iOn = 0;
m_flLastSight = 0;
SetActivity( (Activity)ACT_TURRET_CLOSED_IDLE );
Vector curmins, curmaxs;
curmins = WorldAlignMins();
curmaxs = WorldAlignMaxs();
curmaxs.z = m_iRetractHeight;
curmins.z = -m_iRetractHeight;
SetCollisionBounds( curmins, curmaxs );
Relink();
if (m_iAutoStart)
{
SetThink(AutoSearchThink);
SetNextThink( gpGlobals->curtime + .1 );
}
else
{
SetThink(SUB_DoNothing);
}
}
}
//-----------------------------------------------------------------------------
// 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 );
}
//=========================================================
// Deploy - go active
//=========================================================
void CNPC_BaseTurret::Deploy(void)
{
SetNextThink( gpGlobals->curtime + 0.1 );
StudioFrameAdvance( );
if (GetSequence() != TURRET_ANIM_DEPLOY)
{
m_iOn = 1;
SetTurretAnim(TURRET_ANIM_DEPLOY);
CPASAttenuationFilter filter( this );
EmitSound( filter, entindex(), "Turret.Deploy" );
m_OnActivate.FireOutput(this, this);
}
if (IsSequenceFinished())
{
Vector curmins, curmaxs;
curmins = WorldAlignMins();
curmaxs = WorldAlignMaxs();
curmaxs.z = m_iDeployHeight;
curmins.z = -m_iDeployHeight;
SetCollisionBounds( curmins, curmaxs );
m_vecCurAngles.x = 0;
QAngle angles = GetAbsAngles();
if (m_iOrientation == TURRET_ORIENTATION_CEILING)
{
m_vecCurAngles.y = UTIL_AngleMod( angles.y + 180 );
}
else
{
m_vecCurAngles.y = UTIL_AngleMod( angles.y );
}
SetTurretAnim(TURRET_ANIM_SPIN);
m_flPlaybackRate = 0;
SetThink(&CNPC_BaseTurret::SearchThink);
}
m_flLastSight = gpGlobals->curtime + m_flMaxWait;
}
//-----------------------------------------------------------------------------
// Get a position in *world space* inside the vehicle for the player to exit at
// NOTE: This doesn't check for obstructions
//-----------------------------------------------------------------------------
void CBaseTFVehicle::GetInitialPassengerExitPoint( int nRole, Vector *pAbsPoint, QAngle *pAbsAngles )
{
char pAttachmentName[32];
Q_snprintf( pAttachmentName, sizeof( pAttachmentName ), "vehicle_exit_passenger%d", nRole );
int exitAttachmentIndex = LookupAttachment(pAttachmentName);
if (exitAttachmentIndex <= 0)
{
// bad attachment, just return the origin
*pAbsPoint = GetAbsOrigin();
pAbsPoint->z += WorldAlignMaxs()[2] + 50.0f;
return;
}
QAngle vehicleExitAngles;
if( !pAbsAngles )
{
pAbsAngles = &vehicleExitAngles;
}
GetAttachment( exitAttachmentIndex, *pAbsPoint, *pAbsAngles );
}
// This creates a vphysics object with a shadow controller that follows the AI
IPhysicsObject *C_RagdollShadow::VPhysicsInitShadow( bool allowPhysicsMovement, bool allowPhysicsRotation )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return NULL;
}
// If this entity already has a physics object, then it should have been deleted prior to making this call.
Assert(!m_pPhysicsObject);
// make sure m_vecOrigin / m_vecAngles are correct
const Vector &origin = GetAbsOrigin();
QAngle angles = GetAbsAngles();
IPhysicsObject *pPhysicsObject = NULL;
if ( GetSolid() == SOLID_BBOX )
{
const char *pSurfaceProps = "flesh";
if ( GetModelIndex() && modelinfo->GetModelType( GetModel() ) == mod_studio )
{
pSurfaceProps = Studio_GetDefaultSurfaceProps( hdr );
}
angles = vec3_angle;
CPhysCollide *pCollide = PhysCreateBbox( WorldAlignMins(), WorldAlignMaxs() );
if ( !pCollide )
return NULL;
pPhysicsObject = PhysModelCreateCustom( this, pCollide, origin, angles, pSurfaceProps );
}
else
{
pPhysicsObject = PhysModelCreateRagdoll( this, GetModelIndex(), origin, angles );
}
VPhysicsSetObject( pPhysicsObject );
pPhysicsObject->SetShadow( Vector(1e4,1e4,1e4), AngularImpulse(1e4,1e4,1e4), allowPhysicsMovement, allowPhysicsRotation );
pPhysicsObject->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, 0 );
// PhysAddShadow( this );
return pPhysicsObject;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CObjectResupply::CalculatePlacement( CBaseTFPlayer *pPlayer )
{
trace_t tr;
Vector vecAiming;
// Get an aim vector. Don't use GetAimVector() because we don't want autoaiming.
Vector vecSrc = pPlayer->Weapon_ShootPosition( );
pPlayer->EyeVectors( &vecAiming );
Vector vecTarget;
VectorMA( vecSrc, 90, vecAiming, vecTarget );
m_vecBuildOrigin = vecTarget;
// Angle it towards me
Vector vecForward = pPlayer->WorldSpaceCenter() - m_vecBuildOrigin;
SetLocalAngles( QAngle( 0, UTIL_VecToYaw( vecForward ), 0 ) );
// Is there something to attach to?
// Use my bounding box, not the build box, so I fit to the wall
UTIL_TraceLine( vecSrc, vecTarget, MASK_SOLID, pPlayer, COLLISION_GROUP_PLAYER_MOVEMENT, &tr);
//UTIL_TraceHull( vecSrc, vecTarget, WorldAlignMins(), WorldAlignMaxs(), MASK_SOLID, pPlayer, TFCOLLISION_GROUP_OBJECT, &tr );
m_vecBuildOrigin = tr.endpos;
bool bTryToPlaceGroundVersion = false;
if ( tr.allsolid || (tr.fraction == 1.0) )
{
bTryToPlaceGroundVersion = true;
}
else
{
// Make sure we're planting on the world
CBaseEntity *pEntity = tr.m_pEnt;
if ( pEntity != GetWorldEntity() )
{
bTryToPlaceGroundVersion = true;
}
}
// Make sure the wall we've touched is vertical
if ( !bTryToPlaceGroundVersion && fabs(tr.plane.normal.z) > 0.3 )
{
bTryToPlaceGroundVersion = true;
}
// Aborting?
if ( bTryToPlaceGroundVersion )
{
// We couldn't find a wall, so try and place a ground version instead
if ( GetTeamNumber() == TEAM_HUMANS )
{
SetModel( RESUPPLY_GROUND_MODEL_HUMAN );
}
else
{
SetModel( RESUPPLY_GROUND_MODEL );
}
UTIL_SetSize(this, RESUPPLY_GROUND_MINS, RESUPPLY_GROUND_MAXS);
m_vecBuildMins = WorldAlignMins() - Vector( 4,4,0 );
m_vecBuildMaxs = WorldAlignMaxs() + Vector( 4,4,0 );
return BaseClass::CalculatePlacement( pPlayer );
}
SetupAttachedVersion();
m_vecBuildMins = WorldAlignMins() - Vector( 4,4,0 );
m_vecBuildMaxs = WorldAlignMaxs() + Vector( 4,4,0 );
// Set the angles
vecForward = tr.plane.normal;
SetLocalAngles( QAngle( 0, UTIL_VecToYaw( vecForward ), 0 ) );
// Trace back from the corners
Vector vecMins, vecMaxs, vecModelMins, vecModelMaxs;
const model_t *pModel = GetModel();
modelinfo->GetModelBounds( pModel, vecModelMins, vecModelMaxs );
// Check the four build points
Vector vecPointCheck = (vecForward * 32);
Vector vecUp = Vector(0,0,1);
Vector vecRight;
CrossProduct( vecUp, vecForward, vecRight );
float flWidth = fabs(vecModelMaxs.y - vecModelMins.y) * 0.5;
float flHeight = fabs(vecModelMaxs.z - vecModelMins.z) * 0.5;
bool bResult = true;
if ( bResult )
{
bResult = CheckBuildPoint( m_vecBuildOrigin + (vecRight * flWidth) + (vecUp * flHeight), vecPointCheck );
}
if ( bResult )
{
bResult = CheckBuildPoint( m_vecBuildOrigin + (vecRight * flWidth) - (vecUp * flHeight), vecPointCheck );
}
if ( bResult )
{
bResult = CheckBuildPoint( m_vecBuildOrigin - (vecRight * flWidth) + (vecUp * flHeight), vecPointCheck );
}
if ( bResult )
{
bResult = CheckBuildPoint( m_vecBuildOrigin - (vecRight * flWidth) - (vecUp * flHeight), vecPointCheck );
}
AttemptToFindPower();
return bResult;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flDot -
// flDist -
// Output : int
//-----------------------------------------------------------------------------
int CWeaponSMG1::WeaponRangeAttack2Condition( float flDot, float flDist )
{
CAI_BaseNPC *npcOwner = GetOwner()->MyNPCPointer();
return COND_NONE;
/*
// --------------------------------------------------------
// Assume things haven't changed too much since last time
// --------------------------------------------------------
if (gpGlobals->curtime < m_flNextGrenadeCheck )
return m_lastGrenadeCondition;
*/
// -----------------------
// If moving, don't check.
// -----------------------
if ( npcOwner->IsMoving())
return COND_NONE;
CBaseEntity *pEnemy = npcOwner->GetEnemy();
if (!pEnemy)
return COND_NONE;
Vector vecEnemyLKP = npcOwner->GetEnemyLKP();
if ( !( pEnemy->GetFlags() & FL_ONGROUND ) && pEnemy->GetWaterLevel() == 0 && vecEnemyLKP.z > (GetAbsOrigin().z + WorldAlignMaxs().z) )
{
//!!!BUGBUG - we should make this check movetype and make sure it isn't FLY? Players who jump a lot are unlikely to
// be grenaded.
// don't throw grenades at anything that isn't on the ground!
return COND_NONE;
}
// --------------------------------------
// Get target vector
// --------------------------------------
Vector vecTarget;
if (random->RandomInt(0,1))
{
// magically know where they are
vecTarget = pEnemy->WorldSpaceCenter();
}
else
{
// toss it to where you last saw them
vecTarget = vecEnemyLKP;
}
// vecTarget = m_vecEnemyLKP + (pEnemy->BodyTarget( GetLocalOrigin() ) - pEnemy->GetLocalOrigin());
// estimate position
// vecTarget = vecTarget + pEnemy->m_vecVelocity * 2;
if ( ( vecTarget - npcOwner->GetLocalOrigin() ).Length2D() <= COMBINE_MIN_GRENADE_CLEAR_DIST )
{
// crap, I don't want to blow myself up
m_flNextGrenadeCheck = gpGlobals->curtime + 1; // one full second.
return (COND_NONE);
}
// ---------------------------------------------------------------------
// Are any friendlies near the intended grenade impact area?
// ---------------------------------------------------------------------
CBaseEntity *pTarget = NULL;
while ( ( pTarget = gEntList.FindEntityInSphere( pTarget, vecTarget, COMBINE_MIN_GRENADE_CLEAR_DIST ) ) != NULL )
{
//Check to see if the default relationship is hatred, and if so intensify that
if ( npcOwner->IRelationType( pTarget ) == D_LI )
{
// crap, I might blow my own guy up. Don't throw a grenade and don't check again for a while.
m_flNextGrenadeCheck = gpGlobals->curtime + 1; // one full second.
return (COND_WEAPON_BLOCKED_BY_FRIEND);
}
}
// ---------------------------------------------------------------------
// Check that throw is legal and clear
// ---------------------------------------------------------------------
// FIXME: speed is based on difficulty...
Vector vecToss = VecCheckThrow( this, npcOwner->GetLocalOrigin() + Vector(0,0,60), vecTarget, 600.0, 0.5 );
if ( vecToss != vec3_origin )
{
m_vecTossVelocity = vecToss;
// don't check again for a while.
// JAY: HL1 keeps checking - test?
//m_flNextGrenadeCheck = gpGlobals->curtime;
m_flNextGrenadeCheck = gpGlobals->curtime + 0.3; // 1/3 second.
return COND_CAN_RANGE_ATTACK2;
}
else
{
// don't check again for a while.
m_flNextGrenadeCheck = gpGlobals->curtime + 1; // one full second.
return COND_WEAPON_SIGHT_OCCLUDED;
}
}
void C_WeaponSpawner::ClientThink()
{
m_qAngle.y += 90 * gpGlobals->frametime;
if ( m_qAngle.y >= 360 )
m_qAngle.y -= 360;
SetAbsAngles( m_qAngle );
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
bool bShouldGlow = false;
bool bTouchingPlayer = false;
if ( pPlayer )
{
Vector vecPlayerOrigin = pPlayer->GetAbsOrigin();
Vector vecPlayerMins = vecPlayerOrigin + pPlayer->GetPlayerMins();
Vector vecPlayerMaxs = vecPlayerOrigin + pPlayer->GetPlayerMaxs();
bTouchingPlayer = IsBoxIntersectingBox( GetAbsOrigin() + WorldAlignMins(), GetAbsOrigin() + WorldAlignMaxs(), vecPlayerMins, vecPlayerMaxs );
// Disable the outline if the weapon has been picked up.
if ( !m_bRespawning && !m_bDisabled )
{
// Temp crutch for Occluded\Unoccluded glow parameters not working.
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), pPlayer->EyePosition(), MASK_OPAQUE, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction == 1.0f )
{
bShouldGlow = true;
}
}
}
if ( m_bShouldGlow != bShouldGlow || m_bTouchingPlayer != bTouchingPlayer )
{
m_bShouldGlow = bShouldGlow;
m_bTouchingPlayer = bTouchingPlayer;
UpdateGlowEffect();
}
SetNextClientThink( CLIENT_THINK_ALWAYS );
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_LightStalk::Spawn( void )
{
Precache();
SetModel( LIGHTSTALK_MODEL );
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
UTIL_SetSize( this, Vector(-80,-80,0), Vector(80,80,32));
Relink();
SetActivity( ACT_IDLE );
SetNextThink( gpGlobals->curtime + 0.1f );
m_pGlow = CSprite::SpriteCreate( LIGHTSTALK_GLOW_SPRITE, GetLocalOrigin() + Vector(0,0,(WorldAlignMins().z+WorldAlignMaxs().z)*0.5), false );
m_pGlow->SetTransparency( kRenderGlow, m_clrRender->r, m_clrRender->g, m_clrRender->b, m_clrRender->a, kRenderFxGlowShell );
m_pGlow->SetScale( 1.0 );
m_pGlow->SetAttachment( this, 1 );
LightRise();
}
//-----------------------------------------------------------------------------
// Default to a simple single trace, but allow overriding.
// This is used for the strider, so it can determine the height based on the legs.
//-----------------------------------------------------------------------------
void UnitBaseAirLocomotion::UpdateCurrentHeight()
{
trace_t pm;
UTIL_TraceHull( mv->origin, mv->origin-Vector(0, 0, MAX_TRACE_LENGTH), WorldAlignMins(), WorldAlignMaxs(),
MASK_NPCWORLDSTATIC, m_pOuter, GetOuter()->CalculateIgnoreOwnerCollisionGroup(), &pm );
m_fCurrentHeight = fabs( pm.endpos.z-mv->origin.z );
}
void CNPC_Dog::SetPlayerAvoidState( void )
{
bool bIntersectingBoneFollowers = false;
bool bIntersectingNPCBox = false;
Vector vNothing;
GetSequenceLinearMotion( GetSequence(), &vNothing );
bool bIsMoving = ( IsMoving() || ( vNothing != vec3_origin ) );
//If we are coming out of a script, check if we are stuck inside the player.
if ( m_bPerformAvoidance || ( ShouldPlayerAvoid() && bIsMoving ) )
{
trace_t trace;
Vector vMins, vMaxs;
Vector vWorldMins, vWorldMaxs;
Vector vPlayerMins, vPlayerMaxs;
physfollower_t *pBone;
int i;
#ifdef SecobMod__Enable_Fixed_Multiplayer_AI
CBasePlayer *pLocalPlayer = UTIL_GetNearestPlayer(GetAbsOrigin());
#else
CBasePlayer *pLocalPlayer = AI_GetSinglePlayer();
#endif //SecobMod__Enable_Fixed_Multiplayer_AI
if ( pLocalPlayer )
{
vWorldMins = WorldAlignMins();
vWorldMaxs = WorldAlignMaxs();
vPlayerMins = pLocalPlayer->GetAbsOrigin() + pLocalPlayer->WorldAlignMins();
vPlayerMaxs = pLocalPlayer->GetAbsOrigin() + pLocalPlayer->WorldAlignMaxs();
// check if the player intersects the bounds of any of the bone followers
for ( i = 0; i < m_BoneFollowerManager.GetNumBoneFollowers(); i++ )
{
pBone = m_BoneFollowerManager.GetBoneFollower( i );
if ( pBone && pBone->hFollower )
{
pBone->hFollower->CollisionProp()->WorldSpaceSurroundingBounds( &vMins, &vMaxs );
if ( IsBoxIntersectingBox( vMins, vMaxs, vPlayerMins, vPlayerMaxs ) )
{
bIntersectingBoneFollowers = true;
break;
}
}
}
bIntersectingNPCBox = IsBoxIntersectingBox( GetAbsOrigin() + vWorldMins, GetAbsOrigin() + vWorldMaxs, vPlayerMins, vPlayerMaxs );
if ( ai_debug_avoidancebounds.GetBool() )
{
int iRed = ( bIntersectingNPCBox == true ) ? 255 : 0;
NDebugOverlay::Box( GetAbsOrigin(), vWorldMins, vWorldMaxs, iRed, 0, 255, 64, 0.1 );
// draw the bounds of the bone followers
for ( i = 0; i < m_BoneFollowerManager.GetNumBoneFollowers(); i++ )
{
pBone = m_BoneFollowerManager.GetBoneFollower( i );
if ( pBone && pBone->hFollower )
{
pBone->hFollower->CollisionProp()->WorldSpaceSurroundingBounds( &vMins, &vMaxs );
iRed = ( IsBoxIntersectingBox( vMins, vMaxs, vPlayerMins, vPlayerMaxs ) ) ? 255 : 0;
NDebugOverlay::Box( vec3_origin, vMins, vMaxs, iRed, 0, 255, 64, 0.1 );
}
}
}
}
}
m_bPlayerAvoidState = ShouldPlayerAvoid();
m_bPerformAvoidance = bIntersectingNPCBox || bIntersectingBoneFollowers;
if ( GetCollisionGroup() == COLLISION_GROUP_NPC || GetCollisionGroup() == COLLISION_GROUP_NPC_ACTOR )
{
if ( bIntersectingNPCBox == true )
{
SetCollisionGroup( COLLISION_GROUP_NPC_ACTOR );
}
else
{
SetCollisionGroup( COLLISION_GROUP_NPC );
}
if ( bIntersectingBoneFollowers == true )
{
MantainBoneFollowerCollisionGroups( COLLISION_GROUP_NPC_ACTOR );
}
else
{
MantainBoneFollowerCollisionGroups( COLLISION_GROUP_NPC );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Override to check throw
// Input :
// Output :
//-----------------------------------------------------------------------------
int CWeaponMolotov::WeaponRangeAttack1Condition( float flDot, float flDist )
{
// If things haven't changed too much since last time
// just return that previously calculated value
if (gpGlobals->curtime < m_fNextThrowCheck )
{
return m_iThrowBits;
}
if ( flDist < m_fMinRange1) {
m_iThrowBits = COND_TOO_CLOSE_TO_ATTACK;
}
else if (flDist > m_fMaxRange1) {
m_iThrowBits = COND_TOO_FAR_TO_ATTACK;
}
else if (flDot < 0.5) {
m_iThrowBits = COND_NOT_FACING_ATTACK;
}
// If moving, can't throw.
else if ( m_flGroundSpeed != 0 )
{
m_iThrowBits = COND_NONE;
}
else {
// Ok we should check again as some time has passed
// This function is only used by NPC's so we can cast to a Base Monster
CAI_BaseNPC *pNPC = GetOwner()->MyNPCPointer();
CBaseEntity *pEnemy = pNPC->GetEnemy();
if (!pEnemy)
{
m_iThrowBits = COND_NONE;
}
// Get Enemy Position
Vector vecTarget;
pEnemy->CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.5f, 0.0f ), &vecTarget );
// Get Toss Vector
Vector throwStart = pNPC->Weapon_ShootPosition();
Vector vecToss;
CBaseEntity* pBlocker = NULL;
float throwDist = (throwStart - vecTarget).Length();
float fGravity = sv_gravity.GetFloat();
float throwLimit = pNPC->ThrowLimit(throwStart, vecTarget, fGravity, 35, WorldAlignMins(), WorldAlignMaxs(), pEnemy, &vecToss, &pBlocker);
// If I can make the throw (or most of the throw)
if (!throwLimit || (throwLimit != throwDist && throwLimit > 0.8*throwDist))
{
m_vecTossVelocity = vecToss;
m_iThrowBits = COND_CAN_RANGE_ATTACK1;
}
else
{
m_iThrowBits = COND_NONE;
}
}
// don't check again for a while.
m_fNextThrowCheck = gpGlobals->curtime + 0.33; // 1/3 second.
return m_iThrowBits;
}
