void CPendulum :: PendulumUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if (!ShouldToggle(useType)) return; if ( pev->speed ) // Pendulum is moving, stop it and auto-return if necessary { if ( FBitSet( pev->spawnflags, SF_PENDULUM_AUTO_RETURN ) ) { float delta; delta = CBaseToggle :: AxisDelta( pev->spawnflags, pev->angles, m_start ); UTIL_SetAvelocity(this, m_maxSpeed * pev->movedir); //LRC //pev->avelocity = m_maxSpeed * pev->movedir; SetNextThink(delta / m_maxSpeed); SetThink(&CPendulum ::StopThink); } else { pev->speed = 0; // Dead stop DontThink(); UTIL_SetAvelocity(this, g_vecZero); //LRC //pev->avelocity = g_vecZero; } } else { SetNextThink(0.1); // start the pendulum moving SetThink(&CPendulum ::SwingThink); m_time = gpGlobals->time; // Save time to calculate dt m_dampSpeed = m_maxSpeed; } }
// // SpinDown - decelerates a moving func_rotating to a standstill. // void CFuncRotating :: SpinDown( void ) { SetNextThink( 0.1 ); m_fCurSpeed = m_fCurSpeed - ( pev->speed * m_flFanFriction ); UTIL_SetAvelocity(this, pev->movedir * m_fCurSpeed); //pev->avelocity = pev->avelocity - ( pev->movedir * ( pev->speed * m_flFanFriction ) );//spin down slower than spinup // if we've met or exceeded target speed, set target speed and stop thinking if (m_fCurSpeed <= 0) { m_iState = STATE_OFF; m_fCurSpeed = 0; UTIL_SetAvelocity(this, g_vecZero); //pev->avelocity = g_vecZero;// set speed in case we overshot // stop sound, we're done EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning /* Stop */), 0, 0, SND_STOP, m_pitch); SetThink(&CFuncRotating :: Rotate ); Rotate(); } else { RampPitchVol(FALSE); } }
// // SpinUp - accelerates a non-moving func_rotating up to it's speed // void CFuncRotating :: SpinUp( void ) { //Vector vecAVel;//rotational velocity SetNextThink( 0.1 ); m_fCurSpeed = m_fCurSpeed + ( pev->speed * m_flFanFriction ); UTIL_SetAvelocity(this, pev->movedir * m_fCurSpeed); //pev->avelocity = pev->avelocity + ( pev->movedir * ( pev->speed * m_flFanFriction ) ); //vecAVel = pev->avelocity;// cache entity's rotational velocity // if we've met or exceeded target speed, set target speed and stop thinking if ( m_fCurSpeed >= pev->speed ) { m_iState = STATE_ON; m_fCurSpeed = pev->speed; UTIL_SetAvelocity(this, pev->movedir * pev->speed); //pev->avelocity = pev->movedir * pev->speed;// set speed in case we overshot EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning), m_flVolume, m_flAttenuation, SND_CHANGE_PITCH | SND_CHANGE_VOL, FANPITCHMAX); SetThink(&CFuncRotating :: Rotate ); Rotate(); } else { RampPitchVol(TRUE); } }
void CPendulum :: SwingThink( void ) { float delta, dt; delta = CBaseToggle :: AxisDelta( pev->spawnflags, pev->angles, m_center ); dt = gpGlobals->time - m_time; // How much time has passed? m_time = gpGlobals->time; // Remember the last time called if ( delta > 0 && m_accel > 0 ) pev->speed -= m_accel * dt; // Integrate velocity else pev->speed += m_accel * dt; if ( pev->speed > m_maxSpeed ) pev->speed = m_maxSpeed; else if ( pev->speed < -m_maxSpeed ) pev->speed = -m_maxSpeed; // scale the destdelta vector by the time spent traveling to get velocity UTIL_SetAvelocity(this, pev->speed * pev->movedir); //LRC //pev->avelocity = pev->speed * pev->movedir; // ALERT(at_console, "m_damp %f, m_dampSpeed %f\n", m_damp, m_dampSpeed); // ALERT(at_console, "SwingThink: delta %f, dt %f, speed %f, avel %f %f %f\n", delta, dt, pev->speed, pev->avelocity.x, pev->avelocity.y, pev->avelocity.z); // Call this again SetNextThink(0.1); SetThink(&CPendulum ::SwingThink); // if (m_pMoveWith) // correct MoveWith problems associated with fast-thinking entities // UTIL_AssignOrigin(this, m_vecMoveWithOffset + m_pMoveWith->pev->origin); if ( m_damp ) { m_dampSpeed -= m_damp * m_dampSpeed * dt; if ( m_dampSpeed < 30.0 ) { UTIL_SetAngles(this, m_center); //LRC //pev->angles = m_center; pev->speed = 0; ALERT(at_debug, "**CANCELLING pendulum think!\n"); DontThink(); UTIL_SetAvelocity(this, g_vecZero); //LRC //pev->avelocity = g_vecZero; } else if ( pev->speed > m_dampSpeed ) pev->speed = m_dampSpeed; else if ( pev->speed < -m_dampSpeed ) pev->speed = -m_dampSpeed; } }
void CBaseToggle :: AngularMoveNow() { // ALERT(at_console, "AngularMoveNow %f\n", pev->ltime); Vector vecDestAngle; if (m_pMoveWith) vecDestAngle = m_vecFinalAngle + m_pMoveWith->pev->angles; else vecDestAngle = m_vecFinalAngle; // Already there? if (vecDestAngle == pev->angles) { AngularMoveDone(); return; } // set destdelta to the vector needed to move Vector vecDestDelta = vecDestAngle - pev->angles; // divide by speed to get time to reach dest float flTravelTime = vecDestDelta.Length() / m_flAngularMoveSpeed; // set nextthink to trigger a call to AngularMoveDone when dest is reached SetNextThink( flTravelTime, TRUE ); SetThink(&CBaseToggle :: AngularMoveDone ); // scale the destdelta vector by the time spent traveling to get velocity UTIL_SetAvelocity(this, vecDestDelta / flTravelTime ); }
//========================================================= // Rotating Use - when a rotating brush is triggered //========================================================= void CFuncRotating :: RotatingUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if (!ShouldToggle(useType)) return; // is this a brush that should accelerate and decelerate when turned on/off (fan)? if ( FBitSet ( pev->spawnflags, SF_BRUSH_ACCDCC ) ) { // fan is spinning, so stop it. if ( m_fCurSpeed != 0 ) // if ( pev->avelocity != g_vecZero ) { m_iState = STATE_TURN_OFF; SetThink(&CFuncRotating :: SpinDown ); //EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, (char *)STRING(pev->noiseStop), // m_flVolume, m_flAttenuation, 0, m_pitch); SetNextThink( 0.1 ); } else// fan is not moving, so start it { m_iState = STATE_TURN_ON; SetThink(&CFuncRotating :: SpinUp ); EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning), 0.01, m_flAttenuation, 0, FANPITCHMIN); SetNextThink( 0.1 ); } } else // if ( !FBitSet ( pev->spawnflags, SF_BRUSH_ACCDCC ) )//this is a normal start/stop brush. { if ( m_fCurSpeed != 0 ) //LRC // if ( pev->avelocity != g_vecZero ) { m_iState = STATE_OFF; // play stopping sound here SetThink(&CFuncRotating :: SpinDown ); // EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, (char *)STRING(pev->noiseStop), // m_flVolume, m_flAttenuation, 0, m_pitch); SetNextThink( 0.1 ); // pev->avelocity = g_vecZero; } else { m_iState = STATE_ON; EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning), m_flVolume, m_flAttenuation, 0, FANPITCHMAX); //LRC m_fCurSpeed = pev->speed; UTIL_SetAvelocity(this, pev->movedir * pev->speed); // pev->avelocity = pev->movedir * pev->speed; SetThink(&CFuncRotating :: Rotate ); Rotate(); } } }
void CPendulum :: StopThink( void ) { UTIL_SetAngles(this, m_start); //LRC //pev->angles = m_start; pev->speed = 0; DontThink(); UTIL_SetAvelocity(this, g_vecZero); //LRC //pev->avelocity = g_vecZero; }
void CTriggerCamera::TurnOff( void ) { if( m_pGoalEnt ) m_pGoalEnt = m_pGoalEnt->GetPrev(); UTIL_SetVelocity( this, g_vecZero ); UTIL_SetAvelocity( this, g_vecZero ); UpdatePlayerView(); m_iState = STATE_OFF; DontThink(); }
/* ============ After rotating, set angle to exact final angle, call "move done" function ============ */ void CBaseToggle :: AngularMoveDoneNow( void ) { // ALERT(at_console, "AngularMoveDone %f\n", pev->ltime); UTIL_SetAvelocity(this, g_vecZero); if (m_pMoveWith) { UTIL_SetAngles(this, m_vecFinalAngle + m_pMoveWith->pev->angles); } else { UTIL_SetAngles(this, m_vecFinalAngle); } DontThink(); if ( m_pfnCallWhenMoveDone ) (this->*m_pfnCallWhenMoveDone)(); }
void CBaseDoor::Blocked( CBaseEntity *pOther ) { CBaseEntity *pTarget = NULL; CBaseDoor *pDoor = NULL; // ALERT(at_debug, "%s blocked\n", STRING(pev->targetname)); // Hurt the blocker a little. if ( pev->dmg ) if (m_hActivator) pOther->TakeDamage( pev, m_hActivator->pev, pev->dmg, DMG_CRUSH ); //AJH Attribute damage to he who switched me. else pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH ); // if a door has a negative wait, it would never come back if blocked, // so let it just squash the object to death real fast if (m_flWait >= 0) { //LRC - thanks to [insert name here] for this if ( !FBitSet( pev->spawnflags, SF_DOOR_SILENT ) ) STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMoving) ); if (m_toggle_state == TS_GOING_DOWN) { DoorGoUp(); } else { DoorGoDown(); } } // Block all door pieces with the same targetname here. //LRC - in immediate mode don't do this, doors are expected to do it themselves. if ( !m_iImmediateMode && !FStringNull ( pev->targetname ) ) { for (;;) { pTarget = UTIL_FindEntityByTargetname(pTarget, STRING(pev->targetname)); if ( !pTarget ) break; if ( VARS( pTarget->pev ) != pev && FClassnameIs ( pTarget->pev, "func_door" ) || FClassnameIs ( pTarget->pev, "func_door_rotating" ) ) { pDoor = GetClassPtr( (CBaseDoor *) VARS(pTarget->pev) ); if ( pDoor->m_flWait >= 0) { // avelocity == velocity!? LRC if (pDoor->pev->velocity == pev->velocity && pDoor->pev->avelocity == pev->velocity) { // this is the most hacked, evil, bastardized thing I've ever seen. kjb if ( FClassnameIs ( pTarget->pev, "func_door" ) ) {// set origin to realign normal doors pDoor->pev->origin = pev->origin; UTIL_SetVelocity(pDoor, g_vecZero);// stop! } else {// set angles to realign rotating doors pDoor->pev->angles = pev->angles; UTIL_SetAvelocity(pDoor, g_vecZero); } } if ( pDoor->m_toggle_state == TS_GOING_DOWN) pDoor->DoorGoUp(); else pDoor->DoorGoDown(); } } } } }