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