d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
114 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 0fb75b41fd
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0fb75b41fd'
${ noResults }
source-engine/game/shared/tf/tf_quest_restriction.cpp

2700 lines
82 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "KeyValues.h"
#include "schemainitutils.h"
#ifdef CLIENT_DLL
#include "c_tf_player.h"
#include <igameresources.h>
#include "tf_gc_client.h"
#else
#include "tf_player.h"
#include "iscorer.h"
#endif // #ifdef CLIENT_DLL
#include "tf_quest_restriction.h"
#include "tf_gamerules.h"
#include "tf_item_schema.h"
#include "econ_item_system.h"
#include "tf_logic_robot_destruction.h"
#include "tier2/fileutils.h"
#include "steamworks_gamestats.h"
#include "tf_quickplay_shared.h"
static const int s_nMinConnectedPlayersForQuestProgress = 2;
static const int s_nMaxInputCount = 100;
static const char *g_skQuestEventsFile = "tf/scripts/items/unencrypted/_quest_events.txt";
template<typename CTFQuestConditionSubClass_t>
CTFQuestCondition *CreateCTFQuestConditionSubClass()
{
return new CTFQuestConditionSubClass_t();
}
typedef CTFQuestCondition *(*pfnQuestCreate)();
#define FIELD_NONE 0
#define FIELD_PLAYER 1<<0
#define FIELD_OBJECT 1<<1
#define FIELD_WEAPON_NAME 1<<2
#define FIELD_SCORER 1<<3
#define FIELD_CUSTOM_DAMAGE 1<<4
#define FIELD_WEAPON_TYPE 1<<5
#define FIELD_FLAG_EVENT 1<<6
#define FIELD_TEAM 1<<7
#define FIELD_LOADOUT_POSITION 1<<8
#define FIELD_CONDITION 1<<9
#define FIELD_CRIT 1<<10
#define FIELD_WEAPON_DEF_INDEX 1<<11
#define FIELD_HALLOWEEN_BOSS_TYPE 1<<12
#define FIELD_HALLOWEEN_MINIGAME_TYPE 1<<13
#define FIELD_WEAPON_CLASS 1<<14
#define FIELD_BONUSEFFECT 1<<15
#define FIELD_DEFLECTED_PROJECTILE 1<<16
#define FIELD_LAST_FIELD FIELD_DEFLECTED_PROJECTILE
const char* k_pszQuestConditionRequiredFieldStrings[] =
{
"player", // FIELD_PLAYER
"object_type", // FIELD_OBJECT
"weapon_name", // FIELD_WEAPON_NAME
"scorer", // FIELD_SCORER
"custom_damage", // FIELD_CUSTOM_DAMAGE
"weapon_type", // FIELD_WEAPON_TYPE
"flag_event", // FIELD_FLAG_EVENT
"team_restriction", // FIELD_TEAM
"loadout_position", // FIELD_LOADOUT_POSITION
"condition", // FIELD_CONDITION
"crit_kill", // FIELD_CRIT
"weapon_def_index", // FIELD_WEAPON_DEF_INDEX
"halloween_boss_type", // FIELD_HALLOWEEN_BOSS_TYPE
"minigame_type", // FIELD_HALLOWEEN_MINIGAME_TYPE
"weapon_class", // FIELD_WEAPON_CLASS
"bonuseffect", // FIELD_BONUSEFFECT
"deflected_projectile", // FIELD_DEFLECTED_PROJECTILE
};
struct QuestConditionEntry_t;
CUtlMap< const char*, QuestConditionEntry_t* > k_mapConditions( StringLessThan );
struct QuestConditionEntry_t
{
QuestConditionEntry_t( const char* pszName, int nRequiredField, pfnQuestCreate pfnCreate )
: m_nRequiredFields( nRequiredField )
, m_pfnQuestCreate( pfnCreate )
, m_pszFieldName( pszName )
{
k_mapConditions.Insert( pszName, this );
}
int m_nRequiredFields;
pfnQuestCreate m_pfnQuestCreate;
const char* m_pszFieldName;
};
#define REGISTER_QUEST_CONDITION_SUB_CLASS( derivedClass, condName, nCondReqFields ) QuestConditionEntry_t k_s##condName##RegisteredEntry( #condName, nCondReqFields, CreateCTFQuestConditionSubClass< derivedClass > );
bool IsValidServerForQuests( CSteamID steamIDQuestOwner )
{
// Check if we're on beta. If so, allow it.
if ( ( engine->GetAppID() == 810 || engine->GetAppID() == 440 )
&& ( steamIDQuestOwner.GetEUniverse() == k_EUniverseBeta || steamIDQuestOwner.GetEUniverse() == k_EUniverseDev ) )
return true;
// TODO Do we want to exclude quest progress after the match is over or during warm-up? We'd need another function
// and to check it in appropriate spots -- this guy returning false if the match is over gives the user
// "Invalid server" status on their quest display and so on.
// We only allow for quests to be tracked on Valve servers -- check if we joined via MM. Don't care if the match is
// still running.
EMatchGroup eMatchGroup = TFGameRules()->GetCurrentMatchGroup();
bool bTrustedMatch = ( eMatchGroup != k_nMatchGroup_Invalid ) && GetMatchGroupDescription( eMatchGroup )->BIsTrustedServersOnly();
if ( !bTrustedMatch )
return false;
return true;
}
void GetInvalidReasonsNames( const InvalidReasonsContainer_t& invalidReasons, CUtlVector< CUtlString >& vecStrings )
{
static const char* arReasons[] =
{
"#TF_QuestInvalid_WrongMap", // INVALID_QUEST_REASON_WRONG_MAP = 0,
"#TF_QuestInvalid_WrongClass", // INVALID_QUEST_REASON_WRONG_CLASS,
"#TF_QuestInvalid_GameMode", // INVALID_QUEST_REASON_WRONG_GAME_MODE,
"#TF_QuestInvalid_NotEnoughPlayers", // INVALID_QUEST_REASON_NOT_ENOUGH_PLAYERS,
"#TF_QuestInvalid_ValveServers", // INVALID_QUEST_REASON_VALVE_SERVERS_ONLY,
"#TF_QuestInvalid_MvM", // INVALID_QUEST_REASON_NO_MVM
};
for( int i=0; i < invalidReasons.m_bits.GetNumBits(); ++i )
{
if ( invalidReasons.m_bits.IsBitSet( i ) )
{
vecStrings.AddToTail( arReasons[i] );
}
}
}
KeyValues* GetQuestEventsKeyValues()
{
static KeyValues *pQuestEvents = NULL;
if ( pQuestEvents == NULL )
{
CUtlBuffer bufRawData;
bufRawData.SetBufferType( true, true );
bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestEventsFile, NULL, bufRawData );
if ( !bReadFileOK )
{
AssertMsg1( false, "Couldn't load quest events file: %s!", g_skQuestEventsFile );
return NULL;
}
pQuestEvents = new KeyValues( "quest_events" );
pQuestEvents->LoadFromBuffer( NULL, bufRawData );
}
return pQuestEvents;
}
// getting key of params that are unique per event
void GetValidParamsKeyFromEvent( const char *pszKeyName, const char *pszRestrictionName, const char *pszEventName, KeyValues *pRequiredKeys )
{
KeyValues *pQuestEvents = GetQuestEventsKeyValues();
if ( pQuestEvents )
{
KeyValues *pEvent = pQuestEvents->FindKey( pszEventName );
AssertMsg1( pEvent, "Failed to find specified event name %s", pszEventName );
if ( pEvent )
{
KeyValues *pRestriction = pEvent->FindKey( pszRestrictionName );
AssertMsg2( pRestriction, "Failed to find specified restriction name %s :: %s", pszEventName, pszRestrictionName );
if ( pRestriction )
{
KeyValues *pParamsKey = pRestriction->FindKey( pszKeyName );
AssertMsg3( pParamsKey, "Failed to find specified param key name %s :: %s :: %s", pszEventName, pszRestrictionName, pszKeyName );
if ( pParamsKey )
{
if ( pParamsKey->GetString( "uses_method", NULL ) )
{
KeyValues* pKVMethod = pParamsKey->FindKey( "method" );
AssertMsg3( pKVMethod, "Failed to find method block in %s :: %s :: %s", pszEventName, pszRestrictionName, pszKeyName );
if ( pKVMethod )
{
const char* pszType = pKVMethod->GetString( "type", NULL );
AssertMsg3( pszType, "Missing method type in %s :: %s :: %s", pszEventName, pszRestrictionName, pszKeyName );
if ( FStrEq( pszType, "weapon_def_index" ) )
{
KeyValues *pWeaponNames = new KeyValues( "value" );
const CTFItemDefinition* pItemDef = NULL;
const CEconItemSchema::SortedItemDefinitionMap_t& mapItems = GetItemSchema()->GetSortedItemDefinitionMap();
FOR_EACH_MAP( mapItems, it )
{
pItemDef = static_cast< const CTFItemDefinition* >( mapItems[it] );
Assert( pItemDef->GetDefinitionIndex() != INVALID_ITEM_DEF_INDEX );
if ( pItemDef->GetDefaultLoadoutSlot() == LOADOUT_POSITION_PRIMARY
|| pItemDef->GetDefaultLoadoutSlot() == LOADOUT_POSITION_SECONDARY
|| pItemDef->GetDefaultLoadoutSlot() == LOADOUT_POSITION_MELEE
|| pItemDef->GetDefaultLoadoutSlot() == LOADOUT_POSITION_PDA
|| pItemDef->GetDefaultLoadoutSlot() == LOADOUT_POSITION_PDA2
|| pItemDef->GetDefaultLoadoutSlot() == LOADOUT_POSITION_BUILDING )
{
KeyValues *pNewWeapon = pWeaponNames->CreateNewKey();
pNewWeapon->SetName( CFmtStr( "%d", pItemDef->GetDefinitionIndex() ) );
pNewWeapon->SetString( "english_name", pItemDef->GetDefinitionName() );
}
}
pRequiredKeys->AddSubKey( pWeaponNames );
}
else if ( FStrEq( pszType, "weapon_name" ) )
{
KeyValues *pWeaponNames = new KeyValues( "value" );
// Add a few here that we magically use in the code elsewhere. Sigh...
pWeaponNames->AddSubKey( new KeyValues( "obj_attachment_sapper" ) );
pWeaponNames->AddSubKey( new KeyValues( "building_carried_destroyed" ) );
const CEconItemDefinition* pItemDef = NULL;
const CEconItemSchema::SortedItemDefinitionMap_t& mapItems = GetItemSchema()->GetSortedItemDefinitionMap();
for ( int it = mapItems.FirstInorder(); it != mapItems.InvalidIndex(); it = mapItems.NextInorder( it ) )
{
pItemDef = mapItems[it];
if ( pItemDef->GetIconClassname() )
{
pWeaponNames->AddSubKey( new KeyValues( pItemDef->GetIconClassname() ) );
}
}
pRequiredKeys->AddSubKey( pWeaponNames );
}
else if ( FStrEq( pszType, "weapon_type" ) )
{
KeyValues *pWeaponType = new KeyValues( "value" );
for ( int i=0; i<TF_WEAPON_COUNT; ++i )
{
const char *pszWeaponName = WeaponIdToAlias( i );
KeyValues *pNewWeapon = pWeaponType->CreateNewKey();
pNewWeapon->SetName( CFmtStr( "%d", i ) );
pNewWeapon->SetString( "english_name", pszWeaponName );
}
pRequiredKeys->AddSubKey( pWeaponType );
}
else if ( FStrEq( pszType, "item_class" ) )
{
KeyValues *pItemClassNames = new KeyValues( "value" );
const CEconItemDefinition* pItemDef = NULL;
const CEconItemSchema::SortedItemDefinitionMap_t& mapItems = GetItemSchema()->GetSortedItemDefinitionMap();
CUtlMap< const char*, int > mapTypeNames( StringLessThan );
for ( int it = mapItems.FirstInorder(); it != mapItems.InvalidIndex(); it = mapItems.NextInorder( it ) )
{
pItemDef = mapItems[it];
const char *pszClass = pItemDef->GetItemClass();
if ( pszClass && mapTypeNames.Find( pszClass ) == mapTypeNames.InvalidIndex() )
{
mapTypeNames.Insert( pszClass );
pItemClassNames->AddSubKey( new KeyValues( pItemDef->GetItemClass() ) );
}
}
pRequiredKeys->AddSubKey( pItemClassNames );
}
else
{
AssertMsg5( false, "Type %s in %s :: %s :: %s didnt match any types defined in %s", pszType, pszEventName, pszRestrictionName, pszKeyName, __FUNCTION__ );
}
}
}
else
{
pRequiredKeys->AddSubKey( pParamsKey->MakeCopy() );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFQuestCondition::CTFQuestCondition()
: m_pParent( NULL )
{}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFQuestCondition::~CTFQuestCondition()
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFQuestCondition::BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
// check if restriction name matches the keyvalue name
//const char *pszType = pKVItem->GetString( "type" );
//SCHEMA_INIT_CHECK( FStrEq( pszType, GetConditionName() ), "%s", CFmtStr( "Invalid quest restriction name '%s' for '%s'", pszType, GetConditionName() ).Get() )
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Print out debug text
//-----------------------------------------------------------------------------
void CTFQuestCondition::PrintDebugText() const
{
DevMsg( "'%s %s'", GetConditionName(), GetValueString() );
}
//-----------------------------------------------------------------------------
// Purpose: Get the owner player
//-----------------------------------------------------------------------------
const CTFPlayer *CTFQuestCondition::GetQuestOwner() const
{
if ( m_pParent )
return m_pParent->GetQuestOwner();
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Global quest objective validation checks
//-----------------------------------------------------------------------------
bool CTFQuestCondition::IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
if ( pOwner )
{
CSteamID steamIDOwner;
const_cast< CTFPlayer* >( pOwner )->GetSteamID( &steamIDOwner ); // Ugh
// Can only do quests on Valve servers
if ( !IsValidServerForQuests( steamIDOwner ) )
{
invalidReasons.m_bits.Set( INVALID_QUEST_REASON_VALVE_SERVERS_ONLY );
}
}
// Cannot do quests in MvM
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
invalidReasons.m_bits.Set( INVALID_QUEST_REASON_NO_MVM );
}
return true;
}
void CTFQuestCondition::GetValidRestrictions( CUtlVector< const char* >& vecOutValidChildren ) const
{
const CTFQuestCondition* pParent = this;
const CTFQuestEvaluator* pEvaluatorParent = NULL;
while( pParent && !pEvaluatorParent )
{
pEvaluatorParent = dynamic_cast< const CTFQuestEvaluator* >( pParent );
pParent = pParent->GetParent();
}
KeyValues* pKVQuestEvents = GetQuestEventsKeyValues();
KeyValues* pKVEvent = pKVQuestEvents->FindKey( pEvaluatorParent->GetEventName() );
FOR_EACH_MAP( k_mapConditions, i )
{
QuestConditionEntry_t* pCondEntry = k_mapConditions[ i ];
// All fields need to be present in the event for the condition to be a valid child
bool bAnyFound = false;
bool bAllFound = true;
if ( pCondEntry->m_nRequiredFields != FIELD_NONE )
{
int nMaxCount = Q_log2( FIELD_LAST_FIELD );
for( int nField = 0; nField <= nMaxCount && bAllFound; ++nField )
{
if ( pCondEntry->m_nRequiredFields & (1<<nField) )
{
bAnyFound = true;
bAllFound &= pKVEvent->FindKey( k_pszQuestConditionRequiredFieldStrings[ nField ] ) != NULL;
}
}
}
else
{
bAllFound = true;
bAnyFound = true;
}
if ( bAnyFound && bAllFound )
{
vecOutValidChildren.AddToTail( k_mapConditions.Key( i ) );
}
}
}
void CTFQuestCondition::GetValidEvaluators( CUtlVector< const char* >& vecOutValidChildren ) const
{
vecOutValidChildren.AddToTail( "event_listener" );
vecOutValidChildren.AddToTail( "counter" );
}
void CTFQuestRestriction::GetValidTypes( CUtlVector< const char* >& vecOutValidChildren ) const
{
GetValidRestrictions( vecOutValidChildren );
}
void CTFQuestRestriction::GetValidChildren( CUtlVector< const char* >& vecOutValidChildren ) const
{
GetValidRestrictions( vecOutValidChildren );
}
CTFQuestEvaluator::CTFQuestEvaluator()
{
m_pszAction = NULL;
}
void CTFQuestEvaluator::GetOutputKeyValues( KeyValues *pOutputKeys )
{
if ( m_pszAction )
{
pOutputKeys->SetString( "action", m_pszAction );
}
}
void CTFQuestEvaluator::GetValidTypes( CUtlVector< const char* >& vecOutValidChildren ) const
{
GetValidEvaluators( vecOutValidChildren );
}
void CTFQuestEvaluator::GetValidChildren( CUtlVector< const char* >& vecOutValidChildren ) const
{
GetValidRestrictions( vecOutValidChildren );
}
//-----------------------------------------------------------------------------
// Purpose: base quest operator restriction
//-----------------------------------------------------------------------------
class CTFQuestOperatorRestriction: public CTFQuestRestriction
{
public:
DECLARE_CLASS( CTFQuestOperatorRestriction, CTFQuestRestriction )
virtual ~CTFQuestOperatorRestriction()
{
m_vecRestrictions.PurgeAndDeleteElements();
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
int nInputCount = 0;
FOR_EACH_TRUE_SUBKEY( pKVItem, pSubKey )
{
if ( GetMaxInputCount() > 0 )
{
SCHEMA_INIT_CHECK( nInputCount < GetMaxInputCount(), "%s", CFmtStr( "Too many input for operator '%s'. expected %d input(s)", GetConditionName(), GetMaxInputCount() ).Get() );
}
const char *pszType = pSubKey->GetString( "type" );
CTFQuestRestriction *pNewRestriction = CreateRestrictionByName( pszType, this );
SCHEMA_INIT_CHECK( pNewRestriction != NULL, "%s", CFmtStr( "Failed to create quest restriction name '%s' for '%s'", pszType, GetConditionName() ).Get() );
SCHEMA_INIT_CHECK( pNewRestriction->BInitFromKV( pSubKey, pVecErrors ), "Failed to init from KeyValues" );
m_vecRestrictions.AddToTail( pNewRestriction );
nInputCount++;
}
SCHEMA_INIT_CHECK( nInputCount > 0 && nInputCount <= GetMaxInputCount(), "%s", CFmtStr( "Invalid number of specified input. Expected from 0 to %d inputs.", GetMaxInputCount() ).Get() );
return true;
}
virtual bool IsOperator() const OVERRIDE { return true; }
virtual void PrintDebugText() const OVERRIDE
{
DevMsg( "( " );
FOR_EACH_VEC( m_vecRestrictions, i )
{
if ( i == 0 )
{
m_vecRestrictions[i]->PrintDebugText();
}
else
{
DevMsg( " %s ", GetConditionName() );
m_vecRestrictions[i]->PrintDebugText();
}
}
DevMsg( " )" );
}
CTFQuestCondition* AddChildByName( const char *pszChildName ) OVERRIDE
{
if ( m_vecRestrictions.Count() >= GetMaxInputCount() )
{
Assert( m_vecRestrictions.Count() < GetMaxInputCount() );
return NULL;
}
CTFQuestRestriction *pNewRestriction = CreateRestrictionByName( pszChildName, this );
if ( pNewRestriction )
{
m_vecRestrictions.AddToTail( pNewRestriction );
}
return pNewRestriction;
}
virtual int GetChildren( CUtlVector< CTFQuestCondition* >& vecChildren ) OVERRIDE
{
FOR_EACH_VEC( m_vecRestrictions, i )
{
vecChildren.AddToTail( m_vecRestrictions[i] );
}
return vecChildren.Count();
}
bool RemoveAndDeleteChild( CTFQuestCondition *pChild ) OVERRIDE
{
CTFQuestRestriction *pRestrictionChild = assert_cast< CTFQuestRestriction* >( pChild );
bool bRemoved = m_vecRestrictions.FindAndFastRemove( pRestrictionChild );
Assert( bRemoved );
if ( bRemoved )
{
delete pChild;
}
return bRemoved;
}
virtual int GetMaxInputCount() const OVERRIDE { return s_nMaxInputCount; }
protected:
CUtlVector< CTFQuestRestriction* > m_vecRestrictions;
};
//-----------------------------------------------------------------------------
// Purpose: AND quest operator restriction
//-----------------------------------------------------------------------------
class CTFQuestAndOperatorRestriction : public CTFQuestOperatorRestriction
{
public:
DECLARE_CLASS( CTFQuestAndOperatorRestriction, CTFQuestOperatorRestriction )
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
FOR_EACH_VEC( m_vecRestrictions, i )
{
if ( !m_vecRestrictions[i]->PassesRestrictions( pEvent ) )
return false;
}
return true;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
BaseClass::IsValidForPlayer( pOwner, invalidReasons );
bool bIsForLocalPlayer = false;
InvalidReason operatorReasons;
FOR_EACH_VEC( m_vecRestrictions, i )
{
bIsForLocalPlayer |= m_vecRestrictions[i]->IsValidForPlayer( pOwner, operatorReasons );
}
if ( bIsForLocalPlayer )
{
invalidReasons.m_bits.Or( operatorReasons.m_bits, &invalidReasons.m_bits );
}
return bIsForLocalPlayer;
}
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestAndOperatorRestriction, AND, FIELD_NONE );
//-----------------------------------------------------------------------------
// Purpose: OR quest operator restriction
//-----------------------------------------------------------------------------
class CTFQuestOrOperatorRestriction : public CTFQuestOperatorRestriction
{
public:
DECLARE_CLASS( CTFQuestOrOperatorRestriction, CTFQuestOperatorRestriction )
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
FOR_EACH_VEC( m_vecRestrictions, i )
{
if ( m_vecRestrictions[i]->PassesRestrictions( pEvent ) )
return true;
}
return false;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
BaseClass::IsValidForPlayer( pOwner, invalidReasons );
bool bIsForLocalPlayer = false;
FOR_EACH_VEC( m_vecRestrictions, i )
{
InvalidReason operatorReason;
if ( m_vecRestrictions[i]->IsValidForPlayer( pOwner, operatorReason ) )
{
bIsForLocalPlayer = true;
invalidReasons.m_bits.Or( operatorReason.m_bits, &invalidReasons.m_bits );
}
}
return bIsForLocalPlayer;
}
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestOrOperatorRestriction, OR, FIELD_NONE );
//-----------------------------------------------------------------------------
// Purpose: NOT quest operator restriction
//-----------------------------------------------------------------------------
class CTFQuestNotOperatorRestriction : public CTFQuestOperatorRestriction
{
public:
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
return !m_vecRestrictions[0]->PassesRestrictions( pEvent );
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
return false;
}
virtual void PrintDebugText() const OVERRIDE
{
CTFQuestRestriction *pRestriction = m_vecRestrictions[0];
if ( pRestriction->IsOperator() )
{
DevMsg( "%s ", GetConditionName() );
pRestriction->PrintDebugText();
}
else
{
// add () for non-operator to keep the debug text format consistent
DevMsg( "%s ( ", GetConditionName() );
pRestriction->PrintDebugText();
DevMsg( " )" );
}
}
protected:
virtual int GetMaxInputCount() const OVERRIDE { return 1; }
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestNotOperatorRestriction, NOT, FIELD_NONE );
class CTFGenericStringRestriction : public CTFQuestRestriction
{
public:
CTFGenericStringRestriction()
: m_pszKeyName( NULL )
, m_pszValue( NULL )
{}
virtual const char *GetConditionName() const OVERRIDE { return m_pszFieldName; }
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_pszKeyName = pKVItem->GetString( "key_to_lookup" );
SCHEMA_INIT_CHECK( m_pszKeyName != NULL, "Missing key to lookup for generic_string restriction!" );
m_pszValue = pKVItem->GetString( "value" );
SCHEMA_INIT_CHECK( m_pszValue != NULL, "Missing value to compare against for generic_string restriction!" );
return true;
}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
const char* pszValue = pEvent->GetString( m_pszKeyName );
if ( pszValue )
{
return FStrEq( pszValue, m_pszValue );
}
return false;
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "key_to_lookup", m_pszKeyName );
pOutputKeys->SetString( "value", m_pszValue );
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestRestriction::GetRequiredParamKeys( pRequiredKeys );
GetValidParamsKeyFromEvent( "key_to_lookup", m_pszFieldName, m_pszEventName, pRequiredKeys );
GetValidParamsKeyFromEvent( "value", m_pszFieldName, m_pszEventName, pRequiredKeys );
}
protected:
const char *m_pszKeyName;
const char *m_pszValue;
};
class CTFGenericSubStringRestriction : public CTFGenericStringRestriction
{
public:
CTFGenericSubStringRestriction()
{}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
const char* pszValue = pEvent->GetString( m_pszKeyName );
if ( pszValue )
{
return V_stristr( pszValue, m_pszValue ) != NULL;
}
return false;
}
};
class CTFWeaponClassRestriction : public CTFGenericStringRestriction
{
public:
CTFWeaponClassRestriction()
{}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
const char* pszValue = pEvent->GetString( m_pszKeyName );
if ( pszValue )
{
const CEconItemDefinition* pItemDef = GetItemSchema()->GetItemDefinition( atoi( pszValue ) );
Assert( pItemDef );
if ( pItemDef )
{
return FStrEq( pItemDef->GetItemClass(), m_pszValue );
}
}
return false;
}
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFGenericStringRestriction, crit_kill, FIELD_CRIT );
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFGenericStringRestriction, weapon_def_index, FIELD_WEAPON_DEF_INDEX );
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFGenericStringRestriction, weapon_name, FIELD_WEAPON_NAME );
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFGenericStringRestriction, halloween_boss_type, FIELD_HALLOWEEN_BOSS_TYPE );
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFGenericStringRestriction, minigame_type, FIELD_HALLOWEEN_MINIGAME_TYPE );
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFGenericStringRestriction, bonuseffect, FIELD_BONUSEFFECT );
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFWeaponClassRestriction, weapon_class, FIELD_WEAPON_CLASS );
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFGenericSubStringRestriction, deflected_projectile, FIELD_DEFLECTED_PROJECTILE );
//-----------------------------------------------------------------------------
// Purpose: quest player restriction
//-----------------------------------------------------------------------------
class CTFQuestBasePlayerRestriction : public CTFQuestRestriction
{
public:
CTFQuestBasePlayerRestriction()
: m_pszPlayerKey( NULL )
, m_pszPlayerMethod( NULL )
{}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_pszPlayerKey = pKVItem->GetString( "player_key", NULL );
Assert( m_pszPlayerKey );
SCHEMA_INIT_CHECK( m_pszPlayerKey != NULL, "missing 'player_key'" );
static const char *s_pszValidGetMethod[] =
{
"by_id",
"by_entindex",
"by_cappers"
};
m_pszPlayerMethod = pKVItem->GetString( "get_player" );
bool bIsValidMethod = false;
for ( int i=0; i<ARRAYSIZE( s_pszValidGetMethod ); ++i )
{
if ( FStrEq( m_pszPlayerMethod, s_pszValidGetMethod[i] ) )
{
bIsValidMethod = true;
break;
}
}
SCHEMA_INIT_CHECK( bIsValidMethod, "Invalid 'get_player'" );
return true;
}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
CTFPlayer *pPlayer = GetPlayerFromEvent( pEvent );
if ( !pPlayer )
return false;
return BPlayerCheck( pPlayer, pEvent );
}
CTFPlayer *GetPlayerFromEvent( IGameEvent *pEvent ) const
{
CTFPlayer *pPlayer = NULL;
if ( FStrEq( m_pszPlayerMethod, "by_id" ) )
{
int iPlayerID = pEvent->GetInt( m_pszPlayerKey );
pPlayer = ToTFPlayer( UTIL_PlayerByUserId( iPlayerID ) );
}
else if ( FStrEq( m_pszPlayerMethod, "by_entindex" ) )
{
int iPlayerIndex = pEvent->GetInt( m_pszPlayerKey );
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
}
else if ( FStrEq( m_pszPlayerMethod, "by_cappers" ) )
{
Assert( FStrEq( m_pszPlayerKey, "cappers" ) );
const CTFPlayer *pQuestOwner = GetQuestOwner();
const char *cappers = pEvent->GetString( m_pszPlayerKey );
for ( int i = 0; i < Q_strlen( cappers ); i++ )
{
int iPlayerIndex = (int)cappers[i];
CTFPlayer *pCapper = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pCapper == pQuestOwner )
{
pPlayer = pCapper;
break;
}
}
}
return pPlayer;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestRestriction::GetRequiredParamKeys( pRequiredKeys );
GetValidParamsKeyFromEvent( "player_key", "player", m_pszEventName, pRequiredKeys );
GetValidParamsKeyFromEvent( "get_player", "player", m_pszEventName, pRequiredKeys );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "player_key", m_pszPlayerKey );
pOutputKeys->SetString( "get_player", m_pszPlayerMethod );
}
protected:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const = 0;
const char *m_pszPlayerKey;
const char *m_pszPlayerMethod;
};
//-----------------------------------------------------------------------------
// Purpose: quest player restriction
//-----------------------------------------------------------------------------
class CTFQuestPlayerDisguiseRestriction : public CTFQuestBasePlayerRestriction
{
public:
CTFQuestPlayerDisguiseRestriction() {}
enum EDisguiseTargetState_t
{
DISGUISE_STATE_OWNER_IS_PLAYER,
DISGUISE_STATE_OWNER_IS_NOT_PLAYER,
DISGUISE_STATE_PLAYER_IS_OWNER,
DISGUISE_STATE_PLAYER_IS_NOT_OWNER,
DISGUISE_STATE_DONT_CARE
};
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_eDisguiseState = (EDisguiseTargetState_t)pKVItem->GetInt( "disguise_target", DISGUISE_STATE_DONT_CARE );
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
// Disguise state
{
KeyValues *pKVDisguiseKeys = new KeyValues( "disguise_target" );
pKVDisguiseKeys->SetString( "english_name", "Disguise" );
// DISGUISE_STATE_OWNER_IS_PLAYER
KeyValues * pKVDisguiseState = pKVDisguiseKeys->CreateNewKey();
pKVDisguiseState->SetName( "0" );
pKVDisguiseState->SetString( "english_name", "Owner disguised as the player" );
// DISGUISE_STATE_OWNER_IS_NOT_PLAYER
pKVDisguiseState = pKVDisguiseKeys->CreateNewKey();
pKVDisguiseState->SetName( "1" );
pKVDisguiseState->SetString( "english_name", "Owner NOT disguised as the player" );
// DISGUISE_STATE_PLAYER_IS_OWNER
pKVDisguiseState = pKVDisguiseKeys->CreateNewKey();
pKVDisguiseState->SetName( "2" );
pKVDisguiseState->SetString( "english_name", "Player disguised as the owner" );
// DISGUISE_STATE_PLAYER_IS_NOT_OWNER
pKVDisguiseState = pKVDisguiseKeys->CreateNewKey();
pKVDisguiseState->SetName( "3" );
pKVDisguiseState->SetString( "english_name", "Player NOT disguised as the owner" );
pRequiredKeys->AddSubKey( pKVDisguiseKeys );
}
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetInt( "disguise_target", m_eDisguiseState );
}
protected:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
// Disguise state check
const CTFPlayer* pPlayerDisguiseTarget = ToTFPlayer( pPlayer->m_Shared.GetDisguiseTarget() );
const CTFPlayer* pOwnerDisguiseTarget = ToTFPlayer( GetQuestOwner()->m_Shared.GetDisguiseTarget() );
// owner in disguise
if ( pOwnerDisguiseTarget )
{
// must disguise as same class to look the same
if ( m_eDisguiseState == DISGUISE_STATE_OWNER_IS_PLAYER && pOwnerDisguiseTarget == pPlayer && GetQuestOwner()->m_Shared.GetDisguiseClass() == pPlayer->GetPlayerClass()->GetClassIndex() )
return true;
if ( m_eDisguiseState == DISGUISE_STATE_OWNER_IS_NOT_PLAYER && pOwnerDisguiseTarget != pPlayer )
return true;
}
// player in disguise
if ( pPlayerDisguiseTarget )
{
// must disguise as same class to look the same
if ( m_eDisguiseState == DISGUISE_STATE_PLAYER_IS_OWNER && pPlayerDisguiseTarget == GetQuestOwner() && pPlayer->m_Shared.GetDisguiseClass() == GetQuestOwner()->GetPlayerClass()->GetClassIndex() )
return true;
if ( m_eDisguiseState == DISGUISE_STATE_PLAYER_IS_NOT_OWNER && pPlayerDisguiseTarget != GetQuestOwner() )
return true;
}
return false;
}
EDisguiseTargetState_t m_eDisguiseState;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestPlayerDisguiseRestriction, player_disguise, FIELD_PLAYER );
//-----------------------------------------------------------------------------
// Purpose: quest player jumping-state restriction
//-----------------------------------------------------------------------------
class CTFQuestPlayerJumpingRestriction : public CTFQuestBasePlayerRestriction
{
public:
CTFQuestPlayerJumpingRestriction() {}
enum EJumpingState_t
{
JUMPING_STATE_IS_NOT_JUMPING = 0,
JUMPING_STATE_IS_JUMPING,
JUMPING_STATE_IS_DOUBLE_JUMPING,
JUMPING_STATE_IS_TRIPLE_JUMPING,
};
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_eJumpingState = (EJumpingState_t)pKVItem->GetInt( "jumping_state", JUMPING_STATE_IS_NOT_JUMPING );
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
// Jumping state
{
KeyValues *pKVJumpingKeys = new KeyValues( "jumping_state" );
pKVJumpingKeys->SetString( "english_name", "Jumping" );
KeyValues * pKVJumpState = pKVJumpingKeys->CreateNewKey();
pKVJumpState->SetName( "0" );
pKVJumpState->SetString( "english_name", "Must NOT be jumping" );
pKVJumpState = pKVJumpingKeys->CreateNewKey();
pKVJumpState->SetName( "1" );
pKVJumpState->SetString( "english_name", "Must be at least jumping" );
pKVJumpState = pKVJumpingKeys->CreateNewKey();
pKVJumpState->SetName( "2" );
pKVJumpState->SetString( "english_name", "Must be at least double-jumping" );
pKVJumpState = pKVJumpingKeys->CreateNewKey();
pKVJumpState->SetName( "3" );
pKVJumpState->SetString( "english_name", "Must be at least triple-jumping" );
pRequiredKeys->AddSubKey( pKVJumpingKeys );
}
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetInt( "jumping_state", m_eJumpingState );
}
protected:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
#ifdef GAME_DLL
CTFPlayer* pNonConstPlayer = const_cast< CTFPlayer* >( pPlayer );
int nNumJumps = pNonConstPlayer->GetGroundEntity() == NULL ? 1 : 0;
nNumJumps += pPlayer->m_Shared.GetAirDash();
nNumJumps += pPlayer->m_bScattergunJump;
if ( m_eJumpingState == JUMPING_STATE_IS_NOT_JUMPING )
{
return nNumJumps == 0;
}
else if ( m_eJumpingState == JUMPING_STATE_IS_JUMPING )
{
return nNumJumps >= 1;
}
else if ( m_eJumpingState == JUMPING_STATE_IS_DOUBLE_JUMPING )
{
return nNumJumps >= 2;
}
else if ( m_eJumpingState == JUMPING_STATE_IS_TRIPLE_JUMPING )
{
return nNumJumps >= 3;
}
else
{
AssertMsg1( false, "Unhandled EJumpingState_t case %d!", m_eJumpingState );
}
#endif
return false;
}
EJumpingState_t m_eJumpingState;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestPlayerJumpingRestriction, player_jumping, FIELD_PLAYER );
//-----------------------------------------------------------------------------
// Purpose: quest player alive-state restriction
//-----------------------------------------------------------------------------
class CTFQuestPlayerAliveRestriction : public CTFQuestBasePlayerRestriction
{
public:
CTFQuestPlayerAliveRestriction() {}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_bAliveState = pKVItem->GetBool( "alive_state", true );
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
KeyValues *pKVAliveKeys = new KeyValues( "alive_state" );
pKVAliveKeys->SetString( "english_name", "Alive" );
KeyValues * pKVAliveState = pKVAliveKeys->CreateNewKey();
pKVAliveState->SetName( "1" );
pKVAliveState->SetString( "english_name", "Must be alive" );
pKVAliveState = pKVAliveKeys->CreateNewKey();
pKVAliveState->SetName( "0" );
pKVAliveState->SetString( "english_name", "Must be dead" );
pRequiredKeys->AddSubKey( pKVAliveKeys );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetInt( "alive_state", m_bAliveState );
}
protected:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
return ( pPlayer->m_iHealth > 0 ) == m_bAliveState;
}
bool m_bAliveState;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestPlayerAliveRestriction, player_alive, FIELD_PLAYER );
//-----------------------------------------------------------------------------
// Purpose: quest player distance restriction relative to the owner
//-----------------------------------------------------------------------------
class CTFQuestPlayerDistanceRestriction : public CTFQuestBasePlayerRestriction
{
public:
CTFQuestPlayerDistanceRestriction() {}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_eCheckType = (EDistanceCheck_t)pKVItem->GetInt( "distance_check_type", INVALID_CHECK_TYPE );
SCHEMA_INIT_CHECK( m_eCheckType != INVALID_CHECK_TYPE, "Invalid distance_check_type %d!", m_eCheckType );
m_nDistance = pKVItem->GetInt( "distance_to_check", 0 );
SCHEMA_INIT_CHECK( m_eCheckType != 0, "Distance must be non-zero!" );
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
KeyValues *pKVDistanceCheckTypeKeys = new KeyValues( "distance_check_type" );
pKVDistanceCheckTypeKeys->SetString( "english_name", "Alive" );
KeyValues * pKVType = pKVDistanceCheckTypeKeys->CreateNewKey();
pKVType->SetName( "1" );
pKVType->SetString( "english_name", "Closer than" );
pKVType = pKVDistanceCheckTypeKeys->CreateNewKey();
pKVType->SetName( "2" );
pKVType->SetString( "english_name", "Further than" );
pRequiredKeys->AddSubKey( pKVDistanceCheckTypeKeys );
KeyValues *pDistanceKey = new KeyValues( "distance_to_check" );
pDistanceKey->SetString( "control_type", "text_entry" );
pRequiredKeys->AddSubKey( pDistanceKey );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetInt( "distance_check_type", m_eCheckType );
pOutputKeys->SetInt( "distance_to_check", m_nDistance );
}
protected:
enum EDistanceCheck_t
{
INVALID_CHECK_TYPE = 0,
CLOSER_THAN,
FURTHER_THAN
};
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
int nTestDist = m_nDistance * m_nDistance;
int nPlayerDistSq = ( pPlayer->GetAbsOrigin() - GetQuestOwner()->GetAbsOrigin() ).LengthSqr();
if ( m_eCheckType == CLOSER_THAN )
{
return nPlayerDistSq < nTestDist;
}
else
{
return nPlayerDistSq > nTestDist;
}
}
EDistanceCheck_t m_eCheckType;
float m_nDistance;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestPlayerDistanceRestriction, player_distance, FIELD_PLAYER );
//-----------------------------------------------------------------------------
// Purpose: quest player restriction
//-----------------------------------------------------------------------------
class CTFQuestPlayerIsOwnerRestriction : public CTFQuestBasePlayerRestriction
{
public:
CTFQuestPlayerIsOwnerRestriction() {}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
// should check if this player is quest owner?
m_bIsOwner = pKVItem->GetBool( "is_owner" );
return true;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
CTFQuestBasePlayerRestriction::IsValidForPlayer( pOwner, invalidReasons );
return m_bIsOwner && pOwner == GetQuestOwner();
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
KeyValues *pIsOwnerKey = new KeyValues( "is_owner" );
pIsOwnerKey->SetString( "english_name", "is_owner" );
KeyValues *pIsOwnerKeyChoiceTrue = new KeyValues( "1" );
pIsOwnerKeyChoiceTrue->SetString( "english_name", "true" );
KeyValues *pIsOwnerKeyChoiceFalse = new KeyValues( "0" );
pIsOwnerKeyChoiceFalse->SetString( "english_name", "false" );
pIsOwnerKey->AddSubKey( pIsOwnerKeyChoiceTrue );
pIsOwnerKey->AddSubKey( pIsOwnerKeyChoiceFalse );
pRequiredKeys->AddSubKey( pIsOwnerKey );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetBool( "is_owner", m_bIsOwner );
}
private:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
return m_bIsOwner == ( pPlayer == GetQuestOwner() );
}
bool m_bIsOwner;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestPlayerIsOwnerRestriction, player_is_owner, FIELD_PLAYER );
//-----------------------------------------------------------------------------
// Purpose: quest class restriction
//-----------------------------------------------------------------------------
class CTFQuestPlayerClassRestriction : public CTFQuestBasePlayerRestriction
{
public:
DECLARE_CLASS( CTFQuestPlayerClassRestriction, CTFQuestBasePlayerRestriction )
CTFQuestPlayerClassRestriction()
{
m_iClass = TF_CLASS_UNDEFINED;
}
virtual const char *GetValueString() const OVERRIDE
{
return GetItemSchema()->GetClassUsabilityStrings()[ m_iClass ];
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
const char *pszClassName = pKVItem->GetString( "value", NULL );
m_iClass = StringFieldToInt( pszClassName, GetItemSchema()->GetClassUsabilityStrings() );
SCHEMA_INIT_CHECK( IsValidTFPlayerClass( m_iClass ), "%s", CFmtStr( "Invalid owner class restriction '%s' for quest objective", pszClassName ).Get() );
return true;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
BaseClass::IsValidForPlayer( pOwner, invalidReasons );
if ( !BPlayerCheck( pOwner, NULL ) )
invalidReasons.m_bits.Set( INVALID_QUEST_REASON_WRONG_CLASS );
return false;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
KeyValues *pClassesKey = new KeyValues( "value" );
for ( int i=0; i<GetItemSchema()->GetClassUsabilityStrings().Count(); ++i )
{
const char *pszClassName = GetItemSchema()->GetClassUsabilityStrings()[i];
pClassesKey->AddSubKey( new KeyValues( pszClassName ) );
}
pRequiredKeys->AddSubKey( pClassesKey );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "value", GetValueString() );
}
private:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
// Check if the classes match
int iClass = pPlayer->GetPlayerClass()->GetClassIndex();
return m_iClass == iClass;
}
int m_iClass;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestPlayerClassRestriction, player_class, FIELD_PLAYER );
//-----------------------------------------------------------------------------
// Purpose: quest player condition restriction
//-----------------------------------------------------------------------------
class CTFQuestPlayerConditionRestriction : public CTFQuestBasePlayerRestriction
{
public:
virtual const char *GetValueString() const OVERRIDE
{
return GetTFConditionName( m_eCondition );
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
const char *pszConditionName = pKVItem->GetString( "value", NULL );
m_eCondition = GetTFConditionFromName( pszConditionName );
SCHEMA_INIT_CHECK( m_eCondition != TF_COND_INVALID, "%s", CFmtStr( "Invalid %s restriction '%s' for quest objective", GetConditionName(), pszConditionName ).Get() );
m_bOwnerMustBeProvider = pKVItem->GetBool( "provider_must_be_owner", false );
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
KeyValues *pConditionsKey = new KeyValues( "value" );
for ( int i=0; i<TF_COND_LAST; ++i )
{
const char *pszConditionName = GetTFConditionName( ETFCond( i ) );
pConditionsKey->AddSubKey( new KeyValues( pszConditionName ) );
}
pRequiredKeys->AddSubKey( pConditionsKey );
KeyValues *pRequireOwnerIsProvider = new KeyValues( "provider_must_be_owner" );
KeyValues *pIsOwnerKeyChoiceTrue = new KeyValues( "1" );
pIsOwnerKeyChoiceTrue->SetString( "english_name", "true" );
pRequireOwnerIsProvider->AddSubKey( pIsOwnerKeyChoiceTrue );
KeyValues *pIsOwnerKeyChoiceFalse = new KeyValues( "0" );
pIsOwnerKeyChoiceFalse->SetString( "english_name", "false" );
pRequireOwnerIsProvider->AddSubKey( pIsOwnerKeyChoiceFalse );
pRequiredKeys->AddSubKey( pRequireOwnerIsProvider );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "value", GetValueString() );
pOutputKeys->SetBool( "provider_must_be_owner", m_bOwnerMustBeProvider );
}
private:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
// Must be in the condition
if ( !pPlayer->m_Shared.InCond( m_eCondition ) )
return false;
// Might require the owner is the provider
if ( m_bOwnerMustBeProvider && pPlayer->m_Shared.GetConditionProvider( m_eCondition ) != GetQuestOwner() )
return false;
return true;
}
ETFCond m_eCondition;
bool m_bOwnerMustBeProvider;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestPlayerConditionRestriction, player_condition, FIELD_PLAYER );
//-----------------------------------------------------------------------------
// Purpose: quest player condition restriction
//-----------------------------------------------------------------------------
class CTFQuestPlayerObjectRestriction : public CTFQuestBasePlayerRestriction
{
public:
DECLARE_CLASS( CTFQuestPlayerObjectRestriction, CTFQuestBasePlayerRestriction )
CTFQuestPlayerObjectRestriction()
: m_pszObjectKey( NULL ),
m_eObjectType( OBJ_DISPENSER )
{}
virtual const char *GetValueString() const OVERRIDE
{
return GetObjectInfo( m_eObjectType )->m_pObjectName;
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_pszObjectKey = pKVItem->GetString( "object_key", NULL );
SCHEMA_INIT_CHECK( m_pszObjectKey != NULL, "Missing object_key" );
const char *pszObjectTypeName = pKVItem->GetString( "value", NULL );
m_eObjectType = (ObjectType_t)GetBuildableId( pszObjectTypeName );
SCHEMA_INIT_CHECK( m_eObjectType != OBJ_LAST, "%s", CFmtStr( "Invalid %s restriction '%s' for quest objective", GetConditionName(), pszObjectTypeName ).Get() );
return true;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
CTFQuestBasePlayerRestriction::IsValidForPlayer( pOwner, invalidReasons );
if ( !pOwner->IsPlayerClass( TF_CLASS_ENGINEER ) )
invalidReasons.m_bits.Set( INVALID_QUEST_REASON_WRONG_CLASS );
return false;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
GetValidParamsKeyFromEvent( "object_key", CTFQuestPlayerObjectRestriction::GetConditionName(), m_pszEventName, pRequiredKeys );
KeyValues *pObjectKey = new KeyValues( "value" );
for ( int i=0; i<OBJ_LAST; ++i )
{
const char *pszObjectName = GetObjectInfo( ObjectType_t(i) )->m_pObjectName;
pObjectKey->AddSubKey( new KeyValues( pszObjectName ) );
}
pRequiredKeys->AddSubKey( pObjectKey );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "object_key", m_pszObjectKey );
pOutputKeys->SetString( "value", GetValueString() );
}
private:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
int nEntIndex = pEvent->GetInt( m_pszObjectKey );
#ifdef GAME_DLL
CBaseEntity *pObj = UTIL_EntityByIndex( nEntIndex );
#else
CBaseEntity *pObj = ClientEntityList().GetEnt( nEntIndex );
#endif
CBaseObject *pPlayerObj = pPlayer->GetObjectOfType( m_eObjectType );
return pObj && pPlayerObj && pObj == pPlayerObj;
}
const char *m_pszObjectKey;
ObjectType_t m_eObjectType;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestPlayerObjectRestriction, object_type, FIELD_PLAYER | FIELD_OBJECT );
//-----------------------------------------------------------------------------
// Purpose: quest player condition restriction
//-----------------------------------------------------------------------------
class CTFQuestScorerRestriction : public CTFQuestBasePlayerRestriction
{
public:
CTFQuestScorerRestriction()
: m_pszScorerKey( NULL )
{}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_pszScorerKey = pKVItem->GetString( "scorer_key", NULL );
SCHEMA_INIT_CHECK( m_pszScorerKey != NULL, "Missing scorer key" );
return true;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
BaseClass::IsValidForPlayer( pOwner, invalidReasons );
if ( !pOwner->IsPlayerClass( TF_CLASS_ENGINEER ) )
invalidReasons.m_bits.Set( INVALID_QUEST_REASON_WRONG_CLASS );
return false;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
GetValidParamsKeyFromEvent( "scorer_key", GetConditionName(), m_pszEventName, pRequiredKeys );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "scorer_key", m_pszScorerKey );
}
private:
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
#ifdef GAME_DLL
int nEntIndex = pEvent->GetInt( m_pszScorerKey );
CBaseEntity *pEnt = UTIL_EntityByIndex( nEntIndex );
IScorer* pScorer = dynamic_cast< IScorer* >( pEnt );
if ( !pScorer )
return false;
return pScorer->GetScorer() == pPlayer;
#else
return true;
#endif
}
const char *m_pszScorerKey;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestScorerRestriction, scorer, FIELD_PLAYER | FIELD_SCORER );
//-----------------------------------------------------------------------------
// Purpose: quest weapon restriction
//-----------------------------------------------------------------------------
class CTFQuestWeaponTypeRestriction : public CTFGenericStringRestriction
{
public:
virtual const char *GetValueString() const OVERRIDE
{
return WeaponIdToAlias( m_eWeaponType );
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFGenericStringRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_eWeaponType = (ETFWeaponType)atoi( m_pszValue );
SCHEMA_INIT_CHECK( m_eWeaponType != TF_WEAPON_NONE, "%s", CFmtStr( "Invalid weapon restriction '%s' for quest objective", m_pszValue ).Get() );
return true;
}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
ETFWeaponType weaponID = (ETFWeaponType)pEvent->GetInt( m_pszKeyName );
return m_eWeaponType == weaponID;
}
private:
ETFWeaponType m_eWeaponType;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestWeaponTypeRestriction, weapon_type, FIELD_WEAPON_TYPE );
//-----------------------------------------------------------------------------
// Purpose: quest custom damage restriction
//-----------------------------------------------------------------------------
class CTFQuestCustomDamageRestriction : public CTFQuestRestriction
{
public:
virtual const char *GetValueString() const OVERRIDE
{
return GetCustomDamageName( m_eCustomDamageType );
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
const char *pszCustomDamageName = pKVItem->GetString( "value", NULL );
m_eCustomDamageType = GetCustomDamageFromName( pszCustomDamageName );
SCHEMA_INIT_CHECK( m_eCustomDamageType != TF_DMG_CUSTOM_NONE, "%s", CFmtStr( "Invalid weapon restriction '%s' for quest objective", pszCustomDamageName ).Get() );
m_pszCustomDamageKey = pKVItem->GetString( "custom_damage_key", NULL );
SCHEMA_INIT_CHECK( m_pszCustomDamageKey != NULL, "Invalid custom_damage_key!" );
return true;
}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
ETFDmgCustom customDamageType = (ETFDmgCustom)pEvent->GetInt( m_pszCustomDamageKey );
return m_eCustomDamageType == customDamageType;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestRestriction::GetRequiredParamKeys( pRequiredKeys );
GetValidParamsKeyFromEvent( "custom_damage_key", GetConditionName(), m_pszEventName, pRequiredKeys );
KeyValues *pDamageKey = new KeyValues( "value" );
for ( int i=0; i<TF_DMG_CUSTOM_END; ++i )
{
const char *pszCustomDamageName = GetCustomDamageName( ETFDmgCustom( i ) );
pDamageKey->AddSubKey( new KeyValues( pszCustomDamageName ) );
}
pRequiredKeys->AddSubKey( pDamageKey );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "value", GetValueString() );
}
private:
ETFDmgCustom m_eCustomDamageType;
const char *m_pszCustomDamageKey;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestCustomDamageRestriction, custom_damage, FIELD_CUSTOM_DAMAGE );
//-----------------------------------------------------------------------------
// Purpose: quest flag event restriction
//-----------------------------------------------------------------------------
class CTFFlagEventTypeRestriction : public CTFQuestRestriction
{
public:
CTFFlagEventTypeRestriction()
: m_eEventType( TF_FLAGEVENT_CAPTURE )
, m_pszKeyName( NULL )
{}
virtual const char *GetValueString() const OVERRIDE
{
return GetCTFEventName( m_eEventType );
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
const char *pszEventType = pKVItem->GetString( "value", NULL );
m_eEventType = GetCTFEventTypeFromName( pszEventType );
SCHEMA_INIT_CHECK( m_eEventType != TF_NUM_FLAG_EVENTS, "%s", CFmtStr( "Invalid CTF Event Type '%s' for quest objective", pszEventType ).Get() );
m_pszKeyName = pKVItem->GetString( "event_key", "eventtype" );
SCHEMA_INIT_CHECK( m_pszKeyName != NULL, "Missing \"event_key\" for flag_event_type" );
return true;
}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
ETFFlagEventTypes eEventType = (ETFFlagEventTypes)pEvent->GetInt( m_pszKeyName );
return m_eEventType == eEventType;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestRestriction::GetRequiredParamKeys( pRequiredKeys );
GetValidParamsKeyFromEvent( "event_key", "flag_event", m_pszEventName, pRequiredKeys );
KeyValues *pEventKey = new KeyValues( "value" );
for ( int i=1; i<TF_NUM_FLAG_EVENTS; ++i )
{
const char *pszEventType = GetCTFEventName( ETFFlagEventTypes( i ) );
pEventKey->AddSubKey( new KeyValues( pszEventType ) );
}
pRequiredKeys->AddSubKey( pEventKey );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "value", GetValueString() );
pOutputKeys->SetString( "event_key", m_pszKeyName );
}
private:
ETFFlagEventTypes m_eEventType;
const char* m_pszKeyName;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFFlagEventTypeRestriction, flag_event_type, FIELD_FLAG_EVENT );
static const char *s_pszTeamRestrictionNames[] =
{
"TEAM_ANY",
"TEAM_IS_OWNERS",
"TEAM_IS_NOT_OWNERS",
};
//-----------------------------------------------------------------------------
// Purpose: quest custom damage restriction
//-----------------------------------------------------------------------------
class CTFQuestTeamRestriction : public CTFQuestRestriction
{
public:
enum ETeamRestriction
{
TEAM_RESTRICTION_ANY = 0,
TEAM_RESTRICTION_IS_OWNERS,
TEAM_RESTRICTION_IS_NOT_OWNERS,
TEAM_RESTRICTION_MAX
};
CTFQuestTeamRestriction()
: m_eTeamRestriction( TEAM_RESTRICTION_ANY )
, m_pszTeamKey( NULL )
{}
virtual const char *GetValueString() const OVERRIDE
{
return s_pszTeamRestrictionNames[ m_eTeamRestriction ];
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_eTeamRestriction = (ETeamRestriction)pKVItem->GetInt( "team_requirement", TEAM_RESTRICTION_ANY );
m_pszTeamKey = pKVItem->GetString( "team_key", NULL );
SCHEMA_INIT_CHECK( m_pszTeamKey != NULL, "Missing \"m_pszTeamKey\" in team_restriction" );
return true;
}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
int nTeam = pEvent->GetInt( m_pszTeamKey, TEAM_INVALID );
if ( nTeam == TEAM_INVALID )
{
AssertMsg( 0, "This event doesn't specify a team." );
return false;
}
const CTFPlayer *pOwner = GetQuestOwner();
bool bTeamIsOwners = nTeam == pOwner->GetTeamNumber();
if ( ( m_eTeamRestriction == TEAM_RESTRICTION_IS_OWNERS && !bTeamIsOwners ) ||
( m_eTeamRestriction == TEAM_RESTRICTION_IS_NOT_OWNERS && bTeamIsOwners ) )
{
return false;
}
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestRestriction::GetRequiredParamKeys( pRequiredKeys );
GetValidParamsKeyFromEvent( "team_key", GetConditionName(), m_pszEventName, pRequiredKeys );
KeyValues *pTeamReq = new KeyValues( "team_requirement" );
for( int i=0; i<TEAM_RESTRICTION_MAX; ++i )
{
KeyValues *pTeam = new KeyValues( CFmtStr( "%d", i ) );
pTeam->SetString( "english_name", s_pszTeamRestrictionNames[ i ] );
pTeamReq->AddSubKey( pTeam );
}
pRequiredKeys->AddSubKey( pTeamReq );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetInt( "team_requirement", m_eTeamRestriction );
pOutputKeys->SetString( "team_key", m_pszTeamKey );
}
private:
ETeamRestriction m_eTeamRestriction;
const char* m_pszTeamKey;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestTeamRestriction, team_restriction, FIELD_TEAM );
//-----------------------------------------------------------------------------
// Purpose: quest map restriction
//-----------------------------------------------------------------------------
class CTFQuestMapRestriction : public CTFQuestRestriction
{
public:
DECLARE_CLASS( CTFQuestMapRestriction, CTFQuestRestriction )
CTFQuestMapRestriction()
: m_pszMapName( NULL )
{
}
virtual const char *GetValueString() const OVERRIDE
{
return m_pszMapName;
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_pszMapName = pKVItem->GetString( "value", NULL );
SCHEMA_INIT_CHECK( m_pszMapName != NULL, "Missing map name." );
// TODO: validate map name against some white list here
return true;
}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
return IsValidMap();
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
BaseClass::IsValidForPlayer( pOwner, invalidReasons );
if ( !IsValidMap() )
invalidReasons.m_bits.Set( INVALID_QUEST_REASON_WRONG_MAP );
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
//const CUtlVector<SchemaMap_t>& maps = GetItemSchema()->GetMaps();
KeyValues *pMapKey = new KeyValues( "value" );
pMapKey->SetString( "control_type", "text_entry" );
/*for ( int i=0; i<maps.Count(); ++i )
{
const char *pszMapName = maps[i].pszMapName;
pMapKey->AddSubKey( new KeyValues( pszMapName ) );
}*/
pRequiredKeys->AddSubKey( pMapKey );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "value", GetValueString() );
}
private:
bool IsValidMap() const
{
#ifdef CLIENT_DLL
const char *pszMapName = TFGameRules()->MapName();
#else
const char *pszMapName = gpGlobals->mapname.ToCStr();
#endif
return !V_stricmp( m_pszMapName, pszMapName );
}
const char *m_pszMapName;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestMapRestriction, map, FIELD_NONE );
//-----------------------------------------------------------------------------
// Purpose: quest game type restriction
//-----------------------------------------------------------------------------
class CTFQuestGameTypeRestriction : public CTFQuestRestriction
{
public:
DECLARE_CLASS( CTFQuestGameTypeRestriction, CTFQuestRestriction )
CTFQuestGameTypeRestriction()
: m_eGameType( (ETFGameType)0 )
{}
virtual const char *GetValueString() const OVERRIDE
{
return GetEnumGameTypeName( m_eGameType );
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
const char *pszVal = pKVItem->GetString( "value", NULL );
SCHEMA_INIT_CHECK( pszVal != NULL, "Missing game_type name." );
m_eGameType = GetGameTypeFromName( pszVal );
SCHEMA_INIT_CHECK( m_eGameType != TF_GAMETYPE_UNDEFINED, "Invalid game_type name." );
return true;
}
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
return TFGameRules()->GetGameType() == m_eGameType;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
BaseClass::IsValidForPlayer( pOwner, invalidReasons );
if ( TFGameRules()->GetGameType() != m_eGameType )
invalidReasons.m_bits.Set( INVALID_QUEST_REASON_WRONG_GAME_MODE );
return false;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestRestriction::GetRequiredParamKeys( pRequiredKeys );
KeyValues *pGameType = new KeyValues( "value" );
for ( int i=0; i<TF_GAMETYPE_COUNT; ++i )
{
const char *pszGameType = GetEnumGameTypeName( ETFGameType( i ) );
pGameType->AddSubKey( new KeyValues( pszGameType ) );
}
pRequiredKeys->AddSubKey( pGameType );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "value", GetValueString() );
}
private:
ETFGameType m_eGameType;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestGameTypeRestriction, game_type, FIELD_NONE );
static const char *s_loadout_position_names[] =
{
// Weapons & Equipment
"LOADOUT_POSITION_PRIMARY",
"LOADOUT_POSITION_SECONDARY",
"LOADOUT_POSITION_MELEE",
"LOADOUT_POSITION_UTILITY",
"LOADOUT_POSITION_BUILDING",
"LOADOUT_POSITION_PDA",
"LOADOUT_POSITION_PDA2",
// Wearables. If you add new wearable slots, make sure you add them to IsWearableSlot() below this.
"LOADOUT_POSITION_HEAD",
"LOADOUT_POSITION_MISC",
// other
"LOADOUT_POSITION_ACTION",
// More wearables, yay!
"LOADOUT_POSITION_MISC2",
// taunts
"LOADOUT_POSITION_TAUNT",
"LOADOUT_POSITION_TAUNT2",
"LOADOUT_POSITION_TAUNT3",
"LOADOUT_POSITION_TAUNT4",
"LOADOUT_POSITION_TAUNT5",
"LOADOUT_POSITION_TAUNT6",
"LOADOUT_POSITION_TAUNT7",
"LOADOUT_POSITION_TAUNT8",
#ifdef STAGING_ONLY
// Extra PDA mod slots
"LOADOUT_POSITION_PDA_ADDON1",
"LOADOUT_POSITION_PDA_ADDON2",
"LOADOUT_POSITION_PDA3",
//LOADOUT_POSITION_MISC3,
//LOADOUT_POSITION_MISC4,
//LOADOUT_POSITION_MISC5,
//LOADOUT_POSITION_MISC6,
//LOADOUT_POSITION_MISC7,
//LOADOUT_POSITION_MISC8,
//LOADOUT_POSITION_MISC9,
//LOADOUT_POSITION_MISC10,
"LOADOUT_POSITION_BUILDING2",
#endif // STAGING_ONLY
};
COMPILE_TIME_ASSERT( ARRAYSIZE( s_loadout_position_names ) == CLASS_LOADOUT_POSITION_COUNT );
//-----------------------------------------------------------------------------
// Purpose: quest loadout position restriction
//-----------------------------------------------------------------------------
class CTFQuestLoadoutPositionRestriction : public CTFQuestBasePlayerRestriction
{
public:
DECLARE_CLASS( CTFQuestLoadoutPositionRestriction, CTFQuestRestriction )
CTFQuestLoadoutPositionRestriction()
: m_eLoadoutPosition( LOADOUT_POSITION_INVALID )
, m_pszLoadoutKey( NULL )
{}
virtual const char *GetValueString() const OVERRIDE
{
if ( m_eLoadoutPosition == LOADOUT_POSITION_INVALID )
{
return "LOADOUT_POSITION_INVALID";
}
return s_loadout_position_names[ m_eLoadoutPosition ];
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestBasePlayerRestriction::BInitFromKV( pKVItem, pVecErrors ) )
return false;
const char *pszVal = pKVItem->GetString( "value", NULL );
SCHEMA_INIT_CHECK( pszVal != NULL, "Missing loadout_position name." );
m_eLoadoutPosition = GetLoadoutPositionByName( pszVal );
SCHEMA_INIT_CHECK( m_eLoadoutPosition != LOADOUT_POSITION_INVALID, "Invalid loadout_position name." );
m_pszPlayerKey = pKVItem->GetString( "player_key", NULL );
SCHEMA_INIT_CHECK( m_pszPlayerKey != NULL, "Missing \"player_key\" in loadout_position" );
m_pszLoadoutKey = pKVItem->GetString( "loadout_key", NULL );
SCHEMA_INIT_CHECK( m_pszLoadoutKey != NULL, "Missing \"loadout_key\" in loadout_position" );
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetRequiredParamKeys( pRequiredKeys );
GetValidParamsKeyFromEvent( "loadout_key", GetConditionName(), m_pszEventName, pRequiredKeys );
KeyValues *pLoadoutPositions = new KeyValues( "value" );
int iLoadoutPositionCount = ARRAYSIZE( s_loadout_position_names );
for ( int i=0; i<iLoadoutPositionCount; ++i )
{
const char *pszLoadoutPosition = s_loadout_position_names[i];
pLoadoutPositions->AddSubKey( new KeyValues( pszLoadoutPosition ) );
}
pRequiredKeys->AddSubKey( pLoadoutPositions );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestBasePlayerRestriction::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "value", GetValueString() );
pOutputKeys->SetString( "loadout_key", m_pszLoadoutKey );
}
private:
loadout_positions_t GetLoadoutPositionByName( const char *pszLoadoutPositionName )
{
int iLoadoutPositionCount = ARRAYSIZE( s_loadout_position_names );
for ( int i=0; i<iLoadoutPositionCount; ++i )
{
if ( FStrEq( pszLoadoutPositionName, s_loadout_position_names[i] ) )
{
return loadout_positions_t(i);
}
}
return LOADOUT_POSITION_INVALID;
}
virtual bool BPlayerCheck( const CTFPlayer* pPlayer, IGameEvent *pEvent ) const OVERRIDE
{
int iClass = pPlayer->GetPlayerClass()->GetClassIndex();
item_definition_index_t iItemDef = pEvent->GetInt( m_pszLoadoutKey, INVALID_ITEM_DEF_INDEX );
if ( iItemDef != INVALID_ITEM_DEF_INDEX )
{
GameItemDefinition_t *pDef = ItemSystem()->GetStaticDataForItemByDefIndex( iItemDef );
Assert( pDef );
if ( pDef )
{
return pDef->GetLoadoutSlot( iClass ) == m_eLoadoutPosition;
}
}
return false;
}
loadout_positions_t m_eLoadoutPosition;
const char* m_pszLoadoutKey;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFQuestLoadoutPositionRestriction, loadout_position, FIELD_PLAYER | FIELD_LOADOUT_POSITION );
//-----------------------------------------------------------------------------
// Purpose: quest player condition restriction
//-----------------------------------------------------------------------------
class CTFConditionQuestCondition : public CTFQuestRestriction
{
public:
CTFConditionQuestCondition()
: m_pszKeyName( NULL )
{}
virtual const char *GetValueString() const OVERRIDE
{
return GetTFConditionName( m_eCondition );
}
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
const char *pszKeyName = pKVItem->GetString( "condition_key", NULL );
SCHEMA_INIT_CHECK( pszKeyName != NULL, "Missing key_to_lookup in condition" );
const char *pszConditionName = pKVItem->GetString( "value" );
m_eCondition = GetTFConditionFromName( pszConditionName );
SCHEMA_INIT_CHECK( m_eCondition != TF_COND_INVALID, "%s", CFmtStr( "Invalid %s restriction '%s' for quest objective", GetConditionName(), pszConditionName ).Get() );
return true;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
KeyValues *pConditionsKey = new KeyValues( "value" );
for ( int i=0; i<TF_COND_LAST; ++i )
{
const char *pszConditionName = GetTFConditionName( ETFCond( i ) );
pConditionsKey->AddSubKey( new KeyValues( pszConditionName ) );
}
GetValidParamsKeyFromEvent( "condition_key", GetConditionName(), m_pszEventName, pRequiredKeys );
pRequiredKeys->AddSubKey( pConditionsKey );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
pOutputKeys->SetString( "value", GetValueString() );
pOutputKeys->SetString( "condition_key", m_pszKeyName );
}
private:
virtual bool PassesRestrictions( IGameEvent *pEvent ) const OVERRIDE
{
return pEvent->GetInt( m_pszKeyName ) == m_eCondition;
}
ETFCond m_eCondition;
const char *m_pszKeyName;
};
REGISTER_QUEST_CONDITION_SUB_CLASS( CTFConditionQuestCondition, condition, FIELD_CONDITION );
CTFQuestRestriction *CreateRestrictionByName( const char *pszName, CTFQuestCondition* pParent )
{
CTFQuestRestriction *pNewRestriction = NULL;
auto idx = k_mapConditions.Find( pszName );
if ( idx != k_mapConditions.InvalidIndex() )
{
pNewRestriction = static_cast<CTFQuestRestriction*>( k_mapConditions[ idx ]->m_pfnQuestCreate() );
pNewRestriction->SetFieldName( k_mapConditions[ idx ]->m_pszFieldName );
pNewRestriction->SetTypeName( k_mapConditions.Key( idx ) );
}
if ( pNewRestriction )
{
pNewRestriction->SetParent( pParent );
const char *pszEventName = pParent->GetEventName();
// in the case that parent has no event name (new node from editor)
// default the event name to the first valid event from the global event list
if ( !pszEventName )
{
KeyValues *pQuestEvents = GetQuestEventsKeyValues();
if ( pQuestEvents )
{
const KeyValues *pFirstKey = pQuestEvents->GetFirstTrueSubKey();
if ( pFirstKey )
{
pszEventName = pFirstKey->GetName();
}
}
}
pNewRestriction->SetEventName( pszEventName );
}
AssertMsg( pNewRestriction, "Invalid quest restriction type '%s'", pszName );
return pNewRestriction;
}
//-----------------------------------------------------------------------------
// Purpose: quest event
//-----------------------------------------------------------------------------
class CTFQuestEventListener : public CTFQuestEvaluator, public CGameEventListener
{
public:
DECLARE_CLASS( CTFQuestEventListener, CTFQuestEvaluator )
CTFQuestEventListener()
{
m_pRestrictions = NULL;
m_pszEventName = NULL;
m_pszOverrideScoreKeyName = NULL;
}
virtual ~CTFQuestEventListener()
{
if ( m_pRestrictions )
{
delete m_pRestrictions;
}
}
virtual const char *GetConditionName() const OVERRIDE { return "event_listener"; }
virtual const char *GetValueString() const OVERRIDE { return m_pszEventName; }
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestEvaluator::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_pszEventName = pKVItem->GetString( "event_name", NULL );
SCHEMA_INIT_CHECK( m_pszEventName != NULL, "%s", CFmtStr( "Invalid %s condition. Missing 'event_name'", GetConditionName() ).Get() );
#ifdef GAME_DLL // Only the server needs to listen for events
ListenForGameEvent( m_pszEventName );
#endif
m_pszOverrideScoreKeyName = pKVItem->GetString( "score_key_name", "none" );
SCHEMA_INIT_CHECK( m_pszOverrideScoreKeyName != NULL, "Missing score_key_name" );
FOR_EACH_TRUE_SUBKEY( pKVItem, pSubKey )
{
SCHEMA_INIT_CHECK( !m_pRestrictions, "%s", CFmtStr( "Too many input for operator '%s'.", GetConditionName() ).Get() );
const char *pszType = pSubKey->GetString( "type" );
m_pRestrictions = CreateRestrictionByName( pszType, this );
SCHEMA_INIT_CHECK( m_pRestrictions != NULL, "%s", CFmtStr( "Failed to create quest restriction name '%s' for '%s'", pszType, GetConditionName() ).Get() );
SCHEMA_INIT_CHECK( m_pRestrictions->BInitFromKV( pSubKey, pVecErrors ), "Failed to init from KeyValues" );
}
return true;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
BaseClass::IsValidForPlayer( pOwner, invalidReasons );
int nNumFound = 0;
for ( int i = 1; i <= gpGlobals->maxClients && nNumFound < s_nMinConnectedPlayersForQuestProgress; ++i )
{
#ifdef CLIENT_DLL
IGameResources *gr = GameResources();
if ( !gr || !gr->IsConnected( i ) )
continue;
#else
CBasePlayer* pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
#endif
++nNumFound;
}
if ( nNumFound < s_nMinConnectedPlayersForQuestProgress )
invalidReasons.m_bits.Set( INVALID_QUEST_REASON_NOT_ENOUGH_PLAYERS );
if ( m_pRestrictions )
{
m_pRestrictions->IsValidForPlayer( pOwner, invalidReasons );
}
return true;
}
virtual void FireGameEvent( IGameEvent *pEvent ) OVERRIDE
{
// This can happen when the player's SteamID isn't setup yet after a
// disconnect -> reconnect
if ( GetQuestOwner() == NULL )
return;
InvalidReasonsContainer_t invalidReasons;
IsValidForPlayer( GetQuestOwner(), invalidReasons );
if ( !invalidReasons.m_bits.IsAllClear() )
return;
const char *pszEventName = pEvent->GetName();
if ( FStrEq( m_pszEventName, pszEventName ) )
{
if ( !m_pRestrictions || m_pRestrictions->PassesRestrictions( pEvent ) )
{
int nScoreOverride = m_pszOverrideScoreKeyName ? pEvent->GetInt( m_pszOverrideScoreKeyName, 1 ) : 1;
EvaluateCondition( this, nScoreOverride );
}
}
}
virtual void EvaluateCondition( CTFQuestEvaluator *pSender, int nScore ) OVERRIDE
{
Assert( GetParent() && GetParent()->IsEvaluator() );
assert_cast< CTFQuestEvaluator* >( GetParent() )->EvaluateCondition( pSender, nScore ) ;
}
virtual void ResetCondition() OVERRIDE
{
// DO NOTHING
}
CTFQuestCondition* AddChildByName( const char *pszChildName ) OVERRIDE
{
if ( m_pRestrictions )
{
Assert( m_pRestrictions == NULL );
return NULL;
}
m_pRestrictions = CreateRestrictionByName( pszChildName, this );
Assert( m_pRestrictions );
return m_pRestrictions;
}
virtual int GetChildren( CUtlVector< CTFQuestCondition* >& vecChildren ) OVERRIDE
{
if ( m_pRestrictions )
{
vecChildren.AddToTail( m_pRestrictions );
return vecChildren.Count();
}
return 0;
}
bool RemoveAndDeleteChild( CTFQuestCondition *pChild ) OVERRIDE
{
bool bRemoved = m_pRestrictions == pChild;
Assert( bRemoved );
if ( bRemoved )
{
delete m_pRestrictions;
m_pRestrictions = NULL;
}
return bRemoved;
}
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestEvaluator::GetRequiredParamKeys( pRequiredKeys );
KeyValues *pQuestEvents = GetQuestEventsKeyValues();
if ( pQuestEvents )
{
KeyValues *pScoreKeys = new KeyValues( "score_key_name" );
KeyValues *pEventsKey = new KeyValues( "event_name" );
FOR_EACH_TRUE_SUBKEY( pQuestEvents, pSubKey )
{
const char *pszEventName = pSubKey->GetName();
pEventsKey->AddSubKey( new KeyValues( pszEventName ) );
if ( m_pszEventName && FStrEq( pszEventName, m_pszEventName ) )
{
KeyValues* pScoreSubKeys = pSubKey->FindKey( "score_keys" );
if ( pScoreSubKeys )
{
FOR_EACH_TRUE_SUBKEY( pScoreSubKeys, pScore )
{
pScoreKeys->AddSubKey( new KeyValues( pScore->GetName() ) );
}
}
}
}
pRequiredKeys->AddSubKey( pEventsKey );
if ( pScoreKeys->GetFirstTrueSubKey() )
{
pScoreKeys->AddSubKey( new KeyValues( "none" ) );
pRequiredKeys->AddSubKey( pScoreKeys );
}
}
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestEvaluator::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetString( "event_name", GetValueString() );
pOutputKeys->SetString( "score_key_name", m_pszOverrideScoreKeyName );
}
virtual const char* GetEventName() const OVERRIDE
{
return m_pszEventName;
}
virtual void SetEventName( const char *pszEventName ) OVERRIDE
{
m_pszEventName = pszEventName;
}
virtual int GetMaxInputCount() const { return 1; }
protected:
const char *m_pszEventName;
const char *m_pszOverrideScoreKeyName;
CTFQuestRestriction *m_pRestrictions;
};
//-----------------------------------------------------------------------------
// Purpose: count evaluator
//-----------------------------------------------------------------------------
class CTFQuestCountEvaluator : public CTFQuestEvaluator
{
public:
DECLARE_CLASS( CTFQuestCountEvaluator, CTFQuestEvaluator )
virtual ~CTFQuestCountEvaluator()
{
m_vecChildren.PurgeAndDeleteElements();
}
virtual const char *GetConditionName() const OVERRIDE { return "counter"; }
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ ) OVERRIDE
{
if ( !CTFQuestEvaluator::BInitFromKV( pKVItem, pVecErrors ) )
return false;
m_nStart = m_nCount = pKVItem->GetInt( "start" );
m_nEnd = pKVItem->GetInt( "end" );
FOR_EACH_TRUE_SUBKEY( pKVItem, pSubKey )
{
const char *pszType = pSubKey->GetString( "type" );
CTFQuestEvaluator *pNewCond = assert_cast< CTFQuestEvaluator* >( CreateEvaluatorByName( pszType, this ) );
SCHEMA_INIT_CHECK( pNewCond && pNewCond->BInitFromKV( pSubKey, pVecErrors ), "Failed to init from KeyValues" );
const char *pszAction = pSubKey->GetString( "action", NULL );
SCHEMA_INIT_CHECK( pszAction != NULL, "Missing action key" );
pNewCond->SetAction( pszAction );
m_vecChildren.AddToTail( pNewCond );
}
return true;
}
virtual bool IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
BaseClass::IsValidForPlayer( pOwner, invalidReasons );
bool bIsForLocalPlayer = false;
FOR_EACH_VEC( m_vecChildren, i )
{
bIsForLocalPlayer |= m_vecChildren[i]->IsValidForPlayer( pOwner, invalidReasons );
}
return bIsForLocalPlayer;
}
virtual void EvaluateCondition( CTFQuestEvaluator *pSender, int nScore ) OVERRIDE
{
const char *pszAction = pSender->GetAction();
if ( FStrEq( pszAction, "increment" ) )
{
m_nCount += nScore;
}
else if ( FStrEq( pszAction, "decrement" ) )
{
m_nCount -= nScore;
// Don't dip below 0!
m_nCount = Max( 0, m_nCount );
}
else if ( FStrEq( pszAction, "reset" ) )
{
m_nCount = 0;
}
else
{
AssertMsg( 0, "Invalid evaluation condition '%s' for '%s'", pSender->GetConditionName(), GetConditionName() );
}
// Check how many time over we've scored
int nNumScored = m_nCount / m_nEnd;
// Store the remainded
m_nCount -= ( nNumScored * m_nEnd );
if ( nNumScored > 0 )
{
Assert( GetParent() && GetParent()->IsEvaluator() );
assert_cast< CTFQuestEvaluator* >( GetParent() )->EvaluateCondition( this, nNumScored ) ;
}
}
virtual void ResetCondition() OVERRIDE
{
m_nCount = 0;
FOR_EACH_VEC( m_vecChildren, i )
{
m_vecChildren[i]->ResetCondition();
}
}
enum ECounterSubType
{
COUNTER_INCREMENT = 0,
COUNTER_DECREMENT,
COUNTER_RESET,
COUNTER_TYPE_COUNT
};
virtual int GetChildrenSubTypeCount() const { return COUNTER_TYPE_COUNT; }
virtual int GetChildren( CUtlVector< CTFQuestCondition* >& vecChildren ) OVERRIDE
{
for ( int i=0; i<m_vecChildren.Count(); ++i )
{
vecChildren.AddToTail( m_vecChildren[i] );
}
return vecChildren.Count();
}
bool RemoveAndDeleteChild( CTFQuestCondition *pChild ) OVERRIDE
{
CTFQuestEvaluator *pEvaluatorChild = assert_cast< CTFQuestEvaluator* >( pChild );
bool bRemoved = m_vecChildren.FindAndFastRemove( pEvaluatorChild );
Assert( bRemoved );
if ( bRemoved )
{
delete pChild;
}
return bRemoved;
}
CTFQuestCondition* AddChildByName( const char *pszChildName ) OVERRIDE
{
CTFQuestEvaluator *pNewEvaluator = CreateEvaluatorByName( pszChildName, this );
if ( pNewEvaluator )
{
m_vecChildren.AddToTail( pNewEvaluator );
}
return pNewEvaluator;
}
virtual int GetMaxInputCount() const { return s_nMaxInputCount; }
virtual void GetRequiredParamKeys( KeyValues *pRequiredKeys ) OVERRIDE
{
CTFQuestEvaluator::GetRequiredParamKeys( pRequiredKeys );
KeyValues* pKVCounts = pRequiredKeys->CreateNewKey();
pKVCounts->SetName( "end" );
pKVCounts->SetString( "control_type", "text_entry" );
}
virtual void GetOutputKeyValues( KeyValues *pOutputKeys ) OVERRIDE
{
CTFQuestEvaluator::GetOutputKeyValues( pOutputKeys );
pOutputKeys->SetInt( "end", m_nEnd );
}
virtual void GetValidChildren( CUtlVector< const char* >& vecOutValidChildren ) const OVERRIDE
{
vecOutValidChildren.AddToTail( "event_listener" );
vecOutValidChildren.AddToTail( "counter" );
}
private:
CUtlVector< CTFQuestEvaluator* > m_vecChildren;
int m_nCount;
int m_nStart;
int m_nEnd;
};
void CTFQuestEvaluator::GetRequiredParamKeys( KeyValues *pRequiredKeys )
{
if ( GetParent() && dynamic_cast< CTFQuestCountEvaluator* >( GetParent() ) )
{
KeyValues *pActionsKey = new KeyValues( "action" );
pActionsKey->AddSubKey( new KeyValues( "increment" ) );
pActionsKey->AddSubKey( new KeyValues( "decrement" ) );
pActionsKey->AddSubKey( new KeyValues( "reset" ) );
pRequiredKeys->AddSubKey( pActionsKey );
}
}
CTFQuestEvaluator *CreateEvaluatorByName( const char *pszName, CTFQuestCondition* pParent )
{
CTFQuestEvaluator *pNewEvaluator = NULL;
if ( FStrEq( pszName, "event_listener" ) )
{
pNewEvaluator = new CTFQuestEventListener;
}
else if ( FStrEq( pszName, "counter" ) )
{
pNewEvaluator = new CTFQuestCountEvaluator;
}
if ( pNewEvaluator )
{
pNewEvaluator->SetParent( pParent );
}
AssertMsg( pNewEvaluator, "Invalid quest evaluator type '%s'", pszName );
return pNewEvaluator;
}