2442 lines
67 KiB
C++
2442 lines
67 KiB
C++
// Copyright (C) 2007 Id Software, Inc.
|
|
//
|
|
|
|
#include "precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#include "../framework/Licensee.h"
|
|
|
|
#include "roles/Inventory.h"
|
|
#include "roles/FireTeams.h"
|
|
#include "roles/ObjectiveManager.h"
|
|
#include "roles/Tasks.h"
|
|
#include "structures/TeamManager.h"
|
|
#include "rules/GameRules.h"
|
|
#include "Player.h"
|
|
#include "../framework/BuildVersion.h"
|
|
#include "../framework/KeyInput.h"
|
|
#include "guis/UserInterfaceLocal.h"
|
|
#include "guis/UserInterfaceManagerLocal.h"
|
|
#include "guis/UIList.h"
|
|
#include "guis/UIRadialMenu.h"
|
|
#include "CommandMapInfo.h"
|
|
#include "demos/DemoManager.h"
|
|
#include "rules/UserGroup.h"
|
|
#include "rules/AdminSystem.h"
|
|
#include "rules/VoteManager.h"
|
|
#include "Atmosphere.h"
|
|
#include "misc/Door.h"
|
|
#include "vehicles/Transport.h"
|
|
#include "vehicles/VehicleWeapon.h"
|
|
#include "ScriptEntity.h"
|
|
#include "Waypoints/LocationMarker.h"
|
|
#include "proficiency/StatsTracker.h"
|
|
#include "../framework/async/Demo.h"
|
|
#include "../sys/sys_local.h"
|
|
|
|
#ifndef _XENON
|
|
#include "../sdnet/SDNet.h"
|
|
#endif
|
|
|
|
#define ON_UIVALID( handle, thename ) sdUserInterfaceLocal* thename = GetUserInterface( handle ); if ( thename )
|
|
#define ON_UIINVALID( handle, thename ) sdUserInterfaceLocal* thename = GetUserInterface( handle ); if ( !thename )
|
|
|
|
idList< qhandle_t > idGameLocal::taskListHandles;
|
|
|
|
/*
|
|
================
|
|
idGameLocal::HandleGuiEvent
|
|
================
|
|
*/
|
|
bool idGameLocal::HandleGuiEvent( const sdSysEvent* event ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
return false;
|
|
}
|
|
|
|
ON_UIVALID( uiMainMenuHandle, ui ) {
|
|
if ( ui->IsActive() ) {
|
|
return ui->PostEvent( event );
|
|
}
|
|
}
|
|
|
|
sdHudModule* module = localPlayerProperties.GetActiveHudModule();
|
|
if ( module && module->HandleGuiEvent( event ) ) {
|
|
return true;
|
|
}
|
|
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
if ( localPlayer ) {
|
|
if( isServer && event->GetKey() == K_F1 && event->IsKeyDown() && isPaused && localPlayer->IsSinglePlayerToolTipPlaying() ) {
|
|
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "unPauseGame\n" );
|
|
return true;
|
|
}
|
|
|
|
if ( localPlayer->HandleGuiEvent( event ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if ( rules ) {
|
|
if ( rules->HandleGuiEvent( event ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idGameLocal::TranslateGuiBind
|
|
================
|
|
*/
|
|
bool idGameLocal::TranslateGuiBind( const idKey& key, sdKeyCommand** cmd ) {
|
|
ON_UIVALID( uiMainMenuHandle, ui ) {
|
|
if ( ui->IsActive() ) {
|
|
if ( ui->Translate( key, cmd ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
sdHudModule* module = gameLocal.localPlayerProperties.GetActiveHudModule();
|
|
if ( module != NULL ) {
|
|
sdUserInterfaceLocal* ui = module->GetGui();
|
|
if ( ui != NULL ) {
|
|
if ( ui->Translate( key, cmd ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
if ( localPlayer ) {
|
|
if ( localPlayer->TranslateGuiBind( key, cmd ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if ( rules != NULL ) {
|
|
if ( rules->TranslateGuiBind( key, cmd ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::ShowMainMenu
|
|
============
|
|
*/
|
|
void idGameLocal::ShowMainMenu() {
|
|
ON_UIVALID( uiMainMenuHandle, ui ) {
|
|
ui->Activate();
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::HideMainMenu
|
|
============
|
|
*/
|
|
void idGameLocal::HideMainMenu() {
|
|
// ao: never called
|
|
|
|
ON_UIVALID( uiMainMenuHandle, ui ) {
|
|
ui->Deactivate( true );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::IsMainMenuActive
|
|
============
|
|
*/
|
|
bool idGameLocal::IsMainMenuActive() {
|
|
ON_UIVALID( uiMainMenuHandle, ui ) {
|
|
return ui->IsActive();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::DrawMainMenu
|
|
============
|
|
*/
|
|
void idGameLocal::DrawMainMenu() {
|
|
ON_UIINVALID( uiMainMenuHandle, ui ) {
|
|
return;
|
|
}
|
|
|
|
if ( gamestate == GAMESTATE_NOMAP ) {
|
|
sdGlobalStatsTracker::GetInstance().UpdateStatsRequests();
|
|
}
|
|
|
|
ui->Draw();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::DrawSystemUI
|
|
============
|
|
*/
|
|
void idGameLocal::DrawSystemUI() {
|
|
ON_UIINVALID( uiSystemUIHandle, ui ) {
|
|
return;
|
|
}
|
|
|
|
ui->Draw();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::DrawLoadScreen
|
|
============
|
|
*/
|
|
void idGameLocal::DrawLoadScreen() {
|
|
ON_UIINVALID( uiLevelLoadHandle, ui ) {
|
|
return;
|
|
}
|
|
|
|
ui->Activate();
|
|
ui->Update();
|
|
ui->Draw();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::DrawPureWaitScreen
|
|
============
|
|
*/
|
|
void idGameLocal::DrawPureWaitScreen() {
|
|
ON_UIINVALID( pureWaitHandle, ui ) {
|
|
return;
|
|
}
|
|
|
|
ui->Activate();
|
|
ui->Update();
|
|
ui->Draw();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateKeyBindingList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateKeyBindingList( sdUIList* list ) {
|
|
assert( list );
|
|
|
|
using namespace sdProperties;
|
|
idStr category;
|
|
if( sdProperty* property = list->GetScope().GetProperties().GetProperty( "bindCategory", PT_STRING )) {
|
|
category = *property->value.stringValue;
|
|
}
|
|
|
|
sdUIList::ClearItems( list );
|
|
const sdDeclKeyBinding* bind = gameLocal.declKeyBindingType.LocalFind( category, false );
|
|
if( bind == NULL ) {
|
|
return;
|
|
}
|
|
|
|
idWStr text;
|
|
for( int i = 0; i < bind->GetKeys().GetNumKeyVals(); i++ ) {
|
|
const idKeyValue* kv = bind->GetKeys().GetKeyVal( i );
|
|
int item = sdUIList::InsertItem( list, va( L"<loc = '%hs'>", kv->GetKey().c_str() ), -1, 0 );
|
|
|
|
int numKeys = 0;
|
|
keyInputManager->KeysFromBinding( gameLocal.GetDefaultBindContext(), kv->GetValue(), numKeys, NULL );
|
|
|
|
idKey** keys = NULL;
|
|
|
|
if( numKeys > 0 ) {
|
|
keys = static_cast< idKey** >( _alloca( numKeys * sizeof( idKey* ) ) );
|
|
keyInputManager->KeysFromBinding( gameLocal.GetDefaultBindContext(), kv->GetValue(), numKeys, keys );
|
|
}
|
|
|
|
if( numKeys > 0 ) {
|
|
assert( keys != NULL );
|
|
keys[ 0 ]->GetLocalizedText( text );
|
|
sdUIList::CleanUserInput( text );
|
|
sdUIList::SetItemText( list, text.c_str(), item, 1 );
|
|
} else {
|
|
sdUIList::SetItemText( list, L"<loc = 'guis/mainmenu/bindings/unbound'>", item, 1 );
|
|
}
|
|
if( numKeys > 1 ) {
|
|
assert( keys != NULL );
|
|
keys[ 1 ]->GetLocalizedText( text );
|
|
sdUIList::CleanUserInput( text );
|
|
sdUIList::SetItemText( list, text.c_str(), item, 2 );
|
|
} else {
|
|
sdUIList::SetItemText( list, L"<loc = 'guis/mainmenu/bindings/unbound'>", item, 2 );
|
|
}
|
|
sdUIList::SetItemText( list, va( L"%hs", kv->GetValue().c_str() ), item, 3 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateCrosshairList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateCrosshairList( sdUIList* list ) {
|
|
assert( list != NULL );
|
|
|
|
sdUIList::ClearItems( list );
|
|
|
|
int num = gameLocal.declStringMapType.Num();
|
|
for( int i = 0; i < num; i++ ) {
|
|
const sdDeclStringMap* decl = gameLocal.declStringMapType.LocalFindByIndex( i, false );
|
|
if( idStr::Icmpn( decl->GetName(), "crosshairs", 10 ) != 0 ) {
|
|
continue;
|
|
}
|
|
// ensure we're parsed
|
|
gameLocal.declStringMapType.LocalFindByIndex( i, true );
|
|
|
|
const idDict& dict = decl->GetDict();
|
|
for( int j = 0; j < dict.GetNumKeyVals(); j++ ) {
|
|
const idKeyValue* kv = dict.GetKeyVal( j );
|
|
sdUIList::InsertItem( list, va( L"<material = 'literal: %hs'>\t%hs\t%hs", kv->GetValue().c_str(), decl->GetName(), kv->GetKey().c_str() ), -1, 0 );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateDemoList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateDemoList( sdUIList* list ) {
|
|
|
|
sdUIList::ClearItems( list );
|
|
idFileList* files = fileSystem->ListFiles( "demos", ".ndm" );
|
|
if( files == NULL ) {
|
|
return;
|
|
}
|
|
|
|
idStr file;
|
|
idWStr date;
|
|
idStr fullPath;
|
|
sysTime_t time;
|
|
|
|
if( files->GetNumFiles() > 0 ) {
|
|
list->BeginBatch();
|
|
list->SetItemGranularity( files->GetNumFiles() );
|
|
for( int i = 0; i < files->GetNumFiles(); i++ ) {
|
|
file = files->GetFile( i );
|
|
if( networkSystem->CanPlayDemo( file.c_str() ) ) {
|
|
unsigned int timeStamp;
|
|
|
|
fullPath = files->GetBasePath();
|
|
fullPath += "/" + file;
|
|
fileSystem->ReadFile( fullPath, NULL, &timeStamp );
|
|
|
|
sys->SecondsToTime( timeStamp, time );
|
|
sdNetProperties::FormatTimeStamp( time, date );
|
|
|
|
file.StripFileExtension();
|
|
int index = sdUIList::InsertItem( list, va( L"%hs\t%ls\t%hs", file.c_str(), date.c_str(), fullPath.c_str() ), -1, 0 );
|
|
list->SetItemDataInt( timeStamp, index, 1, true );
|
|
}
|
|
}
|
|
list->EndBatch();
|
|
}
|
|
|
|
fileSystem->FreeFileList( files );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateVehiclePlayerList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateVehiclePlayerList( sdUIList* list ) {
|
|
idPlayer* localPlayer = gameLocal.GetLocalViewPlayer();
|
|
if ( localPlayer == NULL ) {
|
|
if( g_debugPlayerList.GetInteger() ) {
|
|
sdUIList::ClearItems( list );
|
|
idWStr formatString;
|
|
for( int i = 0; i < g_debugPlayerList.GetInteger(); i++ ) {
|
|
formatString = va( L"<material = \"soldier\" >\tPlayer%i", i );
|
|
sdUIList::InsertItem( list, formatString.c_str(), -1, 0 );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
sdUIList::ClearItems( list );
|
|
|
|
idEntity* proxy = localPlayer->GetProxyEntity();
|
|
if( proxy == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if ( sdUsableInterface* iface = proxy->GetUsableInterface() ) {
|
|
const wchar_t* formatString;
|
|
|
|
int selIndex = -1;
|
|
idWStr cleanPlayerName;
|
|
|
|
for( int i = 0; i < iface->GetNumPositions(); i++ ) {
|
|
const idPlayer* player = iface->GetPlayerAtPosition( i );
|
|
if( player == NULL ) {
|
|
if( g_debugPlayerList.GetInteger() ) {
|
|
formatString = va( L"<material = \"soldier\" >\tPlayer%i", i );
|
|
sdUIList::InsertItem( list, formatString, -1, 0 );
|
|
}
|
|
continue;
|
|
}
|
|
if( const sdDeclPlayerClass* pc = player->GetInventory().GetClass() ) {
|
|
cleanPlayerName = va( L"%hs", player->userInfo.name.c_str() );
|
|
sdUIList::CleanUserInput( cleanPlayerName );
|
|
formatString = va( L"<material = \"%hs\" >\t%ls", ( pc == NULL ) ? "" : pc->GetName(), cleanPlayerName.c_str() );
|
|
int index = sdUIList::InsertItem( list, formatString, -1, 0 );
|
|
if( player == localPlayer ) {
|
|
selIndex = index;
|
|
}
|
|
}
|
|
}
|
|
list->SelectItem( selIndex );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateScoreboardList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateScoreboardList( sdUIList* list ) {
|
|
if( gameLocal.rules ) {
|
|
idStr teamName;
|
|
if( sdUserInterfaceLocal* ui = list->GetUI() ) {
|
|
ui->PopScriptVar( teamName );
|
|
}
|
|
gameLocal.rules->UpdateScoreboard( list, teamName );
|
|
} else {
|
|
if( sdUserInterfaceLocal* ui = list->GetUI() ) {
|
|
idStr name;
|
|
ui->PopScriptVar( name );
|
|
ui->PushScriptVar( 0.0f );
|
|
ui->PushScriptVar( 0.0f );
|
|
ui->PushScriptVar( 0.0f );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreatePlayerAdminList
|
|
============
|
|
*/
|
|
void idGameLocal::CreatePlayerAdminList( sdUIList* list ) {
|
|
sdAdminSystem::GetInstance().CreatePlayerAdminList( list );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateUserGroupList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateUserGroupList( sdUIList* list ) {
|
|
sdUserGroupManager::GetInstance().CreateUserGroupList( list );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateUserGroupList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateServerConfigList( sdUIList* list ) {
|
|
sdUserGroupManager::GetInstance().CreateServerConfigList( list );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamListEntry
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamListEntry( sdUIList* list, int index, idPlayer* player ) {
|
|
static const idVec4 noDraw( 0.0f, 0.0f, 0.0f, 0.0f );
|
|
|
|
sdUIList::InsertItem( list, L"", index, 0 );
|
|
|
|
const sdDeclPlayerClass* cls = player->GetInventory().GetClass();
|
|
if ( cls != NULL ) {
|
|
// class
|
|
sdUIList::SetItemIcon( list, cls->GetName(), index, 0 );
|
|
}
|
|
|
|
// rank/voip
|
|
bool sendingVoice = ( sys->Milliseconds() - networkSystem->GetLastVoiceReceivedTime( player->entityNumber ) ) < SEC2MS( 0.5f );
|
|
if ( sendingVoice ) {
|
|
sdUIList::SetItemIcon( list, "voip", index, 1 );
|
|
sdUIList::SetItemForeColor( list, colorWhite, index, 1 );
|
|
} else if ( const sdDeclRank* rank = player->GetProficiencyTable().GetRank() ) {
|
|
sdUIList::SetItemIcon( list, rank->GetMaterial(), index, 1 );
|
|
sdUIList::SetItemForeColor( list, colorWhite, index, 1 );
|
|
} else {
|
|
sdUIList::SetItemForeColor( list, noDraw, index, 1 );
|
|
}
|
|
|
|
// name
|
|
|
|
idWStr cleanPlayerName = va( L"%hs", player->userInfo.cleanName.c_str() );
|
|
sdUIList::CleanUserInput( cleanPlayerName );
|
|
|
|
sdUIList::SetItemText( list, cleanPlayerName.c_str(), index, 2 );
|
|
|
|
if( player->IsInLimbo() ) {
|
|
sdUIList::SetItemForeColor( list, colorBlack, index, 2 );
|
|
} else {
|
|
float healthFrac = player->GetHealth() / ( float )player->GetMaxHealth();
|
|
healthFrac = idMath::ClampFloat( 0.0f, 1.0f, healthFrac );
|
|
idVec4 healthColor( 1.0f - healthFrac, healthFrac, 0.0f, 1.0f );
|
|
sdUIList::SetItemForeColor( list, healthColor, index, 2 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
|
|
int listType;
|
|
if( sdUserInterfaceLocal* ui = list->GetUI() ) {
|
|
ui->PopScriptVar( listType );
|
|
}
|
|
|
|
if ( gameLocal.rules == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if ( gameLocal.GetLocalPlayer() == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if ( listType == FIRETEAMLIST_MYFIRETEAM ) {
|
|
CreateFireTeamList_MyFireTeam( list );
|
|
} else if ( listType == FIRETEAMLIST_MAIN ) {
|
|
CreateFireTeamList_Main( list );
|
|
} else if ( listType == FIRETEAMLIST_JOIN ) {
|
|
CreateFireTeamList_Join( list );
|
|
} else if ( listType == FIRETEAMLIST_INVITE ) {
|
|
CreateFireTeamList_Invite( list );
|
|
} else if ( listType == FIRETEAMLIST_KICK ) {
|
|
CreateFireTeamList_Kick( list );
|
|
} else if ( listType == FIRETEAMLIST_PROMOTE ) {
|
|
CreateFireTeamList_Promote( list );
|
|
} else if ( listType == FIRETEAMLIST_MANAGE ) {
|
|
CreateFireTeamList_Manage( list );
|
|
} else {
|
|
assert( 0 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamList_MyFireTeam
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamList_MyFireTeam( sdUIList* list ) {
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( localPlayer->entityNumber );
|
|
if ( fireTeam != NULL ) {
|
|
int index = 0;
|
|
for ( int i = 0; i < fireTeam->GetNumMembers(); i++, index++ ) {
|
|
idPlayer* player = fireTeam->GetMember( i );
|
|
CreateFireTeamListEntry( list, index, player );
|
|
}
|
|
if ( g_debugPlayerList.GetInteger() ) {
|
|
int i = 0;
|
|
|
|
int num = 8;
|
|
while ( list->GetNumItems() < num ) {
|
|
idWStr formatString = va( L"<material = \"soldier\" >\t<material = \"guis/assets/icons/rank01\" >\tPlayer%i\t<fore = 1,1,1,1>100.00XP\t100%%", i );
|
|
sdUIList::InsertItem( list, formatString.c_str(), -1, 0 );
|
|
i++;
|
|
}
|
|
}
|
|
} else {
|
|
sdTeamInfo* localTeam = localPlayer->GetGameTeam();
|
|
if ( localTeam == NULL ) {
|
|
return;
|
|
}
|
|
|
|
idStaticList< idPlayer*, MAX_CLIENTS > playerList;
|
|
|
|
// Mission teams
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer* player = gameLocal.GetClient( i );
|
|
if ( player == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player->GetGameTeam() != localTeam ) {
|
|
continue;
|
|
}
|
|
|
|
if ( gameLocal.rules->GetPlayerFireTeam( i ) != NULL ) {
|
|
continue;
|
|
}
|
|
|
|
if( player->GetActiveTaskHandle() != localPlayer->GetActiveTaskHandle() ) {
|
|
continue;
|
|
}
|
|
|
|
playerList.Append( player );
|
|
}
|
|
|
|
for ( int i = 0; i < playerList.Num() && i < MAX_MISSION_TEAM_PLAYERS; i++ ) {
|
|
idPlayer* player = playerList[ i ];
|
|
CreateFireTeamListEntry( list, i, player );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamList_Main
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamList_Main( sdUIList* list ) {
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
|
|
bool canJoin = false;
|
|
bool canCreate = false;
|
|
for ( int i = 0; i < sdTeamInfo::MAX_FIRETEAMS; i++ ) {
|
|
sdFireTeam& fireTeam = localPlayer->GetTeam()->GetFireTeam( i );
|
|
if ( fireTeam.GetNumMembers() > 0 ) {
|
|
if ( !fireTeam.IsPrivate() ) {
|
|
if ( fireTeam.MaxMembers() - fireTeam.GetNumMembers() > 0 ) {
|
|
canJoin = true;
|
|
}
|
|
}
|
|
} else {
|
|
canCreate = true;
|
|
}
|
|
}
|
|
|
|
if ( canJoin ) {
|
|
sdUIList::InsertItem( list, va( L" 1. %ls\tcanjoin", common->LocalizeText( "guis/hud/fireteam/menu/join" ).c_str() ), 0, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L" 1. ^1%ls\tcannot", common->LocalizeText( "guis/hud/fireteam/menu/join" ).c_str() ), 0, 0 );
|
|
}
|
|
|
|
if ( canCreate ) {
|
|
sdUIList::InsertItem( list, va( L" 2. %ls\tcancreate", common->LocalizeText( "guis/hud/fireteam/menu/create" ).c_str() ), 1, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L" 2. ^1%ls\tcannot", common->LocalizeText( "guis/hud/fireteam/menu/create" ).c_str() ), 1, 0 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamList_Join
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamList_Join( sdUIList* list ) {
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
|
|
int num = 0;
|
|
for ( int i = 0; i < sdTeamInfo::MAX_FIRETEAMS; i++ ) {
|
|
sdFireTeam& fireTeam = localPlayer->GetTeam()->GetFireTeam( i );
|
|
if ( !fireTeam.IsPrivate() ) {
|
|
if ( fireTeam.GetNumMembers() > 0 && fireTeam.MaxMembers() - fireTeam.GetNumMembers() > 0 ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %hs\t%i", num+1, fireTeam.GetName(), i ), i, 0 );
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamList_Invite
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamList_Invite( sdUIList* list ) {
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( localPlayer->entityNumber );
|
|
|
|
if ( fireTeam == NULL ) {
|
|
return;
|
|
}
|
|
|
|
int page;
|
|
if( sdUserInterfaceLocal* ui = list->GetUI() ) {
|
|
ui->PopScriptVar( page );
|
|
}
|
|
|
|
assert( page >= 0 && page <= 1 );
|
|
|
|
int numAdded = 0;
|
|
int numFound = 0;
|
|
if ( fireTeam->MaxMembers() - fireTeam->GetNumMembers() >= 1 ) {
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer *p = gameLocal.GetClient( i );
|
|
if ( p != NULL && p->GetTeam() == localPlayer->GetTeam() ) {
|
|
if ( gameLocal.rules->GetPlayerFireTeam( i ) == NULL ) {
|
|
numFound++;
|
|
if ( numFound > FIRETEAMLIST_PAGE_NUM_PLAYERS * page && numAdded < FIRETEAMLIST_PAGE_NUM_PLAYERS ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %hs\t%hs", numAdded+1, p->userInfo.cleanName.c_str(), p->userInfo.cleanName.c_str() ), numAdded, 0 );
|
|
numAdded++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( numFound != numAdded ) {
|
|
if ( page == 1 ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tprevpage", numAdded+1, common->LocalizeText( "guis/hud/fireteam/menu/prevpage" ).c_str() ), numAdded, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tnextpage", numAdded+1, common->LocalizeText( "guis/hud/fireteam/menu/nextpage" ).c_str() ), numAdded, 0 );
|
|
}
|
|
numAdded++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamList_Kick
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamList_Kick( sdUIList* list ) {
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( localPlayer->entityNumber );
|
|
|
|
if ( fireTeam == NULL ) {
|
|
return;
|
|
}
|
|
|
|
int numAdded = 0;
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer* p = gameLocal.GetClient( i );
|
|
if ( p != NULL && p != localPlayer && fireTeam->IsMember( p ) ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %hs\t%hs", numAdded+1, p->userInfo.cleanName.c_str(), p->userInfo.cleanName.c_str() ), numAdded, 0 );
|
|
numAdded++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamList_Promote
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamList_Promote( sdUIList* list ) {
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( localPlayer->entityNumber );
|
|
|
|
if ( fireTeam == NULL ) {
|
|
return;
|
|
}
|
|
|
|
int numAdded = 0;
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer* p = gameLocal.GetClient( i );
|
|
if ( p != NULL && p != localPlayer && fireTeam->IsMember( p ) ) {
|
|
if ( !p->userInfo.isBot ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %hs\t%hs", numAdded+1, p->userInfo.cleanName.c_str(), p->userInfo.cleanName.c_str() ), numAdded, 0 );
|
|
numAdded++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateFireTeamList_Manage
|
|
============
|
|
*/
|
|
void idGameLocal::CreateFireTeamList_Manage( sdUIList* list ) {
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( localPlayer->entityNumber );
|
|
|
|
if ( fireTeam == NULL ) {
|
|
return;
|
|
}
|
|
|
|
int index = 0;
|
|
|
|
if ( fireTeam->IsCommander( localPlayer ) ) {
|
|
bool canInvite = false;
|
|
if ( fireTeam->MaxMembers() - fireTeam->GetNumMembers() > 0 ) {
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer *p = gameLocal.GetClient( i );
|
|
if ( p != NULL && p->GetTeam() == localPlayer->GetTeam() ) {
|
|
if ( gameLocal.rules->GetPlayerFireTeam( i ) == NULL ) {
|
|
canInvite = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( canInvite ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tcaninvite", index+1, common->LocalizeText( "guis/hud/fireteam/menu/invite" ).c_str() ), index, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L" %i. ^1%ls\tcannot", index+1, common->LocalizeText( "guis/hud/fireteam/menu/invite" ).c_str() ), index, 0 );
|
|
}
|
|
index++;
|
|
|
|
if ( fireTeam->GetNumMembers() > 1 ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tcankick", index+1, common->LocalizeText( "guis/hud/fireteam/menu/kick" ).c_str() ), index, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L" %i. ^1%ls\tcannot", index+1, common->LocalizeText( "guis/hud/fireteam/menu/kick" ).c_str() ), index, 0 );
|
|
}
|
|
index++;
|
|
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tdisband", index+1, common->LocalizeText( "guis/hud/fireteam/menu/disband" ).c_str() ), index, 0 );
|
|
index++;
|
|
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tleave", index+1, common->LocalizeText( "guis/hud/fireteam/menu/leave" ).c_str() ), index, 0 );
|
|
index++;
|
|
|
|
|
|
int numPromote = 0;
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer* p = gameLocal.GetClient( i );
|
|
if ( p != NULL && p != localPlayer && fireTeam->IsMember( p ) ) {
|
|
if ( !p->userInfo.isBot ) {
|
|
numPromote++;
|
|
}
|
|
}
|
|
}
|
|
if ( numPromote > 0 ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tcanpromote", index+1, common->LocalizeText( "guis/hud/fireteam/menu/promote" ).c_str() ), index, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L" %i. ^1%ls\tcannot", index+1, common->LocalizeText( "guis/hud/fireteam/menu/promote" ).c_str() ), index, 0 );
|
|
}
|
|
index++;
|
|
|
|
if ( fireTeam->IsPrivate() ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tpublic", index+1, common->LocalizeText( "guis/hud/fireteam/menu/makepublic" ).c_str() ), index, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tprivate", index+1, common->LocalizeText( "guis/hud/fireteam/menu/makeprivate" ).c_str() ), index, 0 );
|
|
}
|
|
index++;
|
|
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\trename", index+1, common->LocalizeText( "guis/hud/fireteam/menu/rename" ).c_str() ), index, 0 );
|
|
index++;
|
|
} else {
|
|
bool canPropose = false;
|
|
if ( fireTeam->MaxMembers() - fireTeam->GetNumMembers() >= 1 ) {
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer *p = gameLocal.GetClient( i );
|
|
if ( p != NULL && p->GetTeam() == localPlayer->GetTeam() ) {
|
|
if ( gameLocal.rules->GetPlayerFireTeam( i ) == NULL ) {
|
|
canPropose = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( canPropose ) {
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tcanpropose", index+1, common->LocalizeText( "guis/hud/fireteam/menu/propose" ).c_str() ), index, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L" %i. ^1%ls\tcannot", index+1, common->LocalizeText( "guis/hud/fireteam/menu/propose" ).c_str() ), index, 0 );
|
|
}
|
|
index++;
|
|
|
|
sdUIList::InsertItem( list, va( L" %i. %ls\tleave", index+1, common->LocalizeText( "guis/hud/fireteam/menu/leave" ).c_str() ), index, 0 );
|
|
index++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GeneratePlayerListForTask
|
|
============
|
|
*/
|
|
void idGameLocal::GeneratePlayerListForTask( idStr& playerList, const sdPlayerTask* task ) {
|
|
sdStringBuilder_Heap builder;
|
|
playerList.Clear();
|
|
|
|
sdTaskManagerLocal& manager = sdTaskManager::GetInstance();
|
|
|
|
for( int playerIndex = 0; playerIndex < gameLocal.numClients; playerIndex++ ) {
|
|
idPlayer* player = gameLocal.GetClient( playerIndex );
|
|
if ( player == NULL ) {
|
|
continue;
|
|
}
|
|
if ( player->GetActiveTaskHandle() != task->GetHandle() ) {
|
|
continue;
|
|
}
|
|
|
|
builder += " " + player->userInfo.name;
|
|
}
|
|
builder.ToString( playerList );
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::InsertTask
|
|
============
|
|
*/
|
|
int idGameLocal::InsertTask( sdUIList* list, const sdPlayerTask* task, bool highlightActive ) {
|
|
const char* iconMat = "guis/nodraw";
|
|
if ( task->GetInfo()->GetNumWayPoints() > 0 ) {
|
|
const idMaterial* mat = task->GetInfo()->GetWaypointIcon( 0 );
|
|
if( mat != NULL ) {
|
|
iconMat = mat->GetName();
|
|
}
|
|
}
|
|
|
|
idWStr xpString = task->GetInfo()->GetXPString();
|
|
sdUIList::CleanUserInput( xpString );
|
|
|
|
int index = sdUIList::InsertItem( list, va( L"<material = \"::%hs\">\t%ls\t<align = right>%ls",
|
|
iconMat, task->GetTitle(), xpString.c_str() ), -1, 0 );
|
|
|
|
return index;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateActiveTaskList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateActiveTaskList( sdUIList* list ) {
|
|
sdTaskManagerLocal& manager = sdTaskManager::GetInstance();
|
|
|
|
sdUIList::ClearItems( list );
|
|
bool showAll;
|
|
list->GetUI()->PopScriptVar( showAll );
|
|
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
idPlayer* localPlayerView = gameLocal.GetLocalViewPlayer();
|
|
if ( localPlayerView == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if ( g_debugPlayerList.GetInteger() ) {
|
|
sdUIList::InsertItem( list, L"Task 1", 0, 1 );
|
|
idWStrList parms( 1 );
|
|
keyInputManager->KeysFromBinding( gameLocal.GetDefaultBindContext(), "_taskmenu", true, parms.Alloc() );
|
|
sdUIList::InsertItem( list, va( L"<fore = 0 1 0 1>\t%ls", common->LocalizeText( "guis/hud/tasks_are_available", parms ).c_str() ), -1, 1 );
|
|
return;
|
|
}
|
|
|
|
sdTeamInfo* team = localPlayerView->GetGameTeam();
|
|
if ( team == NULL ) {
|
|
return;
|
|
}
|
|
|
|
bool canSelect = true;
|
|
sdPlayerTask* activeTask = NULL;
|
|
|
|
sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( localPlayerView->entityNumber );
|
|
if ( fireTeam != NULL ) {
|
|
activeTask = fireTeam->GetCommander()->GetActiveTask();
|
|
canSelect = fireTeam->GetCommander() == localPlayer;
|
|
} else {
|
|
activeTask = localPlayerView->GetActiveTask();
|
|
}
|
|
|
|
const sdPlayerTask::nodeType_t& objectiveTasks = sdTaskManager::GetInstance().GetObjectiveTasks( team );
|
|
sdPlayerTask* objectiveTask = objectiveTasks.Next();
|
|
if ( ( showAll || activeTask == NULL ) && objectiveTask != NULL ) {
|
|
int index = InsertTask( list, objectiveTask, false );
|
|
if( activeTask == NULL ) {
|
|
list->SelectItem( index );
|
|
}
|
|
}
|
|
|
|
gameLocal.localPlayerProperties.SetHasTask( !showAll && canSelect && ( activeTask != NULL || ( activeTask == NULL && objectiveTask != NULL ) ) );
|
|
|
|
if( showAll && canSelect && localPlayerView == localPlayer ) {
|
|
playerTaskList_t miniList;
|
|
manager.BuildTaskList( localPlayer, miniList );
|
|
int num = Min( sdPlayerTask::MAX_CHOOSABLE_TASKS, miniList.Num() );
|
|
|
|
for( int i = 0; i < num; i++ ) {
|
|
int index = InsertTask( list, miniList[ i ], false );
|
|
if( activeTask == miniList[ i ] ){
|
|
list->SelectItem( index );
|
|
}
|
|
}
|
|
/*
|
|
int index = sdUIList::InsertItem( list, common->LocalizeText( "guis/game/scoreboard/nomission" ).c_str(), -1, 1 );
|
|
if( activeTask == NULL ) {
|
|
list->SelectItem( index );
|
|
}
|
|
*/
|
|
idWStrList args( 1 );
|
|
keyInputManager->KeysFromBinding( gameLocal.GetDefaultBindContext(), "_taskmenu", true, args.Alloc() );
|
|
|
|
const idWStr localized = common->LocalizeText( "guis/hud/tasks_are_available", args );
|
|
sdUIList::InsertItem( list, localized.c_str(), -1, 1 );
|
|
|
|
return;
|
|
}
|
|
|
|
if ( activeTask != NULL ) {
|
|
int index = InsertTask( list, activeTask, false );
|
|
list->SelectItem( index );
|
|
}
|
|
|
|
if ( localPlayerView != localPlayer ) {
|
|
return;
|
|
}
|
|
|
|
playerTaskList_t miniList;
|
|
manager.BuildTaskList( localPlayer, miniList );
|
|
|
|
int numAvailableTasks = miniList.Num();
|
|
|
|
if( objectiveTask != NULL ) {
|
|
numAvailableTasks++;
|
|
}
|
|
|
|
if ( numAvailableTasks > 1 && canSelect ) {
|
|
idWStrList args( 1 );
|
|
keyInputManager->KeysFromBinding( gameLocal.GetDefaultBindContext(), "_taskmenu", true, args.Alloc() );
|
|
|
|
const idWStr localized = common->LocalizeText( "guis/hud/tasks_are_available", args );
|
|
sdUIList::InsertItem( list, localized.c_str(), -1, 1 );
|
|
}
|
|
|
|
if ( list->GetNumItems() == 0 ) {
|
|
const idWStr localized = common->LocalizeText( "guis/hud/no_tasks" );
|
|
sdUIList::InsertItem( list, localized.c_str(), -1, 1 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GetTaskListHandle
|
|
============
|
|
*/
|
|
qhandle_t idGameLocal::GetTaskListHandle( int index ) {
|
|
if ( index < 0 || index >= taskListHandles.Num() ) {
|
|
return -1;
|
|
}
|
|
|
|
return taskListHandles[ index ];
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::TestGUI_f
|
|
============
|
|
*/
|
|
void idGameLocal::TestGUI_f( const idCmdArgs& args ) {
|
|
if( args.Argc() < 2 || idStr::Length( args.Argv( 1 )) == 0 ) {
|
|
gameLocal.uiMainMenuHandle = gameLocal.LoadUserInterface( "mainmenu", false, true );
|
|
} else {
|
|
gameLocal.uiMainMenuHandle = gameLocal.LoadUserInterface( args.Argv( 1 ), false, true );
|
|
// jrad - something of a hack:
|
|
// ensure that we're pushing the proper times through to the gui
|
|
sdUserInterfaceLocal* ui =gameLocal.GetUserInterface( gameLocal.uiMainMenuHandle );
|
|
if( ui != NULL ) {
|
|
ui->SetGUIFlag( sdUserInterfaceLocal::GUI_FRONTEND );
|
|
}
|
|
}
|
|
gameLocal.ShowMainMenu();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idGameLocal::LoadUserInterface
|
|
================
|
|
*/
|
|
guiHandle_t idGameLocal::LoadUserInterface( const char* name, bool requireUnique, bool permanent, const char* theme, sdHudModule* module ) {
|
|
return uiManager->AllocUI( name, requireUnique, permanent, theme, module );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idGameLocal::FreeUserInterface
|
|
================
|
|
*/
|
|
void idGameLocal::FreeUserInterface( guiHandle_t handle ) {
|
|
uiManager->FreeUserInterface( handle );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idGameLocal::GetUserInterface
|
|
================
|
|
*/
|
|
sdUserInterfaceLocal* idGameLocal::GetUserInterface( const guiHandle_t handle ) {
|
|
return static_cast< sdUserInterfaceLocal* >( uiManager->GetUserInterface( handle ) );
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GetUserInterfaceWindow
|
|
============
|
|
*/
|
|
sdUIWindow* idGameLocal::GetUserInterfaceWindow( const guiHandle_t handle, const char* windowName ) {
|
|
if( handle.IsValid() ) {
|
|
sdUserInterfaceLocal* ui = GetUserInterface( handle );
|
|
if( ui ) {
|
|
return ui->GetWindow( windowName )->Cast< sdUIWindow >();
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GetUserInterfaceProperty
|
|
============
|
|
*/
|
|
sdProperties::sdProperty* idGameLocal::GetUserInterfaceProperty( guiHandle_t handle, const char* propertyName, sdProperties::ePropertyType expectedType ) {
|
|
if( sdUserInterfaceLocal* ui = GetUserInterface( handle ) ) {
|
|
return ui->GetState().GetProperty( propertyName, expectedType );
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GetUserInterfaceProperty_r
|
|
============
|
|
*/
|
|
sdProperties::sdProperty* idGameLocal::GetUserInterfaceProperty_r( guiHandle_t handle, const char* propertyName, sdProperties::ePropertyType expectedType ) {
|
|
sdProperties::sdProperty* property = GetUserInterfaceProperty( handle, propertyName, expectedType );
|
|
if( property ) {
|
|
return property;
|
|
}
|
|
|
|
if( sdUserInterfaceLocal* ui = GetUserInterface( handle ) ) {
|
|
idLexer parser( propertyName, idStr::Length( propertyName ), "GetUserInterfaceProperty_r", sdDeclGUI::LEXER_FLAGS | LEXFL_NOERRORS );
|
|
|
|
sdUserInterfaceScope* scope = GetUserInterfaceScope( ui->GetState(), &parser );
|
|
if( scope ) {
|
|
idToken token;
|
|
if( parser.ReadToken( &token )) {
|
|
return scope->GetProperty( token, expectedType );
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idGameLocal::GetUserInterfaceScope
|
|
================
|
|
*/
|
|
sdUserInterfaceScope* idGameLocal::GetGlobalUserInterfaceScope( sdUserInterfaceScope& scope, const char* name ) {
|
|
for( int i = 0; i < uiScopes.Num(); i++ ) {
|
|
guiScope_t& scope = uiScopes[ i ];
|
|
if( idStr::Icmp( name, scope.name ) == 0 ) {
|
|
return scope.scope;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idGameLocal::GetUserInterfaceScope
|
|
================
|
|
*/
|
|
sdUserInterfaceScope* idGameLocal::GetUserInterfaceScope( sdUserInterfaceScope& scope, idLexer* src ) {
|
|
idToken dot;
|
|
idToken token;
|
|
|
|
if ( !src->ReadToken( &token ) ) {
|
|
return &scope;
|
|
}
|
|
|
|
if ( token.type != TT_NAME ) {
|
|
src->UnreadToken( &token );
|
|
return &scope;
|
|
}
|
|
|
|
sdUserInterfaceScope* altScope = &scope;
|
|
|
|
sdUserInterfaceScope* globalScope = GetGlobalUserInterfaceScope( scope, token );
|
|
if ( globalScope ) {
|
|
if ( !src->ReadToken( &dot ) || dot != "." ) {
|
|
src->UnreadToken( &dot );
|
|
src->UnreadToken( &token );
|
|
return &scope;
|
|
}
|
|
src->ReadToken( &token );
|
|
altScope = globalScope;
|
|
}
|
|
|
|
while( true ) {
|
|
sdUserInterfaceScope* temp;
|
|
if ( !token.Cmp( "self" ) ) {
|
|
temp = altScope;
|
|
} else {
|
|
temp = altScope->GetSubScope( token );
|
|
}
|
|
|
|
if ( !temp || !src->ReadToken( &dot ) ) {
|
|
src->UnreadToken( &token );
|
|
return altScope;
|
|
}
|
|
|
|
if ( dot != "." ) {
|
|
src->UnreadToken( &dot );
|
|
src->UnreadToken( &token );
|
|
return altScope;
|
|
}
|
|
|
|
src->ReadToken( &token );
|
|
altScope = temp;
|
|
|
|
if ( token.type != TT_NAME ) {
|
|
return altScope;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
sdUIScopeParser::sdUIScopeParser
|
|
================
|
|
*/
|
|
sdUIScopeParser::sdUIScopeParser( const char* text ) {
|
|
idStr::Copynz( entryText, text, sizeof( entryText ) );
|
|
|
|
int len = idStr::Length( entryText );
|
|
( *entries.Alloc() ) = entryText;
|
|
int index = 0;
|
|
while ( ( index = idStr::FindChar( entryText, '.', index, len - 1 ) ) != idStr::INVALID_POSITION ) {
|
|
entryText[ index ] = '\0';
|
|
index++;
|
|
const char** entry = entries.Alloc();
|
|
if ( entry == NULL ) {
|
|
gameLocal.Error( "sdUIScopeParser: Max Entries Hit" );
|
|
}
|
|
*entry = &entryText[ index ];
|
|
}
|
|
|
|
entryIndex = 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idGameLocal::GetUserInterfaceScope
|
|
================
|
|
*/
|
|
sdUserInterfaceScope* idGameLocal::GetUserInterfaceScope( sdUserInterfaceScope& scope, sdUIScopeParser& src ) {
|
|
sdUserInterfaceScope* altScope = &scope;
|
|
|
|
const char* token = src.GetNextEntry();
|
|
if ( src.IsLastEntry() ) {
|
|
src.Revert();
|
|
return altScope;
|
|
}
|
|
|
|
sdUserInterfaceScope* globalScope = GetGlobalUserInterfaceScope( scope, token );
|
|
if ( globalScope != NULL ) {
|
|
altScope = globalScope;
|
|
token = src.GetNextEntry();
|
|
}
|
|
|
|
while ( true ) {
|
|
if ( src.IsLastEntry() ) {
|
|
src.Revert();
|
|
return altScope;
|
|
}
|
|
|
|
sdUserInterfaceScope* temp = altScope->GetSubScope( token );
|
|
if ( temp == NULL ) {
|
|
gameLocal.Warning( "idGameLocal::GetUserInterfaceScope Failed To Find Scope: '%s'", token );
|
|
return altScope;
|
|
}
|
|
|
|
altScope = temp;
|
|
token = src.GetNextEntry();
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GuiFrameEvents
|
|
============
|
|
*/
|
|
void idGameLocal::GuiFrameEvents( bool outOfSequence ) {
|
|
uiManager->Update( outOfSequence );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateInventoryList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateInventoryList( sdUIList* list ) {
|
|
sdUserInterfaceLocal* ui = list->GetUI();
|
|
|
|
assert( ui );
|
|
|
|
idStr classname;
|
|
int bank;
|
|
int package;
|
|
|
|
ui->PopScriptVar( classname );
|
|
ui->PopScriptVar( bank );
|
|
ui->PopScriptVar( package );
|
|
|
|
|
|
idPlayer* player = gameLocal.GetLocalPlayer();
|
|
idList< itemBankPair_t > items;
|
|
ui->EnumerateItemsForBank( items, classname, bank, package );
|
|
|
|
for( int i = 0; i < items.Num(); i++ ) {
|
|
const wchar_t* formatString = va( L"<material = '::%hs'>\t<align = top><loc = '%hs'>", items[ i ].first->GetData().GetString( "mtr_weaponmenu", "default" ), items[ i ].first->GetItemName()->GetName() );
|
|
int index = sdUIList::InsertItem( list, formatString, -1, 0 );
|
|
list->SetItemDataInt( items[ i ].second, index, 0 );
|
|
}
|
|
}
|
|
|
|
typedef sdPair< int, const vidmode_t* > modePair_t;
|
|
struct sortVidMode_t {
|
|
int operator()( const modePair_t& a, const modePair_t& b ) {
|
|
if( a.second->width == b.second->width ) {
|
|
return a.second->height - b.second->height;
|
|
}
|
|
return a.second->width - b.second->width;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateVideoModeList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateVideoModeList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
|
|
bool fullScreen;
|
|
list->GetUI()->PopScriptVar( fullScreen );
|
|
|
|
int aspect;
|
|
list->GetUI()->PopScriptVar( aspect );
|
|
|
|
int currentMode = cvarSystem->GetCVarInteger( "r_mode" );
|
|
int startMode = 3;
|
|
int selIndex = -1;
|
|
|
|
static const char* ratios[ 4 ] = {
|
|
"(4:3)",
|
|
"(16:9)",
|
|
"(16:10)",
|
|
"(5:4)"
|
|
};
|
|
|
|
idList< modePair_t > modes;
|
|
|
|
for( int i = startMode; i < common->GetNumVideoModes(); i++ ) {
|
|
const vidmode_t& mode = common->GetVideoMode( i );
|
|
// don't show modes that the monitor says it doesn't support
|
|
if ( fullScreen && !mode.available ) {
|
|
continue;
|
|
}
|
|
if ( aspect != -1 && aspect != mode.aspectRatio ) {
|
|
continue;
|
|
}
|
|
modes.Append( modePair_t( i, &mode ) );
|
|
}
|
|
|
|
sdQuickSort( modes.Begin(), modes.End(), sortVidMode_t() );
|
|
|
|
|
|
int nextBestModeWidth = -1;
|
|
int nextBestMode = -1;
|
|
|
|
const int currentWidth = currentMode == -1 ? cvarSystem->GetCVarInteger( "r_customWidth" ) : common->GetVideoMode( currentMode ).width;
|
|
|
|
for( int i = 0; i < modes.Num(); i++ ) {
|
|
const vidmode_t& mode = *modes[ i ].second;
|
|
int index = sdUIList::InsertItem( list, va( L"%ix%i %hs\t%i", mode.width, mode.height, ratios[ mode.aspectRatio ], modes[ i ].first ), -1, 0 );
|
|
if( modes[ i ].first == currentMode ) {
|
|
selIndex = index;
|
|
}
|
|
if( modes[ i ].second->width < currentWidth && modes[ i ].second->width > nextBestModeWidth ) {
|
|
nextBestMode = index;
|
|
nextBestModeWidth = modes[ i ].second->width;
|
|
}
|
|
}
|
|
|
|
if( selIndex != -1 ) {
|
|
list->SelectItem( selIndex );
|
|
} else if( nextBestMode != -1 ) {
|
|
list->SelectItem( nextBestMode );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateCampaignList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateCampaignList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
for( int i = 0; i < gameLocal.campaignMetaDataList->GetNumMetaData(); i++ ) {
|
|
const metaDataContext_t& metaDataContext = gameLocal.campaignMetaDataList->GetMetaDataContext( i );
|
|
if ( !gameLocal.IsMetaDataValidForPlay( metaDataContext, true ) ) {
|
|
continue;
|
|
}
|
|
const idDict& dict = *metaDataContext.meta;
|
|
|
|
const char* materialName = dict.GetString( "server_shot_thumb" );
|
|
const char* prettyName = dict.GetString( "pretty_name" );
|
|
const char* defName = dict.GetString( "metadata_name" );
|
|
int index = sdUIList::InsertItem( list, va( L"%hs\t%hs\t%hs", prettyName, defName, materialName ), -1, 0 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateMapList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateMapList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
|
|
sdAddonMetaDataList* metaData = fileSystem->ListAddonMetaData( "mapMetaData" );
|
|
for( int i = 0; i < metaData->GetNumMetaData(); i++ ) {
|
|
const metaDataContext_t& metaDataContext = metaData->GetMetaDataContext( i );
|
|
if ( !gameLocal.IsMetaDataValidForPlay( metaDataContext, true ) ) {
|
|
continue;
|
|
}
|
|
const idDict& data = *metaDataContext.meta;
|
|
|
|
const char* materialName = data.GetString( "server_shot_thumb", "levelshots/thumbs/generic.tga" );
|
|
const char* defName = data.GetString( "metadata_name" );
|
|
const char* prettyName = data.GetString( "pretty_name" );
|
|
int index = sdUIList::InsertItem( list, va( L"%hs\t%hs\t%hs", prettyName, defName, materialName ), -1, 0 );
|
|
}
|
|
|
|
fileSystem->FreeAddonMetaDataList( metaData );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::PacifierUpdate
|
|
============
|
|
*/
|
|
void idGameLocal::PacifierUpdate() {
|
|
gameLocal.localPlayerProperties.PacifierUpdate();
|
|
|
|
deviceContext->BeginEmitFullScreen();
|
|
|
|
if ( sdUserInterfaceLocal* ui = GetUserInterface( uiLevelLoadHandle ) ) {
|
|
ui->SetCurrentTime( sys->Milliseconds() );
|
|
ui->Update();
|
|
ui->Draw();
|
|
}
|
|
|
|
deviceContext->End();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::ShowLevelLoadScreen
|
|
============
|
|
*/
|
|
void idGameLocal::ShowLevelLoadScreen( const char* mapName ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
return;
|
|
}
|
|
/*
|
|
if ( !reloadingSameMap ) {
|
|
bytesNeededForMapLoad = GetBytesNeededForMapLoad( mapName );
|
|
} else {
|
|
bytesNeededForMapLoad = 30 * 1024 * 1024;
|
|
}
|
|
*/
|
|
idStr stripped = mapName;
|
|
stripped.StripFileExtension();
|
|
|
|
mapMetaData = mapMetaDataList->FindMetaData( stripped, &defaultMetaData );
|
|
mapInfo = declMapInfoType.LocalFind( mapMetaData->GetString( "mapinfo", "default" ) );
|
|
|
|
using namespace sdProperties;
|
|
if ( sdUserInterfaceScope* scope = globalProperties.GetSubScope( "mapinfo" ) ) {
|
|
if ( sdProperty* property = scope->GetProperty( "numObjectives", PT_FLOAT ) ) {
|
|
*property->value.floatValue = mapInfo->GetData().GetFloat( "numObjectives", "0" );
|
|
}
|
|
}
|
|
|
|
|
|
sdUserInterfaceLocal* ui;
|
|
|
|
ui = GetUserInterface( pureWaitHandle );
|
|
if ( ui != NULL ) {
|
|
ui->Deactivate( false );
|
|
}
|
|
|
|
uiLevelLoadHandle = LoadUserInterface( "loadscreen", false, true );
|
|
|
|
UpdateCampaignStats( true );
|
|
|
|
ui = GetUserInterface( uiLevelLoadHandle );
|
|
if ( ui != NULL ) {
|
|
ui->SetCurrentTime( sys->Milliseconds() );
|
|
ui->Activate();
|
|
PacifierUpdate();
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::UpdateLevelLoadScreen
|
|
============
|
|
*/
|
|
void idGameLocal::UpdateLevelLoadScreen( const wchar_t* status ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
return;
|
|
}
|
|
|
|
using namespace sdProperties;
|
|
sdUserInterfaceScope* scope = globalProperties.GetSubScope( "mapinfo" );
|
|
if( scope ) {
|
|
if( sdProperty* property = scope->GetProperty( "mapStatus", PT_WSTRING )) {
|
|
*property->value.wstringValue = status;
|
|
}
|
|
}
|
|
common->PacifierUpdate();
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::HideLevelLoadScreen
|
|
============
|
|
*/
|
|
void idGameLocal::HideLevelLoadScreen() {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
return;
|
|
}
|
|
|
|
if ( sdUserInterfaceLocal* ui = GetUserInterface( uiLevelLoadHandle ) ) {
|
|
ui->Deactivate();
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GetUIManager
|
|
============
|
|
*/
|
|
sdUserInterfaceManager* idGameLocal::GetUIManager() {
|
|
return uiManager;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::SetGUIFloat
|
|
============
|
|
*/
|
|
void idGameLocal::SetGUIFloat( int handle, const char* name, float value ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceScope* scope;
|
|
if ( handle == GUI_GLOBALS_HANDLE ) {
|
|
scope = &gameLocal.globalProperties;
|
|
} else {
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if ( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::SetGUIFloat: could not find GUI" );
|
|
return;
|
|
}
|
|
scope = &ui->GetState();
|
|
}
|
|
|
|
sdUIScopeParser parser( name );
|
|
scope = gameLocal.GetUserInterfaceScope( *scope, parser );
|
|
|
|
sdProperties::sdProperty* prop = NULL;
|
|
|
|
const char* token = parser.GetNextEntry();
|
|
if ( token == NULL ) {
|
|
assert( false );
|
|
} else {
|
|
prop = scope->GetProperty( token, sdProperties::PT_FLOAT );
|
|
}
|
|
|
|
if ( prop != NULL ) {
|
|
*( prop->value.floatValue ) = value;
|
|
} else {
|
|
gameLocal.Warning( "idGameLocal::SetGUIFloat: could not find float property '%s'", name );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GetGUIFloat
|
|
============
|
|
*/
|
|
float idGameLocal::GetGUIFloat( int handle, const char* name ) {
|
|
if( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceScope* scope;
|
|
|
|
if ( handle == GUI_GLOBALS_HANDLE ) {
|
|
scope = &gameLocal.globalProperties;
|
|
} else {
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::GetGUIFloat: could not find GUI" );
|
|
return 0.0f;
|
|
}
|
|
scope = &ui->GetState();
|
|
}
|
|
|
|
sdUIScopeParser parser( name );
|
|
scope = gameLocal.GetUserInterfaceScope( *scope, parser );
|
|
|
|
sdProperties::sdProperty* prop = NULL;
|
|
|
|
const char* token = parser.GetNextEntry();
|
|
if ( token == NULL ) {
|
|
assert( false );
|
|
} else {
|
|
prop = scope->GetProperty( token, sdProperties::PT_FLOAT );
|
|
}
|
|
|
|
if ( prop == NULL ) {
|
|
gameLocal.Warning( "idGameLocal::GetGUIFloat: could not find float property '%s'", name );
|
|
return 0.f;
|
|
}
|
|
|
|
return prop->value.floatValue->GetValue();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::SetGUIInt
|
|
============
|
|
*/
|
|
void idGameLocal::SetGUIInt( int handle, const char* name, int value ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceScope* scope;
|
|
if ( handle == GUI_GLOBALS_HANDLE ) {
|
|
scope = &gameLocal.globalProperties;
|
|
} else {
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if ( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::SetGUIInt: could not find GUI" );
|
|
return;
|
|
}
|
|
scope = &ui->GetState();
|
|
}
|
|
|
|
sdUIScopeParser parser( name );
|
|
scope = gameLocal.GetUserInterfaceScope( *scope, parser );
|
|
|
|
sdProperties::sdProperty* prop = NULL;
|
|
|
|
const char* token = parser.GetNextEntry();
|
|
if ( token == NULL ) {
|
|
assert( false );
|
|
} else {
|
|
prop = scope->GetProperty( token, sdProperties::PT_INT );
|
|
}
|
|
|
|
if ( prop != NULL ) {
|
|
*( prop->value.intValue ) = value;
|
|
} else {
|
|
gameLocal.Warning( "idGameLocal::SetGUIInt: could not find int property '%s'", name );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::SetGUIVec2
|
|
============
|
|
*/
|
|
void idGameLocal::SetGUIVec2( int handle, const char* name, const idVec2& value ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceScope* scope;
|
|
if ( handle == GUI_GLOBALS_HANDLE ) {
|
|
scope = &gameLocal.globalProperties;
|
|
} else {
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::SetGUIVec2: could not find GUI" );
|
|
return;
|
|
}
|
|
scope = &ui->GetState();
|
|
}
|
|
|
|
sdUIScopeParser parser( name );
|
|
scope = gameLocal.GetUserInterfaceScope( *scope, parser );
|
|
|
|
sdProperties::sdProperty* prop = NULL;
|
|
|
|
const char* token = parser.GetNextEntry();
|
|
if ( token == NULL ) {
|
|
assert( false );
|
|
} else {
|
|
prop = scope->GetProperty( token, sdProperties::PT_VEC2 );
|
|
}
|
|
|
|
if ( prop != NULL ) {
|
|
*( prop->value.vec2Value ) = value;
|
|
} else {
|
|
gameLocal.Warning( "idGameLocal::SetGUIVec2: could not find vec2 property '%s'", name );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::SetGUIVec3
|
|
============
|
|
*/
|
|
void idGameLocal::SetGUIVec3( int handle, const char* name, const idVec3& value ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceScope* scope;
|
|
if ( handle == GUI_GLOBALS_HANDLE ) {
|
|
scope = &gameLocal.globalProperties;
|
|
} else {
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::SetGUIVec3: could not find GUI" );
|
|
return;
|
|
}
|
|
scope = &ui->GetState();
|
|
}
|
|
|
|
sdUIScopeParser parser( name );
|
|
scope = gameLocal.GetUserInterfaceScope( *scope, parser );
|
|
|
|
sdProperties::sdProperty* prop = NULL;
|
|
|
|
const char* token = parser.GetNextEntry();
|
|
if ( token == NULL ) {
|
|
assert( false );
|
|
} else {
|
|
prop = scope->GetProperty( token, sdProperties::PT_VEC3 );
|
|
}
|
|
|
|
if ( prop != NULL ) {
|
|
*( prop->value.vec3Value ) = value;
|
|
} else {
|
|
gameLocal.Warning( "idGameLocal::SetGUIVec3: could not find vec3 property '%s'", name );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::SetGUIVec4
|
|
============
|
|
*/
|
|
void idGameLocal::SetGUIVec4( int handle, const char* name, const idVec4& value ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceScope* scope;
|
|
if ( handle == GUI_GLOBALS_HANDLE ) {
|
|
scope = &gameLocal.globalProperties;
|
|
} else {
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::SetGUIVec4: could not find GUI" );
|
|
return;
|
|
}
|
|
scope = &ui->GetState();
|
|
}
|
|
|
|
sdUIScopeParser parser( name );
|
|
scope = gameLocal.GetUserInterfaceScope( *scope, parser );
|
|
|
|
sdProperties::sdProperty* prop = NULL;
|
|
|
|
const char* token = parser.GetNextEntry();
|
|
if ( token == NULL ) {
|
|
assert( false );
|
|
} else {
|
|
prop = scope->GetProperty( token, sdProperties::PT_VEC4 );
|
|
}
|
|
|
|
if ( prop != NULL ) {
|
|
*( prop->value.vec4Value ) = value;
|
|
} else {
|
|
gameLocal.Warning( "idGameLocal::SetGUIVec4: could not find vec4 property '%s'", name );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::SetGUIString
|
|
============
|
|
*/
|
|
void idGameLocal::SetGUIString( int handle, const char* name, const char* value ) {
|
|
if ( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceScope* scope;
|
|
if ( handle == GUI_GLOBALS_HANDLE ) {
|
|
scope = &gameLocal.globalProperties;
|
|
} else {
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::SetGUIString: could not find GUI" );
|
|
return;
|
|
}
|
|
scope = &ui->GetState();
|
|
}
|
|
|
|
sdUIScopeParser parser( name );
|
|
scope = gameLocal.GetUserInterfaceScope( *scope, parser );
|
|
|
|
sdProperties::sdProperty* prop = NULL;
|
|
|
|
const char* token = parser.GetNextEntry();
|
|
if ( token == NULL ) {
|
|
assert( false );
|
|
} else {
|
|
prop = scope->GetProperty( token, sdProperties::PT_STRING );
|
|
}
|
|
|
|
if ( prop != NULL ) {
|
|
*( prop->value.stringValue ) = value;
|
|
} else {
|
|
gameLocal.Warning( "idGameLocal::SetGUIString: could not find string property '%s'", name );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::SetGUIWString
|
|
============
|
|
*/
|
|
void idGameLocal::SetGUIWString( int handle, const char* name, const wchar_t* value ) {
|
|
if( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceScope* scope;
|
|
|
|
if ( handle == GUI_GLOBALS_HANDLE ) {
|
|
scope = &gameLocal.globalProperties;
|
|
} else {
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::SetGUIWString: could not find GUI" );
|
|
return;
|
|
}
|
|
scope = &ui->GetState();
|
|
}
|
|
|
|
sdUIScopeParser parser( name );
|
|
scope = gameLocal.GetUserInterfaceScope( *scope, parser );
|
|
|
|
sdProperties::sdProperty* prop = NULL;
|
|
|
|
const char* token = parser.GetNextEntry();
|
|
if ( token == NULL ) {
|
|
assert( false );
|
|
} else {
|
|
prop = scope->GetProperty( token, sdProperties::PT_WSTRING );
|
|
}
|
|
|
|
if ( prop != NULL ) {
|
|
*( prop->value.wstringValue ) = value;
|
|
} else {
|
|
gameLocal.Warning( "idGameLocal::SetGUIWString: could not find string property '%s'", name );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::SetGUITheme
|
|
============
|
|
*/
|
|
void idGameLocal::SetGUITheme( guiHandle_t handle, const char* theme ) {
|
|
if( !handle ) {
|
|
gameLocal.Error( "SetGUITheme: Invalid GUI handle." );
|
|
return;
|
|
}
|
|
|
|
sdUserInterfaceLocal* ui = static_cast< sdUserInterfaceLocal* >( uiManager->GetUserInterface( handle ) );
|
|
if( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::SetGUITheme : Could not find GUI." );
|
|
return;
|
|
}
|
|
ui->SetTheme( theme );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::GUIPostNamedEvent
|
|
============
|
|
*/
|
|
void idGameLocal::GUIPostNamedEvent( int handle, const char* window, const char* name ) {
|
|
if( networkSystem->IsDedicated() ) {
|
|
gameLocal.Warning( "Tried to run a GUI command on the server" );
|
|
}
|
|
|
|
sdUserInterfaceLocal* ui = gameLocal.GetUserInterface( handle );
|
|
if( !ui ) {
|
|
gameLocal.Warning( "idGameLocal::GUIPostNamedEvent: could not find GUI" );
|
|
return;
|
|
}
|
|
sdUIObject* object = NULL;
|
|
if( idStr::Length( window )) {
|
|
object = ui->GetWindow( window );
|
|
}
|
|
|
|
if( !object && idStr::Length( window )) {
|
|
gameLocal.Warning( "idGameLocal::GUIPostNamedEvent: could not find window '%s'", window );
|
|
return;
|
|
} else if( object ) {
|
|
object->PostNamedEvent( name, false );
|
|
} else {
|
|
ui->PostNamedEvent( name );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::UpdateCampaignStats
|
|
============
|
|
*/
|
|
void idGameLocal::UpdateCampaignStats( bool allowMedia ) {
|
|
if( networkSystem->IsDedicated() ) {
|
|
return;
|
|
}
|
|
|
|
sdGameRules* rulesInstance = gameLocal.GetRulesInstance( serverInfo.GetString( "si_rules" ) );
|
|
|
|
if( rulesInstance != NULL ) {
|
|
rulesInstance->UpdateClientFromServerInfo( serverInfo, allowMedia );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateWeaponSwitchList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateWeaponSwitchList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
if( localPlayer == NULL ) {
|
|
return;
|
|
}
|
|
|
|
using namespace sdProperties;
|
|
|
|
const sdInventory& inv = localPlayer->GetInventory();
|
|
const int currentWeapon = inv.GetCurrentWeapon();
|
|
const int switchingWeapon = inv.GetSwitchingWeapon();
|
|
|
|
if( currentWeapon == -1 || switchingWeapon == -1 ) {
|
|
return;
|
|
}
|
|
|
|
const sdDeclInvItem* item = inv.GetItem( currentWeapon );
|
|
const sdDeclInvItem* switchItem = inv.GetItem( switchingWeapon );
|
|
|
|
typedef sdPair< const sdDeclInvItem*, int > invElement_t;
|
|
idStaticList< invElement_t, 10 > items;
|
|
|
|
for( int i = 0; i < inv.GetNumItems(); i++ ) {
|
|
if ( !inv.CanAutoEquip( i, false ) ) {
|
|
continue;
|
|
}
|
|
|
|
const sdDeclInvItem* item = inv.GetItem( i );
|
|
if ( inv.GetSlotForWeapon( i ) != -1 ) {
|
|
int j = 0;
|
|
const sdDeclInvSlot* slot = gameLocal.declInvSlotType.LocalFindByIndex( item->GetSlot() );
|
|
|
|
while( j < items.Num() ) {
|
|
if( item->GetSlot() < items[ j ].first->GetSlot() ) {
|
|
break;
|
|
}
|
|
|
|
const sdDeclInvSlot* otherSlot = gameLocal.declInvSlotType.LocalFindByIndex( items[ j ].first->GetSlot() );
|
|
if( slot->GetBank() < otherSlot->GetBank() ) {
|
|
break;
|
|
}
|
|
|
|
j++;
|
|
}
|
|
items.Insert( invElement_t( item, i ), j );
|
|
}
|
|
}
|
|
|
|
int offset = 0;
|
|
for( int i = 0; i < items.Num(); i++ ) {
|
|
int bankNumber = i;
|
|
const sdDeclInvItem* invItem = inv.GetItem( items[ i ].second );
|
|
const bool available = inv.CheckWeaponHasAmmo( invItem ) || invItem->GetData().GetBool( "select_when_empty", "0" );
|
|
const char* material = invItem->GetData().GetString( "mtr_weaponmenu", "_default" );
|
|
const int title = invItem->GetItemName()->Index();
|
|
float weaponAmmo = -1.0f;
|
|
|
|
const idList< itemClip_t >& itemClips = invItem->GetClips();
|
|
|
|
if ( itemClips.Num() && itemClips[ 0 ].ammoPerShot > 0 ) {
|
|
float ammo;
|
|
float totalAmmo;
|
|
if( invItem->GetData().GetBool( "show_all_ammo", "0" )) {
|
|
ammo = inv.GetAmmo( itemClips[ 0 ].ammoType ) / itemClips[ 0 ].ammoPerShot;
|
|
totalAmmo = inv.GetMaxAmmo( itemClips[ 0 ].ammoType ) / itemClips[ 0 ].ammoPerShot;
|
|
} else {
|
|
ammo = inv.GetClip( items[ i ].second, 0 );
|
|
totalAmmo = inv.GetClipSize( items[ i ].second, 0 );
|
|
}
|
|
weaponAmmo = idMath::ClampFloat( 0.0f, 1.0f, ammo / totalAmmo );
|
|
}
|
|
|
|
int index = sdUIList::InsertItem( list, va( L"%i\t<material = '::%hs'>\t%f\t%i\t%i", invItem->GetSlot(), material, weaponAmmo, title, available ), -1, 0 );
|
|
|
|
if( invItem == switchItem ) {
|
|
list->SelectItem( index );
|
|
localPlayer->SetWeaponSelectionItemIndex( bankNumber );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateColorList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateColorList( sdUIList* list ) {
|
|
idVec4 customColor;
|
|
list->GetUI()->PopScriptVar( customColor );
|
|
|
|
idStr currentColorStr;
|
|
list->GetUI()->PopScriptVar( currentColorStr );
|
|
|
|
idVec4 currentColor = colorWhite;
|
|
if( !currentColorStr.IsEmpty() ) {
|
|
currentColor = sdTypeFromString< idVec4 >( currentColorStr.c_str() );
|
|
}
|
|
|
|
// if refreshing, only add new custom colors
|
|
bool refreshOnly;
|
|
list->GetUI()->PopScriptVar( refreshOnly );
|
|
|
|
if( refreshOnly == false ) {
|
|
sdUIList::ClearItems( list );
|
|
}
|
|
|
|
idWStr str;
|
|
idWStr colorSymbol;
|
|
idStr color;
|
|
|
|
bool customMatchesDefault = false;
|
|
int toSelect = -1;
|
|
static const float COLOR_EPSILON = 0.001f;
|
|
|
|
// check against previous custom colors
|
|
if( refreshOnly == false || list->GetNumItems() == 0 ) {
|
|
// skip default color
|
|
for( int i = 1; i < COLOR_BITS + 1; i++ ) {
|
|
const idVec4& c = idStr::ColorForIndex( i );
|
|
if( c.ToVec3().Compare( customColor.ToVec3(), COLOR_EPSILON ) ) {
|
|
customMatchesDefault = true;
|
|
}
|
|
colorSymbol = va( L"%hs", idStr::StrForColorIndex( i ) );
|
|
sdUIList::CleanUserInput( colorSymbol );
|
|
color = c.ToString( 2 );
|
|
str = va( L"<fore = %hs><material = '::guis/assets/white'>\t%ls\t%hs", color.c_str(), colorSymbol.c_str(), color.c_str() );
|
|
int index = sdUIList::InsertItem( list, str.c_str(), -1, 0 );
|
|
|
|
if( currentColor.ToVec3().Compare( c.ToVec3(), COLOR_EPSILON ) ) {
|
|
toSelect = index;
|
|
}
|
|
}
|
|
} else {
|
|
for( int i = 0; i < list->GetNumItems(); i++ ) {
|
|
idVec4 c = sdTypeFromString< idVec4 >( va( "%ls", list->GetItemText( i, 2, true ) ) );
|
|
if( c.ToVec3().Compare( customColor.ToVec3(), COLOR_EPSILON ) ) {
|
|
customMatchesDefault = true;
|
|
}
|
|
if( currentColor.ToVec3().Compare( c.ToVec3(), COLOR_EPSILON ) ) {
|
|
toSelect = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if( !customMatchesDefault ) {
|
|
str = va( L"<fore = %hs><material = '::guis/assets/white'>\t%\t%hs", customColor.ToString( 2 ), customColor.ToString( 2 ) );
|
|
int index = sdUIList::InsertItem( list, str.c_str(), -1, 0 );
|
|
if( currentColor.ToVec3().Compare( customColor.ToVec3(), COLOR_EPSILON ) ) {
|
|
toSelect = index;
|
|
}
|
|
}
|
|
list->SelectItem( toSelect );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateSpawnLocationList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateSpawnLocationList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
idStr team;
|
|
list->GetUI()->PopScriptVar( team );
|
|
|
|
const sdTeamInfo* info = sdTeamManager::GetInstance().GetTeamSafe( team.c_str() );
|
|
if( info == NULL ) {
|
|
return;
|
|
}
|
|
|
|
int currentSpawn = -1;
|
|
int defaultSpawn = -1;
|
|
|
|
int numLocs = info->GetNumSpawnLocations();
|
|
int* spawnCounts = static_cast< int* >( _alloca( numLocs * sizeof( int ) ) );
|
|
memset( &spawnCounts[ 0 ], 0, numLocs * sizeof( int ) );
|
|
|
|
const idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
for( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer* player = gameLocal.GetClient( i );
|
|
if( player == NULL || player->GetGameTeam() != info ) {
|
|
continue;
|
|
}
|
|
const idEntity* playerSpawnLoc = player->GetSpawnPoint();
|
|
for( int si = 0; si < numLocs; si++ ) {
|
|
const idEntity* spawn = info->GetSpawnLocation( si );
|
|
if( playerSpawnLoc == NULL && spawn == info->GetDefaultSpawn() ) {
|
|
defaultSpawn = si;
|
|
if( playerSpawnLoc == NULL ) {
|
|
spawnCounts[ defaultSpawn ]++;
|
|
break;
|
|
}
|
|
}
|
|
if( spawn == playerSpawnLoc ) {
|
|
spawnCounts[ si ]++;
|
|
|
|
if( player == localPlayer ) {
|
|
currentSpawn = si;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
idWStr loc;
|
|
for( int i = 0; i < numLocs; i++ ) {
|
|
const idEntity* spawn = info->GetSpawnLocation( i );
|
|
|
|
sdLocationMarker::GetLocationText( spawn->GetPhysics()->GetOrigin(), loc );
|
|
int index = sdUIList::InsertItem( list, va( L"%ls\t%i\t%hs", loc.c_str(), spawnCounts[ i ], spawn->GetName() ), -1, 0 );
|
|
if( i == currentSpawn ) {
|
|
list->SelectItem( index );
|
|
}
|
|
}
|
|
int index = sdUIList::InsertItem( list, L"<loc = 'guis/mainmenu/defaultspawn'>\t\t", -1, 0 );
|
|
if( currentSpawn == -1 ) {
|
|
list->SelectItem( index );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateMSAAList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateMSAAList( sdUIList* list ) {
|
|
int num = renderSystem->GetNumMSAAModes();
|
|
for (int i=0; i<num; i++) {
|
|
int val;
|
|
const char *msaaName = renderSystem->GetMSAAMode( i, val );
|
|
int index = sdUIList::InsertItem( list, va( L"%hs", msaaName ), -1, 0 );
|
|
list->SetItemDataInt( val, index, 0, true );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateSoundPlaybackList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateSoundPlaybackList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
const idWStrList* devices = soundSystem->ListSoundPlaybackDevices();
|
|
|
|
for( int i = 0; devices != NULL && i < devices->Num(); i++ ) {
|
|
const idWStr& str = (*devices)[ i ];
|
|
int hash = soundSystem->GetAudioDeviceHash( str.c_str() );
|
|
sdUIList::InsertItem( list, va( L"%ls\t%d", str.c_str(), hash ), -1, 0 );
|
|
}
|
|
|
|
soundSystem->FreeDeviceList( devices );
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateSoundCaptureList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateSoundCaptureList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
|
|
const idWStrList* devices = soundSystem->ListSoundCaptureDevices();
|
|
|
|
for( int i = 0; devices != NULL && i < devices->Num(); i++ ) {
|
|
const idWStr& str = (*devices)[ i ];
|
|
int hash = soundSystem->GetAudioDeviceHash( str.c_str() );
|
|
sdUIList::InsertItem( list, va( L"%ls\t%d", str.c_str(), hash ), -1, 0 );
|
|
}
|
|
|
|
soundSystem->FreeDeviceList( devices );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateModList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateModList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
|
|
idModList* mods = fileSystem->ListMods();
|
|
|
|
if( mods != NULL ) {
|
|
for( int i = 0; i < mods->GetNumMods(); i++ ) {
|
|
sdUIList::InsertItem( list, va( L"%hs\t%hs", mods->GetDescription( i ), mods->GetMod( i ) ), -1, 0 );
|
|
}
|
|
fileSystem->FreeModList( mods );
|
|
}
|
|
}
|
|
|
|
static void AddLifeStatsItems( sdUIList* list, const char* material, const idList< const sdStatsTracker::lifeStatsData_t* >& data ) {
|
|
for( int i = 0; i < data.Num(); i++ ) {
|
|
const sdStatsTracker::lifeStatsData_t* item = data[ i ];
|
|
const lifeStat_t& stat = gameLocal.lifeStats[ item->index ];
|
|
|
|
|
|
switch( item->newValue.GetType() ) {
|
|
case sdNetStatKeyValue::SVT_INT:
|
|
case sdNetStatKeyValue::SVT_INT_MAX:
|
|
if( stat.isTimeBased ) {
|
|
idStr::hmsFormat_t format;
|
|
format.showZeroMinutes = true;
|
|
|
|
sdUIList::InsertItem( list, va( L"<material = '%hs'>\t<loc = '%hs'>\t%hs (%hs)", material, stat.text->GetName(), idStr::MS2HMS( item->newValue.GetInt() * 1000, format ), idStr::MS2HMS( item->oldValue.GetInt() * 1000, format ) ), -1, 0 );
|
|
} else {
|
|
sdUIList::InsertItem( list, va( L"<material = '%hs'>\t<loc = '%hs'>\t%i (%i)", material, stat.text->GetName(), item->newValue.GetInt(), item->oldValue.GetInt() ), -1, 0 );
|
|
}
|
|
break;
|
|
case sdNetStatKeyValue::SVT_FLOAT:
|
|
case sdNetStatKeyValue::SVT_FLOAT_MAX:
|
|
sdUIList::InsertItem( list, va( L"<material = '%hs'>\t<loc = '%hs'>\t%i (%i)", material, stat.text->GetName(), idMath::Ftoi( idMath::Ceil( item->newValue.GetFloat() ) ), idMath::Ftoi( idMath::Ceil( item->oldValue.GetFloat() ) ) ), -1, 0 );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateLifeStatsList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateLifeStatsList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
|
|
idList< const sdStatsTracker::lifeStatsData_t* > improved;
|
|
idList< const sdStatsTracker::lifeStatsData_t* > unchanged;
|
|
idList< const sdStatsTracker::lifeStatsData_t* > worse;
|
|
|
|
sdGlobalStatsTracker::GetInstance().GetTopLifeStats( improved, unchanged, worse );
|
|
|
|
|
|
AddLifeStatsItems( list, "improved", improved );
|
|
AddLifeStatsItems( list, "unchanged", unchanged );
|
|
AddLifeStatsItems( list, "nodraw", worse );
|
|
}
|
|
|
|
|
|
class sdSortCategories {
|
|
public:
|
|
sdSortCategories( const sdProficiencyTable& table ) : table( table ) {}
|
|
int operator()( const sdDeclPlayerClass::proficiencyCategory_t* lhs, const sdDeclPlayerClass::proficiencyCategory_t* rhs ) {
|
|
float lhsPercent = table.GetPercent( lhs->index );
|
|
float rhsPercent = table.GetPercent( rhs->index );
|
|
|
|
return ( idMath::Ftoi( rhsPercent * 100 ) ) - ( idMath::Ftoi( lhsPercent * 100 ) );
|
|
}
|
|
|
|
const sdProficiencyTable& table;
|
|
};
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreatePredictedUpgradesList
|
|
============
|
|
*/
|
|
void idGameLocal::CreatePredictedUpgradesList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
if( localPlayer == NULL ) {
|
|
return;
|
|
}
|
|
|
|
const sdTeamInfo* ti = localPlayer->GetGameTeam();
|
|
idList< const sdDeclPlayerClass::proficiencyCategory_t* > bestCategories;
|
|
|
|
const sdProficiencyTable& table = localPlayer->GetProficiencyTable();
|
|
|
|
for( int i = 0; i < gameLocal.declPlayerClassType.Num(); i++ ) {
|
|
const sdDeclPlayerClass* pc = gameLocal.declPlayerClassType.LocalFindByIndex( i );
|
|
if( pc->GetTeam() != ti && ti != NULL ) {
|
|
continue;
|
|
}
|
|
|
|
for ( int j = 0; j < pc->GetNumProficiencies(); j++ ) {
|
|
const sdDeclPlayerClass::proficiencyCategory_t& category = pc->GetProficiency( j );
|
|
|
|
float percent = table.GetPercent( category.index );
|
|
if( percent >= 1.0f ) {
|
|
continue;
|
|
}
|
|
|
|
int k;
|
|
for( k = 0; k < bestCategories.Num(); k++ ) {
|
|
if( bestCategories[ k ]->index == category.index ) {
|
|
break;
|
|
}
|
|
}
|
|
if( k >= bestCategories.Num() ) {
|
|
bestCategories.Append( &category );
|
|
}
|
|
}
|
|
}
|
|
|
|
sdQuickSort( bestCategories.Begin(), bestCategories.End(), sdSortCategories( table ) );
|
|
|
|
int numAdded = 0;
|
|
for( int i = 0; i < bestCategories.Num() && numAdded < 2; i++ ) {
|
|
int currentLevel = table.GetLevel( bestCategories[ i ]->index );
|
|
if( currentLevel < bestCategories[ i ]->upgrades.Num() ) {
|
|
const sdDeclProficiencyType* type = gameLocal.declProficiencyTypeType.LocalFindByIndex( bestCategories[ i ]->index );
|
|
|
|
const sdDeclPlayerClass::proficiencyUpgrade_t& upgrade = bestCategories[ i ]->upgrades[ currentLevel ];
|
|
int index = sdUIList::InsertItem( list, va( L"<material = '%hs'>\t<loc = '%hs'>\t<flags customdraw>%hs",
|
|
upgrade.materialInfo.c_str(),
|
|
upgrade.title->GetName(),
|
|
type->GetName() ),
|
|
-1, 0 );
|
|
|
|
float percent = table.GetPercent( bestCategories[ i ]->index );
|
|
|
|
// push some extra data along for the GUI
|
|
list->SetItemDataInt( percent * 100 , index, 0, true );
|
|
list->SetItemDataInt( currentLevel, index, 1, true );
|
|
numAdded++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idGameLocal::CreateUpgradesReviewList
|
|
============
|
|
*/
|
|
void idGameLocal::CreateUpgradesReviewList( sdUIList* list ) {
|
|
sdUIList::ClearItems( list );
|
|
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
if( localPlayer == NULL ) {
|
|
return;
|
|
}
|
|
|
|
const sdTeamInfo* ti = localPlayer->GetGameTeam();
|
|
const sdProficiencyTable& table = localPlayer->GetProficiencyTable();
|
|
|
|
idList< const sdDeclPlayerClass::proficiencyCategory_t* > bestCategories;
|
|
|
|
for( int i = 0; i < gameLocal.declPlayerClassType.Num(); i++ ) {
|
|
const sdDeclPlayerClass* pc = gameLocal.declPlayerClassType.LocalFindByIndex( i );
|
|
if( pc->GetTeam() != ti && ti != NULL ) {
|
|
continue;
|
|
}
|
|
|
|
for ( int j = 0; j < pc->GetNumProficiencies(); j++ ) {
|
|
const sdDeclPlayerClass::proficiencyCategory_t& category = pc->GetProficiency( j );
|
|
|
|
int k;
|
|
for( k = 0; k < bestCategories.Num(); k++ ) {
|
|
if( bestCategories[ k ]->index == category.index ) {
|
|
break;
|
|
}
|
|
}
|
|
if( k < bestCategories.Num() ) {
|
|
continue;
|
|
}
|
|
|
|
bestCategories.Append( &category );
|
|
|
|
int currentLevel = table.GetLevel(category.index );
|
|
|
|
for ( int level = 0; level < currentLevel && level < category.upgrades.Num(); level++ ) {
|
|
const sdDeclPlayerClass::proficiencyUpgrade_t& upgrade = category.upgrades[ level ];
|
|
|
|
int index = sdUIList::InsertItem( list, va( L"<material = '%hs'>\t<loc = '%hs'>",
|
|
upgrade.materialInfo.c_str(),
|
|
upgrade.title->GetName()),
|
|
-1, 0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idGameLocal::UpdateHudStats
|
|
===============
|
|
*/
|
|
void idGameLocal::UpdateHudStats( idPlayer* player ) {
|
|
localPlayerProperties.Update( player );
|
|
limboProperties.Update();
|
|
sdAdminSystem::GetInstance().UpdateProperties();
|
|
}
|
|
|
|
#undef ON_UIVALID
|
|
#undef ON_UIINVALID
|
|
|