606 lines
19 KiB
C++
606 lines
19 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Data shared between the client & game dlls
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include "tf_shareddefs.h"
|
|
#include "tier0/dbg.h"
|
|
#include "basetypes.h"
|
|
#include <KeyValues.h>
|
|
|
|
#ifndef CLIENT_DLL
|
|
|
|
#include "tf_team.h"
|
|
#include "tf_class_commando.h"
|
|
#include "tf_class_defender.h"
|
|
#include "tf_class_escort.h"
|
|
#include "tf_class_infiltrator.h"
|
|
#include "tf_class_medic.h"
|
|
#include "tf_class_recon.h"
|
|
#include "tf_class_sniper.h"
|
|
#include "tf_class_support.h"
|
|
#include "tf_class_sapper.h"
|
|
#include "tf_class_pyro.h"
|
|
|
|
#else
|
|
|
|
#include "c_tfteam.h"
|
|
#include "c_tf_class_commando.h"
|
|
#include "c_tf_class_defender.h"
|
|
#include "c_tf_class_escort.h"
|
|
#include "c_tf_class_infiltrator.h"
|
|
#include "c_tf_class_medic.h"
|
|
#include "c_tf_class_recon.h"
|
|
#include "c_tf_class_sniper.h"
|
|
#include "c_tf_class_support.h"
|
|
#include "c_tf_class_sapper.h"
|
|
#include "c_tf_class_pyro.h"
|
|
|
|
#define CTFTeam C_TFTeam
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
ConVar inv_demo( "inv_demo","0", FCVAR_REPLICATED, "Invasion demo." );
|
|
ConVar lod_effect_distance( "lod_effect_distance","3240000", FCVAR_REPLICATED, "Distance at which effects LOD." );
|
|
ConVar tf_cheapobjects( "tf_cheapobjects","0", FCVAR_REPLICATED, "Set to 1 and all objects will cost 0" );
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// OBJECTS
|
|
//--------------------------------------------------------------------------
|
|
static int g_iClassInfo_Undecided[] =
|
|
{
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Recon[] =
|
|
{
|
|
OBJ_WAGON,
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Commando[] =
|
|
{
|
|
OBJ_POWERPACK,
|
|
OBJ_VEHICLE_BOOST,
|
|
OBJ_DRAGONSTEETH,
|
|
OBJ_MANNED_MISSILELAUNCHER,
|
|
OBJ_SANDBAG_BUNKER,
|
|
OBJ_DRAGONSTEETH,
|
|
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Medic[] =
|
|
{
|
|
OBJ_POWERPACK,
|
|
OBJ_SELFHEAL,
|
|
OBJ_BUFF_STATION,
|
|
OBJ_MANNED_PLASMAGUN,
|
|
OBJ_SANDBAG_BUNKER,
|
|
OBJ_BUNKER,
|
|
OBJ_DRAGONSTEETH,
|
|
OBJ_SHIELDWALL,
|
|
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Defender[] =
|
|
{
|
|
OBJ_POWERPACK,
|
|
OBJ_SENTRYGUN_PLASMA,
|
|
OBJ_MANNED_MISSILELAUNCHER,
|
|
OBJ_BARBED_WIRE,
|
|
OBJ_DRAGONSTEETH,
|
|
OBJ_TOWER,
|
|
OBJ_SANDBAG_BUNKER,
|
|
OBJ_BUNKER,
|
|
OBJ_DRIVER_MACHINEGUN,
|
|
//OBJ_MORTAR,
|
|
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Sniper[] =
|
|
{
|
|
OBJ_WAGON,
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Support[] =
|
|
{
|
|
OBJ_WAGON,
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Escort[] =
|
|
{
|
|
OBJ_SHIELDWALL,
|
|
OBJ_MANNED_SHIELD,
|
|
OBJ_SANDBAG_BUNKER,
|
|
OBJ_BUNKER,
|
|
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Sapper[] =
|
|
{
|
|
OBJ_POWERPACK,
|
|
OBJ_DRAGONSTEETH,
|
|
OBJ_TOWER,
|
|
OBJ_SANDBAG_BUNKER,
|
|
OBJ_MANNED_PLASMAGUN,
|
|
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Infiltrator[] =
|
|
{
|
|
OBJ_WAGON,
|
|
OBJ_LAST
|
|
};
|
|
|
|
static int g_iClassInfo_Pyro[] =
|
|
{
|
|
OBJ_WAGON,
|
|
OBJ_LAST
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool IsObjectAnUpgrade( int iObjectType )
|
|
{
|
|
return ( iObjectType >= OBJ_SELFHEAL && iObjectType < OBJ_BATTERING_RAM );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool IsObjectAVehicle( int iObjectType )
|
|
{
|
|
return ( iObjectType >= OBJ_BATTERING_RAM && iObjectType < OBJ_TOWER );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool IsObjectADefensiveBuilding( int iObjectType )
|
|
{
|
|
return ( iObjectType >= OBJ_TOWER );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// PLAYER CLASSES
|
|
//--------------------------------------------------------------------------
|
|
|
|
#if defined( CLIENT_DLL )
|
|
|
|
#define DEFINE_PLAYERCLASS_ALLOC_FNS( className, iClass ) \
|
|
C_PlayerClass* AllocClient##className##( C_BaseTFPlayer *pPlayer ) \
|
|
{ \
|
|
return new C_PlayerClass##className##( pPlayer ); \
|
|
} \
|
|
CPlayerClass* AllocServer##className##( CBaseTFPlayer *pPlayer ) \
|
|
{ \
|
|
Assert( false ); \
|
|
return NULL; \
|
|
}
|
|
|
|
#define GENERATE_PLAYERCLASS_INFO( className ) \
|
|
AllocClient##className##, AllocServer##className, NULL
|
|
|
|
|
|
// ------------------------------------------------------------------------------------- //
|
|
// DT_AllPlayerClasses recv table.
|
|
// ------------------------------------------------------------------------------------- //
|
|
|
|
BEGIN_RECV_TABLE_NOBASE( C_AllPlayerClasses, DT_AllPlayerClasses )
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_COMMANDO]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassCommandoData ), DataTableRecvProxy_PointerDataTable ),
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_DEFENDER]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassDefenderData ), DataTableRecvProxy_PointerDataTable ),
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_ESCORT]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassEscortData ), DataTableRecvProxy_PointerDataTable ),
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_INFILTRATOR]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassInfiltratorData ), DataTableRecvProxy_PointerDataTable ),
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_MEDIC]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassMedicData ), DataTableRecvProxy_PointerDataTable ),
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_RECON]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassReconData ), DataTableRecvProxy_PointerDataTable ),
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_SNIPER]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassSniperData ), DataTableRecvProxy_PointerDataTable ),
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_SUPPORT]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassSupportData ), DataTableRecvProxy_PointerDataTable ),
|
|
RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_SAPPER]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassSapperData ), DataTableRecvProxy_PointerDataTable )
|
|
END_RECV_TABLE()
|
|
|
|
#else
|
|
|
|
#define DEFINE_PLAYERCLASS_ALLOC_FNS( className, iClass ) \
|
|
ConVar class_##className##_health( "class_" #className "_health", "0", FCVAR_NONE, #className "'s max health" ); \
|
|
C_PlayerClass* AllocClient##className##( C_BaseTFPlayer *pPlayer ) \
|
|
{ \
|
|
Assert( false ); \
|
|
return NULL; \
|
|
} \
|
|
CPlayerClass* AllocServer##className##( CBaseTFPlayer *pPlayer ) \
|
|
{ \
|
|
return new CPlayerClass##className##( pPlayer, iClass ); \
|
|
}
|
|
|
|
#define GENERATE_PLAYERCLASS_INFO( className ) \
|
|
AllocClient##className##, AllocServer##className, &class_##className##_health
|
|
|
|
|
|
// ------------------------------------------------------------------------------------- //
|
|
// DT_AllPlayerClasses recv table.
|
|
// ------------------------------------------------------------------------------------- //
|
|
|
|
BEGIN_SEND_TABLE_NOBASE( CAllPlayerClasses, DT_AllPlayerClasses )
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_COMMANDO]), &REFERENCE_SEND_TABLE( DT_PlayerClassCommandoData ), SendProxy_DataTablePtrToDataTable ),
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_DEFENDER]), &REFERENCE_SEND_TABLE( DT_PlayerClassDefenderData ), SendProxy_DataTablePtrToDataTable ),
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_ESCORT]), &REFERENCE_SEND_TABLE( DT_PlayerClassEscortData ), SendProxy_DataTablePtrToDataTable ),
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_INFILTRATOR]),&REFERENCE_SEND_TABLE( DT_PlayerClassInfiltratorData ), SendProxy_DataTablePtrToDataTable ),
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_MEDIC]), &REFERENCE_SEND_TABLE( DT_PlayerClassMedicData ), SendProxy_DataTablePtrToDataTable ),
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_RECON]), &REFERENCE_SEND_TABLE( DT_PlayerClassReconData ), SendProxy_DataTablePtrToDataTable ),
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_SNIPER]), &REFERENCE_SEND_TABLE( DT_PlayerClassSniperData ), SendProxy_DataTablePtrToDataTable ),
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_SUPPORT]), &REFERENCE_SEND_TABLE( DT_PlayerClassSupportData ), SendProxy_DataTablePtrToDataTable ),
|
|
SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_SAPPER]), &REFERENCE_SEND_TABLE( DT_PlayerClassSapperData ), SendProxy_DataTablePtrToDataTable )
|
|
END_SEND_TABLE()
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------------------------- //
|
|
// CAllPlayerClasses implementation.
|
|
// ------------------------------------------------------------------------------------- //
|
|
|
|
CAllPlayerClasses::CAllPlayerClasses( PLAYER_TYPE *pPlayer )
|
|
{
|
|
for ( int i=0; i < TFCLASS_CLASS_COUNT; i++ )
|
|
{
|
|
m_pClasses[i] = NULL;
|
|
|
|
#if defined( CLIENT_DLL )
|
|
if ( GetTFClassInfo( i )->m_pClientAlloc )
|
|
m_pClasses[i] = GetTFClassInfo( i )->m_pClientAlloc( pPlayer );
|
|
#else
|
|
if ( GetTFClassInfo( i )->m_pServerAlloc )
|
|
m_pClasses[i] = GetTFClassInfo( i )->m_pServerAlloc( pPlayer );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
CAllPlayerClasses::~CAllPlayerClasses()
|
|
{
|
|
for ( int i=0; i < TFCLASS_CLASS_COUNT; i++ )
|
|
{
|
|
delete m_pClasses[i];
|
|
}
|
|
}
|
|
|
|
PLAYER_CLASS_TYPE* CAllPlayerClasses::GetPlayerClass( int iClass )
|
|
{
|
|
Assert( iClass >= 0 && iClass < TFCLASS_CLASS_COUNT );
|
|
return m_pClasses[iClass];
|
|
}
|
|
|
|
|
|
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Recon, TFCLASS_RECON );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Commando, TFCLASS_COMMANDO );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Medic, TFCLASS_MEDIC );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Defender, TFCLASS_DEFENDER );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Sniper, TFCLASS_SNIPER );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Support, TFCLASS_SUPPORT );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Escort, TFCLASS_ESCORT );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Sapper, TFCLASS_SAPPER );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Infiltrator, TFCLASS_INFILTRATOR );
|
|
DEFINE_PLAYERCLASS_ALLOC_FNS( Pyro, TFCLASS_PYRO );
|
|
|
|
CTFClassInfo g_TFClassInfos[ TFCLASS_CLASS_COUNT ] =
|
|
{
|
|
{ "Undecided", g_iClassInfo_Undecided, false, NULL, NULL, NULL },
|
|
{ "Recon", g_iClassInfo_Recon, false, GENERATE_PLAYERCLASS_INFO( Recon ) },
|
|
{ "Commando", g_iClassInfo_Commando, true, GENERATE_PLAYERCLASS_INFO( Commando ) },
|
|
{ "Medic", g_iClassInfo_Medic, true, GENERATE_PLAYERCLASS_INFO( Medic ) },
|
|
{ "Defender", g_iClassInfo_Defender, true, GENERATE_PLAYERCLASS_INFO( Defender ) },
|
|
{ "Sniper", g_iClassInfo_Sniper, false, GENERATE_PLAYERCLASS_INFO( Sniper ) },
|
|
{ "Support", g_iClassInfo_Support, false, GENERATE_PLAYERCLASS_INFO( Support ) },
|
|
{ "Escort", g_iClassInfo_Escort, true, GENERATE_PLAYERCLASS_INFO( Escort ) },
|
|
{ "Sapper", g_iClassInfo_Sapper, true, GENERATE_PLAYERCLASS_INFO( Sapper ) },
|
|
{ "Infiltrator",g_iClassInfo_Infiltrator, false, GENERATE_PLAYERCLASS_INFO( Infiltrator ) },
|
|
{ "Pyro", g_iClassInfo_Pyro, false, GENERATE_PLAYERCLASS_INFO( Pyro ) }
|
|
};
|
|
|
|
|
|
const CTFClassInfo* GetTFClassInfo( int i )
|
|
{
|
|
Assert( i >= 0 && i < TFCLASS_CLASS_COUNT );
|
|
return &g_TFClassInfos[i];
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------ //
|
|
// CObjectInfo tables.
|
|
// ------------------------------------------------------------------------------------------------ //
|
|
|
|
CObjectInfo::CObjectInfo( char *pObjectName )
|
|
{
|
|
m_pObjectName = pObjectName;
|
|
m_pClassName = NULL;
|
|
m_flBuildTime = -9999;
|
|
m_nMaxObjects = -9999;
|
|
m_Cost = -9999;
|
|
m_CostMultiplierPerInstance = -999;
|
|
m_UpgradeCost = -9999;
|
|
m_MaxUpgradeLevel = -9999;
|
|
m_pBuilderWeaponName = NULL;
|
|
m_pBuilderPlacementString = NULL;
|
|
m_SelectionSlot = -9999;
|
|
m_SelectionPosition = -9999;
|
|
m_bSolidToPlayerMovement = false;
|
|
m_flSapperAttachTime = -9999;
|
|
m_pIconActive = NULL;
|
|
}
|
|
|
|
|
|
CObjectInfo::~CObjectInfo()
|
|
{
|
|
delete [] m_pClassName;
|
|
delete [] m_pStatusName;
|
|
delete [] m_pBuilderWeaponName;
|
|
delete [] m_pBuilderPlacementString;
|
|
delete [] m_pIconActive;
|
|
}
|
|
|
|
|
|
CObjectInfo g_ObjectInfos[OBJ_LAST] =
|
|
{
|
|
CObjectInfo( "OBJ_POWERPACK" ),
|
|
CObjectInfo( "OBJ_RESUPPLY" ),
|
|
CObjectInfo( "OBJ_SENTRYGUN_PLASMA" ),
|
|
CObjectInfo( "OBJ_SENTRYGUN_ROCKET_LAUNCHER" ),
|
|
CObjectInfo( "OBJ_SHIELDWALL" ),
|
|
CObjectInfo( "OBJ_RESOURCEPUMP" ),
|
|
CObjectInfo( "OBJ_RESPAWN_STATION" ),
|
|
CObjectInfo( "OBJ_RALLYFLAG" ),
|
|
CObjectInfo( "OBJ_MANNED_PLASMAGUN" ),
|
|
CObjectInfo( "OBJ_MANNED_MISSILELAUNCHER" ),
|
|
CObjectInfo( "OBJ_MANNED_SHIELD" ),
|
|
CObjectInfo( "OBJ_EMPGENERATOR" ),
|
|
CObjectInfo( "OBJ_BUFF_STATION" ),
|
|
CObjectInfo( "OBJ_BARBED_WIRE" ),
|
|
CObjectInfo( "OBJ_MCV_SELECTION_PANEL" ),
|
|
CObjectInfo( "OBJ_MAPDEFINED" ),
|
|
CObjectInfo( "OBJ_MORTAR" ),
|
|
CObjectInfo( "OBJ_SELFHEAL" ),
|
|
CObjectInfo( "OBJ_ARMOR_UPGRADE" ),
|
|
CObjectInfo( "OBJ_VEHICLE_BOOST" ),
|
|
CObjectInfo( "OBJ_EXPLOSIVES" ),
|
|
CObjectInfo( "OBJ_DRIVER_MACHINEGUN" ),
|
|
CObjectInfo( "OBJ_BATTERING_RAM" ),
|
|
CObjectInfo( "OBJ_SIEGE_TOWER" ),
|
|
CObjectInfo( "OBJ_WAGON" ),
|
|
CObjectInfo( "OBJ_FLATBED" ),
|
|
CObjectInfo( "OBJ_VEHICLE_MORTAR" ),
|
|
CObjectInfo( "OBJ_VEHICLE_TELEPORT_STATION" ),
|
|
CObjectInfo( "OBJ_VEHICLE_TANK" ),
|
|
CObjectInfo( "OBJ_VEHICLE_MOTORCYCLE" ),
|
|
CObjectInfo( "OBJ_WALKER_STRIDER" ),
|
|
CObjectInfo( "OBJ_WALKER_MINI_STRIDER" ),
|
|
CObjectInfo( "OBJ_TOWER" ),
|
|
CObjectInfo( "OBJ_TUNNEL" ),
|
|
CObjectInfo( "OBJ_SANDBAG_BUNKER" ),
|
|
CObjectInfo( "OBJ_BUNKER" ),
|
|
CObjectInfo( "OBJ_DRAGONSTEETH" ),
|
|
};
|
|
|
|
|
|
char* ReadAndAllocStringValue( KeyValues *pSub, const char *pName, const char *pFilename )
|
|
{
|
|
const char *pValue = pSub->GetString( pName, NULL );
|
|
if ( !pValue )
|
|
{
|
|
DevWarning( "Can't get key value '%s' from file '%s'.\n", pName, pFilename );
|
|
return "";
|
|
}
|
|
|
|
int len = Q_strlen( pValue ) + 1;
|
|
char *pAlloced = new char[ len ];
|
|
Assert( pAlloced );
|
|
Q_strncpy( pAlloced, pValue, len );
|
|
return pAlloced;
|
|
}
|
|
|
|
|
|
bool AreObjectInfosLoaded()
|
|
{
|
|
return g_ObjectInfos[0].m_pClassName != NULL;
|
|
}
|
|
|
|
|
|
void LoadObjectInfos( IBaseFileSystem *pFileSystem )
|
|
{
|
|
const char *pFilename = "scripts/objects.txt";
|
|
|
|
// Make sure this stuff hasn't already been loaded.
|
|
Assert( !AreObjectInfosLoaded() );
|
|
|
|
KeyValues *pValues = new KeyValues( "Object descriptions" );
|
|
if ( !pValues->LoadFromFile( pFileSystem, pFilename, "GAME" ) )
|
|
{
|
|
Error( "Can't open %s for object info.", pFilename );
|
|
pValues->deleteThis();
|
|
return;
|
|
}
|
|
|
|
// Now read each class's information in.
|
|
for ( int iObj=0; iObj < ARRAYSIZE( g_ObjectInfos ); iObj++ )
|
|
{
|
|
CObjectInfo *pInfo = &g_ObjectInfos[iObj];
|
|
KeyValues *pSub = pValues->FindKey( pInfo->m_pObjectName );
|
|
if ( !pSub )
|
|
{
|
|
Error( "Missing section '%s' from %s.", pInfo->m_pObjectName, pFilename );
|
|
pValues->deleteThis();
|
|
return;
|
|
}
|
|
|
|
// Read all the info in.
|
|
if ( (pInfo->m_flBuildTime = pSub->GetFloat( "BuildTime", -999 )) == -999 ||
|
|
(pInfo->m_nMaxObjects = pSub->GetInt( "MaxObjects", -999 )) == -999 ||
|
|
(pInfo->m_Cost = pSub->GetInt( "Cost", -999 )) == -999 ||
|
|
(pInfo->m_CostMultiplierPerInstance = pSub->GetFloat( "CostMultiplier", -999 )) == -999 ||
|
|
(pInfo->m_UpgradeCost = pSub->GetInt( "UpgradeCost", -999 )) == -999 ||
|
|
(pInfo->m_MaxUpgradeLevel = pSub->GetInt( "MaxUpgradeLevel", -999 )) == -999 ||
|
|
(pInfo->m_SelectionSlot = pSub->GetInt( "SelectionSlot", -999 )) == -999 ||
|
|
(pInfo->m_SelectionPosition = pSub->GetInt( "SelectionPosition", -999 )) == -999 ||
|
|
(pInfo->m_flSapperAttachTime = pSub->GetInt( "SapperAttachTime", -999 )) == -999 )
|
|
{
|
|
Error( "Missing data for object '%s' in %s.", pInfo->m_pObjectName, pFilename );
|
|
pValues->deleteThis();
|
|
return;
|
|
}
|
|
|
|
pInfo->m_pClassName = ReadAndAllocStringValue( pSub, "ClassName", pFilename );
|
|
pInfo->m_pStatusName = ReadAndAllocStringValue( pSub, "StatusName", pFilename );
|
|
pInfo->m_pBuilderWeaponName = ReadAndAllocStringValue( pSub, "BuilderWeaponName", pFilename );
|
|
pInfo->m_pBuilderPlacementString = ReadAndAllocStringValue( pSub, "BuilderPlacementString", pFilename );
|
|
pInfo->m_bSolidToPlayerMovement = pSub->GetInt( "SolidToPlayerMovement", 0 ) ? true : false;
|
|
pInfo->m_pIconActive = ReadAndAllocStringValue( pSub, "Icon", pFilename );
|
|
}
|
|
|
|
pValues->deleteThis();
|
|
}
|
|
|
|
|
|
const CObjectInfo* GetObjectInfo( int iObject )
|
|
{
|
|
Assert( iObject >= 0 && iObject < OBJ_LAST );
|
|
Assert( AreObjectInfosLoaded() );
|
|
return &g_ObjectInfos[iObject];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return true if the specified class is allowed to build the specified object type
|
|
//-----------------------------------------------------------------------------
|
|
bool ClassCanBuild( int iClass, int iObjectType )
|
|
{
|
|
for ( int i = 0; i < OBJ_LAST; i++ )
|
|
{
|
|
// Hit the end?
|
|
if ( g_TFClassInfos[iClass].m_pClassObjects[i] == OBJ_LAST )
|
|
return false;
|
|
|
|
// Found it?
|
|
if ( g_TFClassInfos[iClass].m_pClassObjects[i] == iObjectType )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the cost of another object of the specified type
|
|
// If bLast is set, return the cost of the last built object of the specified type
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int CalculateObjectCost( int iObjectType, int iNumberOfObjects, int iTeam, bool bLast )
|
|
{
|
|
if ( tf_cheapobjects.GetInt() )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Find out how much the next object should cost
|
|
if ( bLast )
|
|
{
|
|
iNumberOfObjects = MAX(0,iNumberOfObjects-1);
|
|
}
|
|
|
|
int iCost = GetObjectInfo( iObjectType )->m_Cost;
|
|
|
|
// If a cost is negative, it means the first object of that type is free, and then
|
|
// it counts up as normal, using the negative value.
|
|
if ( iCost < 0 )
|
|
{
|
|
if ( iNumberOfObjects == 0 )
|
|
return 0;
|
|
iCost *= -1;
|
|
iNumberOfObjects--;
|
|
}
|
|
|
|
// MCVs have special rules: The team's first one is always free
|
|
if ( iObjectType == OBJ_VEHICLE_TELEPORT_STATION )
|
|
{
|
|
CTFTeam *pTeam = (CTFTeam *)GetGlobalTeam(iTeam);
|
|
if ( pTeam && pTeam->GetNumObjects(OBJ_VEHICLE_TELEPORT_STATION) == 0 )
|
|
{
|
|
iCost = 0;
|
|
}
|
|
}
|
|
|
|
// Human objects cost less across the board
|
|
if ( iTeam == TEAM_HUMANS )
|
|
{
|
|
iCost = ( ((float)iCost) * 0.8 );
|
|
}
|
|
|
|
// Calculate the cost based upon the number of objects
|
|
for ( int i = 0; i < iNumberOfObjects; i++ )
|
|
{
|
|
iCost *= GetObjectInfo( iObjectType )->m_CostMultiplierPerInstance;
|
|
}
|
|
|
|
return iCost;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Calculate the cost to upgrade an object of a specific type
|
|
//-----------------------------------------------------------------------------
|
|
int CalculateObjectUpgrade( int iObjectType, int iObjectLevel )
|
|
{
|
|
// Max level?
|
|
if ( iObjectLevel >= GetObjectInfo( iObjectType )->m_MaxUpgradeLevel )
|
|
return 0;
|
|
|
|
int iCost = GetObjectInfo( iObjectType )->m_UpgradeCost;
|
|
for ( int i = 0; i < (iObjectLevel - 1); i++ )
|
|
{
|
|
iCost *= OBJECT_UPGRADE_COST_MULTIPLIER_PER_LEVEL;
|
|
}
|
|
|
|
return iCost;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// MORTAR
|
|
//--------------------------------------------------------------------------
|
|
// Names for each mortar ammo type
|
|
char *MortarAmmoNames[ MA_LASTAMMOTYPE ] =
|
|
{
|
|
"Normal Rounds",
|
|
//"Smoke Rounds",
|
|
"Cluster Rounds",
|
|
"Starburst Rounds",
|
|
};
|
|
|
|
// Techs needs for each mortar ammo type
|
|
char *MortarAmmoTechs[ MA_LASTAMMOTYPE ] =
|
|
{
|
|
"",
|
|
//"mortar_ammo_smoke",
|
|
"mortar_ammo_cluster",
|
|
"mortar_ammo_starburst",
|
|
};
|
|
|
|
// Max amounts of each mortar ammo type in a single mortar
|
|
int MortarAmmoMax[ MA_LASTAMMOTYPE ] =
|
|
{
|
|
-1, // -1 is infinite ammo
|
|
//20,
|
|
20,
|
|
10,
|
|
};
|