//----------------------------------------------------------------------------- // 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 ); }