1174 lines
37 KiB
C++
1174 lines
37 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Shared interface to the tech tree & individual technologies
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
|
|
#ifndef CLIENT_DLL
|
|
#include "tf_player.h"
|
|
#include "tf_team.h"
|
|
#include "info_customtech.h"
|
|
#endif
|
|
#include "techtree.h"
|
|
|
|
bool ParseTechnologyFile( CUtlVector< CBaseTechnology* > &pTechnologyList, IFileSystem* pFileSystem, int nTeamNumber, char *sFileName );
|
|
|
|
// Color codes for resources
|
|
rescolor sResourceColor = { 64, 255, 64 };
|
|
|
|
// Prototype names for resources
|
|
char sResourceName[] = "Jojierium";
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBaseTechnology::CBaseTechnology( void )
|
|
{
|
|
m_nTechLevel = 0;
|
|
ZeroPreferences();
|
|
SetAvailable( false );
|
|
SetActive( false );
|
|
SetPreferred( false );
|
|
SetVoters( 0 );
|
|
SetCost( 0 );
|
|
SetDirty( false );
|
|
m_fResourceLevel = 0;
|
|
memset( m_ClassResults, 0, sizeof( m_ClassResults ) );
|
|
memset( m_pszName, 0, sizeof( m_pszName ) );
|
|
memset( m_pszPrintName, 0, sizeof( m_pszPrintName ) );
|
|
memset( m_pszDescription, 0, sizeof( m_pszDescription ) );
|
|
memset( m_pszTeamSoundFile, 0, sizeof( m_pszTeamSoundFile ) );
|
|
memset( m_apszContainedTechs, 0, sizeof( m_apszContainedTechs ) );
|
|
memset( m_pContainedTechs, 0, sizeof(m_pContainedTechs) );
|
|
memset( m_apszDependentTechs, 0, sizeof( m_apszDependentTechs ) );
|
|
memset( m_pDependentTechs, 0, sizeof(m_pDependentTechs) );
|
|
m_iContainedTechs = 0;
|
|
m_iDependentTechs = 0;
|
|
m_iTeamSound = 0;
|
|
m_bGoalTechnology = false;
|
|
m_bClassUpgrade = false;
|
|
m_bVehicle = false;
|
|
m_bTechLevelUpgrade = false;
|
|
m_bResourceTech = false;
|
|
|
|
memset( m_szTextureName, 0, sizeof( m_szTextureName ) );
|
|
m_nTextureID = 0;
|
|
|
|
memset( m_szButtonName, 0, sizeof( m_szButtonName ) );
|
|
|
|
m_nNumWeaponAssociations = 0;
|
|
memset( m_rgszWeaponAssociation, 0, sizeof( m_rgszWeaponAssociation ) );
|
|
|
|
SetHidden( false );
|
|
ResetHintsGiven();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBaseTechnology::~CBaseTechnology( void )
|
|
{
|
|
}
|
|
|
|
static bool NameStartsWith( const char *name, const char *prefix )
|
|
{
|
|
if ( !name || !name[ 0 ] || !prefix || !prefix[ 0 ] )
|
|
return false;
|
|
|
|
if ( !strnicmp( name, prefix, strlen( prefix ) ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the technology name
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetName( const char *pName )
|
|
{
|
|
Q_strncpy( m_pszName, pName, sizeof(m_pszName) );
|
|
|
|
// Determine special information about this technology
|
|
m_bClassUpgrade = NameStartsWith( pName, "class_" );
|
|
m_bVehicle = NameStartsWith( pName, "vehicle_" );
|
|
m_bTechLevelUpgrade = NameStartsWith( pName, "tech_level_" );
|
|
// HACK: Assume global techs relate to resources for now
|
|
m_bResourceTech = NameStartsWith( pName, "g_" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the technology print name
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetPrintName( const char *pName )
|
|
{
|
|
Q_strncpy( m_pszPrintName, pName, sizeof(m_pszPrintName) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the technology description
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetDescription( const char *pDesc )
|
|
{
|
|
Q_strncpy( m_pszDescription, pDesc, sizeof(m_pszDescription) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pName -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetButtonName( const char *pName )
|
|
{
|
|
Q_strncpy( m_szButtonName, pName, sizeof(m_szButtonName) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the technology level
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetLevel( int iLevel )
|
|
{
|
|
m_nTechLevel = iLevel;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *texture -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetTextureName( const char *texture )
|
|
{
|
|
Q_strncpy( m_szTextureName, texture, sizeof( m_szTextureName ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : id -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetTextureId( int id )
|
|
{
|
|
m_nTextureID = id;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the technologies resource costs
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetCost( float fResourceCost )
|
|
{
|
|
m_fResourceCost = fResourceCost;
|
|
|
|
RecalculateOverallLevel();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set a specific class's sound
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetClassResultSound( int iClass, const char *pSound )
|
|
{
|
|
if (!pSound)
|
|
return;
|
|
|
|
Assert( iClass >= 0 && iClass < TFCLASS_CLASS_COUNT );
|
|
|
|
// Class of 0 is the team's sound file
|
|
if ( iClass == 0 )
|
|
{
|
|
Q_strncpy( m_pszTeamSoundFile, pSound, sizeof(m_pszTeamSoundFile) );
|
|
}
|
|
else
|
|
{
|
|
m_ClassResults[iClass].bClassTouched = true;
|
|
Q_strncpy( m_ClassResults[iClass].pszSoundFile, pSound, sizeof(m_ClassResults[iClass].pszSoundFile) );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : associate -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetClassResultAssociateWeapons( int iClass, bool associate )
|
|
{
|
|
Assert( iClass >= 0 && iClass < TFCLASS_CLASS_COUNT );
|
|
|
|
m_ClassResults[iClass].m_bAssociateWeaponsForClass = associate;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set a specific class's precached sound
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetClassResultSound( int iClass, int iSound )
|
|
{
|
|
Assert( iClass >= 0 && iClass < TFCLASS_CLASS_COUNT );
|
|
|
|
// Class of 0 is the team's sound file
|
|
if ( iClass == 0 )
|
|
{
|
|
m_iTeamSound = iSound;
|
|
}
|
|
else
|
|
{
|
|
m_ClassResults[iClass].iSound = iSound;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set a specific class's description
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetClassResultDescription( int iClass, const char *pDesc )
|
|
{
|
|
if (!pDesc)
|
|
return;
|
|
|
|
Assert( iClass > 0 && iClass < TFCLASS_CLASS_COUNT );
|
|
m_ClassResults[iClass].bClassTouched = true;
|
|
|
|
Q_strncpy( m_ClassResults[iClass].pszDescription, pDesc, sizeof(m_ClassResults[iClass].pszDescription) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Add a technology contained within this one
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::AddContainedTechnology( const char *pszTech )
|
|
{
|
|
Q_strncpy( m_apszContainedTechs[ m_iContainedTechs ], pszTech, sizeof(m_apszContainedTechs[0]) );
|
|
m_iContainedTechs++;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Add a technology dependency within this one
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::AddDependentTechnology( const char *pszTech )
|
|
{
|
|
Q_strncpy( m_apszDependentTechs[ m_iDependentTechs ], pszTech, sizeof(m_apszDependentTechs[0]) );
|
|
m_iDependentTechs++;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns true if this technology affects the specified class
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::AffectsClass( int iClass )
|
|
{
|
|
// If this technology directly affects this class, return true
|
|
if ( m_ClassResults[ iClass ].bClassTouched )
|
|
return true;
|
|
|
|
// If not, do any of our contained techs affect the specified class
|
|
for (int i = 0; i < m_iContainedTechs; i++ )
|
|
{
|
|
if ( m_pContainedTechs[i] )
|
|
{
|
|
if ( m_pContainedTechs[i]->AffectsClass( iClass ) )
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::IsClassUpgrade( void )
|
|
{
|
|
return m_bClassUpgrade;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::IsVehicle( void )
|
|
{
|
|
return m_bVehicle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::IsResourceTech( void )
|
|
{
|
|
return m_bResourceTech;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::IsTechLevelUpgrade( void )
|
|
{
|
|
return m_bTechLevelUpgrade;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the level to which this technology belongs
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetLevel( void )
|
|
{
|
|
return m_nTechLevel;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Cost of technology in resource specified
|
|
//-----------------------------------------------------------------------------
|
|
float CBaseTechnology::GetResourceCost( void )
|
|
{
|
|
return m_fResourceCost;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieves the current amount of resources spent on the technology
|
|
//-----------------------------------------------------------------------------
|
|
float CBaseTechnology::GetResourceLevel( void )
|
|
{
|
|
return m_fResourceLevel;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets a resource level to an amount
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetResourceLevel( float flResourceLevel )
|
|
{
|
|
if ( m_fResourceLevel == flResourceLevel )
|
|
return;
|
|
|
|
m_fResourceLevel = flResourceLevel;
|
|
|
|
// Update my level & watchers
|
|
RecalculateOverallLevel();
|
|
UpdateWatchers();
|
|
|
|
// Force me to be resent to clients
|
|
SetDirty( true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Increase the level of the specified resource spent on this technology
|
|
// Output : Returns true if the technology's had enough resources to be bought
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::IncreaseResourceLevel( float flResourcesToSpend )
|
|
{
|
|
SetResourceLevel( m_fResourceLevel + flResourcesToSpend );
|
|
|
|
// Have my costs been met?
|
|
if ( GetResourceLevel() < GetResourceCost() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Figure out my overall owned percentage
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::RecalculateOverallLevel( void )
|
|
{
|
|
if ( !GetResourceCost() )
|
|
{
|
|
m_flOverallOwnedPercentage = 0;
|
|
}
|
|
else
|
|
{
|
|
m_flOverallOwnedPercentage = GetResourceLevel() / GetResourceCost();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
float CBaseTechnology::GetOverallLevel( void )
|
|
{
|
|
return m_flOverallOwnedPercentage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Force this technology to complete itself
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::ForceComplete( void )
|
|
{
|
|
SetResourceLevel( GetResourceCost() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::IsAGoalTechnology( void )
|
|
{
|
|
return m_bGoalTechnology;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetGoalTechnology( bool bGoal )
|
|
{
|
|
m_bGoalTechnology = bGoal;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the name of this technology
|
|
// Output : const
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetName( void )
|
|
{
|
|
return m_pszName;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns printable name of this technology
|
|
// Output : const
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetPrintName( void )
|
|
{
|
|
return m_pszPrintName;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : const char
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetButtonName( void )
|
|
{
|
|
return m_szButtonName;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : const char
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetTextureName(void )
|
|
{
|
|
return m_szTextureName;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetTextureId( void )
|
|
{
|
|
return m_nTextureID;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns description for item
|
|
// Output : const char
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetDescription( int iPlayerClass )
|
|
{
|
|
// If we have a custom description for the local player's class, return that instead
|
|
if ( AffectsClass( iPlayerClass ) )
|
|
{
|
|
if ( m_ClassResults[iPlayerClass].pszDescription )
|
|
return m_ClassResults[iPlayerClass].pszDescription;
|
|
}
|
|
|
|
// Otherwise, return the general description
|
|
return m_pszDescription;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns sound filename to play for this technology
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetSoundFile( int iClass )
|
|
{
|
|
// Class of 0 is the team sound
|
|
if ( !iClass )
|
|
return m_pszTeamSoundFile;
|
|
|
|
Assert(iClass > 0 && iClass < TFCLASS_CLASS_COUNT );
|
|
return m_ClassResults[iClass].pszSoundFile;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns sound to play for this technology
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetSound( int iClass )
|
|
{
|
|
// Class of 0 is the team sound
|
|
if ( !iClass )
|
|
return m_iTeamSound;
|
|
|
|
Assert(iClass > 0 && iClass < TFCLASS_CLASS_COUNT );
|
|
return m_ClassResults[iClass].iSound;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : iClass -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::GetAssociateWeaponsForClass( int iClass )
|
|
{
|
|
if ( !iClass )
|
|
return false;
|
|
|
|
Assert(iClass > 0 && iClass < TFCLASS_CLASS_COUNT );
|
|
return m_ClassResults[iClass].m_bAssociateWeaponsForClass;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns whether the technology is available to the team
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetAvailable( bool state )
|
|
{
|
|
if ( state != m_bAvailable )
|
|
{
|
|
SetDirty( true );
|
|
}
|
|
|
|
m_bAvailable = state;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determine whether team posses the technology
|
|
// Output : Returns 1 if available, 0 otherwise
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetAvailable( void )
|
|
{
|
|
return m_bAvailable;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Zero out team preference counters
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::ZeroPreferences( void )
|
|
{
|
|
if ( m_nPreferenceCount )
|
|
{
|
|
SetDirty( true );
|
|
}
|
|
|
|
m_nPreferenceCount = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Increment preference counter
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::IncrementPreferences( void )
|
|
{
|
|
m_nPreferenceCount++;
|
|
SetDirty( true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieve preference count
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetPreferenceCount( void )
|
|
{
|
|
return m_nPreferenceCount;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetNumWeaponAssociations( void )
|
|
{
|
|
return m_nNumWeaponAssociations;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : char const
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetAssociatedWeapon( int index )
|
|
{
|
|
if ( index < 0 || index >= m_nNumWeaponAssociations )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
return m_rgszWeaponAssociation[ index ];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *weaponname -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::AddAssociatedWeapon( const char *weaponname )
|
|
{
|
|
if ( m_nNumWeaponAssociations >= MAX_ASSOCIATED_WEAPONS )
|
|
{
|
|
Assert( !"CBaseTechnology::AddAssociatedWeapon: m_nNumWeaponAssociations >= MAX_ASSOCIATED_WEAPONS" );
|
|
return;
|
|
}
|
|
Q_strncpy( m_rgszWeaponAssociation[ m_nNumWeaponAssociations++ ], weaponname, TECHNOLOGY_WEAPONNAME_LENGTH );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetNumberContainedTechs( void )
|
|
{
|
|
return m_iContainedTechs;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetContainedTechName( int iTech )
|
|
{
|
|
Assert( iTech >= 0 && iTech < m_iContainedTechs );
|
|
return m_apszContainedTechs[ iTech ];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetContainedTech( int iTech, CBaseTechnology *pTech )
|
|
{
|
|
Assert( iTech >= 0 && iTech < m_iContainedTechs );
|
|
m_pContainedTechs[iTech] = pTech;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetNumberDependentTechs( void )
|
|
{
|
|
return m_iDependentTechs;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBaseTechnology::GetDependentTechName( int iTech )
|
|
{
|
|
Assert( iTech >= 0 && iTech < m_iDependentTechs );
|
|
return m_apszDependentTechs[ iTech ];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetDependentTech( int iTech, CBaseTechnology *pTech )
|
|
{
|
|
Assert( iTech >= 0 && iTech < m_iDependentTechs );
|
|
Assert( pTech );
|
|
m_pDependentTechs[iTech] = pTech;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return true if this tech depends on the specified tech
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::DependsOn( CBaseTechnology *pTech )
|
|
{
|
|
for ( int i = 0; i < GetNumberDependentTechs(); i++ )
|
|
{
|
|
if ( m_pDependentTechs[i] == pTech )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return true if this tech has a dependent tech that's not been completed yet
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::HasInactiveDependencies( void )
|
|
{
|
|
for ( int i = 0; i < GetNumberDependentTechs(); i++ )
|
|
{
|
|
// This condition can occur if there's a bug in the .txt file
|
|
// where a tech is told to depend on a non-existent tech
|
|
if (!m_pDependentTechs[i])
|
|
continue;
|
|
|
|
// Client uses m_bActive, Server uses m_bAvailable (?)
|
|
if ( m_pDependentTechs[i]->GetAvailable() == false && m_pDependentTechs[i]->GetActive() == false )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Dirty bit, used for fast knowledge of when to resend techs
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::IsDirty( void )
|
|
{
|
|
return m_bDirty;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetDirty( bool bDirty )
|
|
{
|
|
m_bDirty = bDirty;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set availability state for item
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetActive( bool state )
|
|
{
|
|
m_bActive = state;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieve availability state
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::GetActive( void )
|
|
{
|
|
return m_bActive;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set whether this is our local preferred item
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetPreferred( bool state )
|
|
{
|
|
m_bPreferred = state;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieve local preferred state
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::GetPreferred( void )
|
|
{
|
|
return m_bPreferred;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the number of players preferring this tech
|
|
// Input : voters -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetVoters( int voters )
|
|
{
|
|
m_nVoters = voters;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the number of players preferring this tech
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseTechnology::GetVoters( void )
|
|
{
|
|
return m_nVoters;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : hide -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetHidden( bool hide )
|
|
{
|
|
m_bHidden = hide;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::IsHidden( void )
|
|
{
|
|
return m_bHidden;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::ResetHintsGiven( void )
|
|
{
|
|
m_HintsGiven.RemoveAll();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseTechnology::GetHintsGiven( int type )
|
|
{
|
|
if ( m_HintsGiven.Find( type ) != m_HintsGiven.InvalidIndex() )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : given -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::SetHintsGiven( int type, bool given )
|
|
{
|
|
if ( given )
|
|
{
|
|
if ( m_HintsGiven.Find( type ) != m_HintsGiven.InvalidIndex() )
|
|
return;
|
|
|
|
m_HintsGiven.AddToTail( type );
|
|
}
|
|
else
|
|
{
|
|
int idx = m_HintsGiven.Find( type );
|
|
if ( idx == m_HintsGiven.InvalidIndex() )
|
|
return;
|
|
|
|
m_HintsGiven.Remove( idx );
|
|
}
|
|
}
|
|
|
|
//====================================================================================================================
|
|
// EVIL GAME DLL ONLY CODE FOR TECHNOLOGIES
|
|
//====================================================================================================================
|
|
#ifndef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::AddTechnologyToPlayer( CBaseTFPlayer *pPlayer )
|
|
{
|
|
// Tell playerclasses listed to recalculate their technologies, only if they're listed in the class results
|
|
if ( pPlayer->PlayerClass() )
|
|
{
|
|
if ( m_ClassResults[ pPlayer->PlayerClass() ].bClassTouched )
|
|
{
|
|
CPlayerClass *pPlayerClass = pPlayer->GetPlayerClass();
|
|
pPlayerClass->GainedNewTechnology( this );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::AddTechnologyToTeam( CTFTeam *pTeam )
|
|
{
|
|
SetAvailable( true );
|
|
|
|
// Enable all the technologies this group contains
|
|
if ( m_iContainedTechs )
|
|
{
|
|
for (int i = 0; i < m_iContainedTechs; i++ )
|
|
{
|
|
if ( m_pContainedTechs[i] )
|
|
{
|
|
pTeam->EnableTechnology( m_pContainedTechs[i] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A technology watcher entity wants to register as a watcher for this technology
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::RegisterWatcher( CInfoCustomTechnology *pWatcher )
|
|
{
|
|
m_aWatchers.AddToTail( pWatcher );
|
|
pWatcher->UpdateTechPercentage( 0 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::UpdateWatchers( void )
|
|
{
|
|
// Tell all my watchers
|
|
for (int i = 0; i < m_aWatchers.Size(); i++ )
|
|
{
|
|
m_aWatchers[i]->UpdateTechPercentage( GetOverallLevel() );
|
|
}
|
|
}
|
|
#else
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Client DLL UpdateWatchers does nothing
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseTechnology::UpdateWatchers( void )
|
|
{
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//====================================================================================================================
|
|
// SHARED TECHNOLOGY TREE
|
|
//====================================================================================================================
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Construct raw technology tree
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
CTechnologyTree::CTechnologyTree( IFileSystem* pFileSystem, int nTeamNumber )
|
|
{
|
|
// Reset preference counter
|
|
ClearPreferenceCount();
|
|
|
|
// Parse the list from the data file
|
|
if ( ParseTechnologyFile( m_Technologies, pFileSystem, nTeamNumber, "scripts/technologytree.txt" ) == false )
|
|
{
|
|
Assert(0);
|
|
return;
|
|
}
|
|
|
|
LinkContainedTechnologies();
|
|
LinkDependentTechnologies();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Link all the contained technologies
|
|
//-----------------------------------------------------------------------------
|
|
void CTechnologyTree::LinkContainedTechnologies( void )
|
|
{
|
|
for ( int i=0; i < m_Technologies.Size(); i++)
|
|
{
|
|
for ( int j = 0; j < m_Technologies[i]->GetNumberContainedTechs(); j++ )
|
|
{
|
|
const char *pName = m_Technologies[i]->GetContainedTechName( j );
|
|
CBaseTechnology *pTech = GetTechnology( pName );
|
|
if ( pTech )
|
|
{
|
|
m_Technologies[i]->SetContainedTech( j, pTech );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Link all the dependent technologies
|
|
//-----------------------------------------------------------------------------
|
|
void CTechnologyTree::LinkDependentTechnologies( void )
|
|
{
|
|
for ( int i=0; i < m_Technologies.Size(); i++)
|
|
{
|
|
for ( int j = 0; j < m_Technologies[i]->GetNumberDependentTechs(); j++ )
|
|
{
|
|
const char *pName = m_Technologies[i]->GetDependentTechName( j );
|
|
CBaseTechnology *pTech = GetTechnology( pName );
|
|
if ( pTech )
|
|
{
|
|
m_Technologies[i]->SetDependentTech( j, pTech );
|
|
}
|
|
else
|
|
{
|
|
Warning("Unable to find dependent technology %s!\n", pName );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CTechnologyTree::~CTechnologyTree( void )
|
|
{
|
|
Shutdown();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Delete all items in the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CTechnologyTree::Shutdown( void )
|
|
{
|
|
// Loop through all used items
|
|
int iSize = m_Technologies.Size();
|
|
for ( int i = iSize-1; i >= 0; i-- )
|
|
{
|
|
CBaseTechnology *pItem = m_Technologies[ i ];
|
|
delete pItem;
|
|
}
|
|
m_Technologies.Purge();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Add a new technology to the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CTechnologyTree::AddTechnologyFile( IFileSystem* pFileSystem, int nTeamNumber, char *sFileName )
|
|
{
|
|
ParseTechnologyFile( m_Technologies, pFileSystem, nTeamNumber, sFileName );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the index of the specified item
|
|
//-----------------------------------------------------------------------------
|
|
int CTechnologyTree::GetIndex( CBaseTechnology *pItem )
|
|
{
|
|
for ( int i=0; i < m_Technologies.Size(); i++)
|
|
{
|
|
if ( m_Technologies[i] == pItem )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieve item by index
|
|
//-----------------------------------------------------------------------------
|
|
CBaseTechnology *CTechnologyTree::GetTechnology( int index )
|
|
{
|
|
if ( index < 0 || index >= m_Technologies.Size() )
|
|
return NULL;
|
|
|
|
return m_Technologies[ index ];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBaseTechnology* CTechnologyTree::GetTechnology( const char *pName )
|
|
{
|
|
for ( int i=0; i < m_Technologies.Size(); i++)
|
|
{
|
|
if( stricmp( pName, m_Technologies[i]->GetName() ) == 0 )
|
|
return m_Technologies[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return current number of objects
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CTechnologyTree::GetNumberTechnologies( void )
|
|
{
|
|
return m_Technologies.Size();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set preferred item ( turns off all other preferences first )
|
|
//-----------------------------------------------------------------------------
|
|
void CTechnologyTree::SetPreferredTechnology( CBaseTechnology *pItem )
|
|
{
|
|
// Turn all of the others off
|
|
for ( int i = 0; i < m_Technologies.Size(); i++ )
|
|
{
|
|
CBaseTechnology *item = m_Technologies[ i ];
|
|
item->SetPreferred( false );
|
|
}
|
|
|
|
// Turn this one on
|
|
if ( pItem )
|
|
{
|
|
pItem->SetPreferred( true );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the technology preferred by this client
|
|
//-----------------------------------------------------------------------------
|
|
CBaseTechnology* CTechnologyTree::GetPreferredTechnology( void )
|
|
{
|
|
// Turn all of the others off
|
|
for ( int i = 0; i < m_Technologies.Size(); i++ )
|
|
{
|
|
CBaseTechnology *item = m_Technologies[ i ];
|
|
if ( item->GetPreferred() )
|
|
return item;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the number of players who've voted on techs
|
|
//-----------------------------------------------------------------------------
|
|
int CTechnologyTree::GetPreferenceCount( void )
|
|
{
|
|
return m_nPreferenceCount;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Zero global preference counters
|
|
//-----------------------------------------------------------------------------
|
|
void CTechnologyTree::ClearPreferenceCount( void )
|
|
{
|
|
m_nPreferenceCount = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Increment preference counter
|
|
//-----------------------------------------------------------------------------
|
|
void CTechnologyTree::IncrementPreferences( void )
|
|
{
|
|
m_nPreferenceCount++;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the most voted-for technologies
|
|
// Input : iDesireLevel: 1 = Most voted for, 2 = 2nd most voted for, etc
|
|
//-----------------------------------------------------------------------------
|
|
CBaseTechnology *CTechnologyTree::GetDesiredTechnology( int iDesireLevel )
|
|
{
|
|
Assert( iDesireLevel > 0 && iDesireLevel < m_Technologies.Size() );
|
|
|
|
// Dump the techs into a temporary array
|
|
CBaseTechnology *pSortedTechs[ MAX_TECHNOLOGIES ];
|
|
int iMaxTech = 0;
|
|
for ( int i = 0; i < m_Technologies.Size(); i++ )
|
|
{
|
|
// Skip Techs that are already available
|
|
CBaseTechnology *technology = m_Technologies[i];
|
|
if(!technology)
|
|
continue;
|
|
|
|
if ( technology->GetAvailable() == false )
|
|
{
|
|
pSortedTechs[iMaxTech] = m_Technologies[i];
|
|
iMaxTech++;
|
|
}
|
|
}
|
|
|
|
// Not enough unresearched techs?
|
|
if ( iMaxTech < iDesireLevel )
|
|
return NULL;
|
|
|
|
// Bubble sort the tech array into order of desire
|
|
int swapped = 1;
|
|
while ( swapped )
|
|
{
|
|
swapped = 0;
|
|
for ( int i = 1; i < iMaxTech; i++ )
|
|
{
|
|
if ( pSortedTechs[i]->GetPreferenceCount() > pSortedTechs[i-1]->GetPreferenceCount() )
|
|
{
|
|
CBaseTechnology *pTemp = pSortedTechs[i];
|
|
pSortedTechs[i] = pSortedTechs[i-1];
|
|
pSortedTechs[i-1] = pTemp;
|
|
swapped = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pSortedTechs[ iDesireLevel - 1 ];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find out what percentage of techs in a given level this team owns
|
|
//-----------------------------------------------------------------------------
|
|
float CTechnologyTree::GetPercentageOfTechLevelOwned( int iTechLevel )
|
|
{
|
|
float fTotalTechs = 0;
|
|
float fTechsOwned = 0;
|
|
|
|
for ( int i = 0; i < m_Technologies.Size(); i++ )
|
|
{
|
|
CBaseTechnology *technology = m_Technologies[i];
|
|
if ( !technology )
|
|
continue;
|
|
|
|
if ( technology->GetLevel() != iTechLevel )
|
|
continue;
|
|
|
|
fTotalTechs++;
|
|
|
|
// Do we have it?
|
|
if ( technology->GetAvailable() )
|
|
{
|
|
fTechsOwned++;
|
|
}
|
|
}
|
|
|
|
if ( !fTotalTechs )
|
|
return 0.0;
|
|
|
|
return ( fTechsOwned / fTotalTechs );
|
|
}
|