bool ObjectBase::ChildTypeOk (PObjectType type)
{
// buscamos si puede haber objectos del tipo "type" como hijos
// del actual objeto tipo.
int nmax = 0;
// check allowed child count
if( GetObjectInfo()->GetObjectType()->GetName() == wxT("form") )
{
nmax = GetObjectInfo()->GetObjectType()->FindChildType(type, this->GetPropertyAsInteger(wxT("aui_managed")));
}
else
nmax = GetObjectInfo()->GetObjectType()->FindChildType(type, false);
if (nmax == 0)
return false;
if (nmax < 0)
return true;
// llegados aquí hay que comprobar el número de hijos del tipo pasado
int count = 0;
for (unsigned int i=0; i < GetChildCount() && count <= nmax; i++)
{
if (GetChild(i)->GetObjectInfo()->GetObjectType() == type)
count++;
}
if (count > nmax)
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : char const
//-----------------------------------------------------------------------------
const char *CTFWeaponBuilder::GetPrintName( void ) const
{
if ( GetObjectInfo( m_iObjectType )->m_AltModes.Count() > 0 )
return GetObjectInfo( m_iObjectType )->m_AltModes.Element( m_iObjectMode * 3 + 0 );
return GetObjectInfo( m_iObjectType )->m_pStatusName;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TFWeaponBuilder::SetupObjectSelectionSprite( void )
{
#ifdef CLIENT_DLL
// Use the sprite details from the text file, with a custom sprite
char *iconTexture = GetObjectInfo( m_iObjectType )->m_pIconActive;
if ( iconTexture && iconTexture[ 0 ] )
{
m_pSelectionTextureActive = gHUD.GetIcon( iconTexture );
}
else
{
m_pSelectionTextureActive = NULL;
}
iconTexture = GetObjectInfo( m_iObjectType )->m_pIconInactive;
if ( iconTexture && iconTexture[ 0 ] )
{
m_pSelectionTextureInactive = gHUD.GetIcon( iconTexture );
}
else
{
m_pSelectionTextureInactive = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
// 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;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : char const
//-----------------------------------------------------------------------------
const char *C_TFWeaponBuilder::GetCurrentSelectionObjectName( void )
{
if ( m_iObjectType == -1 || (m_iBuildState == BS_SELECTING) )
return "";
return GetObjectInfo( m_iObjectType )->m_pBuilderWeaponName;
}
//-----------------------------------------------------------------------------
// Frame-based update
//-----------------------------------------------------------------------------
void CVehicleBayVGuiScreen::OnTick()
{
BaseClass::OnTick();
if (!GetEntity())
return;
C_BaseTFPlayer *pLocalPlayer = C_BaseTFPlayer::GetLocalPlayer();
if ( !pLocalPlayer )
return;
int nBankResources = pLocalPlayer ? pLocalPlayer->GetBankResources() : 0;
// Set the vehicles costs
for ( int i = 0; i < NUM_VEHICLES; i++ )
{
if ( !m_pVehicleButtons[i] )
continue;
char buf[128];
int iCost = CalculateObjectCost( g_ValidVehicles[i], pLocalPlayer->GetNumObjects( g_ValidVehicles[i] ), pLocalPlayer->GetTeamNumber() );
Q_snprintf( buf, sizeof( buf ), "%s : %d", GetObjectInfo( g_ValidVehicles[i] )->m_pStatusName, iCost );
m_pVehicleButtons[i]->SetText( buf );
// Can't build if the game hasn't started
if ( CurrentActIsAWaitingAct() )
{
m_pVehicleButtons[i]->SetEnabled( false );
}
else
{
m_pVehicleButtons[i]->SetEnabled( nBankResources >= iCost );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseObject::AddAndParseBuildPoint( int iAttachmentNumber, KeyValues *pkvBuildPoint )
{
int iPoint = AddBuildPoint( iAttachmentNumber );
m_BuildPoints[iPoint].m_bPutInAttachmentSpace = (pkvBuildPoint->GetInt( "PutInAttachmentSpace", 0 ) != 0);
// Now see if we've got a set of valid objects specified
KeyValues *pkvValidObjects = pkvBuildPoint->FindKey( "valid_objects" );
if ( pkvValidObjects )
{
KeyValues *pkvObject = pkvValidObjects->GetFirstSubKey();
while ( pkvObject )
{
const char *pSpecifiedObject = pkvObject->GetName();
int iLenObjName = Q_strlen( pSpecifiedObject );
// Find the object index for the name
for ( int i = 0; i < OBJ_LAST; i++ )
{
if ( !Q_strncasecmp( GetObjectInfo( i )->m_pClassName, pSpecifiedObject, iLenObjName) )
{
AddValidObjectToBuildPoint( iPoint, i );
break;
}
}
pkvObject = pkvObject->GetNextKey();
}
}
}
void Target_Info(unsigned int Serial, unsigned short X, unsigned short Y, int Z)
{
GameObject Obj;
if(Serial == INVALID_SERIAL)
{
ClientPrint("Invalid target");
return;
}
if(GetObjectInfo(Serial, INVALID_IDX, &Obj) == OBJECT_NOTFOUND)
{
ClientPrint("Object not in the world list");
return;
}
ClientPrint("Serial 0x%08X", Obj.Serial);
ClientPrint("Graphic: 0x%04X Color: 0x%04X", Obj.Graphic, Obj.Color);
ClientPrint("Container: 0x%08X Quantity: %d", Obj.Container, Obj.Quantity);
/* if the object wasn't a character, GetObjectInfo frees the pointer */
if(Obj.Character == NULL) return;
/* if it's a character display the info */
ClientPrint("Name %s", Obj.Character->Name);
ClientPrint("HP: %d MaxHP: %d", Obj.Character->HitPoints, Obj.Character->MaxHitPoints);
ClientPrint("Current HP: %d%%", (Obj.Character->HitPoints*100)/Obj.Character->MaxHitPoints);
FREECHAR(Obj);
return;
}
bool ObjectBase::ChildTypeOk (PObjectType type)
{
// buscamos si puede haber objectos del tipo "type" como hijos
// del actual objeto tipo.
int nmax = GetObjectInfo()->GetObjectType()->FindChildType(type);
if (nmax == 0)
return false;
if (nmax < 0)
return true;
// llegados aquí hay que comprobar el número de hijos del tipo pasado
int count = 0;
for (unsigned int i=0; i < GetChildCount() && count <= nmax; i++)
{
if (GetChild(i)->GetObjectInfo()->GetObjectType() == type)
count++;
}
if (count > nmax)
return false;
return true;
}
void delete_files( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts)
{
int ret;
uint32_t *pHandle;
uint32_t *pEnd;
CAMObjectHandlePtr pHandles = 0;
CAMObjectInfoPtr pObjInfo = 0;
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
if (!validate_range( pHandles, pOpts, &pHandle, &pEnd)) {
if (pHandles)
free( pHandles);
return;
}
printf ( "\n Erase files %s\n", pDevInfo->Model);
printf ( " =========== %s\n", underline( pDevInfo->Model));
for (; pHandle <= pEnd; pHandle++) {
ret = GetObjectInfo( hCam, *pHandle, &pObjInfo);
if (ret) {
camcli_error( "Could not get info for handle %d", *pHandle);
if (ret == CAMERR_USBFAILURE)
ClearStall( hCam);
continue;
}
if (pObjInfo->ObjectFormat == PTP_OFC_Association)
printf( " Handle %d is not a file - skipping...\n", *pHandle);
else {
ret = DeleteObject( hCam, *pHandle, 0);
if (ret == 0)
printf(" Erasing %3d (%s)... done\n", *pHandle, pObjInfo->Filename);
else {
camcli_error( "Could not delete handle %d - rc= %X",
*pHandle, ret);
if (ret == CAMERR_USBFAILURE)
ClearStall( hCam);
}
}
free( pObjInfo);
pObjInfo = 0;
}
if (pObjInfo)
free( pObjInfo);
if (pHandles)
free( pHandles);
return;
}
//-----------------------------------------------------------------------------
// 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
//
// Note: Used to contain logic from tf2 that multiple instances of the same object
// cost different amounts. See tf2/game_shared/tf_shareddefs.cpp for details
//-----------------------------------------------------------------------------
int CalculateObjectCost( int iObjectType )
{
if ( tf_cheapobjects.GetInt() )
{
return 0;
}
int iCost = GetObjectInfo( iObjectType )->m_Cost;
return iCost;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
const char *C_TFWeaponBuilder::GetViewModel( int iViewModel ) const
{
if ( GetPlayerOwner() == NULL )
{
return BaseClass::GetViewModel();
}
if ( m_iObjectType != BUILDER_INVALID_OBJECT )
{
return GetObjectInfo( m_iObjectType )->m_pViewModel;
}
return BaseClass::GetViewModel();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFWeaponBuilder::GetWorldModel( void ) const
{
if ( GetPlayerOwner() == NULL )
{
return BaseClass::GetWorldModel();
}
if ( m_iObjectType != BUILDER_INVALID_OBJECT )
{
return GetObjectInfo( m_iObjectType )->m_pPlayerModel;
}
return BaseClass::GetWorldModel();
}
unsigned ReqProg_load()
{
char *src;
char *dst;
char *name;
char ch;
prog_load_ret *ret;
unsigned len;
_DBG1(( "AccLoadProg\r\n" ));
AtEnd = FALSE;
dst = UtilBuff;
src = name = GetInPtr( sizeof( prog_load_req ) );
ret = GetOutPtr( 0 );
while( *src++ != '\0' ) {};
len = GetTotalSize() - (src - name) - sizeof( prog_load_req );
if( len > 126 )
len = 126;
for( ; len > 0; --len ) {
ch = *src++;
if( ch == '\0' ) {
if( len == 1 )
break;
ch = ' ';
}
*dst++ = ch;
}
*dst = '\0';
_DBG1(( "about to debugload\r\n" ));
_DBG1(( "Name :" ));
_DBG1(( name ));
_DBG1(( "\r\n" ));
_DBG1(( "UtilBuff :" ));
_DBG1(( UtilBuff ));
_DBG1(( "\r\n" ));
GetObjectInfo( name );
ret->err = D32DebugLoad( name, UtilBuff, &Proc );
_DBG1(( "back from debugload - %d\r\n", ret->err ));
ret->flags = LD_FLAG_IS_32 | LD_FLAG_IS_PROT | LD_FLAG_DISPLAY_DAMAGED;
if( ret->err == 0 ) {
ret->task_id = Proc.es;
} else {
ret->task_id = 0;
}
ret->mod_handle = 0;
Proc.int_id = -1;
_DBG1(( "done AccLoadProg\r\n" ));
return( sizeof( *ret ) );
}
//-----------------------------------------------------------------------------
// Purpose: Start placing the object
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::StartPlacement( void )
{
StopPlacement();
// Create the slab
m_hObjectBeingBuilt = (CBaseObject*)CreateEntityByName( GetObjectInfo( m_iObjectType )->m_pClassName );
if ( m_hObjectBeingBuilt )
{
m_hObjectBeingBuilt->Spawn();
m_hObjectBeingBuilt->StartPlacement( ToTFPlayer( GetOwner() ) );
// Stomp this here in the same frame we make the object, so prevent clientside warnings that it's under attack
m_hObjectBeingBuilt->m_iHealth = OBJECT_CONSTRUCTION_STARTINGHEALTH;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CInfoBuildPoint::Spawn( void )
{
g_MapDefinedBuildPoints.AddToTail( this );
m_iAllowedObjectType = -1;
if ( m_iszAllowedObject != NULL_STRING )
{
for ( int i = 0; i < OBJ_LAST; i++ )
{
if ( !Q_strcmp( STRING(m_iszAllowedObject), GetObjectInfo(i)->m_pClassName ) )
{
m_iAllowedObjectType = i;
break;
}
}
}
BaseClass::Spawn();
}
void list_files( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo)
{
int i;
struct tm * ptm;
CAMObjectHandlePtr pHandles = 0;
CAMObjectInfoPtr pObjInfo = 0;
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
printf( "\n File list %s\n", pDevInfo->Model);
printf( " ========= %s\n", underline( pDevInfo->Model));
printf("\n Handle\t Size Date Time Name\n");
for (i = 0; i < pHandles->cntHandles; i++) {
if (GetObjectInfo( hCam, pHandles->Handles[i], &pObjInfo)) {
camcli_error( "Could not get object info for handle %d",
pHandles->Handles[i]);
break;
}
if (pObjInfo->ObjectFormat != PTP_OFC_Association) {
ptm = localtime( &pObjInfo->CaptureDate);
printf( " % 4d\t% 9d %04d-%02d-%02d %02d:%02d %s\n",
pHandles->Handles[i], pObjInfo->ObjectCompressedSize,
ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, pObjInfo->Filename);
}
free( pObjInfo);
pObjInfo = 0;
}
if (pObjInfo)
free( pObjInfo);
if (pHandles)
free( pHandles);
return;
}
void Target_TileInfo(unsigned int Serial, unsigned short X, unsigned short Y, int Z)
{
GameObject Obj;
if(Serial == INVALID_SERIAL)
ClientPrint("X: %d Y: %d Z: %d", X, Y, Z);
else
{
if(GetObjectInfo(Serial, INVALID_IDX, &Obj) == OBJECT_NOTFOUND)
{
ClientPrintWarning("The targeted object does not exist in the world list... wtf");
return;
}
ClientPrint("You targeted an object, serial: 0x%08X", Serial);
ClientPrint("Position: X: %d Y: %d Z: %d", Obj.X, Obj.Y, Obj.Z);
}
return;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this player's allowed to build another one of the specified objects
//-----------------------------------------------------------------------------
int CPlayerClass::CanBuild( int iObjectType )
{
int iObjectCount = GetNumObjects( iObjectType );
// Make sure we haven't hit maximum number
if ( tf2_object_hard_limits.GetBool() )
{
if ( iObjectCount >= GetObjectInfo( iObjectType )->m_nMaxObjects )
return CB_LIMIT_REACHED;
}
else
{
// Find out how much the next object should cost
int iCost = CalculateObjectCost( iObjectType, GetNumObjects( iObjectType ), m_pPlayer->GetTeamNumber() );
// Make sure we have enough resources
if ( m_pPlayer->GetBankResources() < iCost )
return CB_NEED_RESOURCES;
}
return CB_CAN_BUILD;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::Precache( void )
{
BaseClass::Precache();
// Precache all the viewmodels we could possibly be building
for ( int iObj=0; iObj < OBJ_LAST; iObj++ )
{
const CObjectInfo *pInfo = GetObjectInfo( iObj );
if ( pInfo )
{
if ( pInfo->m_pViewModel )
{
PrecacheModel( pInfo->m_pViewModel );
}
if ( pInfo->m_pPlayerModel )
{
PrecacheModel( pInfo->m_pPlayerModel );
}
}
}
}
void CrestObjects::ClearCRNodes(bool bC, bool bR)
{
tCRNode* pCRNode;
for(long k=0;k<m_nObjects;k++)
{
ResponseData *pResponse=m_pObjectInfo[k].pResponse;
if(NULL==pResponse) continue;
for(long i=0;i<INSTRUMENT_MAX;i++)
{
if(bC || GetObjectInfo(i)->pIInfo->nGraspStatus==0)
{
pResponse->nCPos[i]=0;
}
if(bR)
{
pResponse->nPPos=0;
//for(i=0;i<RNODES_MAX;i++) m_RNode[i].pVector=NULL;
pResponse->nRPos=pResponse->nRVelocity=pResponse->nRForce=0;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *C_BaseObject::GetHudStatusIcon( void )
{
return GetObjectInfo( GetType() )->m_pHudStatusIcon;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::AllowsAutoSwitchTo( void ) const
{
// ask the object we're building
return GetObjectInfo( m_iObjectType )->m_bAutoSwitchTo;
}
void show_handle_info( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts)
{
uint32_t *pHandle;
uint32_t *pEnd;
struct tm *ptm;
CAMObjectHandlePtr pHandles = 0;
CAMObjectInfoPtr pObjInfo = 0;
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
if (!validate_range( pHandles, pOpts, &pHandle, &pEnd)) {
if (pHandles)
free( pHandles);
return;
}
printf ( "\n File information %s\n", pDevInfo->Model);
printf ( " ================ %s\n", underline( pDevInfo->Model));
for (; pHandle <= pEnd; pHandle++) {
if (GetObjectInfo( hCam, *pHandle, &pObjInfo)) {
camcli_error( "Could not get object info for handle %d", *pHandle);
continue;
}
printf ( " Handle: %04d\n", *pHandle);
printf ( " Filename: %s\n", (pObjInfo->Filename ? pObjInfo->Filename : "[none]"));
if (pObjInfo->CaptureDate == 0)
ptm = 0;
else
ptm = localtime( &pObjInfo->CaptureDate);
if (!ptm)
printf ( " CaptureDate: [unknown]\n");
else
printf ( " CaptureDate: %04d-%02d-%02d %02d:%02d:%02d\n",
ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
if (pObjInfo->ModificationDate == 0)
ptm = 0;
else
ptm = localtime( &pObjInfo->ModificationDate);
if (!ptm)
printf ( " ModificationDate: [unknown]\n");
else
printf ( " ModificationDate: %04d-%02d-%02d %02d:%02d:%02d\n",
ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
printf ( " Keywords: %s\n", (pObjInfo->Keywords ? pObjInfo->Keywords : "[none]"));
printf ( " ProtectionStatus: 0x%04X\t%s\n", pObjInfo->ProtectionStatus, GetCodeName( pObjInfo->ProtectionStatus, CAM_PROTECTION));
printf ( "ObjectCompressedSize: %d\n", pObjInfo->ObjectCompressedSize);
printf ( " ObjectFormat: 0x%04X\t%s\n", pObjInfo->ObjectFormat, GetCodeName( pObjInfo->ObjectFormat, CAM_OBJECT_FORMAT));
printf ( " ImagePixWidth: %d\n", pObjInfo->ImagePixWidth);
printf ( " ImagePixHeight: %d\n", pObjInfo->ImagePixHeight);
printf ( " ImageBitDepth: %d\n", pObjInfo->ImageBitDepth);
printf ( " ThumbCompressedSize: %d\n", pObjInfo->ThumbCompressedSize);
printf ( " ThumbFormat: 0x%04X\t%s\n", pObjInfo->ThumbFormat, GetCodeName( pObjInfo->ThumbFormat, CAM_OBJECT_FORMAT));
printf ( " ThumbPixWidth: %d\n", pObjInfo->ThumbPixWidth);
printf ( " ThumbPixHeight: %d\n", pObjInfo->ThumbPixHeight);
printf ( " ParentObject: %04d\n", pObjInfo->ParentObject);
printf ( " AssociationType: 0x%04X\t%s\n", pObjInfo->AssociationType, GetCodeName( pObjInfo->AssociationType, CAM_ASSOCIATION));
printf ( " AssociationDesc: 0x%04X\n", pObjInfo->AssociationDesc);
printf ( " SequenceNumber: 0x%04X\n", pObjInfo->SequenceNumber);
printf ( " StorageID: 0x%04X\n\n", pObjInfo->StorageID);
free( pObjInfo);
pObjInfo = 0;
}
if (pObjInfo)
free( pObjInfo);
if (pHandles)
free( pHandles);
return;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : char const
//-----------------------------------------------------------------------------
const char *CTFWeaponBuilder::GetPrintName( void ) const
{
return GetObjectInfo( m_iObjectType )->m_pStatusName;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFWeaponBuilder::GetPosition( void ) const
{
return GetObjectInfo( m_iObjectType )->m_SelectionPosition;
}
void get_files( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts)
{
int ret;
int fName;
char *pName;
uint32_t *pHandle;
uint32_t *pEnd;
CAMObjectHandlePtr pHandles = 0;
CAMObjectInfoPtr pObjInfo = 0;
FNSTRUCT fns;
char path[260];
if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) {
camcli_error( "Could not get object handles");
return;
}
fName = parse_filename( pOpts->value, &fns);
if (fName)
pName = path;
else
pName = 0;
if (!validate_range( pHandles, pOpts, &pHandle, &pEnd)) {
if (pHandles)
free( pHandles);
return;
}
if (pOpts->flags & OPT_THUMBNAIL) {
printf ( "\n Save thumbnails %s\n", pDevInfo->Model);
printf ( " =============== %s\n", underline( pDevInfo->Model));
}
else {
printf ( "\n Save files %s\n", pDevInfo->Model);
printf ( " ========== %s\n", underline( pDevInfo->Model));
}
for (; pHandle <= pEnd; pHandle++) {
ret = GetObjectInfo( hCam, *pHandle, &pObjInfo);
if (ret) {
camcli_error( "Could not get info for handle %d", *pHandle);
if (ret == CAMERR_USBFAILURE)
ClearStall( hCam);
continue;
}
if (pObjInfo->ObjectFormat == PTP_OFC_Association)
printf( " Handle %d is not a file - skipping...\n", *pHandle);
else {
if (fName)
make_filename( pName, pObjInfo->Filename, &fns);
ret = os2_get_file( hCam, pObjInfo, *pHandle, pName,
(pOpts->flags & OPT_REPLACE),
(pOpts->flags & OPT_THUMBNAIL));
if (ret == CAMERR_USBFAILURE)
ClearStall( hCam);
}
free( pObjInfo);
pObjInfo = 0;
}
if (pObjInfo)
free( pObjInfo);
if (pHandles)
free( pHandles);
return;
}
void tcHookInfo::DrawOwn(tcGameObject *pHookedObj)
{
std::string s;
char zBuff[128];
float ftextx = 10.0f;
float ftexty = 22.0f;
Vec4 color;
if (pHookedObj == NULL) {return;}
s = pHookedObj->mzUnit.c_str();
color.set(0.4f, 1.0f, 0.4f, 1.0f);
DrawTextR(s.c_str(), ftextx-2.0f, ftexty, defaultFont.get(), color, fontSizeLarge, LEFT_BASE_LINE,
180.0f);
ftexty += 20.0f;
sprintf(zBuff, "%s (id %d)", pHookedObj->GetDisplayClassName(), pHookedObj->mnID);
s = zBuff;
DrawTextR(s.c_str(), ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 20.0f;
/*** mnClassID, mnModelType, mnType (classification) ***/
GetObjectInfo(s, pHookedObj->mpDBObject, pHookedObj);
DrawTextR(s.c_str(), ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 15.0f;
// speed, heading, altitude, terrain info
tcKinematics *pkin = &pHookedObj->mcKin;
int heading_deg = int(C_180OVERPI*pkin->mfHeading_rad + 0.5f);
heading_deg = heading_deg + (int(heading_deg < 0) - int(heading_deg >= 360))*360;
sprintf(zBuff,"%s, hdg %03d, alt %s",
units->GetUserSpeedString(pkin->mfSpeed_kts), heading_deg,
units->GetUserAltitudeString(pkin->mfAlt_m));
s = zBuff;
DrawTextR(s.c_str(), ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 15;
sprintf(zBuff, "Terrain %s", units->GetUserAltitudeString(pHookedObj->mcTerrain.mfHeight_m));
s = zBuff;
DrawTextR(s.c_str(), ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty+=15;
// lat, lon
LonLatToStringB(C_180OVERPI*(float)pkin->mfLon_rad,C_180OVERPI*(float)pkin->mfLat_rad,s);
DrawTextR(s.c_str(), ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 15;
/*** damage ***/
float damageLevelPercent = 100.0f * pHookedObj->GetDamageLevel();
if (damageLevelPercent > 100.0f) damageLevelPercent = 100.0f;
if (damageLevelPercent == 0)
{
strcpy(zBuff,"Damage: none");
}
else if (damageLevelPercent >= 50.0f)
{
color.set(1.0f, 0.4f, 0.4f, 1.0f);
sprintf(zBuff, "Damage: %2.0f%%", damageLevelPercent);
}
else
{
color.set(1.0f, 1.0f, 0.4f, 1.0f);
sprintf(zBuff, "Damage: %2.0f%%", damageLevelPercent);
}
s = zBuff;
DrawTextR(s.c_str(), ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 15;
color.set(0.4f, 1.0f, 0.4f, 1.0f);
// multiplayer info
if (mpSS->IsMultiplayerActive())
{
const std::string& controller = pHookedObj->GetController();
if (controller.size())
{
s = "Controlled by ";
s += controller;
}
else
{
s = "No controller";
}
DrawTextR(s.c_str(), ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 15;
color.set(0.4f, 1.0f, 0.4f, 1.0f);
}
// AI action text for platform objects
tcPlatformObject* pPlatformObj = dynamic_cast<tcPlatformObject*>(pHookedObj);
if (pPlatformObj != NULL)
{
std::string text = pPlatformObj->GetBrain()->GetActionText();
s = "Action: ";
s += text;
DrawTextR(s.c_str(), ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 15;
}
if (tcMissileObject* missile = dynamic_cast<tcMissileObject*>(pHookedObj))
{
sprintf(zBuff, "Runtime: %.1f", missile->RuntimeRemaining());
DrawTextR(zBuff, ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 15;
sprintf(zBuff, "Distance: %s", units->GetUserDistanceString(missile->GetDistanceFromLaunch()));
DrawTextR(zBuff, ftextx, ftexty, defaultFont.get(), color, fontSize, LEFT_BASE_LINE);
ftexty += 15;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFWeaponBuilder::GetSlot( void ) const
{
return GetObjectInfo( m_iObjectType )->m_SelectionSlot;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this weapon should be visible in the weapon selection
//-----------------------------------------------------------------------------
bool C_TFWeaponBuilder::VisibleInWeaponSelection( void )
{
return GetObjectInfo( m_iObjectType )->m_bVisibleInWeaponSelection;
}
