H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-29 17:43:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
79e83bb97f
source-engine/game/server/buttons.cpp

1587 lines
43 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements buttons.
//
//=============================================================================
#include "cbase.h"
#include "doors.h"
#include "ndebugoverlay.h"
#include "spark.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "tier1/strtools.h"
#include "buttons.h"
#include "eventqueue.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
void PlayLockSounds( CBaseEntity *pEdict, locksound_t *pls, int flocked, int fbutton );
string_t MakeButtonSound( int sound ); // get string of button sound number
#define SF_BUTTON_DONTMOVE 1
#define SF_ROTBUTTON_NOTSOLID 1
#define SF_BUTTON_TOGGLE 32 // button stays pushed until reactivated
#define SF_BUTTON_TOUCH_ACTIVATES 256 // Button fires when touched.
#define SF_BUTTON_DAMAGE_ACTIVATES 512 // Button fires when damaged.
#define SF_BUTTON_USE_ACTIVATES 1024 // Button fires when used.
#define SF_BUTTON_LOCKED 2048 // Whether the button is initially locked.
#define SF_BUTTON_SPARK_IF_OFF 4096 // button sparks in OFF state
#define SF_BUTTON_JIGGLE_ON_USE_LOCKED 8192 // whether to jiggle if someone uses us when we're locked
BEGIN_DATADESC( CBaseButton )
DEFINE_KEYFIELD( m_vecMoveDir, FIELD_VECTOR, "movedir" ),
DEFINE_FIELD( m_fStayPushed, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fRotating, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bLockedSound, FIELD_CHARACTER ),
DEFINE_FIELD( m_bLockedSentence, FIELD_CHARACTER ),
DEFINE_FIELD( m_bUnlockedSound, FIELD_CHARACTER ),
DEFINE_FIELD( m_bUnlockedSentence, FIELD_CHARACTER ),
DEFINE_FIELD( m_bLocked, FIELD_BOOLEAN ),
DEFINE_FIELD( m_sNoise, FIELD_SOUNDNAME ),
DEFINE_FIELD( m_flUseLockedTime, FIELD_TIME ),
DEFINE_FIELD( m_bSolidBsp, FIELD_BOOLEAN ),
DEFINE_KEYFIELD( m_sounds, FIELD_INTEGER, "sounds" ),
// DEFINE_FIELD( m_ls, FIELD_SOUNDNAME ), // This is restored in Precache()
// DEFINE_FIELD( m_nState, FIELD_INTEGER ),
// Function Pointers
DEFINE_FUNCTION( ButtonTouch ),
DEFINE_FUNCTION( ButtonSpark ),
DEFINE_FUNCTION( TriggerAndWait ),
DEFINE_FUNCTION( ButtonReturn ),
DEFINE_FUNCTION( ButtonBackHome ),
DEFINE_FUNCTION( ButtonUse ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Lock", InputLock ),
DEFINE_INPUTFUNC( FIELD_VOID, "Unlock", InputUnlock ),
DEFINE_INPUTFUNC( FIELD_VOID, "Press", InputPress ),
DEFINE_INPUTFUNC( FIELD_VOID, "PressIn", InputPressIn ),
DEFINE_INPUTFUNC( FIELD_VOID, "PressOut", InputPressOut ),
// Outputs
DEFINE_OUTPUT( m_OnDamaged, "OnDamaged" ),
DEFINE_OUTPUT( m_OnPressed, "OnPressed" ),
DEFINE_OUTPUT( m_OnUseLocked, "OnUseLocked" ),
DEFINE_OUTPUT( m_OnIn, "OnIn" ),
DEFINE_OUTPUT( m_OnOut, "OnOut" ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( func_button, CBaseButton );
void CBaseButton::Precache( void )
{
// get door button sounds, for doors which require buttons to open
if (m_bLockedSound)
{
m_ls.sLockedSound = MakeButtonSound( (int)m_bLockedSound );
PrecacheScriptSound(m_ls.sLockedSound.ToCStr());
}
if (m_bUnlockedSound)
{
m_ls.sUnlockedSound = MakeButtonSound( (int)m_bUnlockedSound );
PrecacheScriptSound(m_ls.sUnlockedSound.ToCStr());
}
// get sentence group names, for doors which are directly 'touched' to open
switch (m_bLockedSentence)
{
case 1: m_ls.sLockedSentence = MAKE_STRING("NA"); break; // access denied
case 2: m_ls.sLockedSentence = MAKE_STRING("ND"); break; // security lockout
case 3: m_ls.sLockedSentence = MAKE_STRING("NF"); break; // blast door
case 4: m_ls.sLockedSentence = MAKE_STRING("NFIRE"); break; // fire door
case 5: m_ls.sLockedSentence = MAKE_STRING("NCHEM"); break; // chemical door
case 6: m_ls.sLockedSentence = MAKE_STRING("NRAD"); break; // radiation door
case 7: m_ls.sLockedSentence = MAKE_STRING("NCON"); break; // gen containment
case 8: m_ls.sLockedSentence = MAKE_STRING("NH"); break; // maintenance door
case 9: m_ls.sLockedSentence = MAKE_STRING("NG"); break; // broken door
default: m_ls.sLockedSentence = NULL_STRING; break;
}
switch (m_bUnlockedSentence)
{
case 1: m_ls.sUnlockedSentence = MAKE_STRING("EA"); break; // access granted
case 2: m_ls.sUnlockedSentence = MAKE_STRING("ED"); break; // security door
case 3: m_ls.sUnlockedSentence = MAKE_STRING("EF"); break; // blast door
case 4: m_ls.sUnlockedSentence = MAKE_STRING("EFIRE"); break; // fire door
case 5: m_ls.sUnlockedSentence = MAKE_STRING("ECHEM"); break; // chemical door
case 6: m_ls.sUnlockedSentence = MAKE_STRING("ERAD"); break; // radiation door
case 7: m_ls.sUnlockedSentence = MAKE_STRING("ECON"); break; // gen containment
case 8: m_ls.sUnlockedSentence = MAKE_STRING("EH"); break; // maintenance door
default: m_ls.sUnlockedSentence = NULL_STRING; break;
}
if ( m_sNoise != NULL_STRING )
{
PrecacheScriptSound( STRING( m_sNoise ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: Cache user-entity-field values until spawn is called.
// Input : szKeyName -
// szValue -
// Output : Returns true if handled, false if not.
//-----------------------------------------------------------------------------
bool CBaseButton::KeyValue( const char *szKeyName, const char *szValue )
{
if (FStrEq(szKeyName, "locked_sound"))
{
m_bLockedSound = atof(szValue);
}
else if (FStrEq(szKeyName, "locked_sentence"))
{
m_bLockedSentence = atof(szValue);
}
else if (FStrEq(szKeyName, "unlocked_sound"))
{
m_bUnlockedSound = atof(szValue);
}
else if (FStrEq(szKeyName, "unlocked_sentence"))
{
m_bUnlockedSentence = atof(szValue);
}
else
{
return BaseClass::KeyValue( szKeyName, szValue );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Locks the button. If locked, the button will play the locked sound
// when the player tries to use it.
//-----------------------------------------------------------------------------
void CBaseButton::Lock()
{
m_bLocked = true;
}
//-----------------------------------------------------------------------------
// Purpose: Unlocks the button, making it able to be pressed again.
//-----------------------------------------------------------------------------
void CBaseButton::Unlock()
{
m_bLocked = false;
}
//-----------------------------------------------------------------------------
// Purpose: Locks the button. If locked, the button will play the locked sound
// when the player tries to use it.
//-----------------------------------------------------------------------------
void CBaseButton::InputLock( inputdata_t &inputdata )
{
Lock();
}
//-----------------------------------------------------------------------------
// Purpose: Unlocks the button, making it able to be pressed again.
//-----------------------------------------------------------------------------
void CBaseButton::InputUnlock( inputdata_t &inputdata )
{
Unlock();
}
//-----------------------------------------------------------------------------
// Presses or unpresses the button.
//-----------------------------------------------------------------------------
void CBaseButton::Press( CBaseEntity *pActivator, BUTTON_CODE eCode )
{
if ( ( eCode == BUTTON_PRESS ) && ( m_toggle_state == TS_GOING_UP || m_toggle_state == TS_GOING_DOWN ) )
{
return;
}
if ( ( eCode == BUTTON_ACTIVATE ) && ( m_toggle_state == TS_GOING_UP || m_toggle_state == TS_AT_TOP ) )
{
return;
}
if ( ( eCode == BUTTON_RETURN ) && ( m_toggle_state == TS_GOING_DOWN || m_toggle_state == TS_AT_BOTTOM ) )
{
return;
}
// FIXME: consolidate all the button press code into one place!
if (m_bLocked)
{
// play button locked sound
PlayLockSounds(this, &m_ls, TRUE, TRUE);
return;
}
// Temporarily disable the touch function, until movement is finished.
SetTouch( NULL );
if ( ( ( eCode == BUTTON_PRESS ) && ( m_toggle_state == TS_AT_TOP ) ) ||
( ( eCode == BUTTON_RETURN ) && ( m_toggle_state == TS_AT_TOP || m_toggle_state == TS_GOING_UP ) ) )
{
if ( m_sNoise != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = (char*)STRING(m_sNoise);
ep.m_flVolume = 1;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
m_OnPressed.FireOutput(pActivator, this);
ButtonReturn();
}
else if ( ( eCode == BUTTON_PRESS ) ||
( ( eCode == BUTTON_ACTIVATE ) && ( m_toggle_state == TS_AT_BOTTOM || m_toggle_state == TS_GOING_DOWN ) ) )
{
m_OnPressed.FireOutput(pActivator, this);
ButtonActivate();
}
}
//-----------------------------------------------------------------------------
// Presses the button.
//-----------------------------------------------------------------------------
void CBaseButton::InputPress( inputdata_t &inputdata )
{
Press( inputdata.pActivator, BUTTON_PRESS );
}
//-----------------------------------------------------------------------------
// Presses the button, sending it to the top/pressed position.
//-----------------------------------------------------------------------------
void CBaseButton::InputPressIn( inputdata_t &inputdata )
{
Press( inputdata.pActivator, BUTTON_ACTIVATE );
}
//-----------------------------------------------------------------------------
// Unpresses the button, sending it to the unpressed/bottom position.
//-----------------------------------------------------------------------------
void CBaseButton::InputPressOut( inputdata_t &inputdata )
{
Press( inputdata.pActivator, BUTTON_RETURN );
}
//-----------------------------------------------------------------------------
// Purpose: We have been damaged. Possibly activate, depending on our flags.
// Input : pInflictor -
// pAttacker -
// flDamage -
// bitsDamageType -
// Output :
//-----------------------------------------------------------------------------
int CBaseButton::OnTakeDamage( const CTakeDamageInfo &info )
{
m_OnDamaged.FireOutput(m_hActivator, this);
// dvsents2: remove obselete health keyvalue from func_button
if (!HasSpawnFlags(SF_BUTTON_DAMAGE_ACTIVATES) && (m_iHealth == 0))
{
return(0);
}
BUTTON_CODE code = ButtonResponseToTouch();
if ( code == BUTTON_NOTHING )
return 0;
m_hActivator = info.GetAttacker();
// dvsents2: why would activator be NULL here?
if ( m_hActivator == NULL )
return 0;
if (m_bLocked)
{
return(0);
}
// Temporarily disable the touch function, until movement is finished.
SetTouch( NULL );
if ( code == BUTTON_RETURN )
{
if ( m_sNoise != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = (char*)STRING(m_sNoise);
ep.m_flVolume = 1;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
m_OnPressed.FireOutput(m_hActivator, this);
ButtonReturn();
}
else
{
// code == BUTTON_ACTIVATE
m_OnPressed.FireOutput(m_hActivator, this);
ButtonActivate( );
}
return 0;
}
void CBaseButton::Spawn( )
{
//----------------------------------------------------
//determine sounds for buttons
//a sound of 0 should not make a sound
//----------------------------------------------------
if ( m_sounds )
{
m_sNoise = MakeButtonSound( m_sounds );
PrecacheScriptSound(m_sNoise.ToCStr());
}
else
{
m_sNoise = NULL_STRING;
}
Precache();
if ( HasSpawnFlags( SF_BUTTON_SPARK_IF_OFF ) )// this button should spark in OFF state
{
SetThink ( &CBaseButton::ButtonSpark );
SetNextThink( gpGlobals->curtime + 0.5f );// no hurry, make sure everything else spawns
}
// Convert movedir from angles to a vector
QAngle angMoveDir = QAngle( m_vecMoveDir.x, m_vecMoveDir.y, m_vecMoveDir.z );
AngleVectors( angMoveDir, &m_vecMoveDir );
SetMoveType( MOVETYPE_PUSH );
SetSolid( SOLID_BSP );
SetModel( STRING( GetModelName() ) );
if (m_flSpeed == 0)
{
m_flSpeed = 40;
}
m_takedamage = DAMAGE_YES;
if (m_flWait == 0)
{
m_flWait = 1;
}
if (m_flLip == 0)
{
m_flLip = 4;
}
m_toggle_state = TS_AT_BOTTOM;
m_vecPosition1 = GetLocalOrigin();
// Subtract 2 from size because the engine expands bboxes by 1 in all directions making the size too big
Vector vecButtonOBB = CollisionProp()->OBBSize();
vecButtonOBB -= Vector( 2, 2, 2 );
m_vecPosition2 = m_vecPosition1 + (m_vecMoveDir * (DotProductAbs( m_vecMoveDir, vecButtonOBB ) - m_flLip));
// Is this a non-moving button?
if ( ((m_vecPosition2 - m_vecPosition1).Length() < 1) || HasSpawnFlags(SF_BUTTON_DONTMOVE) )
{
m_vecPosition2 = m_vecPosition1;
}
m_fStayPushed = (m_flWait == -1 ? TRUE : FALSE);
m_fRotating = FALSE;
if (HasSpawnFlags(SF_BUTTON_LOCKED))
{
m_bLocked = true;
}
//
// If using activates the button, set its use function.
//
if (HasSpawnFlags(SF_BUTTON_USE_ACTIVATES))
{
SetUse(&CBaseButton::ButtonUse);
}
else
{
SetUse(NULL);
}
//
// If touching activates the button, set its touch function.
//
if (HasSpawnFlags(SF_BUTTON_TOUCH_ACTIVATES))
{
SetTouch( &CBaseButton::ButtonTouch );
}
else
{
SetTouch ( NULL );
}
CreateVPhysics();
}
//-----------------------------------------------------------------------------
bool CBaseButton::CreateVPhysics()
{
VPhysicsInitShadow( false, false );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Button sound table.
// Also used by CBaseDoor to get 'touched' door lock/unlock sounds
// Input : sound - index of sound to look up.
// Output : Returns a pointer to the corresponding sound file.
//-----------------------------------------------------------------------------
string_t MakeButtonSound( int sound )
{
char tmp[1024];
Q_snprintf( tmp, sizeof(tmp), "Buttons.snd%d", sound );
return AllocPooledString(tmp);
}
//-----------------------------------------------------------------------------
// Purpose: Think function that emits sparks at random intervals.
//-----------------------------------------------------------------------------
void CBaseButton::ButtonSpark ( void )
{
SetThink ( &CBaseButton::ButtonSpark );
SetNextThink( gpGlobals->curtime + 0.1 + random->RandomFloat ( 0, 1.5 ) );// spark again at random interval
DoSpark( this, WorldSpaceCenter(), 1, 1, true, vec3_origin );
}
//-----------------------------------------------------------------------------
// Purpose: Called when someone uses us whilst we are locked.
//-----------------------------------------------------------------------------
bool CBaseButton::OnUseLocked( CBaseEntity *pActivator )
{
PlayLockSounds(this, &m_ls, TRUE, TRUE);
if ( gpGlobals->curtime > m_flUseLockedTime )
{
m_OnUseLocked.FireOutput( pActivator, this );
m_flUseLockedTime = gpGlobals->curtime + 0.5;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Use function that starts the button moving.
// Input : pActivator -
// pCaller -
// useType -
// value -
//-----------------------------------------------------------------------------
void CBaseButton::ButtonUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// Ignore touches if button is moving, or pushed-in and waiting to auto-come-out.
// UNDONE: Should this use ButtonResponseToTouch() too?
if (m_toggle_state == TS_GOING_UP || m_toggle_state == TS_GOING_DOWN )
return;
if (m_bLocked)
{
OnUseLocked( pActivator );
return;
}
m_hActivator = pActivator;
if ( m_toggle_state == TS_AT_TOP)
{
//
// If it's a toggle button it can return now. Otherwise, it will either
// return on its own or will stay pressed indefinitely.
//
if ( HasSpawnFlags(SF_BUTTON_TOGGLE))
{
if ( m_sNoise != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = (char*)STRING(m_sNoise);
ep.m_flVolume = 1;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
m_OnPressed.FireOutput(m_hActivator, this);
ButtonReturn();
}
}
else
{
m_OnPressed.FireOutput(m_hActivator, this);
ButtonActivate( );
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns a code indicating how the button should respond to being touched.
// Output : Returns one of the following:
// BUTTON_NOTHING - do nothing
// BUTTON_RETURN -
// BUTTON_ACTIVATE - act as if pressed
//-----------------------------------------------------------------------------
CBaseButton::BUTTON_CODE CBaseButton::ButtonResponseToTouch( void )
{
// Ignore touches if button is moving, or pushed-in and waiting to auto-come-out.
if (m_toggle_state == TS_GOING_UP ||
m_toggle_state == TS_GOING_DOWN ||
(m_toggle_state == TS_AT_TOP && !m_fStayPushed && !HasSpawnFlags(SF_BUTTON_TOGGLE) ) )
return BUTTON_NOTHING;
if (m_toggle_state == TS_AT_TOP)
{
if ( HasSpawnFlags(SF_BUTTON_TOGGLE) && !m_fStayPushed)
{
return BUTTON_RETURN;
}
}
else
return BUTTON_ACTIVATE;
return BUTTON_NOTHING;
}
//-----------------------------------------------------------------------------
// Purpose: Touch function that activates the button if it responds to touch.
// Input : pOther - The entity that touched us.
//-----------------------------------------------------------------------------
void CBaseButton::ButtonTouch( CBaseEntity *pOther )
{
// Ignore touches by anything but players
if ( !pOther->IsPlayer() )
return;
m_hActivator = pOther;
BUTTON_CODE code = ButtonResponseToTouch();
if ( code == BUTTON_NOTHING )
return;
if (!UTIL_IsMasterTriggered(m_sMaster, pOther) || m_bLocked)
{
// play button locked sound
PlayLockSounds(this, &m_ls, TRUE, TRUE);
return;
}
// Temporarily disable the touch function, until movement is finished.
SetTouch( NULL );
if ( code == BUTTON_RETURN )
{
if ( m_sNoise != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = (char*)STRING(m_sNoise);
ep.m_flVolume = 1;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
m_OnPressed.FireOutput(m_hActivator, this);
ButtonReturn();
}
else
{
// code == BUTTON_ACTIVATE
m_OnPressed.FireOutput(m_hActivator, this);
ButtonActivate( );
}
}
//-----------------------------------------------------------------------------
// Purpose: Starts the button moving "in/up".
// Input : *pOther -
//-----------------------------------------------------------------------------
void CBaseButton::ButtonActivate( void )
{
if ( m_sNoise != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = (char*)STRING(m_sNoise);
ep.m_flVolume = 1;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
if (!UTIL_IsMasterTriggered(m_sMaster, m_hActivator) || m_bLocked)
{
// button is locked, play locked sound
PlayLockSounds(this, &m_ls, TRUE, TRUE);
return;
}
else
{
// button is unlocked, play unlocked sound
PlayLockSounds(this, &m_ls, FALSE, TRUE);
}
ASSERT(m_toggle_state == TS_AT_BOTTOM);
m_toggle_state = TS_GOING_UP;
SetMoveDone( &CBaseButton::TriggerAndWait );
if (!m_fRotating)
LinearMove( m_vecPosition2, m_flSpeed);
else
AngularMove( m_vecAngle2, m_flSpeed);
}
//-----------------------------------------------------------------------------
// Purpose: Enables or disables the use capability based on our spawnflags.
//-----------------------------------------------------------------------------
int CBaseButton::ObjectCaps(void)
{
return((BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) |
(HasSpawnFlags(SF_BUTTON_USE_ACTIVATES) ? (FCAP_IMPULSE_USE | FCAP_USE_IN_RADIUS) : 0));
}
//-----------------------------------------------------------------------------
// Purpose: Button has reached the "pressed/top" position. Fire its OnIn output,
// and pause before returning to "unpressed/bottom".
//-----------------------------------------------------------------------------
void CBaseButton::TriggerAndWait( void )
{
ASSERT(m_toggle_state == TS_GOING_UP);
if (!UTIL_IsMasterTriggered(m_sMaster, m_hActivator) || m_bLocked)
{
return;
}
m_toggle_state = TS_AT_TOP;
//
// Re-instate touches if the button is of the toggle variety.
//
if (m_fStayPushed || HasSpawnFlags(SF_BUTTON_TOGGLE ) )
{
if (HasSpawnFlags(SF_BUTTON_TOUCH_ACTIVATES))
{
SetTouch(&CBaseButton::ButtonTouch);
}
else
{
// BUGBUG: ALL buttons no longer respond to touch
SetTouch (NULL);
}
}
//
// If button automatically comes back out, start it moving out.
//
else
{
SetNextThink( gpGlobals->curtime + m_flWait );
SetThink( &CBaseButton::ButtonReturn );
}
m_nState = 1; // use alternate textures
m_OnIn.FireOutput(m_hActivator, this);
}
//-----------------------------------------------------------------------------
// Purpose: Starts the button moving "out/down".
//-----------------------------------------------------------------------------
void CBaseButton::ButtonReturn( void )
{
ASSERT(m_toggle_state == TS_AT_TOP);
m_toggle_state = TS_GOING_DOWN;
SetMoveDone( &CBaseButton::ButtonBackHome );
if (!m_fRotating)
LinearMove( m_vecPosition1, m_flSpeed);
else
AngularMove( m_vecAngle1, m_flSpeed);
m_nState = 0; // use normal textures
}
//-----------------------------------------------------------------------------
// Purpose: Button has returned to the "unpressed/bottom" position. Fire its
// OnOut output and stop moving.
//-----------------------------------------------------------------------------
void CBaseButton::ButtonBackHome( void )
{
ASSERT(m_toggle_state == TS_GOING_DOWN);
m_toggle_state = TS_AT_BOTTOM;
m_OnOut.FireOutput(m_hActivator, this);
//
// Re-instate touch method, movement cycle is complete.
//
if (HasSpawnFlags(SF_BUTTON_TOUCH_ACTIVATES))
{
SetTouch( &CBaseButton::ButtonTouch );
}
else
{
// BUGBUG: ALL buttons no longer respond to touch
SetTouch ( NULL );
}
// reset think for a sparking button
if (HasSpawnFlags( SF_BUTTON_SPARK_IF_OFF ) )
{
SetThink ( &CBaseButton::ButtonSpark );
SetNextThink( gpGlobals->curtime + 0.5f );// no hurry
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CBaseButton::DrawDebugTextOverlays()
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
static const char *pszStates[] =
{
"Pressed",
"Unpressed",
"Pressing...",
"Unpressing...",
"<UNKNOWN STATE>",
};
char tempstr[255];
int nState = m_toggle_state;
if ( ( nState < 0 ) || ( nState > 3 ) )
{
nState = 4;
}
Q_snprintf( tempstr, sizeof(tempstr), "State: %s", pszStates[nState] );
EntityText( text_offset, tempstr, 0 );
text_offset++;
Q_snprintf( tempstr, sizeof(tempstr), "%s", m_bLocked ? "Locked" : "Unlocked" );
EntityText( text_offset, tempstr, 0 );
text_offset++;
}
return text_offset;
}
//
// Rotating button (aka "lever")
//
LINK_ENTITY_TO_CLASS( func_rot_button, CRotButton );
void CRotButton::Spawn( void )
{
//----------------------------------------------------
//determine sounds for buttons
//a sound of 0 should not make a sound
//----------------------------------------------------
if ( m_sounds )
{
m_sNoise = MakeButtonSound( m_sounds );
PrecacheScriptSound(m_sNoise.ToCStr());
}
else
{
m_sNoise = NULL_STRING;
}
// set the axis of rotation
CBaseToggle::AxisDir();
// check for clockwise rotation
if ( HasSpawnFlags( SF_DOOR_ROTATE_BACKWARDS) )
{
m_vecMoveAng = m_vecMoveAng * -1;
}
SetMoveType( MOVETYPE_PUSH );
#ifdef HL1_DLL
SetSolid( SOLID_BSP );
#else
SetSolid( SOLID_VPHYSICS );
#endif
if ( HasSpawnFlags( SF_ROTBUTTON_NOTSOLID ) )
{
AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID );
AddSolidFlags( FSOLID_NOT_SOLID );
}
SetModel( STRING( GetModelName() ) );
if (m_flSpeed == 0)
m_flSpeed = 40;
if (m_flWait == 0)
m_flWait = 1;
if (m_iHealth > 0)
{
m_takedamage = DAMAGE_YES;
}
m_toggle_state = TS_AT_BOTTOM;
m_vecAngle1 = GetLocalAngles();
m_vecAngle2 = GetLocalAngles() + m_vecMoveAng * m_flMoveDistance;
ASSERTSZ(m_vecAngle1 != m_vecAngle2, "rotating button start/end positions are equal\n");
m_fStayPushed = (m_flWait == -1 ? TRUE : FALSE);
m_fRotating = TRUE;
SetUse(&CRotButton::ButtonUse);
//
// If touching activates the button, set its touch function.
//
if (!HasSpawnFlags(SF_BUTTON_TOUCH_ACTIVATES))
{
SetTouch ( NULL );
}
else
{
SetTouch( &CRotButton::ButtonTouch );
}
CreateVPhysics();
}
bool CRotButton::CreateVPhysics( void )
{
VPhysicsInitShadow( false, false );
return true;
}
//-----------------------------------------------------------------------------
// CMomentaryRotButton spawnflags
//-----------------------------------------------------------------------------
#define SF_MOMENTARY_DOOR 1
#define SF_MOMENTARY_NOT_USABLE 2
#define SF_MOMENTARY_AUTO_RETURN 16
BEGIN_DATADESC( CMomentaryRotButton )
DEFINE_FIELD( m_lastUsed, FIELD_INTEGER ),
DEFINE_FIELD( m_start, FIELD_VECTOR ),
DEFINE_FIELD( m_end, FIELD_VECTOR ),
DEFINE_FIELD( m_IdealYaw, FIELD_FLOAT ),
DEFINE_FIELD( m_sNoise, FIELD_SOUNDNAME ),
DEFINE_FIELD( m_bUpdateTarget, FIELD_BOOLEAN ),
DEFINE_KEYFIELD( m_direction, FIELD_INTEGER, "StartDirection" ),
DEFINE_KEYFIELD( m_returnSpeed, FIELD_FLOAT, "returnspeed" ),
DEFINE_KEYFIELD( m_flStartPosition, FIELD_FLOAT, "StartPosition"),
DEFINE_KEYFIELD( m_bSolidBsp, FIELD_BOOLEAN, "solidbsp" ),
// Function Pointers
DEFINE_FUNCTION( UseMoveDone ),
DEFINE_FUNCTION( ReturnMoveDone ),
DEFINE_FUNCTION( SetPositionMoveDone ),
DEFINE_FUNCTION( UpdateThink ),
// Inputs
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetPosition", InputSetPosition ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetPositionImmediately", InputSetPositionImmediately ),
DEFINE_INPUTFUNC( FIELD_VOID, "_DisableUpdateTarget", InputDisableUpdateTarget ),
DEFINE_INPUTFUNC( FIELD_VOID, "_EnableUpdateTarget", InputEnableUpdateTarget ),
// Outputs
DEFINE_OUTPUT( m_Position, "Position" ),
DEFINE_OUTPUT( m_OnUnpressed, "OnUnpressed" ),
DEFINE_OUTPUT( m_OnFullyClosed, "OnFullyClosed" ),
DEFINE_OUTPUT( m_OnFullyOpen, "OnFullyOpen" ),
DEFINE_OUTPUT( m_OnReachedPosition, "OnReachedPosition" ),
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
DEFINE_FIELD( m_bDisabled, FIELD_BOOLEAN )
END_DATADESC()
LINK_ENTITY_TO_CLASS( momentary_rot_button, CMomentaryRotButton );
//-----------------------------------------------------------------------------
// Purpose: Called when spawning, after keyvalues have been handled.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::Spawn( void )
{
CBaseToggle::AxisDir();
m_bUpdateTarget = true;
if ( m_flSpeed == 0 )
{
m_flSpeed = 100;
}
// Clamp start position and issue bounds warning
if (m_flStartPosition < 0.0f || m_flStartPosition > 1.0f)
{
Warning("WARNING: Momentary door (%s) start position not between 0 and 1. Clamping.\n",GetDebugName());
m_flStartPosition = clamp(m_IdealYaw, 0.f, 1.f);
}
// Check direction fields (for backward compatibility)
if (m_direction != 1 && m_direction != -1)
{
m_direction = 1;
}
if (m_flMoveDistance < 0)
{
m_vecMoveAng = m_vecMoveAng * -1;
m_flMoveDistance = -m_flMoveDistance;
}
m_start = GetLocalAngles() - m_vecMoveAng * m_flMoveDistance * m_flStartPosition;
m_end = GetLocalAngles() + m_vecMoveAng * m_flMoveDistance * (1-m_flStartPosition);
m_IdealYaw = m_flStartPosition;
// Force start direction at end points
if (m_flStartPosition == 0.0)
{
m_direction = -1;
}
else if (m_flStartPosition == 1.0)
{
m_direction = 1;
}
if (HasSpawnFlags(SF_BUTTON_LOCKED))
{
m_bLocked = true;
}
if ( HasSpawnFlags( SF_BUTTON_USE_ACTIVATES ) )
{
if ( m_sounds )
{
m_sNoise = MakeButtonSound( m_sounds );
PrecacheScriptSound(m_sNoise.ToCStr());
}
else
{
m_sNoise = NULL_STRING;
}
m_lastUsed = 0;
UpdateTarget(0,this);
}
#ifdef HL1_DLL
SetSolid( SOLID_BSP );
#else
SetSolid( SOLID_VPHYSICS );
#endif
if (HasSpawnFlags(SF_ROTBUTTON_NOTSOLID))
{
AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID );
AddSolidFlags( FSOLID_NOT_SOLID );
}
SetMoveType( MOVETYPE_PUSH );
SetModel( STRING( GetModelName() ) );
CreateVPhysics();
// Slam the object back to solid - if we really want it to be solid.
if ( m_bSolidBsp )
{
SetSolid( SOLID_BSP );
}
m_bDisabled = false;
}
int CMomentaryRotButton::ObjectCaps( void )
{
int flags = BaseClass::ObjectCaps();
if (!HasSpawnFlags(SF_BUTTON_USE_ACTIVATES))
{
return flags;
}
else
{
return (flags | FCAP_CONTINUOUS_USE | FCAP_USE_IN_RADIUS);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CMomentaryRotButton::CreateVPhysics( void )
{
VPhysicsInitShadow( false, false );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMomentaryRotButton::PlaySound( void )
{
if ( m_sNoise == NULL_STRING )
return;
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = (char*)STRING(m_sNoise);
ep.m_flVolume = 1;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
//-----------------------------------------------------------------------------
// Purpose: Returns a given angular position as a value along our motion from 0 to 1.
// Input : vecAngles -
//-----------------------------------------------------------------------------
float CMomentaryRotButton::GetPos( const QAngle &vecAngles )
{
float flScale = 1;
if (( m_vecMoveAng[0] < 0 ) || ( m_vecMoveAng[1] < 0 ) || ( m_vecMoveAng[2] < 0 ))
{
flScale = -1;
}
float flPos = flScale * CBaseToggle::AxisDelta( m_spawnflags, vecAngles, m_start ) / m_flMoveDistance;
return( clamp( flPos, 0.f, 1.f ));
}
//------------------------------------------------------------------------------
// Purpose :
// Input : flPosition
//------------------------------------------------------------------------------
void CMomentaryRotButton::InputSetPosition( inputdata_t &inputdata )
{
m_IdealYaw = clamp( inputdata.value.Float(), 0.f, 1.f );
float flCurPos = GetPos( GetLocalAngles() );
if ( flCurPos < m_IdealYaw )
{
// Moving forward (from start to end).
SetLocalAngularVelocity( m_flSpeed * m_vecMoveAng );
m_direction = 1;
}
else if ( flCurPos > m_IdealYaw )
{
// Moving backward (from end to start).
SetLocalAngularVelocity( -m_flSpeed * m_vecMoveAng );
m_direction = -1;
}
else
{
// We're there already; nothing to do.
SetLocalAngularVelocity( vec3_angle );
return;
}
SetMoveDone( &CMomentaryRotButton::SetPositionMoveDone );
SetThink( &CMomentaryRotButton::UpdateThink );
SetNextThink( gpGlobals->curtime );
//
// Think again in 0.1 seconds or the time that it will take us to reach our movement goal,
// whichever is the shorter interval. This prevents us from overshooting and stuttering when we
// are told to change position in very small increments.
//
QAngle vecNewAngles = m_start + m_vecMoveAng * ( m_IdealYaw * m_flMoveDistance );
float flAngleDelta = fabs( AxisDelta( m_spawnflags, vecNewAngles, GetLocalAngles() ));
float dt = flAngleDelta / m_flSpeed;
if ( dt < TICK_INTERVAL )
{
dt = TICK_INTERVAL;
float speed = flAngleDelta / TICK_INTERVAL;
SetLocalAngularVelocity( speed * m_vecMoveAng * m_direction );
}
dt = clamp( dt, TICK_INTERVAL, TICK_INTERVAL * 6);
SetMoveDoneTime( dt );
}
//------------------------------------------------------------------------------
// Purpose :
// Input : flPosition
//------------------------------------------------------------------------------
void CMomentaryRotButton::InputSetPositionImmediately( inputdata_t &inputdata )
{
m_IdealYaw = clamp( inputdata.value.Float(), 0.f, 1.f );
SetLocalAngles( m_start + m_vecMoveAng * ( m_IdealYaw * m_flMoveDistance ) );
}
//------------------------------------------------------------------------------
// Purpose: Turns off target updates so that we can change the wheel's position
// without changing the target's position. Used for jiggling when locked.
//------------------------------------------------------------------------------
void CMomentaryRotButton::InputDisableUpdateTarget( inputdata_t &inputdata )
{
m_bUpdateTarget = false;
}
//------------------------------------------------------------------------------
// Purpose: Turns target updates back on (after jiggling).
//------------------------------------------------------------------------------
void CMomentaryRotButton::InputEnableUpdateTarget( inputdata_t &inputdata )
{
m_bUpdateTarget = true;
}
//-----------------------------------------------------------------------------
// Purpose: Locks the button. If locked, the button will play the locked sound
// when the player tries to use it.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::Lock()
{
BaseClass::Lock();
SetLocalAngularVelocity( vec3_angle );
SetMoveDoneTime( -1 );
SetMoveDone( NULL );
SetNextThink( TICK_NEVER_THINK );
SetThink( NULL );
}
//-----------------------------------------------------------------------------
// Purpose: Unlocks the button, making it able to be pressed again.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::Unlock()
{
BaseClass::Unlock();
SetMoveDone( &CMomentaryRotButton::ReturnMoveDone );
// Delay before autoreturn.
SetMoveDoneTime( 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose: Fires the appropriate outputs at the extremes of motion.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::OutputMovementComplete( void )
{
if (m_IdealYaw == 1.0)
{
m_OnFullyClosed.FireOutput(this, this);
}
else if (m_IdealYaw == 0.0)
{
m_OnFullyOpen.FireOutput(this, this);
}
m_OnReachedPosition.FireOutput( this, this );
}
//------------------------------------------------------------------------------
// Purpose: MoveDone function for the SetPosition input handler. Tracks our
// progress toward a movement goal and updates our outputs.
//------------------------------------------------------------------------------
void CMomentaryRotButton::SetPositionMoveDone(void)
{
float flCurPos = GetPos( GetLocalAngles() );
if ((( flCurPos >= m_IdealYaw ) && ( m_direction == 1 )) ||
(( flCurPos <= m_IdealYaw ) && ( m_direction == -1 )))
{
//
// We reached or surpassed our movement goal.
//
SetLocalAngularVelocity( vec3_angle );
// BUGBUG: Won't this get the player stuck?
SetLocalAngles( m_start + m_vecMoveAng * ( m_IdealYaw * m_flMoveDistance ) );
SetNextThink( TICK_NEVER_THINK );
SetMoveDoneTime( -1 );
UpdateTarget( m_IdealYaw, this );
OutputMovementComplete();
return;
}
// TODO: change this to use a Think function like ReturnThink.
QAngle vecNewAngles = m_start + m_vecMoveAng * ( m_IdealYaw * m_flMoveDistance );
float flAngleDelta = fabs( AxisDelta( m_spawnflags, vecNewAngles, GetLocalAngles() ));
float dt = flAngleDelta / m_flSpeed;
if ( dt < TICK_INTERVAL )
{
dt = TICK_INTERVAL;
float speed = flAngleDelta / TICK_INTERVAL;
SetLocalAngularVelocity( speed * m_vecMoveAng * m_direction );
}
dt = clamp( dt, TICK_INTERVAL, TICK_INTERVAL * 6);
SetMoveDoneTime( dt );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pActivator -
// pCaller -
// useType -
// value -
//-----------------------------------------------------------------------------
void CMomentaryRotButton::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( m_bDisabled == true )
return;
if (m_bLocked)
{
if ( OnUseLocked( pActivator ) && HasSpawnFlags( SF_BUTTON_JIGGLE_ON_USE_LOCKED ) )
{
// Jiggle two degrees.
float flDist = 2.0 / m_flMoveDistance;
// Must be first!
g_EventQueue.AddEvent( this, "_DisableUpdateTarget", 0, this, this );
variant_t value;
value.SetFloat( flDist );
g_EventQueue.AddEvent( this, "SetPosition", value, 0.01, this, this );
value.SetFloat( 0.0 );
g_EventQueue.AddEvent( this, "SetPosition", value, 0.1, this, this );
value.SetFloat( 0.5 * flDist );
g_EventQueue.AddEvent( this, "SetPosition", value, 0.2, this, this );
value.SetFloat( 0.0 );
g_EventQueue.AddEvent( this, "SetPosition", value, 0.3, this, this );
// Must be last! And must be late enough to cover the settling time.
g_EventQueue.AddEvent( this, "_EnableUpdateTarget", 0.5, this, this );
}
return;
}
//
// Reverse our direction and play movement sound every time the player
// pauses between uses.
//
bool bPlaySound = false;
if ( !m_lastUsed )
{
bPlaySound = true;
m_direction = -m_direction;
//Alert that we've been pressed
m_OnPressed.FireOutput( m_hActivator, this );
}
m_lastUsed = 1;
float flPos = GetPos( GetLocalAngles() );
UpdateSelf( flPos, bPlaySound );
//
// Think every frame while we are moving.
// HACK: Don't reset the think time if we already have a pending think.
// This works around an issue with host_thread_mode > 0 when the player's
// clock runs ahead of the server.
//
if ( !m_pfnThink )
{
SetThink( &CMomentaryRotButton::UpdateThink );
SetNextThink( gpGlobals->curtime );
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles changing direction at the extremes of our range of motion
// and updating our avelocity while being used by the player.
// Input : value - Number from 0 to 1 indicating our desired position within
// our range of motion, 0 = start, 1 = end.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::UpdateSelf( float value, bool bPlaySound )
{
//
// Set our move clock to 0.1 seconds in the future so we stop spinning unless we are
// used again before then.
//
SetMoveDoneTime( 0.1 );
//
// If we hit the end, zero our avelocity and snap to the end angles.
//
if ( m_direction > 0 && value >= 1.0 )
{
SetLocalAngularVelocity( vec3_angle );
SetLocalAngles( m_end );
m_OnFullyClosed.FireOutput(this, this);
return;
}
//
// If we returned to the start, zero our avelocity and snap to the start angles.
//
else if ( m_direction < 0 && value <= 0 )
{
SetLocalAngularVelocity( vec3_angle );
SetLocalAngles( m_start );
m_OnFullyOpen.FireOutput(this, this);
return;
}
if ( bPlaySound )
{
PlaySound();
}
SetLocalAngularVelocity( ( m_direction * m_flSpeed ) * m_vecMoveAng );
SetMoveDone( &CMomentaryRotButton::UseMoveDone );
}
//-----------------------------------------------------------------------------
// Purpose: Updates the value of our position, firing any targets.
// Input : value - New position, from 0 - 1.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::UpdateTarget( float value, CBaseEntity *pActivator )
{
if ( !m_bUpdateTarget )
return;
if (m_Position.Get() != value)
{
m_Position.Set(value, pActivator, this);
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles the end of motion caused by player use.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::UseMoveDone( void )
{
SetLocalAngularVelocity( vec3_angle );
// Make sure our targets stop where we stopped.
float flPos = GetPos( GetLocalAngles() );
UpdateTarget( flPos, this );
// Alert that we've been unpressed
m_OnUnpressed.FireOutput( m_hActivator, this );
m_lastUsed = 0;
if ( !HasSpawnFlags( SF_BUTTON_TOGGLE ) && m_returnSpeed > 0 )
{
SetMoveDone( &CMomentaryRotButton::ReturnMoveDone );
m_direction = -1;
// Delay before autoreturn.
SetMoveDoneTime( 0.1f );
}
else
{
SetThink( NULL );
SetMoveDone( NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose: MoveDone function for rotating back to the start position.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::ReturnMoveDone( void )
{
float value = GetPos( GetLocalAngles() );
if ( value <= 0 )
{
//
// Got back to the start, stop spinning.
//
SetLocalAngularVelocity( vec3_angle );
SetLocalAngles( m_start );
UpdateTarget( 0, NULL );
SetMoveDoneTime( -1 );
SetMoveDone( NULL );
SetNextThink( TICK_NEVER_THINK );
SetThink( NULL );
}
else
{
SetLocalAngularVelocity( -m_returnSpeed * m_vecMoveAng );
SetMoveDoneTime( 0.1f );
SetThink( &CMomentaryRotButton::UpdateThink );
SetNextThink( gpGlobals->curtime + 0.01f );
}
}
//-----------------------------------------------------------------------------
// Purpose: Think function for updating target as we move.
//-----------------------------------------------------------------------------
void CMomentaryRotButton::UpdateThink( void )
{
float value = GetPos( GetLocalAngles() );
UpdateTarget( value, NULL );
SetNextThink( gpGlobals->curtime );
}
//-----------------------------------------------------------------------------
// Purpose: Draw any debug text overlays
// Output : Current text offset from the top
//-----------------------------------------------------------------------------
int CMomentaryRotButton::DrawDebugTextOverlays(void)
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char tempstr[255];
Q_snprintf(tempstr,sizeof(tempstr),"QAngle: %.2f %.2f %.2f", GetLocalAngles()[0], GetLocalAngles()[1], GetLocalAngles()[2]);
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf(tempstr,sizeof(tempstr),"AVelocity: %.2f %.2f %.2f", GetLocalAngularVelocity()[0], GetLocalAngularVelocity()[1], GetLocalAngularVelocity()[2]);
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf(tempstr,sizeof(tempstr),"Target Pos: %3.3f",m_IdealYaw);
EntityText(text_offset,tempstr,0);
text_offset++;
float flCurPos = GetPos(GetLocalAngles());
Q_snprintf(tempstr,sizeof(tempstr),"Current Pos: %3.3f",flCurPos);
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf(tempstr,sizeof(tempstr),"Direction: %s",(m_direction == 1) ? "Forward" : "Backward");
EntityText(text_offset,tempstr,0);
text_offset++;
}
return text_offset;
}
//-----------------------------------------------------------------------------
// Purpose: Input hander that starts the spawner
//-----------------------------------------------------------------------------
void CMomentaryRotButton::InputEnable( inputdata_t &inputdata )
{
Enable();
}
//-----------------------------------------------------------------------------
// Purpose: Input hander that stops the spawner
//-----------------------------------------------------------------------------
void CMomentaryRotButton::InputDisable( inputdata_t &inputdata )
{
Disable();
}
//-----------------------------------------------------------------------------
// Purpose: Start the spawner
//-----------------------------------------------------------------------------
void CMomentaryRotButton::Enable( void )
{
m_bDisabled = false;
}
//-----------------------------------------------------------------------------
// Purpose: Stop the spawner
//-----------------------------------------------------------------------------
void CMomentaryRotButton::Disable( void )
{
m_bDisabled = true;
}
Reference in New Issue Copy Permalink