//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCrane::SetNPCDriver( CNPC_VehicleDriver *pDriver )
{
m_hNPCDriver = pDriver;
m_nNPCButtons = 0;
if ( pDriver )
{
m_flMaxExtensionSpeed = CRANE_EXTENSION_RATE_MAX * 1.5;
m_flMaxTurnSpeed = CRANE_TURN_RATE_MAX * 1.5;
m_flExtensionAccel = CRANE_EXTENSION_ACCEL * 2;
m_flExtensionDecel = CRANE_EXTENSION_DECEL * 20; // Npcs stop quickly to make them more accurate
m_flTurnAccel = CRANE_TURN_ACCEL * 2;
m_flTurnDecel = CRANE_DECEL * 10; // Npcs stop quickly to make them more accurate
// Set our owner entity to be the NPC, so it can path check without hitting us
SetOwnerEntity( pDriver );
}
else
{
// Restore player crane speeds
InitCraneSpeeds();
SetOwnerEntity( NULL );
// Shutdown the crane's sounds
m_ServerVehicle.SoundShutdown( 1.0 );
}
}
void CSatchelCharge::SatchelThink( void )
{
// If attached resize so player can pick up off wall
if (m_bIsAttached)
{
UTIL_SetSize(this, Vector( -2, -2, -6), Vector(2, 2, 6));
}
// See if I can lose my owner (has dropper moved out of way?)
// Want do this so owner can shoot the satchel charge
if (GetOwnerEntity())
{
trace_t tr;
Vector vUpABit = GetAbsOrigin();
vUpABit.z += 5.0;
CBaseEntity* saveOwner = GetOwnerEntity();
SetOwnerEntity( NULL );
UTIL_TraceEntity( this, GetAbsOrigin(), vUpABit, MASK_SOLID, &tr );
if ( tr.startsolid || tr.fraction != 1.0 )
{
SetOwnerEntity( saveOwner );
}
}
// Bounce movement code gets this think stuck occasionally so check if I've
// succeeded in moving, otherwise kill my motions.
else if ((GetAbsOrigin() - m_vLastPosition).LengthSqr()<1)
{
SetAbsVelocity( vec3_origin );
QAngle angVel = GetLocalAngularVelocity();
angVel.y = 0;
SetLocalAngularVelocity( angVel );
// Clear think function
SetThink(NULL);
return;
}
m_vLastPosition= GetAbsOrigin();
StudioFrameAdvance( );
SetNextThink( gpGlobals->curtime + 0.1f );
if (!IsInWorld())
{
UTIL_Remove( this );
return;
}
// Is it attached to a wall?
if (m_bIsAttached)
{
return;
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBaseSpriteProjectile::Spawn( char *pszModel,
const Vector &vecOrigin,
const Vector &vecVelocity,
edict_t *pOwner,
MoveType_t iMovetype,
MoveCollide_t nMoveCollide,
int iDamage,
int iDamageType,
CBaseEntity *pIntendedTarget )
{
Precache();
SetSolid( SOLID_BBOX );
SetModel( pszModel );
UTIL_SetSize( this, vec3_origin, vec3_origin );
m_iDmg = iDamage;
m_iDmgType = iDamageType;
SetMoveType( iMovetype, nMoveCollide );
UTIL_SetOrigin( this, vecOrigin );
SetAbsVelocity( vecVelocity );
SetOwnerEntity( Instance( pOwner ) );
m_hIntendedTarget.Set( pIntendedTarget );
// Call think for free the first time. It's up to derived classes to rethink.
SetNextThink( gpGlobals->curtime );
}
//Note - this only gets called on the server for now despite being shared
void CDHLProjectile::Fire( Vector vecOrigin, Vector vecVelocity, int iDamage, CBaseCombatWeapon *pSrcWeapon, CBasePlayer* pShooter, int iAmmoType )
{
SetOwnerEntity( pShooter );
m_iDamage = m_iOriginalDamage = iDamage;
m_pFiringWeapon = pSrcWeapon;
m_pShooter = pShooter;
m_hShooter = pShooter;
m_iAmmoType = iAmmoType;
m_vecProjectileVelocity = vecVelocity;
m_vecProjectileOrigin = vecOrigin;
CDHLBaseWeapon* pDHLWep = static_cast<CDHLBaseWeapon*>(pShooter->GetActiveWeapon());
m_iType = 0;
if ( pDHLWep )
m_iType = pDHLWep->GetProjectileType();
#ifndef CLIENT_DLL
m_vecCurPosition = vecOrigin;
m_vecCurVelocity = vecVelocity;
SetupGravity(); //Client does this in OnDataChanged() creation
#endif
SetMoveType( MOVETYPE_CUSTOM );
}
//-----------------------------------------------------------------------------
// Purpose: Drop/throw the weapon with the given velocity.
//-----------------------------------------------------------------------------
void CASW_Weapon::Drop( const Vector &vecVelocity )
{
StopAnimation();
StopFollowingEntity( );
SetMoveType( MOVETYPE_FLYGRAVITY );
// clear follow stuff, setup for collision
SetGravity(1.0);
m_iState = WEAPON_NOT_CARRIED;
RemoveEffects( EF_NODRAW );
FallInit();
SetGroundEntity( NULL );
SetTouch(NULL);
IPhysicsObject *pObj = VPhysicsGetObject();
if ( pObj != NULL )
{
AngularImpulse angImp( 200, 200, 200 );
pObj->AddVelocity( &vecVelocity, &angImp );
}
else
{
SetAbsVelocity( vecVelocity );
}
SetNextThink( gpGlobals->curtime + 1.0f );
SetOwnerEntity( NULL );
SetOwner( NULL );
SetModel( GetWorldModel() );
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBaseSpriteProjectile::Spawn( char *pszModel,
const Vector &vecOrigin,
const Vector &vecVelocity,
edict_t *pOwner,
MoveType_t iMovetype,
MoveCollide_t nMoveCollide,
int iDamage,
int iDamageType )
{
Precache();
SetSolid( SOLID_BBOX );
SetModel( pszModel );
UTIL_SetSize( this, vec3_origin, vec3_origin );
m_iDmg = iDamage;
m_iDmgType = iDamageType;
SetMoveType( iMovetype, nMoveCollide );
UTIL_SetOrigin( this, vecOrigin );
SetAbsVelocity( vecVelocity );
SetOwnerEntity( Instance( pOwner ) );
}
void CPlantedC4::Init( CCSPlayer *pevOwner, Vector vecStart, QAngle vecAngles )
{
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_NONE );
SetModel( PLANTED_C4_MODEL ); // Change this to c4 model
SetCollisionBounds( Vector( 0, 0, 0 ), Vector( 8, 8, 8 ) );
SetAbsOrigin( vecStart );
SetAbsAngles( vecAngles );
SetOwnerEntity( pevOwner );
// Detonate in "time" seconds
SetThink( &CPlantedC4::C4Think );
SetNextThink( gpGlobals->curtime + 0.1f );
m_flTimerLength = mp_c4timer.GetInt();
m_flC4Blow = gpGlobals->curtime + m_flTimerLength;
m_flNextDefuse = 0;
m_bStartDefuse = false;
m_bBombTicking = true;
SetFriction( 0.9 );
m_flDefuseLength = 0.0f;
SpawnControlPanels();
}
bool CBoneFollower::Init( CBaseEntity *pOwner, const char *pModelName, solid_t &solid, const Vector &position, const QAngle &orientation )
{
SetOwnerEntity( pOwner );
UTIL_SetModel( this, pModelName );
m_fEffects |= EF_NODRAW; // invisible
#if VISUALIZE_FOLLOWERS_BOUNDINGBOX
m_debugOverlays |= OVERLAY_BBOX_BIT;
#endif
m_modelIndex = modelinfo->GetModelIndex( pModelName );
m_solidIndex = solid.index;
SetAbsOrigin( position );
SetAbsAngles( orientation );
SetMoveType( MOVETYPE_PUSH );
SetSolid( SOLID_VPHYSICS );
SetCollisionGroup( pOwner->GetCollisionGroup() );
AddSolidFlags( FSOLID_CUSTOMRAYTEST | FSOLID_CUSTOMBOXTEST );
solid.params.pGameData = (void *)this;
IPhysicsObject *pPhysics = VPhysicsInitShadow( false, false, &solid );
if ( !pPhysics )
return false;
pPhysics->SetCallbackFlags( pPhysics->GetCallbackFlags() | CALLBACK_GLOBAL_TOUCH );
pPhysics->EnableGravity( false );
return true;
}
void CBeam::SetStartEntity( CBaseEntity *pEntity )
{
Assert( m_nNumBeamEnts >= 2 );
m_hAttachEntity.Set( 0, pEntity );
SetOwnerEntity( pEntity );
RelinkBeam();
pEntity->AddEFlags( EFL_FORCE_CHECK_TRANSMIT );
}
void CRagdollPropAttached::InitRagdollAttached( IPhysicsObject *pAttached, const Vector &forceVector, int forceBone, matrix3x4_t *pPrevBones, matrix3x4_t *pBoneToWorld, float dt, int collisionGroup, CBaseAnimating *pFollow, int boneIndexRoot, const Vector &boneLocalOrigin, int parentBoneAttach, const Vector &worldAttachOrigin )
{
int ragdollAttachedIndex = 0;
if ( parentBoneAttach > 0 )
{
studiohdr_t *pStudioHdr = GetModelPtr();
mstudiobone_t *pBone = pStudioHdr->pBone( parentBoneAttach );
ragdollAttachedIndex = pBone->physicsbone;
}
InitRagdoll( forceVector, forceBone, vec3_origin, pPrevBones, pBoneToWorld, dt, collisionGroup, false );
IPhysicsObject *pRefObject = m_ragdoll.list[ragdollAttachedIndex].pObject;
Vector attachmentPointRagdollSpace;
pRefObject->WorldToLocal( attachmentPointRagdollSpace, worldAttachOrigin );
constraint_ragdollparams_t constraint;
constraint.Defaults();
matrix3x4_t tmp, worldToAttached, worldToReference, constraintToWorld;
Vector offsetWS;
pAttached->LocalToWorld( offsetWS, boneLocalOrigin );
AngleMatrix( QAngle(0, pFollow->GetAbsAngles().y, 0 ), offsetWS, constraintToWorld );
constraint.axes[0].SetAxisFriction( -2, 2, 20 );
constraint.axes[1].SetAxisFriction( 0, 0, 0 );
constraint.axes[2].SetAxisFriction( -15, 15, 20 );
pAttached->GetPositionMatrix( tmp );
MatrixInvert( tmp, worldToAttached );
pRefObject->GetPositionMatrix( tmp );
MatrixInvert( tmp, worldToReference );
ConcatTransforms( worldToReference, constraintToWorld, constraint.constraintToReference );
ConcatTransforms( worldToAttached, constraintToWorld, constraint.constraintToAttached );
// for now, just slam this to be the passed in value
MatrixSetColumn( attachmentPointRagdollSpace, 3, constraint.constraintToReference );
DisableCollisions( pAttached );
m_pAttachConstraint = physenv->CreateRagdollConstraint( pRefObject, pAttached, m_ragdoll.pGroup, constraint );
FollowEntity( pFollow );
SetOwnerEntity( pFollow );
RagdollActivate( m_ragdoll );
Relink();
m_boneIndexAttached = boneIndexRoot;
m_ragdollAttachedObjectIndex = ragdollAttachedIndex;
m_attachmentPointBoneSpace = boneLocalOrigin;
Vector vTemp;
MatrixGetColumn( constraint.constraintToReference, 3, vTemp );
m_attachmentPointRagdollSpace = vTemp;
}
void CTripmineGrenade::MakeBeam( void )
{
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), m_vecEnd, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
m_flBeamLength = tr.fraction;
// If I hit a living thing, send the beam through me so it turns on briefly
// and then blows the living thing up
CBaseEntity *pEntity = tr.m_pEnt;
CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pEntity );
// Draw length is not the beam length if entity is in the way
float drawLength = tr.fraction;
if (pBCC)
{
SetOwnerEntity( pBCC );
UTIL_TraceLine( GetAbsOrigin(), m_vecEnd, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
m_flBeamLength = tr.fraction;
SetOwnerEntity( NULL );
}
// set to follow laser spot
SetThink( &CTripmineGrenade::BeamBreakThink );
// Delay first think slightly so beam has time
// to appear if person right in front of it
SetNextThink( gpGlobals->curtime + 1.0f );
Vector vecTmpEnd = GetLocalOrigin() + m_vecDir * 2048 * drawLength;
m_pBeam = CBeam::BeamCreate( g_pModelNameLaser, 0.35 );
m_pBeam->PointEntInit( vecTmpEnd, this );
m_pBeam->SetColor( 255, 55, 52 );
m_pBeam->SetScrollRate( 25.6 );
m_pBeam->SetBrightness( 64 );
int beamAttach = LookupAttachment("beam_attach");
m_pBeam->SetEndAttachment( beamAttach );
}
void CEconWearable::UnEquip( CBasePlayer *pPlayer )
{
if ( pPlayer )
{
StopFollowingEntity();
SetOwnerEntity( NULL );
ReapplyProvision();
}
}
void CStickyBomb::Touch( CBaseEntity *pOther )
{
// Don't stick if already stuck
if ( GetMoveType() == MOVETYPE_FLYGRAVITY )
{
trace_t tr = GetTouchTrace();
// stickies don't stick to each other or sky
if ( FClassnameIs(pOther, "grenade_stickybomb") || (tr.surface.flags & SURF_SKY) )
{
// bounce
Vector vecNewVelocity;
PhysicsClipVelocity( GetAbsVelocity(), tr.plane.normal, vecNewVelocity, 1.0 );
SetAbsVelocity( vecNewVelocity );
}
else
{
SetAbsVelocity( vec3_origin );
SetMoveType( MOVETYPE_NONE );
if ( pOther->entindex() != 0 )
{
// set up notification if the parent is deleted before we explode
g_pNotify->AddEntity( this, pOther );
if ( (tr.surface.flags & SURF_HITBOX) && modelinfo->GetModelType( pOther->GetModel() ) == mod_studio )
{
CBaseAnimating *pOtherAnim = dynamic_cast<CBaseAnimating *>(pOther);
if ( pOtherAnim )
{
matrix3x4_t bombWorldSpace;
MatrixCopy( EntityToWorldTransform(), bombWorldSpace );
// get the bone info so we can follow the bone
FollowEntity( pOther );
SetOwnerEntity( pOther );
m_boneIndexAttached = pOtherAnim->GetHitboxBone( tr.hitbox );
matrix3x4_t boneToWorld;
pOtherAnim->GetBoneTransform( m_boneIndexAttached, boneToWorld );
// transform my current position/orientation into the hit bone's space
// UNDONE: Eventually we need to intersect with the mesh here
// REVISIT: maybe do something like the decal code to find a spot on
// the mesh.
matrix3x4_t worldToBone, localMatrix;
MatrixInvert( boneToWorld, worldToBone );
ConcatTransforms( worldToBone, bombWorldSpace, localMatrix );
MatrixAngles( localMatrix, m_boneAngles.GetForModify(), m_bonePosition.GetForModify() );
return;
}
}
SetParent( pOther );
}
}
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CGrenade_Molotov::MolotovThink( void )
{
// See if I can lose my owner (has dropper moved out of way?)
// Want do this so owner can throw the brickbat
if (GetOwnerEntity())
{
trace_t tr;
Vector vUpABit = GetAbsOrigin();
vUpABit.z += 5.0;
CBaseEntity* saveOwner = GetOwnerEntity();
SetOwnerEntity( NULL );
UTIL_TraceEntity( this, GetAbsOrigin(), vUpABit, MASK_SOLID, &tr );
if ( tr.startsolid || tr.fraction != 1.0 )
{
SetOwnerEntity( saveOwner );
}
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
void CEconWearable::Equip( CBasePlayer *pPlayer )
{
if ( pPlayer )
{
FollowEntity( pPlayer, true );
SetOwnerEntity( pPlayer );
ChangeTeam( pPlayer->GetTeamNumber() );
ReapplyProvision();
}
}
//-----------------------------------------------------------------------------
// Purpose: Marks the entity for deletion
//-----------------------------------------------------------------------------
void CBaseHelicopter::DelayedKillThink( )
{
// tell owner ( if any ) that we're dead.This is mostly for NPCMaker functionality.
CBaseEntity *pOwner = GetOwnerEntity();
if ( pOwner )
{
pOwner->DeathNotice( this );
SetOwnerEntity( NULL );
}
UTIL_Remove( this );
}
virtual void OnUnload() override
{
for (int i = 0; i < ITFBotHintEntityAutoList::AutoList().Count(); ++i) {
auto hint = rtti_cast<CBaseTFBotHintEntity *>(ITFBotHintEntityAutoList::AutoList()[i]);
if (hint != nullptr) {
CBaseEntity *owner = hint->GetOwnerEntity();
if (owner != nullptr && rtti_cast<CObjectDispenser *>(owner) != nullptr) {
owner->Remove();
hint->SetOwnerEntity(nullptr);
}
}
}
}
void CRagdollPropAttached::Detach()
{
StopFollowingEntity();
SetOwnerEntity( NULL );
SetAbsAngles( vec3_angle );
SetMoveType( MOVETYPE_VPHYSICS );
physenv->DestroyConstraint( m_pAttachConstraint );
m_pAttachConstraint = NULL;
// Go non-solid
SetCollisionGroup( COLLISION_GROUP_DEBRIS );
Relink();
RecheckCollisionFilter();
}
// When teleported (usually by portal)
void CRocket_Turret_Projectile::NotifySystemEvent(CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t ¶ms )
{
// On teleport, we record a pointer to the portal we are arriving at
if ( eventType == NOTIFY_EVENT_TELEPORT )
{
// HACK: Clearing the owner allows collisions with launcher.
// Players have had trouble realizing a launcher's own rockets don't kill it
// because they didn't ever collide. We do this after a portal teleport so it avoids self-collisions on launch.
SetOwnerEntity( NULL );
// Restart smoke trail
UTIL_Remove( m_hRocketTrail );
m_hRocketTrail = NULL; // This shouldn't leak cause the pointer has been handed to the delete list
CreateSmokeTrail();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Rocket::Deflected( CBaseEntity *pDeflectedBy, Vector &vecDir )
{
// Get rocket's speed.
float flVel = GetAbsVelocity().Length();
QAngle angForward;
VectorAngles( vecDir, angForward );
// Now change rocket's direction.
SetAbsAngles( angForward );
SetAbsVelocity( vecDir * flVel );
// And change owner.
IncremenentDeflected();
SetOwnerEntity( pDeflectedBy );
ChangeTeam( pDeflectedBy->GetTeamNumber() );
SetScorer( pDeflectedBy );
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CGrenadeHomer::Launch( CBaseEntity* pOwner,
CBaseEntity* pTarget,
const Vector& vInitVelocity,
float flHomingSpeed,
float flGravity,
int nRocketTrailType)
{
SetOwnerEntity( pOwner );
m_hTarget = pTarget;
SetAbsVelocity( vInitVelocity );
m_flHomingSpeed = flHomingSpeed;
SetGravity( flGravity );
m_nRocketTrailType = nRocketTrailType;
// ----------------------------
// Initialize homing parameters
// ----------------------------
m_flHomingLaunchTime = gpGlobals->curtime;
// -------------
// Smoke trail.
// -------------
if ( (m_nRocketTrailType == HOMER_SMOKE_TRAIL_ON) || (m_nRocketTrailType == HOMER_SMOKE_TRAIL_ALIEN) )
{
StartRocketTrail();
}
SetUse( &CGrenadeHomer::DetonateUse );
SetTouch( &CGrenadeHomer::GrenadeHomerTouch );
SetThink( &CGrenadeHomer::AimThink );
AimThink();
SetNextThink( gpGlobals->curtime );
// Issue danger!
if ( pTarget )
{
// Figure out how long it'll take for me to reach the target.
float flDist = ( pTarget->WorldSpaceCenter() - WorldSpaceCenter() ).Length();
float flTime = MAX( 0.5, flDist / GetAbsVelocity().Length() );
CSoundEnt::InsertSound ( SOUND_DANGER, m_hTarget->GetAbsOrigin(), 300, flTime, pOwner );
}
}
void CGETKnife::SoundThink( void )
{
if ( gpGlobals->curtime < m_flStopFlyingTime )
{
EmitSound( "ThrowingKnife2" );
SetNextThink( gpGlobals->curtime + 0.5f );
}
else
{
// This should never happen, but JUST IN CASE we get stuck flying turn
// us into a physics prop thats able to be picked up
m_bInAir = false;
CollisionProp()->UseTriggerBounds( true, 24 );
SetOwnerEntity( NULL );
SetTouch( &CGETKnife::PickupTouch );
SetThink( &CGETKnife::RemoveThink );
SetNextThink( gpGlobals->curtime + 10.0f );
}
}
void CSnark::Event_Killed( const CTakeDamageInfo &inputInfo )
{
// pev->model = iStringNull;// make invisible
SetThink( &CSnark::SUB_Remove );
SetNextThink( gpGlobals->curtime + 0.1f );
SetTouch( NULL );
// since squeak grenades never leave a body behind, clear out their takedamage now.
// Squeaks do a bit of radius damage when they pop, and that radius damage will
// continue to call this function unless we acknowledge the Squeak's death now. (sjb)
m_takedamage = DAMAGE_NO;
// play squeek blast
CPASAttenuationFilter filter( this, 0.5 );
enginesound->EmitSound( filter, entindex(), CHAN_ITEM, "squeek/sqk_blast1.wav", 1, 0.5, 0, PITCH_NORM );
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), SNARK_EXPLOSION_VOLUME, 3.0 );
UTIL_BloodDrips( WorldSpaceCenter(), Vector( 0, 0, 0 ), BLOOD_COLOR_YELLOW, 80 );
if ( m_hOwner != NULL )
{
RadiusDamage( CTakeDamageInfo( this, m_hOwner, GetDamage(), DMG_BLAST ), GetAbsOrigin(), GetDamage() * 2.5, CLASS_NONE );
}
else
{
RadiusDamage( CTakeDamageInfo( this, this, GetDamage(), DMG_BLAST ), GetAbsOrigin(), GetDamage() * 2.5, CLASS_NONE );
}
// reset owner so death message happens
if ( m_hOwner != NULL )
SetOwnerEntity( m_hOwner );
CTakeDamageInfo info = inputInfo;
info.SetDamageType( DMG_GIB_CORPSE );
BaseClass::Event_Killed( info );
}
bool CBoneFollower::Init( CBaseEntity *pOwner, const char *pModelName, solid_t &solid, const Vector &position, const QAngle &orientation )
{
SetOwnerEntity( pOwner );
UTIL_SetModel( this, pModelName );
AddEffects( EF_NODRAW ); // invisible
m_modelIndex = modelinfo->GetModelIndex( pModelName );
m_solidIndex = solid.index;
SetAbsOrigin( position );
SetAbsAngles( orientation );
SetMoveType( MOVETYPE_PUSH );
SetSolid( SOLID_VPHYSICS );
SetCollisionGroup( pOwner->GetCollisionGroup() );
AddSolidFlags( FSOLID_CUSTOMRAYTEST | FSOLID_CUSTOMBOXTEST );
solid.params.pGameData = (void *)this;
IPhysicsObject *pPhysics = VPhysicsInitShadow( false, false, &solid );
if ( !pPhysics )
return false;
// we can't use the default model bounds because each entity is only one bone of the model
// so compute the OBB of the physics model and use that.
Vector mins, maxs;
physcollision->CollideGetAABB( &mins, &maxs, pPhysics->GetCollide(), vec3_origin, vec3_angle );
SetCollisionBounds( mins, maxs );
pPhysics->SetCallbackFlags( pPhysics->GetCallbackFlags() | CALLBACK_GLOBAL_TOUCH );
pPhysics->EnableGravity( false );
// This is not a normal shadow controller that is trying to go to a space occupied by an entity in the game physics
// This entity is not running PhysicsPusher(), so Vphysics is supposed to move it
// This line of code informs vphysics of that fact
if ( pOwner->IsNPC() )
{
pPhysics->GetShadowController()->SetPhysicallyControlled( true );
}
return true;
}
void CRagdollPropAttached::Detach()
{
SetParent(NULL);
SetOwnerEntity( NULL );
SetAbsAngles( vec3_angle );
SetMoveType( MOVETYPE_VPHYSICS );
RemoveSolidFlags( FSOLID_NOT_SOLID );
physenv->DestroyConstraint( m_pAttachConstraint );
m_pAttachConstraint = NULL;
const float dampingScale = 1.0f / ATTACHED_DAMPING_SCALE;
for ( int i = 0; i < m_ragdoll.listCount; i++ )
{
float damping, rotdamping;
m_ragdoll.list[i].pObject->GetDamping( &damping, &rotdamping );
damping *= dampingScale;
rotdamping *= dampingScale;
m_ragdoll.list[i].pObject->SetDamping( &damping, &damping );
}
// Go non-solid
SetCollisionGroup( COLLISION_GROUP_DEBRIS );
RecheckCollisionFilter();
}
//-----------------------------------------------------------------------------
// Purpose: Setup this projectile's starting values
//-----------------------------------------------------------------------------
void CBasePlasmaProjectile::SetupProjectile( const Vector &vecOrigin, const Vector &vecForward, int damageType, CBaseEntity *pOwner )
{
UTIL_SetOrigin( this, vecOrigin );
QAngle angles;
VectorAngles( vecForward, angles );
SetLocalAngles( angles );
SetOwnerEntity( pOwner );
Spawn();
float flMySpeed = PLASMA_VELOCITY;// + RandomFloat( -500, 500 );
SetAbsVelocity( vecForward * flMySpeed );
m_DamageType = damageType;
m_Shared.Init( vecOrigin, vecForward, flMySpeed );
#ifdef CLIENT_DLL
ResetPositionHistories( GetAbsOrigin() );
#endif
m_Shared.SetSpawnTime( gpGlobals->curtime );
// Set my team
ChangeTeam( pOwner->GetTeamNumber() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBaseGrenadeProj::InitGrenade( const Vector &velocity, const AngularImpulse &angVelocity,
CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo )
{
// We can't use OwnerEntity for grenades, because then the owner can't shoot them with his hitscan weapons (due to collide rules)
// Thrower is used to store the person who threw the grenade, for damage purposes.
SetOwnerEntity( NULL );
SetThrower( pOwner );
SetupInitialTransmittedGrenadeVelocity( velocity );
SetGravity( 0.4f/*BaseClass::GetGrenadeGravity()*/ );
SetFriction( 0.2f/*BaseClass::GetGrenadeFriction()*/ );
SetElasticity( 0.45f/*BaseClass::GetGrenadeElasticity()*/ );
SetDamage( weaponInfo.GetWeaponData( TF_WEAPON_PRIMARY_MODE ).m_nDamage );
SetDamageRadius( weaponInfo.m_flDamageRadius );
ChangeTeam( pOwner->GetTeamNumber() );
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->AddVelocity( &velocity, &angVelocity );
}
}
void CPlantedC4::Init( CCSPlayer *pevOwner, Vector vecStart, QAngle vecAngles )
{
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_BBOX );
SetModel( PLANTED_C4_MODEL ); // Change this to c4 model
SetCollisionBounds( Vector( 0, 0, 0 ), Vector( 8, 8, 8 ) );
SetAbsOrigin( vecStart );
SetAbsAngles( vecAngles );
SetOwnerEntity( pevOwner );
// Detonate in "time" seconds
SetThink( &CPlantedC4::C4Think );
//pGrenade->SetTouch( &CPlantedC4::C4Touch );
SetNextThink( gpGlobals->curtime + 0.1f );
m_flC4Blow = gpGlobals->curtime + c4timer.GetInt();
m_flNextFreqInterval = c4timer.GetInt() / 4;
m_flNextFreq = gpGlobals->curtime;
m_flNextBeep = gpGlobals->curtime + 0.5;
m_iCurWave = 0;
m_sBeepName = NULL;
m_flNextBlink = gpGlobals->curtime + BLINK_INTERVAL;
m_flNextDefuse = 0;
m_bStartDefuse = false;
m_bJustBlew = false;
SetFriction( 0.9 );
Relink();
}
//-----------------------------------------------------------------------------
// Purpose: Stick to an entity (using hierarchy if we can)
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponStriderBuster::StickToEntity( CBaseEntity *pOther )
{
// Make sure the object is travelling fast enough to stick
if ( m_flCollisionSpeedSqr > 50 && !m_bNoseDiving )
{
// See if this is a valid strider bit
if ( ShouldStickToEntity( pOther ) )
{
// Attempt to constraint to it
if ( CreateConstraintToObject( pOther ) )
{
// Only works for striders, at the moment
CBaseEntity *pFollowParent = pOther->GetOwnerEntity();
if ( pFollowParent == NULL )
return false;
// Allows us to identify our constrained object later
SetOwnerEntity( pFollowParent );
// Make a sound
EmitSound( "Weapon_StriderBuster.StickToEntity" );
DispatchParticleEffect( "striderbuster_attach", GetAbsOrigin(), GetAbsAngles(), NULL );
if( striderbuster_use_particle_flare.GetBool() )
{
// We don't have to save any pointers or handles to this because it's parented to the buster.
// So it will die when the buster dies. Yay.
CParticleSystem *pFlare = (CParticleSystem *) CreateEntityByName( "info_particle_system" );
if ( pFlare != NULL )
{
pFlare->KeyValue( "start_active", "1" );
pFlare->KeyValue( "effect_name", "striderbuster_attached_pulse" );
pFlare->SetParent( this );
pFlare->SetLocalOrigin( vec3_origin );
DispatchSpawn( pFlare );
pFlare->Activate();
}
}
else
{
// Create a glow sprite
m_hGlowSprite = CSprite::SpriteCreate( "sprites/orangeflare1.vmt", GetLocalOrigin(), false );
Assert( m_hGlowSprite );
if ( m_hGlowSprite != NULL )
{
m_hGlowSprite->TurnOn();
m_hGlowSprite->SetTransparency( kRenderWorldGlow, 255, 255, 255, 255, kRenderFxNoDissipation );
m_hGlowSprite->SetAbsOrigin( GetAbsOrigin() );
m_hGlowSprite->SetScale( 5.0f );
m_hGlowSprite->m_nRenderFX = kRenderFxStrobeFaster;
m_hGlowSprite->SetGlowProxySize( 16.0f );
m_hGlowSprite->SetParent( this );
}
}
// Stop touching things
SetTouch( NULL );
// Must be a strider
CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(pFollowParent);
if ( pStrider == NULL )
return false;
// Notify the strider we're attaching to him
pStrider->StriderBusterAttached( this );
m_OnAttachToStrider.FireOutput( this, this );
// Start the ping sound.
SetContextThink( &CWeaponStriderBuster::BusterPingThink, gpGlobals->curtime + BUSTER_PING_SOUND_FREQ, s_pBusterPingThinkContext );
// Don't autodelete this one!
WeaponManager_RemoveManaged( this );
return true;
}
return false;
}
}
return false;
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CGrenade_Brickbat::BrickbatThink( void )
{
// -----------------------------------------------------------
// Might be physically simulated so get my velocity manually
// -----------------------------------------------------------
Vector vVelocity;
AngularImpulse vAngVel;
GetVelocity(&vVelocity,&vAngVel);
// See if I can lose my owner (has dropper moved out of way?)
// Want do this so owner can throw the brickbat
if (GetOwnerEntity())
{
trace_t tr;
Vector vUpABit = GetAbsOrigin();
vUpABit.z += 5.0;
CBaseEntity* saveOwner = GetOwnerEntity();
SetOwnerEntity( NULL );
UTIL_TraceEntity( this, GetAbsOrigin(), vUpABit, MASK_SOLID, &tr );
if ( tr.startsolid || tr.fraction != 1.0 )
{
SetOwnerEntity( saveOwner );
}
}
// ---------------------------------------------------------------
// Make sure we're not resting on a living thing's bounding box
// ---------------------------------------------------------------
if (vVelocity.Length() < 0.01)
{
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector(0,0,10), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction < 1.0 && tr.m_pEnt)
{
CBaseEntity *pEntity = tr.m_pEnt;
if (pEntity->GetFlags() & (FL_CLIENT | FL_NPC))
{
// --------------------
// Bounce me off
// --------------------
Vector vNewVel;
vNewVel.y = 100;
vNewVel.x = random->RandomInt(-100,100);
vNewVel.z = random->RandomInt(-100,100);
// If physically simulated
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->AddVelocity( &vNewVel, &vAngVel );
}
// Otherwise
else
{
SetAbsVelocity( vNewVel );
}
}
}
}
if (vVelocity.Length() < 0.01)
{
SpawnBrickbatWeapon();
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
