void CHUDScores::Render()
{
g_pChatMsgs->CanDraw( true );
if (m_nDraw <= 0) return;
g_pChatMsgs->CanDraw( false );
if (m_bControlsInited)
{
if (!m_bScreen && !IsTeamGameType())
m_SingleFrame.Render();
for (int team = 0; team < kNumTeams; team++)
{
if (IsTeamGameType())
{
m_Frame[team].Render();
m_Team[team].Render();
m_Rounds[team].Render();
}
m_Header[team].Render();
for (int i = 0; i < kMaxPlayers; i++)
m_Columns[team][i].Render();
}
m_Server.Render();
}
}
void CHUDRadar::Render()
{
if( !m_bDraw )
return;
SetRenderState();
RADAROBJECT *pRadarObj = LTNULL;
RadarObjectSortList::iterator iter;
uint8 nCount = 0;
for( iter = m_ROSortList.begin(); iter != m_ROSortList.end(); ++iter )
{
pRadarObj = (*iter);
// Check if the radar object has team information in it. Only
// show on same team's radar.
if( IsTeamGameType( ))
{
// Get local clientinfo.
CLIENT_INFO *pLocalCI = g_pInterfaceMgr->GetClientInfoMgr()->GetLocalClient();
if( !pLocalCI )
return;
// Check if the radar is for an opposing player, show them on radar.
if( pRadarObj->m_nVisibleTeamId != INVALID_TEAM &&
pLocalCI->nTeamID != pRadarObj->m_nVisibleTeamId )
continue;
}
if( pRadarObj->m_bDraw )
{
g_pDrawPrim->SetTexture( pRadarObj->m_hTex );
g_pDrawPrim->DrawPrim( &pRadarObj->m_Poly );
++nCount;
}
}
if( IsTeamGameType() )
{
g_pDrawPrim->SetTexture( LTNULL );
g_pDrawPrim->DrawPrim( &teamPoly );
}
RadarPlayerList::iterator sIter = m_Players.begin();
while (sIter != m_Players.end())
{
(*sIter)->Render();
sIter++;
}
}
bool DoomsDayDevice::ReadProp( ObjectCreateStruct* pStruct )
{
GenericProp genProp;
if( IsTeamGameType() )
{
if( g_pLTServer->GetPropGeneric( "Team", &genProp ) == LT_OK )
{
if( genProp.m_String[0] )
{
// The team string should be TeamN, when N is the team id.
char const szTeam[] = "Team";
int nLen = (int)strlen( szTeam );
if( !_strnicmp( genProp.m_String, szTeam, nLen ))
{
uint32 nTeamId = atoi( &genProp.m_String[ nLen ] );
if( nTeamId < MAX_TEAMS )
{
m_nOwningTeamID = nTeamId;
}
}
}
}
}
// Get the diminsions considered to be the drop zone...
if( g_pLTServer->GetPropGeneric( "DropZoneRadius", &genProp ) == LT_OK )
{
m_fDropZoneRadius = genProp.m_Float;
}
return true;
}
void CMenuSystem::OnFocus(LTBOOL bFocus)
{
ClearSelection();
m_List.ClearSelection();
if( bFocus )
{
// Hide the save/load controls if we are a remote client.
if ( !g_pClientMultiplayerMgr->IsConnectedToRemoteServer( ) &&
( g_pGameClientShell->GetGameType() == eGameTypeSingle ||
g_pGameClientShell->GetGameType() == eGameTypeCooperative
)
)
{
m_pSaveCtrl->Show( LTTRUE );
m_pLoadCtrl->Show( LTTRUE );
}
else
{
m_pSaveCtrl->Show( LTFALSE );
m_pLoadCtrl->Show( LTFALSE );
}
m_pSaveCtrl->Enable(g_pClientSaveLoadMgr->CanSaveGame());
if (IsMultiplayerGame())
{
m_pPlayerCtrl->Show( LTTRUE );
m_pTeamCtrl->Show( IsTeamGameType() );
m_pHostCtrl->Show( !g_pClientMultiplayerMgr->IsConnectedToRemoteServer( ) );
m_pServerCtrl->Show(g_pClientMultiplayerMgr->IsConnectedToRemoteServer( ));
if (g_pClientMultiplayerMgr->IsConnectedToRemoteServer( ))
{
std::string str = g_pClientMultiplayerMgr->GetStartGameRequest( ).m_HostInfo.m_sName;
str += " : ";
str += g_pClientMultiplayerMgr->GetStartGameRequest( ).m_TCPAddress;
m_pServerCtrl->SetString(str.c_str());
}
}
else
{
m_pPlayerCtrl->Show( LTFALSE );
m_pTeamCtrl->Show( LTFALSE );
m_pHostCtrl->Show( LTFALSE );
m_pServerCtrl->Show( LTFALSE );
}
if (m_fScale != g_pInterfaceResMgr->GetXRatio())
{
SetScale(g_pInterfaceResMgr->GetXRatio());
}
SetSelection(GetIndex(&m_List));
m_List.ClearSelection();
m_List.NextSelection();
}
}
void DisplayTimer::ReadProp(ObjectCreateStruct *)
{
GenericProp genProp;
if (g_pLTServer->GetPropGeneric("StartCommand", &genProp) == LT_OK)
{
if (genProp.m_String[0])
{
m_hstrStartCmd = g_pLTServer->CreateString(genProp.m_String);
}
}
if (g_pLTServer->GetPropGeneric("EndCommand", &genProp) == LT_OK)
{
if (genProp.m_String[0])
{
m_hstrEndCmd = g_pLTServer->CreateString(genProp.m_String);
}
}
if (g_pLTServer->GetPropGeneric("RemoveWhenDone", &genProp) == LT_OK)
{
m_bRemoveWhenDone = genProp.m_Bool;
}
// Get the team this object belongs to.
if( IsTeamGameType() )
{
if( g_pLTServer->GetPropGeneric( "Team", &genProp ) == LT_OK )
{
if( genProp.m_String[0] )
{
// The team string should be TeamN, when N is the team id.
char const szTeam[] = "Team";
int nLen = (int)strlen( szTeam );
if( !_strnicmp( genProp.m_String, szTeam, nLen ))
{
uint32 nTeamId = atoi( &genProp.m_String[ nLen ] );
if( nTeamId < MAX_TEAMS )
{
m_nTeamId = nTeamId;
}
}
}
}
}
else
{
m_nTeamId = INVALID_TEAM;
}
}
void CHUDRadar::UpdateNamePositions()
{
float fx = (float)(m_NamePos.x) * g_pInterfaceResMgr->GetXRatio();
float fy = (float)(m_NamePos.y) * g_pInterfaceResMgr->GetYRatio();
if( IsTeamGameType() )
{
CClientInfoMgr* pCIMgr = g_pInterfaceMgr->GetClientInfoMgr();
CLIENT_INFO *pLocalCI = pCIMgr->GetLocalClient();
uint8 nTeam = 0;
if( pLocalCI)
{
nTeam = pLocalCI->nTeamID;
}
g_pDrawPrim->SetRGBA4( &teamPoly, nTeamColors[nTeam][1], nTeamColors[nTeam][0], nTeamColors[nTeam][1], nTeamColors[nTeam][2] );
float fw = 90.0f * g_pInterfaceResMgr->GetXRatio();
float fh = 90.0f * g_pInterfaceResMgr->GetYRatio();
g_pDrawPrim->SetXYWH( &teamPoly, fx-fw, fy, fw, fh);
}
RadarPlayerList::iterator iter = m_Players.begin();
while (iter != m_Players.end())
{
CUIFormattedPolyString* pStr = (*iter)->pName;
if (pStr->GetLength())
{
uint8 nSize = (uint8)(12.0f * g_pInterfaceResMgr->GetXRatio());
pStr->SetCharScreenHeight(nSize);
pStr->SetPosition(fx,fy);
fy += (float)pStr->GetHeight();
}
iter++;
}
}
void CHUDRadar::AddPlayer(HOBJECT hObj, uint32 nId)
{
if (!hObj) return;
CClientInfoMgr* pCIMgr = g_pInterfaceMgr->GetClientInfoMgr();
CLIENT_INFO* pCI = pCIMgr->GetClientByID(nId);
HOBJECT hLocalObj = g_pLTClient->GetClientObject();
uint8 nTeamID = INVALID_TEAM;
// Check for teams and only display players of the same team...
if( IsTeamGameType() && hLocalObj != hObj)
{
CLIENT_INFO *pLocalCI = pCIMgr->GetLocalClient();
if( !pLocalCI || !pCI )
return;
if( pLocalCI->nTeamID != pCI->nTeamID )
return;
nTeamID = pCI->nTeamID;
}
bool bDead = false;
if (hLocalObj != hObj)
{
AddObject( hObj, RADAR_PLAYER_ALIVE_TYPE, nTeamID );
}
CCharacterFX *pCharacter = g_pGameClientShell->GetSFXMgr()->GetCharacterFX(hObj);
if (pCharacter && pCharacter->IsPlayerDead())
{
bDead = true;
}
RadarPlayerList::iterator iter = m_Players.begin();
while (iter != m_Players.end() && ( (*iter)->hObj != hObj ) )
{
iter++;
}
RADAR_PLAYER_OBJ* pPlayer = NULL;
//new player...
if (iter == m_Players.end())
{
pPlayer = debug_new(RADAR_PLAYER_OBJ);
m_Players.push_back(pPlayer);
}
else
{
pPlayer = (*iter);
}
pPlayer->nID = nId;
pPlayer->hObj = hObj;
if (!pPlayer->pName)
{
uint8 nFont = 0;
CUIFont* pFont = g_pInterfaceResMgr->GetFont(nFont);
pPlayer->pName = g_pFontManager->CreateFormattedPolyString(pFont,"",0.0f,0.0f);
pPlayer->pName->SetAlignmentH(CUI_HALIGN_RIGHT);
}
if (pCI)
{
pPlayer->pName->SetText(pCI->sName.c_str());
}
SetPlayerDead(hObj,bDead);
UpdateNamePositions();
}
LTBOOL PickupItem::ReadProp(ObjectCreateStruct *pInfo)
{
GenericProp genProp;
if (!pInfo) return LTFALSE;
if (g_pLTServer->GetPropGeneric("PickupCommand", &genProp) == LT_OK)
{
if(genProp.m_String[0])
{
m_hstrPickupCommand = g_pLTServer->CreateString(genProp.m_String);
}
}
if (g_pLTServer->GetPropGeneric("PickupSound", &genProp) == LT_OK)
{
if(genProp.m_String[0])
{
m_hstrSoundFile = g_pLTServer->CreateString(genProp.m_String);
}
}
if (g_pLTServer->GetPropGeneric("RespawnSound", &genProp) == LT_OK)
{
if(genProp.m_String[0])
{
m_hstrRespawnSoundFile = g_pLTServer->CreateString(genProp.m_String);
}
}
// Only get the value of the ModelOverride attribute if we're using
// it...
if (g_pLTServer->GetPropGeneric("UseModelOverride", &genProp) == LT_OK)
{
if (genProp.m_Bool)
{
if (g_pLTServer->GetPropGeneric("ModelOverride", &genProp) == LT_OK)
{
if(genProp.m_String[0])
{
m_hstrModelOverride = g_pLTServer->CreateString(genProp.m_String);
}
}
}
}
if (g_pLTServer->GetPropGeneric("Rotate", &genProp) == LT_OK)
{
m_bRotate = genProp.m_Bool;
}
if (g_pLTServer->GetPropGeneric("Bounce", &genProp) == LT_OK)
{
m_bBounce = genProp.m_Bool;
}
if (g_pLTServer->GetPropGeneric("MoveToFloor", &genProp) == LT_OK)
{
m_bMoveToFloor = genProp.m_Bool;
}
if( g_pLTServer->GetPropGeneric( "TouchPickup", &genProp ) == LT_OK )
{
if( IsCoopMultiplayerGameType() )
{
m_bTouchPickup = genProp.m_Bool;
}
}
if( g_pLTServer->GetPropGeneric( "DMTouchPickup", &genProp ) == LT_OK )
{
if( !IsCoopMultiplayerGameType() )
{
m_bTouchPickup = genProp.m_Bool;
}
}
if( g_pLTServer->GetPropGeneric( "ActivatePickup", &genProp ) == LT_OK )
{
m_bActivatePickup = genProp.m_Bool;
}
if( !IsMultiplayerGame( ))
{
if( g_pLTServer->GetPropGeneric( "SPRespawn", &genProp ) == LT_OK )
{
m_bRespawn = genProp.m_Bool;
}
}
else
{
if( g_pLTServer->GetPropGeneric( "MPRespawn", &genProp ) == LT_OK )
{
m_bRespawn = genProp.m_Bool;
}
}
if (g_pLTServer->GetPropGeneric("RespawnTime", &genProp) == LT_OK)
{
m_fRespawnDelay = genProp.m_Float;
}
if (g_pLTServer->GetPropGeneric("Scale", &genProp) == LT_OK)
{
m_vScale = genProp.m_Vec;
}
if( g_pLTServer->GetPropGeneric( "WorldAnimation", &genProp ) == LT_OK )
{
if( genProp.m_String[0] )
{
m_sWorldAniName = genProp.m_String;
}
}
// Get the team this object belongs to.
if( IsTeamGameType() )
{
if( g_pLTServer->GetPropGeneric( "Team", &genProp ) == LT_OK )
{
m_nTeamId = TeamStringToTeamId( genProp.m_String );
}
}
else
{
m_nTeamId = INVALID_TEAM;
}
return LTTRUE;
}
void CTargetMgr::SetGadgetTarget( bool bDisabling )
{
if (!m_hTarget) return;
CGadgetTargetFX* const pFX = (CGadgetTargetFX*)g_pGameClientShell->GetSFXMgr()->FindSpecialFX(SFX_GADGETTARGET_ID, m_hTarget);
m_bCanActivate = false;
if (!pFX) return;
GadgetTargetType eGadgetType = pFX->GetType();
switch( eGadgetType )
{
case eKeyPad:
m_bCanActivate = (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_CODE_DECIPHERER) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_HACKINGKEYPAD : IDS_TARGET_HACKKEYPAD );
break;
case eCardReader:
m_bCanActivate = (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_CODE_DECIPHERER) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_HACKINGCARDREADER : IDS_TARGET_HACKCARDREADER );
break;
case eCodedText:
m_bCanActivate = (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_CODE_DECIPHERER) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_DECODING : IDS_TARGET_DECODE );
break;
case eComboLock:
m_bCanActivate = (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_WELDER) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_WELDING : IDS_TARGET_WELD );
break;
case ePadLock:
case eDoorKnob:
m_bCanActivate = (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_LOCK_PICK) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_PICKING : IDS_TARGET_PICK );
break;
case eTelephone:
m_bCanActivate = (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_EAVESDROPBUG) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_BUGGING : IDS_TARGET_BUG );
break;
case ePhotographable:
m_bCanActivate = (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_CAMERA) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_PHOTOGRAPHING : IDS_TARGET_PHOTO );
break;
case eBombable:
m_bCanActivate = bDisabling || (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_TIME_BOMB) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_BOMBING : IDS_TARGET_BOMB );
break;
case eInvisibleInk:
m_bCanActivate = (g_pPlayerMgr->GetGadgetFromDamageType(DT_GADGET_INK_REAGENT) != WMGR_INVALID_ID);
SetTargetStringID( bDisabling ? IDS_TARGET_INKING : IDS_TARGET_INK );
break;
case eINVALID:
default:
SetTargetStringID(NULL);
break;
}
if( IsTeamGameType() )
{
// Can only activate a gadget target that belongs to your team...
CLIENT_INFO *pLocalCI = g_pInterfaceMgr->GetClientInfoMgr()->GetLocalClient();
if( !pLocalCI )
return;
if( (pFX->GetTeamID() != INVALID_TEAM) && (pLocalCI->nTeamID != pFX->GetTeamID()) )
{
// The bombable can only be defused by the other team...
if( eGadgetType == eBombable && bDisabling )
{
m_bCanActivate &= true;
}
else
{
m_bCanActivate = false;
}
}
}
m_bCanActivate &= pFX->IsPowerOn();
// Cannot disable a gadget target when carrying a body...
if( g_pPlayerMgr->IsCarryingHeavyObject() )
{
m_bCanActivate = false;
}
if( m_bCanActivate && GTInfoArray[eGadgetType].m_bShowTimeBar )
{
uint8 nProgress = g_pPlayerMgr->GetGadgetDisabler()->GetMaxProgress();
g_pPlayerStats->UpdateMaxProgress( nProgress );
g_pPlayerStats->UpdateProgress( nProgress );
g_pHUDMgr->QueueUpdate( kHUDProgressBar );
}
}
void CTargetMgr::Update()
{
// Do any necessary initialization...
if (m_bFirstUpdate)
{
FirstUpdate();
m_bFirstUpdate = false;
}
if (m_hLockedTarget && m_hTarget == m_hLockedTarget)
{
//are we disabling a GadgetTarget?
if (g_pPlayerMgr->IsDisabling())
{
SetGadgetTarget( true );
return;
}
//are we searching something?
if (g_pPlayerMgr->IsSearching())
{
m_bSearchTarget = true;
SetTargetStringID(IDS_TARGET_SEARCHING);
float fDistAway = 10000.0f;
CheckForIntersect(fDistAway);
return;
}
}
g_pPlayerStats->UpdateMaxProgress( 0 );
g_pPlayerStats->UpdateProgress( 0 );
g_pHUDMgr->QueueUpdate( kHUDProgressBar );
// If we currently have a target, see if it is a body and if so remove the
// glow flag (it may be set again below)...
if (m_hTarget)
{
CBodyFX* pBody = g_pGameClientShell->GetSFXMgr()->GetBodyFX(m_hTarget);
if (pBody)
{
g_pCommonLT->SetObjectFlags(m_hTarget, OFT_User, 0, USRFLG_GLOW);
}
}
// Start fresh
ClearTargetInfo();
//see what we've looking at
float fDistAway = 10000.0f;
CheckForIntersect(fDistAway);
if (!m_hTarget)
{
//nothing to see here
return;
}
m_fTargetRange = fDistAway;
//if its a body's hitbox, check the body instead
CBodyFX* pBody = g_pGameClientShell->GetSFXMgr()->GetBodyFromHitBox(m_hTarget);
if (pBody)
{
m_hTarget = pBody->GetServerObj();
m_ActivationData.m_hTarget = m_hTarget;
if (!m_hTarget) return;
}
//if its a Character's hitbox and it is searchable, check the Character instead
CCharacterFX* pCharacter = g_pGameClientShell->GetSFXMgr()->GetCharacterFromHitBox(m_hTarget);
if (pCharacter)
{
m_hTarget = pCharacter->GetServerObj();
m_ActivationData.m_hTarget = m_hTarget;
if (!m_hTarget) return;
}
uint32 dwUserFlags = 0;
g_pCommonLT->GetObjectFlags(m_hTarget, OFT_User, dwUserFlags);
// If we're on a vehicle (or if we are dead) all we care about is other players in a multiplayer game...
// Some vehicles (like the PlayerLure) let you activate, so we'll just check if the
// vehicle will let us show a crosshair to see if we're on a "true" vehicle or not...
// It would be great if we didn't have to do all these checks, but such is life...
bool bPlayersOnly = g_pPlayerMgr->IsPlayerDead() || (g_pPlayerMgr->GetMoveMgr()->GetVehicleMgr()->CanShowCrosshair() ? false : true);
if (!bPlayersOnly)
{
//special case handling for bodies
if (pBody || pCharacter)
{
bool bCanSearch = !!(dwUserFlags & USRFLG_CAN_SEARCH);
if (pBody)
{
if (fDistAway <= g_vtActivationDistance.GetFloat())
{
// Make target glow, so it stands out more...
g_pCommonLT->SetObjectFlags(m_hTarget, OFT_User, USRFLG_GLOW, USRFLG_GLOW);
}
if (pBody->CanBeRevived() && fDistAway <= g_vtReviveDistance.GetFloat() && IsRevivePlayerGameType( ))
{
// Get the client information of the body and us.
uint32 nId = pBody->GetClientId();
CClientInfoMgr* pCIMgr = g_pInterfaceMgr->GetClientInfoMgr();
CLIENT_INFO* pCI = pCIMgr->GetClientByID(nId);
CLIENT_INFO *pLocalCI = g_pInterfaceMgr->GetClientInfoMgr()->GetLocalClient();
// Only allow us to revive people on the same team. For non-team games,
// the teamid will be set to the same invalid value anyway.
if( pCI && pLocalCI )
{
if (pCI->nTeamID == pLocalCI->nTeamID)
{
m_nString = 0;
FormatString(IDS_TARGET_REVIVE, m_szString, ARRAY_LEN(m_szString), pCI->sName.c_str());
LTVector vObjPos, vDims;
g_pLTClient->GetObjectPos(pBody->GetServerObj(), &vObjPos);
g_pPhysicsLT->GetObjectDims(pBody->GetServerObj(), &vDims);
// Players are non-solid to each other so you can revive right on top of them.
m_bCanActivate = true; //!CheckForCharacters(vObjPos, vDims, pBody->GetClientId());
m_bMoveTarget = true;
m_ActivationData.m_nType = MID_ACTIVATE_REVIVE;
}
else
{
m_nString = 0;
m_bCanActivate = false;
m_bMoveTarget = false;
LTStrCpy(m_szString, pCI->sName.c_str(), ARRAY_LEN(m_szString));
}
return;
}
}
else
{
m_bMoveTarget = (pBody->CanBeCarried() && g_pPlayerMgr->CanDropCarriedObject());
}
}
else if (pCharacter)
{
if( (pCharacter->m_cs.eCrosshairCharacterClass != BAD) && (pCharacter->CanWake()) && (pCharacter->IsUnconscious() || (pCharacter->Slipped() && !pCharacter->m_cs.bIsPlayer)) )
{
SetTargetStringID( IDS_TARGET_WAKEUP );
m_bCanActivate = true;
m_bMoveTarget = g_pPlayerMgr->CanDropCarriedObject() && pCharacter->CanBeCarried();
m_ActivationData.m_nType = MID_ACTIVATE_WAKEUP;
return;
}
m_bMoveTarget = g_pPlayerMgr->CanDropCarriedObject() && pCharacter->CanBeCarried();
}
else
{
m_bMoveTarget = false;
}
if (bCanSearch && fDistAway <= g_vtActivationDistance.GetFloat())
{
// we can search this body
m_bSearchTarget = true;
m_ActivationData.m_nType = MID_ACTIVATE_SEARCH;
SetTargetStringID(IDS_TARGET_SEARCH);
uint8 nProgress = g_pPlayerMgr->GetSearcher()->GetMaxProgress();
g_pPlayerStats->UpdateMaxProgress( nProgress );
g_pPlayerStats->UpdateProgress( nProgress );
g_pHUDMgr->QueueUpdate( kHUDProgressBar );
return;
}
else if (pBody)
{
return;
}
}
else
{
float fGadgetDistance = g_vtActivationDistance.GetFloat();
if( dwUserFlags & USRFLG_GADGET_CAMERA )
{
fGadgetDistance = g_vtCamZoom1MaxDist.GetFloat();
}
// is this a gadget target
if (IsGadgetActivatable(m_hTarget) && (fDistAway <= fGadgetDistance))
{
// looks like we can use a gadget on it...
SetGadgetTarget( false );
return;
}
}
}
//are we aiming at a person?
if (dwUserFlags & USRFLG_CHARACTER)
{
CCharacterFX* const pFX = (CCharacterFX*)g_pGameClientShell->GetSFXMgr()->FindSpecialFX(SFX_CHARACTER_ID, m_hTarget);
// All we care about if we're on a vehicle (or if we are dead) is the Multiplayer check below...
if (!bPlayersOnly)
{
//display debug info if we have any
if( pFX && pFX->GetInfoString() && *pFX->GetInfoString() )
{
SAFE_STRCPY(m_szDebugString,pFX->GetInfoString());
}
else
{
m_szDebugString[0] = NULL;
}
// is this a person we can talk to?
if (dwUserFlags & USRFLG_CAN_ACTIVATE)
{
if (fDistAway <= g_vtActivationDistance.GetFloat())
{
SetTargetStringID(IDS_TARGET_TALK);
return;
}
}
}
// This is the only thing we care about if we're dead or on a vehicle...(we care
// if we're off a vehicle too)
if (IsMultiplayerGame() && pFX && pFX->m_cs.bIsPlayer )
{
uint32 nId = pFX->m_cs.nClientID;
CClientInfoMgr* pCIMgr = g_pInterfaceMgr->GetClientInfoMgr();
CLIENT_INFO* pCI = pCIMgr->GetClientByID(nId);
if (pCI)
{
m_nString = 0;
SAFE_STRCPY(m_szString,pCI->sName.c_str());
if (IsTeamGameType())
{
m_nTargetTeam = pCI->nTeamID;
}
}
return;
}
// All we care about if we're dead or on a vehicle is the Multiplayer check above...
if (!bPlayersOnly)
{
if( (fDistAway <= g_vtTargetDistance.GetFloat()) && pFX )
{
// If a nameid was specified for the model display the name...
uint16 nNameId = g_pModelButeMgr->GetModelNameId( pFX->m_cs.eModelId );
if( nNameId != (uint16)-1 )
{
if( nNameId > 0 )
{
SetTargetStringID( nNameId );
return;
}
// warn the player if we are pointing at a friend...
if( pFX->m_cs.eCrosshairCharacterClass != BAD )
{
SetTargetStringID( IDS_TARGET_INNOCENT );
return;
}
}
}
}
}
// All we care about if we're dead or on a vehicle is the above Multiplayer check...
if (bPlayersOnly)
{
// Didn't see another player in Multiplayer, so we have no target...
ClearTargetInfo();
return;
}
//is this a searchable object?
if (dwUserFlags & USRFLG_CAN_SEARCH && (fDistAway <= g_vtActivationDistance.GetFloat()))
{
m_bSearchTarget = true;
m_ActivationData.m_nType = MID_ACTIVATE_SEARCH;
SetTargetStringID(IDS_TARGET_SEARCH);
uint8 nProgress = g_pPlayerMgr->GetSearcher()->GetMaxProgress();
g_pPlayerStats->UpdateMaxProgress( nProgress );
g_pPlayerStats->UpdateProgress( nProgress );
g_pHUDMgr->QueueUpdate( kHUDProgressBar );
return;
}
// See if this object is part of the activate object list with it's own string ID's...
if( fDistAway <= g_vtActivationDistance.GetFloat() )
{
CActivateObjectHandler *pActivateObj = LTNULL;
CActivateObjectHandler::ActivateObjList::const_iterator iter = CActivateObjectHandler::GetActivateObjectList().begin();
while( iter != CActivateObjectHandler::GetActivateObjectList().end() )
{
pActivateObj = *iter;
if( pActivateObj->GetHOBJECT() == m_hTarget )
{
ACTIVATETYPE *pType = g_pActivateTypeMgr->GetActivateType( pActivateObj->m_nId );
if( pType )
{
// Set whether or not it's disabled and set the string based on the state...
m_bCanActivate = !pActivateObj->m_bDisabled;
uint32 dwStringID = pType->dwStateID[pActivateObj->m_eState];
if( dwStringID != (uint32)-1 )
{
SetTargetStringID( dwStringID );
}
return;
}
}
++iter;
}
}
//can we pick up or activate it?
if (dwUserFlags & USRFLG_CAN_ACTIVATE && (fDistAway <= g_vtActivationDistance.GetFloat()))
{
//special case for bombs to defuse
CGadgetTargetFX* const pGTFX = (CGadgetTargetFX*)g_pGameClientShell->GetSFXMgr()->FindSpecialFX(SFX_GADGETTARGET_ID, m_hTarget);
if (pGTFX)
{
GadgetTargetType eGadgetType = pGTFX->GetType();
if (eBombable == eGadgetType)
{
// Can only defuse a bomb that doesn't belong to your team...
if( IsTeamGameType() )
{
CLIENT_INFO *pLocalCI = g_pInterfaceMgr->GetClientInfoMgr()->GetLocalClient();
if( !pLocalCI )
return;
if( pGTFX->GetTeamID() != INVALID_TEAM )
{
if( pLocalCI->nTeamID == pGTFX->GetTeamID() )
{
m_bCanActivate = false;
}
}
}
SetTargetStringID(IDS_TARGET_DEFUSE);
return;
}
}
CPickupItemFX* const pFX = (CPickupItemFX*)g_pGameClientShell->GetSFXMgr()->FindSpecialFX(SFX_PICKUPITEM_ID, m_hTarget);
// If this is a pickupitem, then display any team association it has.
if( IsTeamGameType() && pFX )
{
m_nTargetTeam = pFX->GetTeamId( );
}
// If we're looking at a pickup, use the take string, otherwise it's just something to interact with.
SetTargetStringID(pFX ? IDS_TARGET_TAKE : IDS_TARGET_USE);
return;
}
// Are we looking at a doomsday piece...
CDoomsdayPieceFX *pDDPiece = dynamic_cast<CDoomsdayPieceFX*>(g_pGameClientShell->GetSFXMgr()->FindSpecialFX( SFX_DOOMSDAYPIECE_ID, m_hTarget ));
if( pDDPiece && (fDistAway <= g_vtActivationDistance.GetFloat()) )
{
m_bCanActivate = false;
m_bMoveTarget = true;
}
}
//returns the damage type of the gadget required to disable the current target
DamageType CTargetMgr::RequiredGadgetDamageType()
{
if (!m_hTarget) return DT_INVALID;
//if can activate without gadget, then don't switch
uint32 dwUserFlags = 0;
g_pCommonLT->GetObjectFlags(m_hTarget, OFT_User, dwUserFlags);
if (dwUserFlags & USRFLG_CAN_ACTIVATE)
return DT_INVALID;
CGadgetTargetFX* const pFX = (CGadgetTargetFX*)g_pGameClientShell->GetSFXMgr()->FindSpecialFX(SFX_GADGETTARGET_ID, m_hTarget);
if (!pFX || !pFX->SwitchWeapons()) return DT_INVALID;
DamageType eDamageType = DT_INVALID;
GadgetTargetType eGadgetType = pFX->GetType();
switch( eGadgetType )
{
case eKeyPad:
case eCardReader:
case eCodedText:
eDamageType = DT_GADGET_CODE_DECIPHERER;
break;
case eComboLock:
eDamageType = DT_GADGET_WELDER;
break;
case ePadLock:
case eDoorKnob:
eDamageType = DT_GADGET_LOCK_PICK;
break;
case eTelephone:
eDamageType = DT_GADGET_EAVESDROPBUG;
break;
case ePhotographable:
eDamageType = DT_GADGET_CAMERA;
break;
case eBombable:
eDamageType = DT_GADGET_TIME_BOMB;
break;
case eInvisibleInk:
eDamageType = DT_GADGET_INK_REAGENT;
break;
case eINVALID:
default:
eDamageType = DT_INVALID;
break;
}
if( IsTeamGameType() )
{
// Only switch to a gadget if the target belongs to our team...
CLIENT_INFO *pLocalCI = g_pInterfaceMgr->GetClientInfoMgr()->GetLocalClient();
if( !pLocalCI )
return DT_INVALID;
if( pFX->GetTeamID() != INVALID_TEAM )
{
if( pLocalCI->nTeamID != pFX->GetTeamID() )
{
eDamageType = DT_INVALID;
}
}
}
return eDamageType;
}
void CHUDScores::Update()
{
if (m_nDraw <= 0) return;
uint32 textCol = (m_bScreen ? m_nScreenTextColor : m_nTextColor);
uint32 playerTextCol = (m_bScreen ? m_nScreenPlayerTextColor : m_nPlayerTextColor);
float fScale = g_pInterfaceResMgr->GetXRatio();
if (fScale != m_fScale)
{
m_fScale = fScale;
m_Server.SetScale(fScale);
m_SingleFrame.SetScale(fScale);
for (int team = 0; team < kNumTeams; team++)
{
m_Team[team].SetScale(fScale);
m_Rounds[team].SetScale(fScale);
m_Header[team].SetScale(fScale);
m_Frame[team].SetScale(fScale);
for (int i = 0; i < kMaxPlayers; i++)
{
m_Columns[team][i].SetScale(fScale);
}
}
}
if (IsTeamGameType())
{
CUserProfile *pProfile = g_pProfileMgr->GetCurrentProfile();
for( uint8 team = 0; team < kNumTeams; ++team )
{
CTeam* pTeam = CTeamMgr::Instance().GetTeam(team);
if (!pTeam) continue;
char szTmp[128];
sprintf(szTmp,"%s : %d",pTeam->GetName(),pTeam->GetScore());
m_Team[team].SetString(szTmp);
sprintf(szTmp,"%s : %d", LoadTempString(IDS_ROUNDS), pTeam->GetRoundScore( ));
m_Rounds[team].SetString(szTmp);
m_Header[team].Show(LTTRUE);
}
}
else
{
m_Team[0].SetString("");
m_Rounds[0].SetString("");
m_Header[1].Show(LTFALSE);
}
m_Server.SetColors(textCol,textCol,textCol);
CClientInfoMgr *pCIMgr = g_pGameClientShell->GetInterfaceMgr( )->GetClientInfoMgr();
if (!pCIMgr) return;
CLIENT_INFO* pCI = pCIMgr->GetFirstClient();
int nTotal = 0;
int count[kNumTeams] = {0,0};
char szTmp[64] = "";
uint16 nHeight[kNumTeams];
nHeight[0] = m_Server.GetBaseHeight() + m_Header[0].GetBaseHeight() + m_Team[0].GetBaseHeight() + 24;
nHeight[1] = m_Team[1].GetBaseHeight() + m_Header[1].GetBaseHeight() + 16;
uint32 nLocalID = 0;
g_pLTClient->GetLocalClientID (&nLocalID);
while (pCI && (nTotal < kMaxPlayers))
{
uint8 nTeam = 0;
if (IsTeamGameType())
{
nTeam = pCI->nTeamID;
}
int ndx = count[nTeam];
if (nTeam < kNumTeams)
{
sprintf( szTmp, "%s%s",pCI->sName.c_str( ), pCI->bIsAdmin ? "[*]" : "" );
m_Columns[nTeam][ndx].GetPolyString(0)->SetText( szTmp );
sprintf(szTmp,"%d",pCI->sScore.GetScore());
m_Columns[nTeam][ndx].GetPolyString(1)->SetText(szTmp);
sprintf(szTmp,"%d",pCI->sScore.GetFrags());
m_Columns[nTeam][ndx].GetPolyString(2)->SetText(szTmp);
sprintf(szTmp,"%d",pCI->sScore.GetTags());
m_Columns[nTeam][ndx].GetPolyString(3)->SetText(szTmp);
sprintf(szTmp,"%d",pCI->nPing);
m_Columns[nTeam][ndx].GetPolyString(4)->SetText(szTmp);
if (nLocalID == pCI->nID)
{
m_Columns[nTeam][ndx].SetColors(playerTextCol,playerTextCol,playerTextCol);
}
else
{
m_Columns[nTeam][ndx].SetColors(textCol,textCol,textCol);
}
m_Columns[nTeam][ndx].Show(LTTRUE);
nHeight[nTeam] += m_Columns[nTeam][ndx].GetBaseHeight();
}
pCI = pCI->pNext;
++count[nTeam];
}
for (int team = 0; team < kNumTeams; team++)
{
m_Team[team].SetColors(textCol,textCol,textCol);
m_Rounds[team].SetColors(textCol,textCol,textCol);
m_Header[team].SetColors(textCol,textCol,textCol);
nHeight[team] += 16;
m_Frame[team].SetSize(m_nFrameWidth,nHeight[team]);
while (count[team] < kMaxPlayers)
{
m_Columns[team][count[team]].Show(LTFALSE);
++count[team];
}
LTIntPt pos = m_BasePos;
if (IsTeamGameType() && team > 0)
{
pos.y += nHeight[team-1] + 8;
UpdateTeamPos(team,pos);
}
}
m_SingleFrame.SetSize(m_nFrameWidth,nHeight[0]+8);
}
