You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
613 lines
17 KiB
613 lines
17 KiB
#include "cbase.h" |
|
#include "asw_button_area.h" |
|
#include "asw_door.h" |
|
#include "asw_player.h" |
|
#include "asw_marine.h" |
|
#include "asw_marine_profile.h" |
|
#include "asw_hack_wire_tile.h" |
|
#include "asw_marine_speech.h" |
|
#include "asw_util_shared.h" |
|
#include "asw_director.h" |
|
#include "asw_gamerules.h" |
|
#include "asw_achievements.h" |
|
#include "cvisibilitymonitor.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
LINK_ENTITY_TO_CLASS( trigger_asw_button_area, CASW_Button_Area ); |
|
|
|
#define ASW_MEDAL_WORTHY_WIRE_HACK 60 |
|
|
|
BEGIN_DATADESC( CASW_Button_Area ) |
|
DEFINE_FIELD(m_bIsDoorButton, FIELD_BOOLEAN), |
|
DEFINE_FIELD(m_hDoorHack, FIELD_EHANDLE), |
|
DEFINE_FIELD(m_bIsInUse, FIELD_BOOLEAN), |
|
DEFINE_FIELD(m_fHackProgress, FIELD_FLOAT), |
|
DEFINE_FIELD(m_fStartedHackTime, FIELD_FLOAT), |
|
DEFINE_FIELD(m_fLastButtonUseTime, FIELD_TIME), |
|
DEFINE_FIELD(m_bWaitingForInput, FIELD_BOOLEAN ), |
|
DEFINE_FIELD(m_bWasLocked, FIELD_BOOLEAN ), |
|
|
|
//DEFINE_KEYFIELD(m_iHackLevel, FIELD_INTEGER, "hacklevel" ), |
|
DEFINE_KEYFIELD(m_bIsLocked, FIELD_BOOLEAN, "locked" ), |
|
DEFINE_KEYFIELD(m_bNoPower, FIELD_BOOLEAN, "nopower" ), |
|
|
|
DEFINE_KEYFIELD(m_bUseAfterHack, FIELD_BOOLEAN, "useafterhack" ), |
|
DEFINE_KEYFIELD(m_bDisableAfterUse, FIELD_BOOLEAN, "disableafteruse" ), |
|
|
|
DEFINE_KEYFIELD( m_iWireColumns, FIELD_INTEGER, "wirecolumns"), |
|
DEFINE_KEYFIELD( m_iWireRows, FIELD_INTEGER, "wirerows"), |
|
DEFINE_KEYFIELD( m_iNumWires, FIELD_INTEGER, "numwires"), |
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "PowerOn", InputPowerOn ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "PowerOff", InputPowerOff ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "ResetHack", InputResetHack ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "Unlock", InputUnlock ), |
|
DEFINE_OUTPUT( m_OnButtonHackStarted, "OnButtonHackStarted" ), |
|
DEFINE_OUTPUT( m_OnButtonHackAt25Percent, "OnButtonHackAt25Percent" ), |
|
DEFINE_OUTPUT( m_OnButtonHackAt50Percent, "OnButtonHackAt50Percent" ), |
|
DEFINE_OUTPUT( m_OnButtonHackAt75Percent, "OnButtonHackAt75Percent" ), |
|
DEFINE_OUTPUT( m_OnButtonHackCompleted, "OnButtonHackCompleted" ), |
|
DEFINE_OUTPUT( m_OnButtonActivated, "OnButtonActivated" ), |
|
END_DATADESC() |
|
|
|
IMPLEMENT_SERVERCLASS_ST(CASW_Button_Area, DT_ASW_Button_Area) |
|
SendPropInt (SENDINFO(m_iHackLevel)), |
|
SendPropBool (SENDINFO(m_bIsLocked)), |
|
SendPropBool (SENDINFO(m_bIsDoorButton)), |
|
SendPropBool (SENDINFO(m_bIsInUse)), |
|
SendPropFloat (SENDINFO(m_fHackProgress)), |
|
SendPropBool (SENDINFO(m_bNoPower)), |
|
SendPropBool (SENDINFO(m_bWaitingForInput)), |
|
SendPropString (SENDINFO( m_NoPowerMessage ) ), |
|
END_SEND_TABLE() |
|
|
|
ConVar asw_ai_button_hacking_scale( "asw_ai_button_hacking_scale", "0.3", FCVAR_CHEAT, "Button panel hacking speed scale for AI marines" ); |
|
ConVar asw_tech_order_hack_range( "asw_tech_order_hack_range", "1200", FCVAR_CHEAT, "Max range when searching for a nearby AI tech to hack for you" ); |
|
ConVar asw_debug_button_skin( "asw_debug_button_skin", "0", FCVAR_CHEAT, "If set, button panels will output skin setting details" ); |
|
extern ConVar asw_simple_hacking; |
|
extern ConVar asw_debug_medals; |
|
|
|
CASW_Button_Area::CASW_Button_Area() |
|
{ |
|
//Msg("[S] CASW_Button_Area created\n"); |
|
AddEFlags( EFL_FORCE_CHECK_TRANSMIT ); |
|
m_iAliensKilledBeforeHack = 0; |
|
|
|
m_iHackLevel = 6; |
|
} |
|
|
|
CASW_Button_Area::~CASW_Button_Area() |
|
{ |
|
if (m_hDoorHack.Get()) |
|
{ |
|
UTIL_Remove(m_hDoorHack.Get()); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when spawning, after keyvalues have been handled. |
|
//----------------------------------------------------------------------------- |
|
void CASW_Button_Area::Spawn( void ) |
|
{ |
|
if (m_flWait == -1) |
|
m_bDisableAfterUse = true; |
|
|
|
BaseClass::Spawn(); |
|
Precache(); |
|
|
|
// check if this button is linked to a door or not |
|
CASW_Door* pDoor = dynamic_cast<CASW_Door*>(m_hUseTarget.Get()); |
|
if (pDoor) |
|
{ |
|
m_bIsDoorButton = true; |
|
} |
|
else |
|
{ |
|
m_bIsDoorButton = false; |
|
} |
|
|
|
if ( m_bIsLocked ) |
|
{ |
|
m_bWasLocked = true; |
|
} |
|
|
|
UpdateWaitingForInput(); |
|
UpdatePanelSkin(); |
|
} |
|
|
|
void CASW_Button_Area::Precache() |
|
{ |
|
PrecacheScriptSound("ASWComputer.HackComplete"); |
|
PrecacheScriptSound("ASWComputer.AccessDenied"); |
|
PrecacheScriptSound("ASWButtonPanel.TileLit"); |
|
} |
|
|
|
void CASW_Button_Area::ActivateUseIcon( CASW_Marine* pMarine, int nHoldType ) |
|
{ |
|
if ( nHoldType == ASW_USE_HOLD_START ) |
|
return; |
|
|
|
// player has used this item |
|
//Msg("Player has activated a button area\n"); |
|
if ( !HasPower() || !ASWGameResource() ) |
|
{ |
|
// todo: launch a window on the client saying there's no power, or whatever message is desired |
|
//Msg("We don't have the power cap'n\n"); |
|
return; |
|
} |
|
if ( m_bIsLocked ) |
|
{ |
|
if ( pMarine->GetMarineProfile()->CanHack() ) |
|
{ |
|
// can hack, get the player to launch his hacking window |
|
if ( !m_bIsInUse ) |
|
{ |
|
if ( pMarine->StartUsing(this) ) |
|
{ |
|
if ( GetHackProgress() <= 0 && pMarine->GetMarineResource() ) |
|
{ |
|
pMarine->GetMarineResource()->m_iDamageTakenDuringHack = 0; |
|
} |
|
m_iAliensKilledBeforeHack = ASWGameResource()->GetAliensKilledInThisMission(); |
|
|
|
m_OnButtonHackStarted.FireOutput( pMarine, this ); |
|
if ( !asw_simple_hacking.GetBool() && pMarine->IsInhabited() ) |
|
{ |
|
if ( !GetCurrentHack() ) // if we haven't created a hack object for this computer yet, then create one |
|
{ |
|
m_hDoorHack = (CASW_Hack_Wire_Tile*) CreateEntityByName( "asw_hack_wire_tile" ); |
|
} |
|
|
|
if ( GetCurrentHack() ) |
|
{ |
|
GetCurrentHack()->InitHack( pMarine->GetCommander(), pMarine, this ); |
|
} |
|
} |
|
|
|
if ( m_iHackLevel > 20 ) |
|
{ |
|
pMarine->GetMarineSpeech()->Chatter( CHATTER_HACK_LONG_STARTED ); |
|
} |
|
else |
|
{ |
|
pMarine->GetMarineSpeech()->Chatter( CHATTER_HACK_STARTED ); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if ( pMarine->m_hUsingEntity.Get() == this ) |
|
{ |
|
pMarine->StopUsing(); |
|
} |
|
//Msg("Panel already in use"); |
|
} |
|
//Msg("Unlocked button\n"); |
|
// test hack puzzle so far |
|
/* |
|
m_hDoorHack = (CASW_Hack_Door*) CreateEntityByName( "asw_hack_door" ); |
|
if (GetCurrentHack()) |
|
{ |
|
//for (int i=0;i<10;i++) |
|
//{ |
|
GetCurrentHack()->InitHack(pPlayer, pMarine, this); |
|
GetCurrentHack()->BuildPuzzle(7); |
|
GetCurrentHack()->ShowPuzzleStatus(); |
|
//} |
|
} |
|
*/ |
|
|
|
|
|
} |
|
else |
|
{ |
|
// can't hack (play some access denied sound) |
|
//Msg("Access denied\n"); |
|
EmitSound("ASWComputer.AccessDenied"); |
|
|
|
// check for a nearby AI tech marine |
|
float flMarineDistance; |
|
CASW_Marine *pTech = UTIL_ASW_NearestMarine( WorldSpaceCenter(), flMarineDistance, MARINE_CLASS_TECH, true ); |
|
if ( pTech && flMarineDistance < asw_tech_order_hack_range.GetFloat() ) |
|
{ |
|
//Msg( "Told tech to hack panel\n" ); |
|
pTech->OrderHackArea( this ); |
|
} |
|
return; |
|
} |
|
} |
|
else |
|
{ |
|
if ( pMarine ) |
|
{ |
|
pMarine->GetMarineSpeech()->Chatter(CHATTER_USE); |
|
} |
|
ActivateUnlockedButton( pMarine ); |
|
} |
|
} |
|
|
|
void CASW_Button_Area::ActivateUnlockedButton(CASW_Marine* pMarine) |
|
{ |
|
// don't use the button if we're in the delay between using |
|
if ( m_fLastButtonUseTime != 0 && gpGlobals->curtime < m_fLastButtonUseTime + m_flWait ) |
|
return; |
|
if ( !pMarine ) |
|
return; |
|
|
|
if( !RequirementsMet( pMarine ) ) |
|
return; |
|
|
|
if ( m_bIsDoorButton ) |
|
{ |
|
// if the door isn't sealed (or greater than a certain amount of damage?) |
|
// then make it open |
|
CASW_Door* pDoor = GetDoor(); |
|
if ( pDoor ) |
|
{ |
|
if (pDoor->GetSealAmount() > 0) |
|
{ |
|
//Msg("Door mechanism not responding. Maintenance Division has been notified of the problem.\n"); |
|
} |
|
else |
|
{ |
|
//Msg("Toggling door...\n"); |
|
variant_t emptyVariant; |
|
pDoor->AcceptInput("Toggle", pMarine, this, emptyVariant, 0); |
|
} |
|
} |
|
} |
|
|
|
// send our 'activated' output |
|
m_OnButtonActivated.FireOutput(pMarine, this); |
|
|
|
// Fire event |
|
IGameEvent * event = gameeventmanager->CreateEvent( "button_area_used" ); |
|
if ( event ) |
|
{ |
|
CASW_Player *pPlayer = pMarine->GetCommander(); |
|
|
|
event->SetInt( "userid", ( pPlayer ? pPlayer->GetUserID() : 0 ) ); |
|
event->SetInt( "entindex", entindex() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
m_fLastButtonUseTime = gpGlobals->curtime; |
|
|
|
UpdateWaitingForInput(); |
|
|
|
if ( m_bDisableAfterUse ) |
|
{ |
|
UTIL_Remove(this); |
|
} |
|
} |
|
|
|
|
|
CASW_Door* CASW_Button_Area::GetDoor() |
|
{ |
|
return dynamic_cast<CASW_Door*>(m_hUseTarget.Get()); |
|
} |
|
|
|
CASW_Hack* CASW_Button_Area::GetCurrentHack() |
|
{ |
|
return dynamic_cast<CASW_Hack*>(m_hDoorHack.Get()); |
|
} |
|
|
|
// traditional Swarm hacking |
|
void CASW_Button_Area::MarineUsing(CASW_Marine* pMarine, float deltatime) |
|
{ |
|
if (m_bIsInUse && m_bIsLocked && ( asw_simple_hacking.GetBool() || !pMarine->IsInhabited() ) ) |
|
{ |
|
float fTime = (deltatime * (1.0f/((float)m_iHackLevel))); |
|
// boost fTime by the marine's hack skill |
|
fTime *= MarineSkills()->GetSkillBasedValueByMarine(pMarine, ASW_MARINE_SKILL_HACKING, ASW_MARINE_SUBSKILL_HACKING_SPEED_SCALE); |
|
fTime *= asw_ai_button_hacking_scale.GetFloat(); |
|
SetHackProgress(m_fHackProgress + fTime, pMarine); |
|
} |
|
} |
|
|
|
void CASW_Button_Area::MarineStartedUsing(CASW_Marine* pMarine) |
|
{ |
|
m_bIsInUse = true; |
|
UpdateWaitingForInput(); |
|
|
|
if ( ASWDirector() && m_bIsLocked ) |
|
{ |
|
ASWDirector()->OnMarineStartedHack( pMarine, this ); |
|
} |
|
} |
|
|
|
void CASW_Button_Area::MarineStoppedUsing(CASW_Marine* pMarine) |
|
{ |
|
//Msg( "Marine stopped using button area\n" ); |
|
m_bIsInUse = false; |
|
UpdateWaitingForInput(); |
|
|
|
if (GetCurrentHack()) // notify our current hack that we've stopped using the console |
|
{ |
|
GetCurrentHack()->MarineStoppedUsing(pMarine); |
|
} |
|
} |
|
|
|
bool CASW_Button_Area::IsActive( void ) |
|
{ |
|
return ( m_bIsInUse || !m_bIsLocked ); |
|
} |
|
|
|
void CASW_Button_Area::InputPowerOn( inputdata_t &inputdata ) |
|
{ |
|
m_bNoPower = false; |
|
UpdateWaitingForInput(); |
|
UpdatePanelSkin(); |
|
} |
|
|
|
void CASW_Button_Area::InputPowerOff( inputdata_t &inputdata ) |
|
{ |
|
m_bNoPower = true; |
|
UpdateWaitingForInput(); |
|
UpdatePanelSkin(); |
|
} |
|
|
|
void CASW_Button_Area::InputUnlock( inputdata_t &inputdata ) |
|
{ |
|
if (m_bIsLocked) |
|
{ |
|
m_bIsLocked = false; |
|
m_fHackProgress = 1.0f; |
|
UpdateWaitingForInput(); |
|
UpdatePanelSkin(); |
|
|
|
CASW_Marine *pMarine = dynamic_cast<CASW_Marine*>(inputdata.pActivator); |
|
|
|
// if set to use on unlock, then do so |
|
if (m_bUseAfterHack && pMarine) |
|
{ |
|
ActivateUnlockedButton(pMarine); |
|
} |
|
} |
|
} |
|
|
|
void CASW_Button_Area::InputResetHack( inputdata_t &inputdata ) |
|
{ |
|
if ( !m_bIsInUse ) |
|
{ |
|
m_fStartedHackTime = false; |
|
SetHackProgress(0, NULL); |
|
m_bIsLocked = true; |
|
UpdateWaitingForInput(); |
|
UpdatePanelSkin(); |
|
if (m_hDoorHack.Get()) |
|
{ |
|
// need to delete the hack |
|
UTIL_Remove(m_hDoorHack.Get()); |
|
m_hDoorHack = NULL; |
|
} |
|
} |
|
} |
|
|
|
void CASW_Button_Area::SetHackProgress(float f, CASW_Marine *pMarine) |
|
{ |
|
CBaseEntity *pActor = pMarine; |
|
if ( !pActor ) |
|
{ |
|
pActor = this; |
|
} |
|
|
|
if (m_fHackProgress <= 0 && f > 0 && m_fStartedHackTime == 0) |
|
{ |
|
m_fStartedHackTime = gpGlobals->curtime; |
|
} |
|
if (m_fHackProgress < 0.25f && f >= 0.25f) |
|
{ |
|
m_OnButtonHackAt25Percent.FireOutput(pActor, this); |
|
} |
|
if (m_fHackProgress < 0.5f && f >= 0.5f) |
|
{ |
|
m_OnButtonHackAt50Percent.FireOutput(pActor, this); |
|
pMarine->GetMarineSpeech()->Chatter(CHATTER_HACK_HALFWAY); |
|
} |
|
if (m_fHackProgress < 0.75f && f >= 0.75f) |
|
{ |
|
m_OnButtonHackAt75Percent.FireOutput(pActor, this); |
|
} |
|
if (m_fHackProgress < 1.0f && f >= 1.0f) |
|
{ |
|
if ( asw_simple_hacking.GetBool() ) |
|
{ |
|
pMarine->StopUsing(); |
|
} |
|
|
|
float time_taken = gpGlobals->curtime - m_fStartedHackTime; |
|
// decide if this was a fast hack or not |
|
float fSpeedScale = 1.0f; |
|
if (pMarine) |
|
fSpeedScale *= MarineSkills()->GetSkillBasedValueByMarine(pMarine, ASW_MARINE_SKILL_HACKING, ASW_MARINE_SUBSKILL_HACKING_SPEED_SCALE); |
|
float ideal_time = UTIL_ASW_CalcFastDoorHackTime(m_iWireRows, m_iWireColumns, m_iNumWires, m_iHackLevel, fSpeedScale); |
|
|
|
bool bFastHack = time_taken <= ideal_time; |
|
if (asw_debug_medals.GetBool()) |
|
{ |
|
Msg("Finished door hack, fast = %d.\n", bFastHack); |
|
Msg(" ideal time is %f you took %f\n", ideal_time, time_taken); |
|
} |
|
if (bFastHack && pMarine && pMarine->GetMarineResource()) |
|
{ |
|
pMarine->GetMarineResource()->m_iFastDoorHacks++; |
|
if ( pMarine->IsInhabited() && pMarine->GetCommander() ) |
|
{ |
|
pMarine->GetCommander()->AwardAchievement( ACHIEVEMENT_ASW_FAST_WIRE_HACKS ); |
|
} |
|
} |
|
|
|
if ( GetCurrentHack() ) |
|
{ |
|
GetCurrentHack()->OnHackComplete(); |
|
} |
|
|
|
if ( pMarine->GetMarineResource() && pMarine->GetMarineResource()->m_iDamageTakenDuringHack <= 0 ) |
|
{ |
|
int nAliensKilled = ASWGameResource() ? ASWGameResource()->GetAliensKilledInThisMission() : 0; |
|
if ( ( nAliensKilled - m_iAliensKilledBeforeHack ) > 10 ) |
|
{ |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CASW_Player *pPlayer = dynamic_cast<CASW_Player*>( UTIL_PlayerByIndex( i ) ); |
|
if ( !pPlayer || !pPlayer->IsConnected() || !pPlayer->GetMarine() || pPlayer->GetMarine() == pMarine ) |
|
continue; |
|
|
|
if ( pPlayer->GetMarine()->GetMarineResource() ) |
|
{ |
|
pPlayer->GetMarine()->GetMarineResource()->m_bProtectedTech = true; |
|
} |
|
pPlayer->AwardAchievement( ACHIEVEMENT_ASW_PROTECT_TECH ); |
|
} |
|
} |
|
} |
|
|
|
// unlock it |
|
m_OnButtonHackCompleted.FireOutput(pActor, this); |
|
m_bIsLocked = false; |
|
UpdateWaitingForInput(); |
|
UpdatePanelSkin(); |
|
|
|
EmitSound("ASWComputer.HackComplete"); |
|
|
|
if ( pMarine && bFastHack ) |
|
{ |
|
pMarine->GetMarineSpeech()->QueueChatter(CHATTER_HACK_BUTTON_FINISHED, gpGlobals->curtime + 2.0f, gpGlobals->curtime + 3.0f); |
|
} |
|
|
|
// if set to use on unlock, then do so |
|
if ( m_bUseAfterHack && pMarine ) |
|
{ |
|
ActivateUnlockedButton(pMarine); |
|
} |
|
|
|
if ( pMarine && !pMarine->IsInhabited() ) |
|
{ |
|
pMarine->StopUsing(); |
|
} |
|
} |
|
|
|
m_fHackProgress = clamp( f, 0.0f, 1.0f ); |
|
} |
|
|
|
bool CASW_Button_Area::KeyValue( const char *szKeyName, const char *szValue ) |
|
{ |
|
if ( FStrEq( szKeyName, "nopowermessage" ) ) |
|
{ |
|
Q_strncpy( m_NoPowerMessage.GetForModify(), szValue, 255 ); |
|
return true; |
|
} |
|
return BaseClass::KeyValue( szKeyName, szValue ); |
|
} |
|
|
|
bool CASW_Button_Area::WaitingForInputVismonEvaluator( CBaseEntity *pVisibleEntity, CBasePlayer *pViewingPlayer ) |
|
{ |
|
CASW_Button_Area *pButtonArea = static_cast< CASW_Button_Area* >( pVisibleEntity ); |
|
return pButtonArea->m_bWaitingForInput; |
|
} |
|
|
|
bool CASW_Button_Area::WaitingForInputVismonCallback( CBaseEntity *pVisibleEntity, CBasePlayer *pViewingPlayer ) |
|
{ |
|
CASW_Button_Area *pButtonArea = static_cast< CASW_Button_Area* >( pVisibleEntity ); |
|
IGameEvent * event = gameeventmanager->CreateEvent( "button_area_active" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "userid", pViewingPlayer->GetUserID() ); |
|
event->SetInt( "entindex", pButtonArea->entindex() ); |
|
event->SetInt( "prop", pButtonArea->m_hPanelProp.Get() ? pButtonArea->m_hPanelProp.Get()->entindex() : pButtonArea->entindex() ); |
|
event->SetBool( "locked", pButtonArea->IsLocked() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void CASW_Button_Area::UpdateWaitingForInput() |
|
{ |
|
bool bOldWaitingForInput = m_bWaitingForInput; |
|
|
|
bool bSet = false; |
|
|
|
if ( m_bIsDoorButton ) |
|
{ |
|
CASW_Door *pDoor = GetDoor(); |
|
if ( pDoor && pDoor->IsAutoOpen() ) |
|
{ |
|
m_bWaitingForInput = false; |
|
bSet = true; |
|
} |
|
} |
|
|
|
if ( !bSet ) |
|
{ |
|
m_bWaitingForInput = ASWGameRules()->GetGameState() == ASW_GS_INGAME && |
|
( !m_bNoPower && !m_bIsInUse && ( m_bIsLocked || ( !m_bWasLocked && m_fLastButtonUseTime == 0 ) ) ); |
|
} |
|
|
|
if ( !bOldWaitingForInput && m_bWaitingForInput ) |
|
{ |
|
VisibilityMonitor_AddEntity( this, asw_visrange_generic.GetFloat() * 0.9f, &CASW_Button_Area::WaitingForInputVismonCallback, &CASW_Button_Area::WaitingForInputVismonEvaluator ); |
|
} |
|
else if ( bOldWaitingForInput && !m_bWaitingForInput ) |
|
{ |
|
VisibilityMonitor_RemoveEntity( this ); |
|
|
|
IGameEvent * event = gameeventmanager->CreateEvent( "button_area_inactive" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "entindex", entindex() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
} |
|
|
|
// updates the panel prop (if any) with a skin to reflect the button's state |
|
void CASW_Button_Area::UpdatePanelSkin() |
|
{ |
|
if ( !m_hPanelProp.Get() ) |
|
return; |
|
|
|
if ( asw_debug_button_skin.GetBool() ) |
|
{ |
|
Msg( "CASW_Button_Area:%d: UpdatePanelSkin\n", entindex() ); |
|
} |
|
CBaseAnimating *pAnim = dynamic_cast<CBaseAnimating*>(m_hPanelProp.Get()); |
|
while (pAnim) |
|
{ |
|
if (HasPower()) |
|
{ |
|
if (m_bIsLocked) |
|
{ |
|
pAnim->m_nSkin = 1; // locked skin |
|
if ( asw_debug_button_skin.GetBool() ) |
|
{ |
|
Msg( " Panel is locked, setting prop %d skin to %d\n", pAnim->entindex(), pAnim->m_nSkin.Get() ); |
|
} |
|
} |
|
else |
|
{ |
|
pAnim->m_nSkin = 2; // unlocked skin |
|
if ( asw_debug_button_skin.GetBool() ) |
|
{ |
|
Msg( " Panel is unlocked, setting prop %d skin to %d\n", pAnim->entindex(), pAnim->m_nSkin.Get() ); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
pAnim->m_nSkin = 0; // no power skin |
|
if ( asw_debug_button_skin.GetBool() ) |
|
{ |
|
Msg( " Panel is no power, setting prop %d skin to %d\n", pAnim->entindex(), pAnim->m_nSkin.Get() ); |
|
} |
|
} |
|
|
|
if (m_bMultiplePanelProps) |
|
pAnim = dynamic_cast<CBaseAnimating*>(gEntList.FindEntityByName( pAnim, m_szPanelPropName )); |
|
else |
|
pAnim = NULL; |
|
} |
|
}
|
|
|