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.
 
 
 
 
 
 

550 lines
19 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "quest_objective_manager.h"
#include "gcsdk/gcclient.h"
#include "gc_clientsystem.h"
#include "econ_quests.h"
#include "tf_gamerules.h"
#include "schemainitutils.h"
#include "econ_item_system.h"
#ifdef CLIENT_DLL
#include "quest_log_panel.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#if defined( DEBUG ) || defined( STAGING_ONLY )
ConVar tf_quests_commit_every_point( "tf_quests_commit_every_point", "0", FCVAR_REPLICATED );
ConVar tf_quests_progress_enabled( "tf_quests_progress_enabled", "1", FCVAR_REPLICATED );
#endif
CQuestObjectiveManager *QuestObjectiveManager( void )
{
static CQuestObjectiveManager g_QuestObjectiveManager;
return &g_QuestObjectiveManager;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseQuestObjectiveTracker::CBaseQuestObjectiveTracker( const CTFQuestObjectiveDefinition* pObjective, CQuestItemTracker* pParent )
: m_nObjectiveDefIndex( pObjective->GetDefinitionIndex() )
, m_pParent( pParent )
, m_pEvaluator( NULL )
{
KeyValues *pKVConditions = pObjective->GetConditionsKeyValues();
AssertMsg( !m_pEvaluator, "%s", CFmtStr( "Too many input for operator '%s'.", GetConditionName() ).Get() );
const char *pszType = pKVConditions->GetString( "type" );
m_pEvaluator = CreateEvaluatorByName( pszType, this );
AssertMsg( m_pEvaluator != NULL, "%s", CFmtStr( "Failed to create quest condition name '%s' for '%s'", pszType, GetConditionName() ).Get() );
SO_TRACKER_SPEW( CFmtStr( "Creating objective tracker def %d for quest def %d on item %llu for user %s\n",
pObjective->GetDefinitionIndex(),
pParent->GetItem()->GetItemDefinition()->GetDefinitionIndex(),
pParent->GetItem()->GetID(),
pParent->GetOwnerSteamID().Render() ),
SO_TRACKER_SPEW_OBJECTIVE_TRACKER_MANAGEMENT );
if ( !m_pEvaluator->BInitFromKV( pKVConditions, NULL ) )
{
AssertMsg( false, "Failed to init from KeyValues" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseQuestObjectiveTracker::~CBaseQuestObjectiveTracker()
{
if ( m_pEvaluator )
{
delete m_pEvaluator;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseQuestObjectiveTracker::IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
return m_pEvaluator->IsValidForPlayer( pOwner, invalidReasons );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const CTFPlayer *CBaseQuestObjectiveTracker::GetQuestOwner() const
{
return GetTrackedPlayer();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseQuestObjectiveTracker::EvaluateCondition( CTFQuestEvaluator *pSender, int nScore )
{
#ifdef GAME_DLL
// tracker should be the root
Assert( !GetParent() );
IncrementCount( nScore );
ResetCondition();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseQuestObjectiveTracker::ResetCondition()
{
m_pEvaluator->ResetCondition();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseQuestObjectiveTracker::UpdateConditions()
{
const CTFQuestObjectiveDefinition *pObjective = (CTFQuestObjectiveDefinition*)ItemSystem()->GetItemSchema()->GetQuestObjectiveByDefIndex( m_nObjectiveDefIndex );
if ( !pObjective )
return false;
// clean up previous evaluator
if ( m_pEvaluator )
{
delete m_pEvaluator;
m_pEvaluator = NULL;
}
CUtlVector< CUtlString > vecErrors;
return BInitFromKV( pObjective->GetConditionsKeyValues(), &vecErrors );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const CTFPlayer* CBaseQuestObjectiveTracker::GetTrackedPlayer() const
{
#ifdef CLIENT_DLL
return ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
#else
return m_pParent->GetTrackedPlayer();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseQuestObjectiveTracker::IncrementCount( int nIncrementValue )
{
const CTFQuestObjectiveDefinition *pObjective = (CTFQuestObjectiveDefinition*)ItemSystem()->GetItemSchema()->GetQuestObjectiveByDefIndex( m_nObjectiveDefIndex );
Assert( pObjective );
if ( !pObjective )
return;
uint32 nPointsToAdd = nIncrementValue * pObjective->GetPoints();
m_pParent->IncrementCount( nPointsToAdd, pObjective );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CQuestItemTracker::CQuestItemTracker( const CSharedObject* pItem, CSteamID SteamIDOwner, CSOTrackerManager* pManager )
: CBaseSOTracker( pItem, SteamIDOwner, pManager )
, m_pItem( NULL )
, m_nStandardPoints( 0 )
, m_nBonusPoints( 0 )
#ifdef GAME_DLL
, m_nStartingStandardPoints( 0 )
, m_nStartingBonusPoints( 0 )
#endif
{
m_pItem = assert_cast< const CEconItem* >( pItem );
// Retrieve starting numbers
UpdatePointsFromSOItem();
SO_TRACKER_SPEW( CFmtStr( "Creating tracker for quest %d on item %llu for user %s with %dsp and %dbp\n",
GetItem()->GetItemDefinition()->GetDefinitionIndex(),
GetItem()->GetID(),
GetOwnerSteamID().Render(),
GetEarnedStandardPoints(),
GetEarnedBonusPoints() ),
SO_TRACKER_SPEW_ITEM_TRACKER_MANAGEMENT );
// Create trackers for each objective
QuestObjectiveDefVec_t vecChosenObjectives;
m_pItem->GetItemDefinition()->GetQuestDef()->GetRolledObjectivesForItem( vecChosenObjectives, m_pItem );
FOR_EACH_VEC( vecChosenObjectives, i )
{
if ( !DoesObjectiveNeedToBeTracked( vecChosenObjectives[i] ) )
continue;
CBaseQuestObjectiveTracker* pNewTracker = new CBaseQuestObjectiveTracker( vecChosenObjectives[i], this );
m_vecObjectiveTrackers.AddToTail( pNewTracker );
}
if ( m_vecObjectiveTrackers.IsEmpty() )
{
SO_TRACKER_SPEW( CFmtStr( "Did not create any objective trackers for quest %d on item %llu for user %s with %dsp and %dbp\n",
GetItem()->GetItemDefinition()->GetDefinitionIndex(),
GetItem()->GetID(),
GetOwnerSteamID().Render(),
GetEarnedStandardPoints(),
GetEarnedBonusPoints() ),
SO_TRACKER_SPEW_OBJECTIVE_TRACKER_MANAGEMENT );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CQuestItemTracker::~CQuestItemTracker()
{
#ifdef CLIENT_DLL
SO_TRACKER_SPEW( CFmtStr( "Deleting tracker for quest %u on item %llu with %usp and %ubp\n",
m_pItem->GetItemDefinition()->GetDefinitionIndex(),
m_pItem->GetItemID(),
m_nStandardPoints,
m_nBonusPoints ),
SO_TRACKER_SPEW_ITEM_TRACKER_MANAGEMENT );
#else
SO_TRACKER_SPEW( CFmtStr( "Deleting tracker for quest %u on item %llu with %usp %ussp %ubp %usbp\n",
m_pItem->GetItemDefinition()->GetDefinitionIndex(),
m_pItem->GetItemID(),
m_nStandardPoints,
m_nStartingStandardPoints,
m_nBonusPoints,
m_nStartingBonusPoints ),
SO_TRACKER_SPEW_ITEM_TRACKER_MANAGEMENT );
#endif
m_vecObjectiveTrackers.PurgeAndDeleteElements();
}
//-----------------------------------------------------------------------------
// Purpose: Take a look at our item and update what we think our points are
// based on the attributes on the item IF they are greater. We NEVER
// want to lose progress for any reason.
//-----------------------------------------------------------------------------
void CQuestItemTracker::UpdatePointsFromSOItem()
{
uint32 nNewPoints = 0;
static CSchemaAttributeDefHandle pAttribDef_EarnedStandardPoints( "quest earned standard points" );
m_pItem->FindAttribute( pAttribDef_EarnedStandardPoints, &nNewPoints );
#ifdef GAME_DLL
m_nStartingStandardPoints = Max( nNewPoints, m_nStartingStandardPoints );
#else
m_nStandardPoints = Max( nNewPoints, m_nStandardPoints );
#endif
nNewPoints = 0;
static CSchemaAttributeDefHandle pAttribDef_EarnedBonusPoints( "quest earned bonus points" );
m_pItem->FindAttribute( pAttribDef_EarnedBonusPoints, &nNewPoints );
#ifdef GAME_DLL
m_nStartingBonusPoints = Max( nNewPoints, m_nStartingBonusPoints );
#else
m_nBonusPoints = Max( nNewPoints, m_nBonusPoints );
#endif
#ifdef GAME_DLL
SendUpdateToClient( NULL );
SO_TRACKER_SPEW( CFmtStr( "Updated points from item. CS:%d S:%d CB:%d B:%d\n", m_nStandardPoints, m_nStartingStandardPoints, m_nBonusPoints, m_nStartingBonusPoints ), SO_TRACKER_SPEW_OBJECTIVES );
#else
SO_TRACKER_SPEW( CFmtStr( "Updated points from item. S:%d B:%d\n", m_nStandardPoints, m_nBonusPoints ), SO_TRACKER_SPEW_OBJECTIVES );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const CBaseQuestObjectiveTracker* CQuestItemTracker::FindTrackerForDefIndex( uint32 nDefIndex ) const
{
FOR_EACH_VEC( m_vecObjectiveTrackers, i )
{
if ( m_vecObjectiveTrackers[ i ]->GetObjectiveDefIndex() == nDefIndex )
{
return m_vecObjectiveTrackers[ i ];
}
}
return NULL;
}
uint32 CQuestItemTracker::GetEarnedStandardPoints() const
{
#ifdef GAME_DLL
return m_nStartingStandardPoints + m_nStandardPoints;
#else
return m_nStandardPoints;
#endif
}
uint32 CQuestItemTracker::GetEarnedBonusPoints() const
{
#ifdef GAME_DLL
return m_nStartingBonusPoints + m_nBonusPoints;
#else
return m_nBonusPoints;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestItemTracker::IncrementCount( uint32 nIncrementValue, const CQuestObjectiveDefinition* pObjective )
{
#if defined( DEBUG ) || defined( STAGING_ONLY )
if ( !tf_quests_progress_enabled.GetBool() )
return;
#endif
#ifdef GAME_DLL
Assert( pObjective );
Assert( m_pItem );
if ( !pObjective || !m_pItem )
return;
auto pQuestDef = m_pItem->GetItemDefinition()->GetQuestDef();
Assert( pQuestDef );
if ( !pQuestDef )
return;
if ( g_pVGuiLocalize && ( g_nQuestSpewFlags & SO_TRACKER_SPEW_OBJECTIVES ) )
{
locchar_t loc_IntermediateName[ MAX_ITEM_NAME_LENGTH ];
locchar_t locValue[ MAX_ITEM_NAME_LENGTH ];
loc_sprintf_safe( locValue, LOCCHAR( "%d" ), pObjective->GetPoints() );
loc_scpy_safe( loc_IntermediateName, CConstructLocalizedString( g_pVGuiLocalize->Find( pObjective->GetDescriptionToken() ), locValue ) );
char szTempObjectiveName[256];
::ILocalize::ConvertUnicodeToANSI( loc_IntermediateName, szTempObjectiveName, sizeof( szTempObjectiveName ));
SO_TRACKER_SPEW( CFmtStr( "Increment for quest: %llu Objective: \"%s\" %d->%d (+%d)\n"
, m_pItem->GetItemID()
, szTempObjectiveName
, m_nStandardPoints + m_nBonusPoints
, m_nStandardPoints + m_nBonusPoints + nIncrementValue
, nIncrementValue ), SO_TRACKER_SPEW_OBJECTIVES );
}
// Regardless of standard or bonus, we fill the standard gauge first
uint32 nMaxStandardPoints = pQuestDef->GetMaxStandardPoints() - GetEarnedStandardPoints();
int nAmountToAdd = Min( nMaxStandardPoints, nIncrementValue );
m_nStandardPoints += nAmountToAdd;
nIncrementValue -= nAmountToAdd;
// If any bonus points left, fill in bonus points
if ( pObjective->IsAdvanced() && nIncrementValue > 0 )
{
uint32 nMaxBonusPoints = pQuestDef->GetMaxBonusPoints() + pQuestDef->GetMaxStandardPoints() - GetEarnedStandardPoints() - GetEarnedBonusPoints();
m_nBonusPoints += Min( nMaxBonusPoints, nIncrementValue );
}
bool bShouldCommit = IsQuestItemReadyToTurnIn( m_pItem );
#if defined( DEBUG ) || defined( STAGING_ONLY )
bShouldCommit |= tf_quests_commit_every_point.GetBool();
#endif
// Once we're over the turn-in threshhold, we need to record every point made.
if ( bShouldCommit )
{
CommitChangesToDB();
}
SendUpdateToClient( pObjective );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Remove and delete any objective trackers that are no longer needed.
// One is considered not needed if it's a tracker for a "standard"
// objective and we're done getting standard points, or if we're at
// full bonus points, then there's no way for us to get points anymore
//-----------------------------------------------------------------------------
void CQuestItemTracker::OnUpdate()
{
FOR_EACH_VEC_BACK( m_vecObjectiveTrackers, i )
{
const CQuestObjectiveDefinition *pObjective = GEconItemSchema().GetQuestObjectiveByDefIndex( m_vecObjectiveTrackers[ i ]->GetObjectiveDefIndex() );
Assert( pObjective );
if ( !pObjective || !DoesObjectiveNeedToBeTracked( pObjective ) )
{
delete m_vecObjectiveTrackers[ i ];
m_vecObjectiveTrackers.Remove( i );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestItemTracker::OnRemove()
{
#ifdef GAME_DLL
CommitRecord_t* pRecord = m_pManager->GetCommitRecord( m_pItem->GetItemID() );
if ( pRecord )
{
CMsgGCQuestObjective_PointsChange* pProto = assert_cast< CMsgGCQuestObjective_PointsChange* >( pRecord->m_pProtoMsg );
pProto->set_update_base_points( true );
}
#endif
}
void CQuestItemTracker::Spew() const
{
CBaseSOTracker::Spew();
FOR_EACH_VEC( m_vecObjectiveTrackers, i )
{
DevMsg( "Tracking objective: %d\n", m_vecObjectiveTrackers[ i ]->GetObjectiveDefIndex() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CQuestItemTracker::DoesObjectiveNeedToBeTracked( const CQuestObjectiveDefinition* pObjective ) const
{
auto pQuestDef = m_pItem->GetItemDefinition()->GetQuestDef();
Assert( pObjective );
if ( pObjective && pQuestDef )
{
// If there's standard points to be earned, all objectives need to be tracked
if ( pQuestDef->GetMaxStandardPoints() > 0 && GetEarnedStandardPoints() < pQuestDef->GetMaxStandardPoints() )
{
return true;
}
// If this objective is advanced, only track it if there's bonus points to be earned
if ( pObjective->IsAdvanced() )
{
return pQuestDef->GetMaxBonusPoints() > 0 && GetEarnedBonusPoints() < pQuestDef->GetMaxBonusPoints();
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestItemTracker::CommitChangesToDB()
{
#ifdef CLIENT_DLL
if ( GetQuestLog() && GetTrackedPlayer() == C_TFPlayer::GetLocalTFPlayer() )
{
GetQuestLog()->MarkQuestsDirty();
}
#else // GAME_DLL
// Nothing to commit? Bail
if ( m_nStandardPoints == 0 && m_nBonusPoints == 0 )
return;
SO_TRACKER_SPEW( CFmtStr( "CommitChangesToDB: %llu S:%d B:%d\n"
, m_pItem->GetItemID()
, GetEarnedStandardPoints()
, GetEarnedBonusPoints() ), 0 );
CSteamID ownerSteamID( m_pItem->GetAccountID(), GetUniverse(), k_EAccountTypeIndividual );
CMsgGCQuestObjective_PointsChange record;
// Cook up our message
record.set_owner_steamid( ownerSteamID.ConvertToUint64() );
record.set_quest_item_id( m_pItem->GetItemID() );
record.set_standard_points( GetEarnedStandardPoints() );
record.set_bonus_points( GetEarnedBonusPoints() ); // Here's the meat
m_pManager->AddCommitRecord( &record, record.quest_item_id(), true );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CQuestItemTracker::IsValidForPlayer( const CTFPlayer *pOwner, InvalidReasonsContainer_t& invalidReasons ) const
{
int nNumInvalid = 0;
FOR_EACH_VEC( m_vecObjectiveTrackers, i )
{
m_vecObjectiveTrackers[ i ]->IsValidForPlayer( pOwner, invalidReasons );
if ( !invalidReasons.IsValid() )
{
++nNumInvalid;
}
}
return nNumInvalid;
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: The server has changed scores. Apply those changes here
//-----------------------------------------------------------------------------
void CQuestItemTracker::UpdateFromServer( uint32 nStandardPoints, uint32 nBonusPoints )
{
SO_TRACKER_SPEW( CFmtStr( "Updating \"%s's\" standard points: %d->%d bonus points: %d->%d\n"
, m_pItem->GetItemDefinition()->GetQuestDef()->GetRolledNameForItem( m_pItem )
, m_nStandardPoints
, nStandardPoints
, m_nBonusPoints
, nBonusPoints )
, SO_TRACKER_SPEW_OBJECTIVES );
m_nStandardPoints = nStandardPoints;
m_nBonusPoints = nBonusPoints;
}
#else
void CQuestItemTracker::SendUpdateToClient( const CQuestObjectiveDefinition* pObjective )
{
const CTFPlayer* pPlayer = GetTrackedPlayer();
// They might've disconnected, so let's check if they're still around
if ( pPlayer )
{
// Update the user on their progress
CSingleUserRecipientFilter filter( GetTrackedPlayer() );
filter.MakeReliable();
UserMessageBegin( filter, "QuestObjectiveCompleted" );
itemid_t nID = m_pItem->GetItemID();
WRITE_BITS( &nID, 64 );
WRITE_WORD( GetEarnedStandardPoints() );
WRITE_WORD( GetEarnedBonusPoints() );
WRITE_WORD( pObjective ? pObjective->GetDefinitionIndex() : (uint32)-1 );
MessageEnd();
}
}
#endif
#if defined( DEBUG ) || defined( STAGING_ONLY )
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestItemTracker::DBG_CompleteQuest()
{
#ifdef GAME_DLL
auto pQuestDef = m_pItem->GetItemDefinition()->GetQuestDef();
uint32 nStandardPointsDelta = pQuestDef->GetMaxStandardPoints() - GetEarnedStandardPoints();
// Cheat!
if ( m_vecObjectiveTrackers.Count() )
{
const_cast< CBaseQuestObjectiveTracker* >( m_vecObjectiveTrackers[0] )->EvaluateCondition( NULL, nStandardPointsDelta );
}
CommitChangesToDB();
#endif
}
#endif