void CBaseDoor::SetToggleState( int state ) { if( state == TS_AT_TOP ) SetAbsOrigin( m_vecPosition2 ); else SetAbsOrigin( m_vecPosition1 ); }
void CSDKPlayer::MoveToNextIntroCamera() { m_pIntroCamera = gEntList.FindEntityByClassname( m_pIntroCamera, "point_viewcontrol" ); // if m_pIntroCamera is NULL we just were at end of list, start searching from start again if(!m_pIntroCamera) m_pIntroCamera = gEntList.FindEntityByClassname(m_pIntroCamera, "point_viewcontrol"); // find the target CBaseEntity *Target = NULL; if( m_pIntroCamera ) { Target = gEntList.FindEntityByName( NULL, STRING(m_pIntroCamera->m_target) ); } // if we still couldn't find a camera, goto T spawn if(!m_pIntroCamera) m_pIntroCamera = gEntList.FindEntityByClassname(m_pIntroCamera, "info_player_terrorist"); SetViewOffset( vec3_origin ); // no view offset UTIL_SetSize( this, vec3_origin, vec3_origin ); // no bbox if( !Target ) //if there are no cameras(or the camera has no target, find a spawn point and black out the screen { if ( m_pIntroCamera.IsValid() ) SetAbsOrigin( m_pIntroCamera->GetAbsOrigin() + VEC_VIEW ); SetAbsAngles( QAngle( 0, 0, 0 ) ); m_pIntroCamera = NULL; // never update again return; } Vector vCamera = Target->GetAbsOrigin() - m_pIntroCamera->GetAbsOrigin(); Vector vIntroCamera = m_pIntroCamera->GetAbsOrigin(); VectorNormalize( vCamera ); QAngle CamAngles; VectorAngles( vCamera, CamAngles ); SetAbsOrigin( vIntroCamera ); SetAbsAngles( CamAngles ); SnapEyeAngles( CamAngles ); m_fIntroCamTime = gpGlobals->curtime + 6; }
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 CFuncPlat::Setup( void ) { //pev->noiseMovement = MAKE_STRING("plats/platmove1.wav"); //pev->noiseStopMoving = MAKE_STRING("plats/platstop1.wav"); if( m_flTLength == 0 ) m_flTLength = 80; if( m_flTWidth == 0 ) m_flTWidth = 10; pev->angles = g_vecZero; pev->solid = SOLID_BSP; pev->movetype = MOVETYPE_PUSH; SetAbsOrigin( GetAbsOrigin() ); // set size and link into world SetSize( pev->mins, pev->maxs ); SetModel( STRING( pev->model ) ); // vecPosition1 is the top position, vecPosition2 is the bottom m_vecPosition1 = GetAbsOrigin(); m_vecPosition2 = GetAbsOrigin(); if( m_flHeight != 0 ) m_vecPosition2.z = GetAbsOrigin().z - m_flHeight; else m_vecPosition2.z = GetAbsOrigin().z - pev->size.z + 8; if( pev->speed == 0 ) pev->speed = 150; if( m_volume == 0 ) m_volume = 0.85; }
//========================================================= // Tracking Hornet hit something //========================================================= void CHornet :: TrackTouch ( CBaseEntity *pOther ) { if ( pOther->edict() == pev->owner || pOther->pev->modelindex == pev->modelindex ) {// bumped into the guy that shot it. pev->solid = SOLID_NOT; return; } if ( IRelationship( pOther ) <= R_NO ) { // hit something we don't want to hurt, so turn around. Vector vecVelocity = GetAbsVelocity(); vecVelocity = vecVelocity.Normalize(); vecVelocity.x *= -1; vecVelocity.y *= -1; SetAbsVelocity( vecVelocity ); SetAbsOrigin( GetAbsOrigin() + GetAbsVelocity() * 4 ); // bounce the hornet off a bit. SetAbsVelocity( GetAbsVelocity() * m_flFlySpeed ); return; } DieTouch( pOther ); }
void CControllerHeadBall::Spawn( void ) { Precache(); // motor pev->movetype = MOVETYPE_FLY; pev->solid = SOLID_BBOX; SetModel( "sprites/xspark4.spr" ); pev->rendermode = kRenderTransAdd; pev->rendercolor.x = 255; pev->rendercolor.y = 255; pev->rendercolor.z = 255; pev->renderamt = 255; pev->scale = 2.0; SetSize( Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) ); SetAbsOrigin( GetAbsOrigin() ); SetThink( &CControllerHeadBall::HuntThink ); SetTouch( &CControllerHeadBall::BounceTouch ); m_vecIdeal = Vector( 0, 0, 0 ); pev->nextthink = gpGlobals->time + 0.1; m_hOwner = Instance( pev->owner ); pev->dmgtime = gpGlobals->time; }
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(); }
void CPropAPC2::Materialize( void ) { //trace_t tr; //UTIL_TraceHull( m_vOriginalSpawnOrigin, m_vOriginalSpawnOrigin, Vector(-38,-38,-38),Vector(38,38,38), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr ); //if ( (tr.startsolid || tr.allsolid) && m_iSpawnTry<3 ) //{ // //Try again in a second. // SetContextThink(&QUA_Strider::Materialize, gpGlobals->curtime + 1.0f, "RESPAWNING" ); // SetNextThink( gpGlobals->curtime + 1.0f ); // m_iSpawnTry++; // return; //} SetAbsOrigin( InicialSpawn ); SetAbsAngles( InicialAngle ); KeyValue( "model", "models/combine_apc.mdl" ); KeyValue( "solid", "6" ); KeyValue( "targetname", "elapc" ); KeyValue( "vehiclescript", "scripts/vehicles/apc.txt" ); Teleport( &InicialSpawn, &InicialAngle, NULL ); Spawn(); Activate(); SetThink( &CPropAPC2::Think ); SetNextThink( gpGlobals->curtime); }
//----------------------------------------------------------------------------- // Purpose: // Input : *pszModelName - // vecOrigin - // vecForceDir - // vecAngularImp - // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool C_Gib::InitializeGib( const char *pszModelName, Vector vecOrigin, Vector vecForceDir, AngularImpulse vecAngularImp, float flLifetime ) { if ( InitializeAsClientEntity( pszModelName, RENDER_GROUP_OPAQUE_ENTITY ) == false ) { Release(); return false; } SetAbsOrigin( vecOrigin ); SetCollisionGroup( COLLISION_GROUP_DEBRIS ); solid_t tmpSolid; PhysModelParseSolid( tmpSolid, this, GetModelIndex() ); m_pPhysicsObject = VPhysicsInitNormal( SOLID_VPHYSICS, 0, false, &tmpSolid ); if ( m_pPhysicsObject ) { float flForce = m_pPhysicsObject->GetMass(); vecForceDir *= flForce; m_pPhysicsObject->ApplyForceOffset( vecForceDir, GetAbsOrigin() ); m_pPhysicsObject->SetCallbackFlags( m_pPhysicsObject->GetCallbackFlags() | CALLBACK_GLOBAL_TOUCH | CALLBACK_GLOBAL_TOUCH_STATIC ); } else { // failed to create a physics object Release(); return false; } SetNextClientThink( gpGlobals->curtime + flLifetime ); return true; }
//----------------------------------------------------------------------------- // Creates the explosion effect //----------------------------------------------------------------------------- void CEnvHeadcrabCanister::Detonate( ) { // Send the impact output m_OnImpacted.FireOutput( this, this, 0 ); if ( !HasSpawnFlags( SF_NO_IMPACT_SOUND ) ) { StopSound( "HeadcrabCanister.IncomingSound" ); EmitSound( "HeadcrabCanister.Explosion" ); } // If we're supposed to be removed, do that now if ( HasSpawnFlags( SF_REMOVE_ON_IMPACT ) ) { SetAbsOrigin( m_vecImpactPosition ); SetModel( ENV_HEADCRABCANISTER_BROKEN_MODEL ); SetMoveType( MOVETYPE_NONE ); IncrementInterpolationFrame(); m_bLanded = true; // Become invisible so our trail can finish up AddEffects( EF_NODRAW ); SetSolidFlags( FSOLID_NOT_SOLID ); SetThink( &CEnvHeadcrabCanister::SUB_Remove ); SetNextThink( gpGlobals->curtime + ENV_HEADCRABCANISTER_TRAIL_TIME ); return; } // Test for damaging things TestForCollisionsAgainstWorld( m_vecImpactPosition ); // Shake the screen unless flagged otherwise if ( !HasSpawnFlags( SF_NO_SHAKE ) ) { CBasePlayer *pPlayer = UTIL_GetNearestPlayer(GetAbsOrigin()); // If the player is on foot, then do a more limited shake float shakeRadius = ( pPlayer && pPlayer->IsInAVehicle() ) ? sk_env_headcrabcanister_shake_radius_vehicle.GetFloat() : sk_env_headcrabcanister_shake_radius.GetFloat(); UTIL_ScreenShake( m_vecImpactPosition, sk_env_headcrabcanister_shake_amplitude.GetFloat(), 150.0, 1.0, shakeRadius, SHAKE_START ); } // Do explosion effects if ( !HasSpawnFlags( SF_NO_IMPACT_EFFECTS ) ) { // Normal explosion ExplosionCreate( m_vecImpactPosition, GetAbsAngles(), this, 50.0f, 500.0f, SF_ENVEXPLOSION_NODLIGHTS | SF_ENVEXPLOSION_NOSPARKS | SF_ENVEXPLOSION_NODAMAGE | SF_ENVEXPLOSION_NOSOUND, 1300.0f ); // Dust explosion AR2Explosion *pExplosion = AR2Explosion::CreateAR2Explosion( m_vecImpactPosition ); if( pExplosion ) { pExplosion->SetLifetime(10); } } }
//----------------------------------------------------------------------------- // Purpose: // Input : push - // Output : trace_t //----------------------------------------------------------------------------- void C_BaseEntity::PhysicsPushEntity( const Vector& push, trace_t *pTrace ) { /* if ( m_pMoveParent ) { Warning( "pushing entity (%s) that has m_pMoveParent!\n", STRING( pev->classname ) ); Assert(0); } */ // NOTE: absorigin and origin must be equal because there is no moveparent Vector prevOrigin; VectorCopy( GetAbsOrigin(), prevOrigin ); trace_t trace; PhysicsCheckSweep( prevOrigin, push, pTrace ); if ( pTrace->fraction ) { SetAbsOrigin( pTrace->endpos ); } // CLIENT DLL HACKS m_vecNetworkOrigin = GetLocalOrigin(); m_angNetworkAngles = GetLocalAngles(); // InvalidatePhysicsRecursive( POSITION_CHANGED | ANGLES_CHANGED ); if ( pTrace->m_pEnt ) { PhysicsImpact( pTrace->m_pEnt, *pTrace ); } }
void CFuncRotating :: KeyValue( KeyValueData* pkvd) { if( FStrEq( pkvd->szKeyName, "fanfriction" )) { m_flFanFriction = Q_atof( pkvd->szValue ) / 100.0f; pkvd->fHandled = TRUE; } else if( FStrEq( pkvd->szKeyName, "spawnorigin" )) { Vector tmp = Q_atov( pkvd->szValue ); if( tmp != g_vecZero ) SetAbsOrigin( tmp ); } else if( FStrEq( pkvd->szKeyName, "sounds" )) { m_sounds = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if( FStrEq( pkvd->szKeyName, "volume" )) { m_flVolume = bound( 0.0f, Q_atof( pkvd->szValue ) / 10.0f, 1.0f ); pkvd->fHandled = TRUE; } else { CBaseDelay::KeyValue( pkvd ); } }
//========================================================= // Tracking Hornet hit something //========================================================= void CNPC_Hornet::TrackTouch ( CBaseEntity *pOther ) { if ( !pOther->IsSolid() || pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS) ) { return; } if ( pOther == GetOwnerEntity() || pOther->GetModelIndex() == GetModelIndex() ) {// bumped into the guy that shot it. //SetSolid( SOLID_NOT ); return; } int nRelationship = IRelationType( pOther ); if ( (nRelationship == D_FR || nRelationship == D_NU || nRelationship == D_LI) ) { // hit something we don't want to hurt, so turn around. Vector vecVel = GetAbsVelocity(); VectorNormalize( vecVel ); vecVel.x *= -1; vecVel.y *= -1; SetAbsOrigin( GetAbsOrigin() + vecVel * 4 ); // bounce the hornet off a bit. SetAbsVelocity( vecVel * m_flFlySpeed ); return; } DieTouch( pOther ); }
void C_PortalGhostRenderable::PerFrameUpdate( void ) { if( m_pGhostedRenderable ) { SetModelName( m_pGhostedRenderable->GetModelName() ); SetModelIndex( m_pGhostedRenderable->GetModelIndex() ); SetEffects( m_pGhostedRenderable->GetEffects() | EF_NOINTERP ); m_flAnimTime = m_pGhostedRenderable->m_flAnimTime; if( m_bSourceIsBaseAnimating ) { C_BaseAnimating *pSource = (C_BaseAnimating *)m_pGhostedRenderable; SetCycle( pSource->GetCycle() ); SetSequence( pSource->GetSequence() ); m_nBody = pSource->m_nBody; m_nSkin = pSource->m_nSkin; } } // Set position and angles relative to the object it's ghosting Vector ptNewOrigin = m_matGhostTransform * m_pGhostedRenderable->GetAbsOrigin(); QAngle qNewAngles = TransformAnglesToWorldSpace( m_pGhostedRenderable->GetAbsAngles(), m_matGhostTransform.As3x4() ); SetAbsOrigin( ptNewOrigin ); SetAbsAngles( qNewAngles ); AddEffects( EF_NOINTERP ); RemoveFromInterpolationList(); g_pClientLeafSystem->RenderableChanged( RenderHandle() ); }
void CFuncTrain::Activate( void ) { // Not yet active, so teleport to first target if( !m_activated ) { m_activated = true; CBaseEntity* pTarg = UTIL_FindEntityByTargetname( nullptr, GetTarget() ); //Use the world if no target was found. Replicates SDK behavior. - Solokiller if( !pTarg ) { pTarg = CWorld::GetInstance(); } pev->target = MAKE_STRING( pTarg->GetTarget() ); //TODO change to EHANDLE - Solokiller m_pevCurrentTarget = pTarg->pev;// keep track of this since path corners change our target for us. SetAbsOrigin( pTarg->GetAbsOrigin() - ( pev->mins + pev->maxs ) * 0.5 ); if( !HasTargetname() ) { // not triggered, so start immediately pev->nextthink = pev->ltime + 0.1; SetThink( &CFuncTrain::Next ); } else pev->spawnflags |= SF_TRAIN_WAIT_RETRIGGER; } }
void CControllerZapBall::Spawn( void ) { Precache(); // motor pev->movetype = MOVETYPE_FLY; pev->solid = SOLID_BBOX; SetModel( "sprites/xspark4.spr" ); pev->rendermode = kRenderTransAdd; pev->rendercolor.x = 255; pev->rendercolor.y = 255; pev->rendercolor.z = 255; pev->renderamt = 255; pev->scale = 0.5; SetSize( Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) ); SetAbsOrigin( GetAbsOrigin() ); SetThink( &CControllerZapBall::AnimateThink ); SetTouch( &CControllerZapBall::ExplodeTouch ); m_hOwner = Instance( pev->owner ); pev->dmgtime = gpGlobals->time; // keep track of when ball spawned pev->nextthink = gpGlobals->time + 0.1; }
void CFuncTrain::Spawn( void ) { Precache(); if( pev->speed == 0 ) pev->speed = 100; if( !HasTarget() ) ALERT( at_console, "FuncTrain with no target" ); if( pev->dmg == 0 ) pev->dmg = 2; pev->movetype = MOVETYPE_PUSH; //Remove tracktrain include when changed if( FBitSet( pev->spawnflags, SF_TRAIN_PASSABLE ) ) pev->solid = SOLID_NOT; else pev->solid = SOLID_BSP; SetModel( STRING( pev->model ) ); SetSize( pev->mins, pev->maxs ); SetAbsOrigin( GetAbsOrigin() ); m_activated = false; if( m_volume == 0 ) m_volume = 0.85; }
//----------------------------------------------------------------------------- // Purpose: These will be useful for weapon_manhack //----------------------------------------------------------------------------- void CPropVehicleManhack::ForcePlayerIn(CBaseEntity *pOwner) { CBasePlayer *pPlayer = ToBasePlayer( pOwner ); if ( !pPlayer || m_hPlayer ) return; if (pPlayer->GetFlags() & FL_DUCKING) { m_bDriverDucked=true; DevMsg("Player ducking\n"); } else m_bDriverDucked=false; //TERO: Lets move the vehicle where we are standing QAngle vehicleStartAngle = QAngle(0, pPlayer->GetAbsAngles().y, 0); SetAbsAngles(vehicleStartAngle); SetAbsOrigin(pPlayer->GetAbsOrigin()); // Make sure we successfully got in the vehicle if ( pPlayer->GetInVehicle( GetServerVehicle(), VEHICLE_ROLE_DRIVER ) == false ) { // The player was unable to enter the vehicle and the output has failed // int falseGetInVehicle=0; Assert( 0 ); //muista vaihtaa tuohon nolla sitten kun poistat intin; return; } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CNPC_VehicleDriver::PrescheduleThink( void ) { if ( !m_hVehicleEntity ) { m_pVehicleInterface = NULL; UTIL_Remove( this ); return; } // Keep up with my vehicle SetAbsOrigin( m_hVehicleEntity->WorldSpaceCenter() ); SetAbsAngles( m_hVehicleEntity->GetAbsAngles() ); BaseClass::PrescheduleThink(); if ( m_NPCState == NPC_STATE_IDLE ) { m_pVehicleInterface->NPC_Brake(); return; } // If we've been picked up by something (dropship probably), abort. if ( m_hVehicleEntity->GetParent() ) { SetState( NPC_STATE_IDLE ); ClearWaypoints(); SetGoalEnt( NULL ); return; } DriveVehicle(); }
//----------------------------------------------------------------------------- // Purpose: This think function simulates (moves/collides) the HeadcrabCanister while in // the world. //----------------------------------------------------------------------------- void CEnvHeadcrabCanister::HeadcrabCanisterWorldThink( void ) { // Get the current time. float flTime = gpGlobals->curtime; Vector vecStartPosition = GetAbsOrigin(); // Update HeadcrabCanister position for swept collision test. Vector vecEndPosition; QAngle vecEndAngles; m_Shared.GetPositionAtTime( flTime, vecEndPosition, vecEndAngles ); if ( !m_bIncomingSoundStarted && !HasSpawnFlags( SF_NO_IMPACT_SOUND ) ) { float flDistSq = ENV_HEADCRABCANISTER_INCOMING_SOUND_TIME * m_Shared.m_flFlightSpeed; flDistSq *= flDistSq; if ( vecEndPosition.DistToSqr(m_vecImpactPosition) <= flDistSq ) { // Figure out if we're close enough to play the incoming sound EmitSound( "HeadcrabCanister.IncomingSound" ); m_bIncomingSoundStarted = true; } } TestForCollisionsAgainstEntities( vecEndPosition ); if ( m_Shared.DidImpact( flTime ) ) { if ( !m_bHasDetonated ) { Detonate(); m_bHasDetonated = true; } if ( !HasSpawnFlags( SF_REMOVE_ON_IMPACT ) ) { Landed(); } return; } // Always move full movement. SetAbsOrigin( vecEndPosition ); // Touch triggers along the way PhysicsTouchTriggers( &vecStartPosition ); SetNextThink( gpGlobals->curtime + 0.2f ); SetAbsAngles( vecEndAngles ); if ( !m_bHasDetonated ) { if ( vecEndPosition.DistToSqr( m_vecImpactPosition ) < BoundingRadius() * BoundingRadius() ) { Detonate(); m_bHasDetonated = true; } } }
void CStomp::Think( void ) { trace_t tr; SetNextThink( gpGlobals->curtime + 0.1 ); // Do damage for this frame Vector vecStart = GetAbsOrigin(); vecStart.z += 30; Vector vecEnd = vecStart + (m_vecMoveDir * m_flSpeed * gpGlobals->frametime); UTIL_TraceHull( vecStart, vecEnd, Vector(-32, -32, -32), Vector(32, 32, 32), MASK_SOLID, m_pOwner, COLLISION_GROUP_NONE, &tr ); // NDebugOverlay::Line( vecStart, vecEnd, 0, 255, 0, false, 10.0f ); if ( tr.m_pEnt ) { CBaseEntity *pEntity = tr.m_pEnt; CTakeDamageInfo info( this, this, 50, DMG_SONIC ); CalculateMeleeDamageForce( &info, m_vecMoveDir, tr.endpos ); pEntity->TakeDamage( info ); } // Accelerate the effect m_flSpeed += (gpGlobals->frametime) * m_uiFramerate; m_uiFramerate += (gpGlobals->frametime) * 2000; // Move and spawn trails while ( gpGlobals->curtime - m_flDmgTime > STOMP_INTERVAL ) { SetAbsOrigin( GetAbsOrigin() + m_vecMoveDir * m_flSpeed * STOMP_INTERVAL ); for ( int i = 0; i < 2; i++ ) { CSprite *pSprite = CSprite::SpriteCreate( GARG_STOMP_SPRITE_NAME, GetAbsOrigin(), TRUE ); if ( pSprite ) { UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector(0,0,500), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr ); pSprite->SetAbsOrigin( tr.endpos ); // pSprite->pev->velocity = Vector(RandomFloat(-200,200),RandomFloat(-200,200),175); pSprite->SetNextThink( gpGlobals->curtime + 0.3 ); pSprite->SetThink( &CSprite::SUB_Remove ); pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxFadeFast ); } g_pEffects->EnergySplash( tr.endpos, tr.plane.normal ); } m_flDmgTime += STOMP_INTERVAL; // Scale has the "life" of this effect m_flScale -= STOMP_INTERVAL * m_flSpeed; if ( m_flScale <= 0 ) { // Life has run out UTIL_Remove(this); // STOP_SOUND( edict(), CHAN_BODY, GARG_STOMP_BUZZ_SOUND ); CPASAttenuationFilter filter( this ); StopSound( entindex(), CHAN_STATIC, GARG_STOMP_BUZZ_SOUND ); } } }
// // Train next - path corner needs to change to next target // void CFuncTrain::Next( void ) { CBaseEntity *pTarg; // now find our next target //TODO: this entity is supposed to work with path_corner only. Other entities will work, but will probably misbehave. - Solokiller //Check for classname and ignore others? pTarg = GetNextTarget(); if( !pTarg ) { if( pev->noiseMovement ) STOP_SOUND( this, CHAN_STATIC, ( char* ) STRING( pev->noiseMovement ) ); // Play stop sound if( pev->noiseStopMoving ) EMIT_SOUND( this, CHAN_VOICE, ( char* ) STRING( pev->noiseStopMoving ), m_volume, ATTN_NORM ); return; } // Save last target in case we need to find it again pev->message = pev->target; pev->target = pTarg->pev->target; m_flWait = pTarg->GetDelay(); if( m_pevCurrentTarget && m_pevCurrentTarget->speed != 0 ) {// don't copy speed from target if it is 0 (uninitialized) pev->speed = m_pevCurrentTarget->speed; ALERT( at_aiconsole, "Train %s speed to %4.2f\n", GetTargetname(), pev->speed ); } m_pevCurrentTarget = pTarg->pev;// keep track of this since path corners change our target for us. pev->enemy = pTarg->edict();//hack if( FBitSet( m_pevCurrentTarget->spawnflags, SF_CORNER_TELEPORT ) ) { // Path corner has indicated a teleport to the next corner. SetBits( pev->effects, EF_NOINTERP ); SetAbsOrigin( pTarg->GetAbsOrigin() - ( pev->mins + pev->maxs )* 0.5 ); Wait(); // Get on with doing the next path corner. } else { // Normal linear move. // CHANGED this from CHAN_VOICE to CHAN_STATIC around OEM beta time because trains should // use CHAN_STATIC for their movement sounds to prevent sound field problems. // this is not a hack or temporary fix, this is how things should be. (sjb). if( pev->noiseMovement ) { STOP_SOUND( this, CHAN_STATIC, ( char* ) STRING( pev->noiseMovement ) ); EMIT_SOUND( this, CHAN_STATIC, ( char* ) STRING( pev->noiseMovement ), m_volume, ATTN_NORM ); } ClearBits( pev->effects, EF_NOINTERP ); SetMoveDone( &CFuncTrain::Wait ); LinearMove( pTarg->GetAbsOrigin() - ( pev->mins + pev->maxs )* 0.5, pev->speed ); } }
void CStomp::Think( void ) { TraceResult tr; pev->nextthink = gpGlobals->time + 0.1; // Do damage for this frame Vector vecStart = GetAbsOrigin(); vecStart.z += 30; Vector vecEnd = vecStart + (pev->movedir * pev->speed * STOMP_FRAMETIME); UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT(pev), &tr ); if ( tr.pHit && tr.pHit != pev->owner ) { CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit ); entvars_t *pevOwner = pev; if ( pev->owner ) pevOwner = VARS(pev->owner); if ( pEntity ) pEntity->TakeDamage( pev, pevOwner, gSkillData.gargantuaDmgStomp, DMG_SONIC ); } // Accelerate the effect pev->speed = pev->speed + (STOMP_FRAMETIME) * pev->framerate; pev->framerate = pev->framerate + (STOMP_FRAMETIME) * 1500; // Move and spawn trails while ( gpGlobals->time - pev->dmgtime > STOMP_INTERVAL ) { SetAbsOrigin( GetAbsOrigin() + pev->movedir * pev->speed * STOMP_INTERVAL ); for ( int i = 0; i < 2; i++ ) { CSprite *pSprite = CSprite::SpriteCreate( GARG_STOMP_SPRITE_NAME, GetAbsOrigin(), TRUE ); if ( pSprite ) { UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 500 ), ignore_monsters, edict(), &tr ); pSprite->SetAbsOrigin( tr.vecEndPos ); pSprite->SetAbsVelocity( Vector(RANDOM_FLOAT(-200,200),RANDOM_FLOAT(-200,200),175)); // pSprite->AnimateAndDie( RANDOM_FLOAT( 8.0, 12.0 ) ); pSprite->pev->nextthink = gpGlobals->time + 0.3; pSprite->SetThink( SUB_Remove ); pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxFadeFast ); } } pev->dmgtime += STOMP_INTERVAL; // Scale has the "life" of this effect pev->scale -= STOMP_INTERVAL * pev->speed; if ( pev->scale <= 0 ) { // Life has run out UTIL_Remove(this); STOP_SOUND( edict(), CHAN_BODY, GARG_STOMP_BUZZ_SOUND ); } } }
//----------------------------------------------------------------------------- // Compute position //----------------------------------------------------------------------------- void C_EnvHeadcrabCanister::ClientThink() { Vector vecEndPosition; QAngle vecEndAngles; m_Shared.GetPositionAtTime( gpGlobals->curtime, vecEndPosition, vecEndAngles ); SetAbsOrigin( vecEndPosition ); SetAbsAngles( vecEndAngles ); }
void CBaseDoor::Spawn() { Precache(); SetMovedir( this ); if( GetSkin() == 0 ) {//normal door if( GetSpawnFlags().Any( SF_DOOR_PASSABLE ) ) SetSolidType( SOLID_NOT ); else SetSolidType( SOLID_BSP ); } else {// special contents SetSolidType( SOLID_NOT ); GetSpawnFlags().AddFlags( SF_DOOR_SILENT ); // water is silent for now } SetMoveType( MOVETYPE_PUSH ); SetAbsOrigin( GetAbsOrigin() ); SetModel( GetModelName() ); if( GetSpeed() == 0 ) SetSpeed( 100 ); m_vecPosition1 = GetAbsOrigin(); // Subtract 2 from size because the engine expands bboxes by 1 in all directions making the size too big m_vecPosition2 = m_vecPosition1 + ( GetMoveDir() * ( fabs( GetMoveDir().x * ( GetBounds().x - 2 ) ) + fabs( GetMoveDir().y * ( GetBounds().y - 2 ) ) + fabs( GetMoveDir().z * ( GetBounds().z - 2 ) ) - m_flLip ) ); ASSERTSZ( m_vecPosition1 != m_vecPosition2, "door start/end positions are equal" ); if( GetSpawnFlags().Any( SF_DOOR_START_OPEN ) ) { // swap pos1 and pos2, put door at pos2 SetAbsOrigin( m_vecPosition2 ); m_vecPosition2 = m_vecPosition1; m_vecPosition1 = GetAbsOrigin(); } m_toggle_state = TS_AT_BOTTOM; // if the door is flagged for USE button activation only, use NULL touch function if( GetSpawnFlags().Any( SF_DOOR_USE_ONLY ) ) { SetTouch( NULL ); } else // touchable button SetTouch( &CBaseDoor::DoorTouch ); }
void CBasePlayerAmmo::Spawn() { SetMoveType( MOVETYPE_TOSS ); SetSolidType( SOLID_TRIGGER ); SetSize( Vector( -16, -16, 0 ), Vector( 16, 16, 16 ) ); SetAbsOrigin( GetAbsOrigin() ); SetTouch( &CBasePlayerAmmo::DefaultTouch ); }
virtual ActionResult<CTFBot> Update(CTFBot *actor, float dt) override { TRACE("[this: %08x] [actor: #%d]", (uintptr_t)this, ENTINDEX(actor)); if (this->m_hHint == nullptr) { return ActionResult<CTFBot>::Done("No hint entity"); } INextBot *nextbot = rtti_cast<INextBot *>(actor); if (nextbot->IsRangeGreaterThan(this->m_hHint->GetAbsOrigin(), 25.0f)) { TRACE_MSG("range_to_hint > 25: pathing\n"); if (this->m_ctRecomputePath.IsElapsed()) { TRACE_MSG("recomputing path\n"); this->m_ctRecomputePath.Start(RandomFloat(1.0f, 2.0f)); CTFBotPathCost cost_func(actor, FASTEST_ROUTE); this->m_PathFollower.Compute(nextbot, this->m_hHint->GetAbsOrigin(), cost_func, 0.0f, true); } this->m_PathFollower.Update(nextbot); if (!this->m_PathFollower.IsValid()) { return ActionResult<CTFBot>::Done("Path failed"); } return ActionResult<CTFBot>::Continue(); } TRACE_MSG("at hint: creating dispenser entity\n"); CBaseEntity *ent = CreateEntityByName("obj_dispenser"); if (ent == nullptr) { return ActionResult<CTFBot>::Done("Couldn't create entity"); } auto dispenser = rtti_cast<CObjectDispenser *>(ent); dispenser->SetName(this->m_hHint->GetEntityName()); dispenser->m_nDefaultUpgradeLevel = 2; dispenser->SetAbsOrigin(this->m_hHint->GetAbsOrigin()); dispenser->SetAbsAngles(this->m_hHint->GetAbsAngles()); dispenser->Spawn(); dispenser->StartPlacement(actor); suppress_speak = true; dispenser->StartBuilding(actor); suppress_speak = false; this->m_hHint->SetOwnerEntity(dispenser); actor->SpeakConceptIfAllowed(MP_CONCEPT_BUILDING_OBJECT, "objtype:dispenser"); return ActionResult<CTFBot>::Done("Built a dispenser"); }
//------------------------------------------------------------------------------ // Purpose : Initialize a gibs position and velocity // Input : // Output : //------------------------------------------------------------------------------ void CGib::InitGib( CBaseEntity *pVictim, float fMinVelocity, float fMaxVelocity ) { // ------------------------------------------------------------------------ // If have a pVictim spawn the gib somewhere in the pVictim's bounding volume // ------------------------------------------------------------------------ if ( pVictim ) { // Find a random position within the bounding box (add 1 to Z to get it out of the ground) Vector vecOrigin; pVictim->CollisionProp()->RandomPointInBounds( vec3_origin, Vector( 1, 1, 1 ), &vecOrigin ); vecOrigin.z += 1.0f; SetAbsOrigin( vecOrigin ); // make the gib fly away from the attack vector Vector vecNewVelocity = g_vecAttackDir * -1; // mix in some noise vecNewVelocity.x += random->RandomFloat ( -0.25, 0.25 ); vecNewVelocity.y += random->RandomFloat ( -0.25, 0.25 ); vecNewVelocity.z += random->RandomFloat ( -0.25, 0.25 ); vecNewVelocity *= random->RandomFloat ( fMaxVelocity, fMinVelocity ); QAngle vecNewAngularVelocity = GetLocalAngularVelocity(); vecNewAngularVelocity.x = random->RandomFloat ( 100, 200 ); vecNewAngularVelocity.y = random->RandomFloat ( 100, 300 ); SetLocalAngularVelocity( vecNewAngularVelocity ); // copy owner's blood color SetBloodColor( pVictim->BloodColor() ); AdjustVelocityBasedOnHealth( pVictim->m_iHealth, vecNewVelocity ); // Attempt to be physical if we can if ( VPhysicsInitNormal( SOLID_BBOX, 0, false ) ) { IPhysicsObject *pObj = VPhysicsGetObject(); if ( pObj != NULL ) { AngularImpulse angImpulse = RandomAngularImpulse( -500, 500 ); pObj->AddVelocity( &vecNewVelocity, &angImpulse ); } } else { SetSolid( SOLID_BBOX ); SetCollisionBounds( vec3_origin, vec3_origin ); SetAbsVelocity( vecNewVelocity ); } SetCollisionGroup( COLLISION_GROUP_DEBRIS ); } LimitVelocity(); }
//----------------------------------------------------------------------------- // Purpose: Starts the vortex working //----------------------------------------------------------------------------- void CGravityVortexController::StartPull( const Vector &origin, float radius, float strength, float duration ) { SetAbsOrigin( origin ); m_flEndTime = gpGlobals->curtime + duration; m_flRadius = radius; m_flStrength= strength; SetThink( &CGravityVortexController::PullThink ); SetNextThink( gpGlobals->curtime + 0.1f ); }
void CBoneFollower::VPhysicsUpdate( IPhysicsObject *pPhysics ) { Vector origin; QAngle angles; pPhysics->GetPosition( &origin, &angles ); SetAbsOrigin( origin ); SetAbsAngles( angles ); }