1596 lines
34 KiB
C++
1596 lines
34 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: LCD support
|
|
//
|
|
//=====================================================================================//
|
|
|
|
#if defined( WIN32 ) && !defined( _X360 )
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
#include "cbase.h"
|
|
|
|
#ifdef POSIX
|
|
#define HICON int
|
|
const int DT_LEFT = 1;
|
|
const int DT_CENTER = 2;
|
|
const int DT_RIGHT = 3;
|
|
#endif
|
|
|
|
#include "hud_lcd.h"
|
|
|
|
#include "vgui_controls/Controls.h"
|
|
#include "vgui_controls/SectionedListPanel.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "vgui/IScheme.h"
|
|
#include "vgui/IVGui.h"
|
|
#include "vgui/ILocalize.h"
|
|
#include "vgui/IPanel.h"
|
|
|
|
#include "c_team.h"
|
|
#include "c_playerresource.h"
|
|
#include "filesystem.h"
|
|
#include "g15/ig15.h"
|
|
|
|
#include "tier0/icommandline.h"
|
|
|
|
#if defined( _X360 )
|
|
#include "xbox/xbox_win32stubs.h"
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#define G15_RESOURCE_FILE "resource/g15.res"
|
|
#define G15_MODULE_NAME "bin/g15.dll"
|
|
|
|
#define SMALL_ITEM_HEIGHT 10
|
|
#define G15_DEFAULT_MAX_CHAT_HISTORY 4
|
|
|
|
CLCD gLCD;
|
|
IHudLCD *hudlcd = &gLCD;
|
|
|
|
CON_COMMAND( g15_reload, "Reloads the Logitech G-15 Keyboard configs." )
|
|
{
|
|
if ( !CommandLine()->FindParm( "-g15" ) )
|
|
{
|
|
Msg( "Must run with -g15 to enable support for the LCD Keyboard\n" );
|
|
return;
|
|
}
|
|
|
|
gLCD.Reload();
|
|
}
|
|
|
|
CON_COMMAND( g15_dumpplayer, "Spew player data." )
|
|
{
|
|
if ( !CommandLine()->FindParm( "-g15" ) )
|
|
{
|
|
Msg( "Must run with -g15 to enable support for the LCD Keyboard\n" );
|
|
return;
|
|
}
|
|
|
|
gLCD.DumpPlayer();
|
|
}
|
|
|
|
static ConVar g15_update_msec( "g15_update_msec", "250", FCVAR_ARCHIVE, "Logitech G-15 Keyboard update interval." );
|
|
|
|
void CLCDItem::Wipe( IG15 *lcd )
|
|
{
|
|
for ( int i = 0; i < m_Children.Count(); ++i )
|
|
{
|
|
if ( m_Children[ i ]->m_Handle )
|
|
{
|
|
lcd->RemoveAndDestroyObject( m_Children[ i ]->m_Handle );
|
|
}
|
|
|
|
m_Children[ i ]->Wipe( lcd );
|
|
|
|
delete m_Children[ i ];
|
|
}
|
|
|
|
m_Children.Purge();
|
|
|
|
}
|
|
void CLCDItemAggregate::Create( IG15 *lcd )
|
|
{
|
|
// Nothing
|
|
}
|
|
|
|
void CLCDItemAggregate::Wipe( IG15 *lcd )
|
|
{
|
|
BaseClass::Wipe( lcd );
|
|
|
|
for ( int i = 0; i < m_Definition.Count(); ++i )
|
|
{
|
|
m_Definition[ i ]->Wipe( lcd );
|
|
|
|
delete m_Definition[ i ];
|
|
}
|
|
|
|
m_Definition.Purge();
|
|
}
|
|
|
|
void CLCDItemAggregate::WipeChildrenOnly( IG15 *lcd )
|
|
{
|
|
BaseClass::Wipe( lcd );
|
|
}
|
|
|
|
void CLCDItemIcon::Create( IG15 *lcd )
|
|
{
|
|
#ifdef WIN32
|
|
m_Handle = lcd->AddIcon( (HICON)m_icon, w, h );
|
|
#else
|
|
m_Handle = lcd->AddIcon( (void *)m_icon, w, h );
|
|
#endif
|
|
lcd->SetOrigin( m_Handle, x, y );
|
|
lcd->SetVisible( m_Handle, false );
|
|
}
|
|
|
|
void CLCDItemText::Create( IG15 *lcd )
|
|
{
|
|
m_Handle = lcd->AddText( G15_STATIC_TEXT, (G15TextSize)m_iSize, m_iAlign, w );
|
|
lcd->SetOrigin( m_Handle, x, y );
|
|
lcd->SetText( m_Handle, m_OriginalText );
|
|
lcd->SetVisible( m_Handle, false );
|
|
}
|
|
|
|
|
|
///-----------------------------------------------------------------------------
|
|
/// Constructor
|
|
///-----------------------------------------------------------------------------
|
|
CLCD::CLCD( void )
|
|
: m_lcd( NULL ),
|
|
m_nCurrentPage( 0 ),
|
|
m_nSubPage( 0 ),
|
|
m_bHadPlayer( false ),
|
|
m_dwNextUpdateTime( 0u ),
|
|
m_nMaxChatHistory( G15_DEFAULT_MAX_CHAT_HISTORY ),
|
|
m_pG15Module( 0 ),
|
|
m_G15Factory( 0 )
|
|
{
|
|
m_Size[ 0 ] = m_Size[ 1 ] = 0;
|
|
}
|
|
|
|
///-----------------------------------------------------------------------------
|
|
/// Destructor
|
|
///-----------------------------------------------------------------------------
|
|
CLCD::~CLCD( void )
|
|
{
|
|
}
|
|
|
|
void CLCD::Reload()
|
|
{
|
|
Shutdown();
|
|
|
|
Msg( "Reloading G15 config\n" );
|
|
|
|
Init();
|
|
}
|
|
|
|
///------------------------------------------------------------------------------
|
|
/// Initializes the LCD device, and sets up the text handles
|
|
///------------------------------------------------------------------------------
|
|
void CLCD::Init( void )
|
|
{
|
|
if ( !CommandLine()->FindParm( "-g15" ) )
|
|
return;
|
|
|
|
if ( m_lcd )
|
|
return;
|
|
|
|
m_pG15Module = Sys_LoadModule( G15_MODULE_NAME );
|
|
if ( !m_pG15Module )
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_G15Factory = Sys_GetFactory( m_pG15Module );
|
|
if ( !m_G15Factory )
|
|
{
|
|
Shutdown();
|
|
return;
|
|
}
|
|
|
|
m_lcd = reinterpret_cast< IG15 * >( m_G15Factory( G15_INTERFACE_VERSION, NULL ) );
|
|
if ( !m_lcd )
|
|
{
|
|
Shutdown();
|
|
return;
|
|
}
|
|
|
|
m_lcd->GetLCDSize( m_Size[ 0 ], m_Size[ 1 ] );
|
|
|
|
m_nCurrentPage = 0;
|
|
m_nSubPage = 0;
|
|
|
|
m_TextSizes.Insert( "small", G15_SMALL );
|
|
m_TextSizes.Insert( "medium", G15_MEDIUM );
|
|
m_TextSizes.Insert( "big", G15_BIG );
|
|
|
|
m_TextAlignments.Insert( "left", DT_LEFT );
|
|
m_TextAlignments.Insert( "center", DT_CENTER );
|
|
m_TextAlignments.Insert( "right", DT_RIGHT );
|
|
|
|
KeyValues *kv = new KeyValues( "G15" );
|
|
if ( kv->LoadFromFile( filesystem, G15_RESOURCE_FILE, "MOD" ) )
|
|
{
|
|
char const *title = kv->GetString( "game", "Source Engine" );
|
|
m_nMaxChatHistory = clamp( 1, kv->GetInt( "chatlines", m_nMaxChatHistory ), 64 );
|
|
Assert( title );
|
|
m_Title = title;
|
|
m_lcd->Init( m_Title.String() );
|
|
|
|
for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() )
|
|
{
|
|
char const *keyName = sub->GetName();
|
|
if ( !Q_stricmp( keyName, "game" ) )
|
|
{
|
|
// Handled above!!!
|
|
}
|
|
else if ( !Q_stricmp( keyName, "icons" ) )
|
|
{
|
|
ParseIconMappings( sub );
|
|
}
|
|
else if ( !Q_stricmp( keyName, "replace" ) )
|
|
{
|
|
ParseReplacements( sub );
|
|
}
|
|
else if ( !Q_stricmp( keyName, "page" ) )
|
|
{
|
|
ParsePage( sub );
|
|
}
|
|
}
|
|
}
|
|
kv->deleteThis();
|
|
|
|
UpdateChat();
|
|
|
|
Msg( "Logitech LCD Keyboard initialized\n" );
|
|
}
|
|
|
|
///--------------------------------------------------------------------------
|
|
/// Destroys the local EZ LCD Object
|
|
///--------------------------------------------------------------------------
|
|
void CLCD::Shutdown( void )
|
|
{
|
|
for ( int i = 0; i < m_Pages.Count(); ++i )
|
|
{
|
|
CLCDPage *page = m_Pages[ i ];
|
|
page->Wipe( m_lcd );
|
|
delete page;
|
|
}
|
|
|
|
m_Pages.Purge();
|
|
|
|
if ( m_lcd )
|
|
{
|
|
m_lcd->Shutdown();
|
|
m_lcd = NULL;
|
|
}
|
|
|
|
m_TextSizes.Purge();
|
|
m_TextAlignments.Purge();
|
|
m_GlobalStats.Purge();
|
|
|
|
m_G15Factory = 0;
|
|
|
|
if ( m_pG15Module )
|
|
{
|
|
Sys_UnloadModule( m_pG15Module );
|
|
m_pG15Module = 0;
|
|
}
|
|
}
|
|
|
|
int CLCD::FindTitlePage()
|
|
{
|
|
for ( int i = 0; i < m_Pages.Count(); ++i )
|
|
{
|
|
if ( m_Pages[ i ]->m_bTitlePage )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
bool CLCD::IsPageValid( int currentPage, C_BasePlayer *player )
|
|
{
|
|
if ( m_Pages[ currentPage ]->m_bTitlePage && player )
|
|
return false;
|
|
|
|
if ( m_Pages[ currentPage ]->m_bRequiresPlayer && !player )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
///---------------------------------------------------------------------
|
|
/// Update routine
|
|
///---------------------------------------------------------------------
|
|
void CLCD::Update( void )
|
|
{
|
|
if ( !m_lcd )
|
|
return ;
|
|
|
|
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
|
|
bool hasplayer = player ? true : false;
|
|
|
|
bool changed = hasplayer != m_bHadPlayer;
|
|
m_bHadPlayer = hasplayer;
|
|
|
|
int pageCount = m_Pages.Count();
|
|
|
|
int prevPage = m_nCurrentPage;
|
|
|
|
if ( pageCount > 0 )
|
|
{
|
|
bool force = false;
|
|
if ( changed && hasplayer )
|
|
{
|
|
force = true;
|
|
m_nCurrentPage = 0;
|
|
m_nSubPage = 0;
|
|
}
|
|
|
|
if ( !IsPageValid( m_nCurrentPage, player ) )
|
|
{
|
|
force = true;
|
|
}
|
|
|
|
if ( m_lcd->ButtonTriggered( G15_BUTTON_1 ) || force )
|
|
{
|
|
m_nSubPage = 0;
|
|
|
|
for ( int i = 0; i < pageCount; ++i )
|
|
{
|
|
m_nCurrentPage = ( m_nCurrentPage + 1 ) % pageCount;
|
|
if ( !IsPageValid( m_nCurrentPage, player ) )
|
|
continue;
|
|
|
|
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( m_lcd->ButtonTriggered( G15_BUTTON_2 ) )
|
|
{
|
|
int pc = m_Pages[ m_nCurrentPage ]->m_nSubPageCount;
|
|
|
|
m_nSubPage = ( m_nSubPage + 1 ) % pc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_nCurrentPage = -1;
|
|
m_nSubPage = 0;
|
|
}
|
|
|
|
bool pageChanged = prevPage != m_nCurrentPage;
|
|
|
|
unsigned int dwCurTime = (unsigned int)( 1000.0 * gpGlobals->realtime );
|
|
|
|
if ( m_lcd->IsConnected() )
|
|
{
|
|
if ( dwCurTime >= m_dwNextUpdateTime || pageChanged )
|
|
{
|
|
m_dwNextUpdateTime = dwCurTime + g15_update_msec.GetInt();
|
|
DisplayCurrentPage( dwCurTime );
|
|
}
|
|
}
|
|
|
|
m_lcd->UpdateLCD( dwCurTime );
|
|
}
|
|
|
|
///--------------------------------------------------------------------------
|
|
///
|
|
///--------------------------------------------------------------------------
|
|
bool CLCD::IsConnected( void ) const
|
|
{
|
|
return m_lcd ? m_lcd->IsConnected() : false;
|
|
}
|
|
|
|
void CLCD::ShowItems_R( CLCDPage *page, unsigned int dwCurTime, CUtlVector< CLCDItem * >& list, bool bShowItems )
|
|
{
|
|
int itemCount = list.Count();
|
|
for ( int j = 0; j < itemCount; ++j )
|
|
{
|
|
CLCDItem *item = list[ j ];
|
|
if ( !item->m_bActive )
|
|
continue;
|
|
|
|
if ( bShowItems )
|
|
{
|
|
switch ( item->m_Type )
|
|
{
|
|
default:
|
|
break;
|
|
case LCDITEM_TEXT:
|
|
{
|
|
CLCDItemText *txt = static_cast< CLCDItemText * >( item );
|
|
if ( txt )
|
|
{
|
|
// Need to build updated text
|
|
CUtlString updated;
|
|
CUtlString str = txt->m_OriginalText;
|
|
BuildUpdatedText( str.String(), updated );
|
|
DoGlobalReplacements( updated );
|
|
ReduceParentheses( updated );
|
|
|
|
m_lcd->SetText( item->m_Handle, updated.String() );
|
|
}
|
|
}
|
|
break;
|
|
case LCDITEM_ICON:
|
|
{
|
|
CLCDItemIcon *icon = static_cast< CLCDItemIcon * >( item );
|
|
if ( icon )
|
|
{
|
|
// Need to build updated text
|
|
CUtlString updated;
|
|
CUtlString str = icon->m_IconName;
|
|
BuildUpdatedText( str.String(), updated );
|
|
DoGlobalReplacements( updated );
|
|
ReduceParentheses( updated );
|
|
|
|
int idx = m_Icons.Find( updated.String() );
|
|
if ( idx != m_Icons.InvalidIndex() )
|
|
{
|
|
icon->m_icon = (void *)m_Icons[ idx ].m_handle;
|
|
}
|
|
|
|
// Recreate
|
|
if ( icon->m_Handle )
|
|
{
|
|
m_lcd->RemoveAndDestroyObject( icon->m_Handle );
|
|
icon->m_Handle = 0;
|
|
}
|
|
icon->Create( m_lcd );
|
|
}
|
|
}
|
|
break;
|
|
case LCDITEM_AGGREGATE:
|
|
{
|
|
CLCDItemAggregate *ag = static_cast< CLCDItemAggregate * >( item );
|
|
if ( ag->m_dwNextUpdateTime > dwCurTime )
|
|
break;
|
|
|
|
// FIXME: encode update interval in text file
|
|
ag->m_dwNextUpdateTime = dwCurTime + 1000;
|
|
|
|
// Blow away current data
|
|
ag->WipeChildrenOnly( m_lcd );
|
|
|
|
CUtlVector< int > validIndices;
|
|
char prefix[ 256 ];
|
|
char altprefix[ 256 ];
|
|
prefix[ 0 ] = 0;
|
|
altprefix[ 0 ] = 0;
|
|
|
|
int curx = ag->x;
|
|
int cury = ag->y;
|
|
|
|
switch ( ag->m_AggType )
|
|
{
|
|
default:
|
|
Assert( 0 );
|
|
break;
|
|
case AGGTYPE_PERPLAYER:
|
|
// Add all players into list
|
|
{
|
|
for ( int pl = 1; pl <= gpGlobals->maxClients; ++pl )
|
|
{
|
|
if ( g_PR && g_PR->IsConnected( pl ) )
|
|
{
|
|
validIndices.AddToTail( pl );
|
|
}
|
|
}
|
|
|
|
Q_strncpy( prefix, "(playerindex)", sizeof( prefix ) );
|
|
Q_strncpy( altprefix, "(playerindexplusone)", sizeof( altprefix ) );
|
|
}
|
|
break;
|
|
case AGGTYPE_PERTEAM:
|
|
{
|
|
C_BasePlayer *local = C_BasePlayer::GetLocalPlayer();
|
|
|
|
if ( local )
|
|
{
|
|
for ( int pl = 1; pl <= gpGlobals->maxClients; ++pl )
|
|
{
|
|
if ( g_PR && g_PR->IsConnected( pl ) && local->GetTeamNumber() == g_PR->GetTeam( pl ) )
|
|
{
|
|
validIndices.AddToTail( pl );
|
|
}
|
|
}
|
|
}
|
|
|
|
Q_strncpy( prefix, "(playerindex)", sizeof( prefix ) );
|
|
Q_strncpy( altprefix, "(playerindexplusone)", sizeof( altprefix ) );
|
|
}
|
|
break;
|
|
}
|
|
|
|
int subPage = 0;
|
|
int spItems = 0;
|
|
|
|
int ecount = validIndices.Count();
|
|
for ( int e = 0; e < ecount; ++e )
|
|
{
|
|
// Now fixup any strings
|
|
int index = validIndices[ e ];
|
|
|
|
char s1[ 512 ], s2[ 512 ];
|
|
Q_snprintf( s1, sizeof( s1 ), "%d", index );
|
|
Q_snprintf( s2, sizeof( s2 ), "%d", index + 1 );
|
|
|
|
// Now replace "playerindex" with the index as needed
|
|
for( int r = 0; r < ag->m_Definition.Count(); ++r )
|
|
{
|
|
CLCDItem *newItem = NULL;
|
|
|
|
CLCDItem *itemDefn = ag->m_Definition[ r ];
|
|
switch ( itemDefn->m_Type )
|
|
{
|
|
default:
|
|
break;
|
|
|
|
case LCDITEM_TEXT:
|
|
{
|
|
CLCDItemText *text = static_cast< CLCDItemText * >(itemDefn);
|
|
CUtlString s;
|
|
s = text->m_OriginalText;
|
|
Replace( s, prefix, s1 );
|
|
Replace( s, altprefix, s2 );
|
|
char itemNumber[ 32 ];
|
|
Q_snprintf( itemNumber, sizeof( itemNumber ), "%d", e +1 );
|
|
|
|
Replace( s, "(itemnumber)", itemNumber );
|
|
|
|
DoGlobalReplacements( s );
|
|
// ReduceParentheses( s );
|
|
|
|
// text->m_OriginalText = s;
|
|
|
|
CLCDItemText *copy = static_cast< CLCDItemText * >( page->Alloc( itemDefn->m_Type ) );
|
|
*copy = *text;
|
|
copy->m_bActive = true;
|
|
copy->m_OriginalText = s;
|
|
copy->Create( m_lcd );
|
|
|
|
m_lcd->SetOrigin( copy->m_Handle, curx + copy->x, cury + copy->y );
|
|
|
|
newItem = copy;
|
|
}
|
|
break;
|
|
case LCDITEM_ICON:
|
|
{
|
|
CLCDItemIcon *icon = static_cast< CLCDItemIcon * >(itemDefn);
|
|
CLCDItemIcon *copy = static_cast< CLCDItemIcon * >( page->Alloc( itemDefn->m_Type ) );
|
|
*copy = *icon;
|
|
copy->m_bActive = true;
|
|
copy->Create( m_lcd );
|
|
|
|
m_lcd->SetOrigin( copy->m_Handle, curx + copy->x, cury + copy->y );
|
|
|
|
newItem = copy;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( newItem )
|
|
{
|
|
++spItems;
|
|
newItem->m_nSubPage = subPage;
|
|
ag->m_Children.AddToTail( newItem );
|
|
}
|
|
}
|
|
|
|
cury += ag->m_yincrement;
|
|
|
|
if ( cury + SMALL_ITEM_HEIGHT > m_Size[ 1 ] )
|
|
{
|
|
spItems = 0;
|
|
++subPage;
|
|
cury = ag->y;
|
|
}
|
|
}
|
|
|
|
if ( spItems > 0 )
|
|
{
|
|
page->m_nSubPageCount = subPage + 1;
|
|
}
|
|
else
|
|
{
|
|
// We thought we needed a new page, but didn't actually use it
|
|
page->m_nSubPageCount = subPage;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_lcd->SetVisible( item->m_Handle, bShowItems && ( ( item->m_nSubPage == -1 ) || item->m_nSubPage == m_nSubPage ) );
|
|
|
|
ShowItems_R( page, dwCurTime, item->m_Children, bShowItems );
|
|
}
|
|
}
|
|
|
|
void CLCD::DisplayCurrentPage( unsigned int dwCurTime )
|
|
{
|
|
int pageCount = m_Pages.Count();
|
|
for ( int i = 0; i < pageCount; ++i )
|
|
{
|
|
bool bShowItems = ( i == m_nCurrentPage ) ? true : false;
|
|
|
|
CLCDPage* page = m_Pages[ i ];
|
|
ShowItems_R( page, dwCurTime, page->m_Children, bShowItems );
|
|
}
|
|
}
|
|
|
|
CLCDItemIcon *CLCD::ParseItemIcon( CLCDPage *page, bool bCreateHandles, KeyValues *sub )
|
|
{
|
|
CLCDItemIcon *item = static_cast< CLCDItemIcon * >( page->Alloc( LCDITEM_ICON ) );
|
|
|
|
item->m_IconName = sub->GetString( "name", "" );
|
|
|
|
item->m_nSubPage = sub->GetInt( "header", 0 ) ? -1 : page->m_nSubPageCount - 1;
|
|
item->w = sub->GetInt( "w", 24 );
|
|
item->h = sub->GetInt( "h", 24 );
|
|
item->x = sub->GetInt( "x", 0 );
|
|
item->y = sub->GetInt( "y", 0 );
|
|
|
|
int idx = m_Icons.Find( item->m_IconName.String() );
|
|
item->m_icon = 0;
|
|
if ( idx != m_Icons.InvalidIndex() )
|
|
{
|
|
item->m_icon = (void *)m_Icons[ idx ].m_handle;
|
|
}
|
|
|
|
if ( bCreateHandles )
|
|
{
|
|
item->Create( m_lcd );
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
CLCDItemText *CLCD::ParseItemText( CLCDPage *page, bool bCreateHandles, KeyValues *sub )
|
|
{
|
|
CLCDItemText *item = static_cast< CLCDItemText * >( page->Alloc( LCDITEM_TEXT ) );
|
|
|
|
const char *initialText = sub->GetString( "text", "" );
|
|
item->m_bHasWildcard = Q_strstr( initialText, "%" ) ? true : false;
|
|
|
|
item->m_nSubPage = sub->GetInt( "header", 0 ) ? -1 : page->m_nSubPageCount - 1;
|
|
item->w = sub->GetInt( "w", 150 );
|
|
item->x = sub->GetInt( "x", 0 );
|
|
item->y = sub->GetInt( "y", 0 );
|
|
|
|
const char *sizeStr = sub->GetString( "size", "small" );
|
|
item->m_iSize = G15_SMALL;
|
|
int iFound = m_TextSizes.Find( sizeStr );
|
|
if ( iFound != m_TextSizes.InvalidIndex() )
|
|
{
|
|
item->m_iSize = m_TextSizes[ iFound ];
|
|
}
|
|
|
|
const char *alignStr = sub->GetString( "align", "left" );
|
|
item->m_iAlign = DT_LEFT;
|
|
iFound = m_TextAlignments.Find( alignStr );
|
|
if ( iFound != m_TextAlignments.InvalidIndex() )
|
|
{
|
|
item->m_iAlign = m_TextAlignments[ iFound ];
|
|
}
|
|
|
|
item->m_OriginalText = initialText;
|
|
if ( bCreateHandles )
|
|
{
|
|
item->Create( m_lcd );
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
void CLCD::ParseItems_R( CLCDPage *page, bool bCreateHandles, KeyValues *kv, CUtlVector< CLCDItem * >& list )
|
|
{
|
|
for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() )
|
|
{
|
|
char const *keyName = sub->GetName();
|
|
if ( !Q_stricmp( keyName, "iterate_players" ) ||
|
|
!Q_stricmp( keyName, "iterate_team" ) )
|
|
{
|
|
int aggType = AGGTYPE_UNKNOWN;
|
|
if ( !Q_stricmp( keyName, "iterate_players" ) )
|
|
{
|
|
aggType = AGGTYPE_PERPLAYER;
|
|
}
|
|
else if ( !Q_stricmp( keyName, "iterate_team" ) )
|
|
{
|
|
aggType = AGGTYPE_PERTEAM;
|
|
}
|
|
|
|
// Now we parse the items out as we generally would
|
|
CLCDItemAggregate *item = static_cast< CLCDItemAggregate * >( page->Alloc( LCDITEM_AGGREGATE ) );
|
|
item->m_AggType = aggType;
|
|
|
|
item->x = sub->GetInt( "x", 0 );
|
|
item->y = sub->GetInt( "y", 0 );
|
|
item->m_yincrement = sub->GetInt( "y_increment", 10 );
|
|
|
|
// Parse the definition
|
|
ParseItems_R( page, false, sub, item->m_Definition );
|
|
|
|
// Add the definition items as "inactive" items to the scene (so they get destroyed)
|
|
for ( int i = 0; i < item->m_Definition.Count(); ++i )
|
|
{
|
|
CLCDItem *pItem = item->m_Definition[ i ];
|
|
pItem->m_bActive = false;
|
|
}
|
|
|
|
list.AddToTail( item );
|
|
}
|
|
else if ( !Q_stricmp( keyName, "static_icon" ) )
|
|
{
|
|
CLCDItemIcon *item = ParseItemIcon( page, true, sub );
|
|
Assert( item );
|
|
list.AddToTail(item );
|
|
}
|
|
else if ( !Q_stricmp( keyName, "static_text" ) )
|
|
{
|
|
CLCDItemText *item = ParseItemText( page, true, sub );
|
|
Assert( item );
|
|
list.AddToTail( item );
|
|
}
|
|
else if ( !Q_stricmp( keyName, "newsubpage" ) )
|
|
{
|
|
// Add to new subpage
|
|
++page->m_nSubPageCount;
|
|
}
|
|
else
|
|
{
|
|
// Skip unknown stuff
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CLCD::ParsePage( KeyValues *kv )
|
|
{
|
|
CLCDPage *newPage = new CLCDPage();
|
|
m_Pages.AddToTail( newPage );
|
|
|
|
newPage->m_bTitlePage = kv->GetInt( "titlepage", 0 ) ? true : false;
|
|
newPage->m_bRequiresPlayer = kv->GetInt( "requiresplayer", 0 ) ? true : false;
|
|
|
|
ParseItems_R( newPage, true, kv, newPage->m_Children );
|
|
}
|
|
|
|
void CLCD::ParseIconMappings( KeyValues *kv )
|
|
{
|
|
for ( KeyValues *icon = kv->GetFirstSubKey(); icon; icon = icon->GetNextKey() )
|
|
{
|
|
IconInfo_t info;
|
|
HICON hIcon = 0;
|
|
char const *name = icon->GetName();
|
|
char fullpath[ 512 ];
|
|
filesystem->RelativePathToFullPath( icon->GetString(), "GAME", fullpath, sizeof( fullpath ) );
|
|
#ifdef WIN32
|
|
hIcon = (HICON)::LoadImageA( NULL, fullpath, IMAGE_ICON, 32, 32, LR_LOADFROMFILE );
|
|
#else
|
|
hIcon = 0;
|
|
#endif
|
|
info.m_handle = (void *)hIcon;
|
|
m_Icons.Insert( name, info );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Simply dumps all data fields in object
|
|
//-----------------------------------------------------------------------------
|
|
class CDescribeData
|
|
{
|
|
public:
|
|
CDescribeData( void const *src );
|
|
|
|
void DescribeShort( const short *invalue, int count );
|
|
void DescribeInt( const int *invalue, int count );
|
|
void DescribeBool( const bool *invalue, int count );
|
|
void DescribeFloat( const float *invalue, int count );
|
|
void DescribeSimpleString( const char *indata, int length );
|
|
void DescribeString( const string_t *instring, int count );
|
|
void DescribeVector( const Vector *inValue, int count );
|
|
void DescribeColor( const Color *invalue, int count );
|
|
void DumpDescription( datamap_t *pMap );
|
|
|
|
void GetValueForField( char const *fieldName, char *buf, size_t bufsize );
|
|
|
|
private:
|
|
void DescribeFields_R( int chain_count, datamap_t *pMap, typedescription_t *pFields, int fieldCount );
|
|
bool BuildFieldPath( CUtlString& path );
|
|
|
|
void const *m_pSrc;
|
|
int m_nSrcOffsetIndex;
|
|
|
|
void Describe( const char *fmt, ... );
|
|
|
|
typedescription_t *m_pCurrentField;
|
|
char const *m_pCurrentClassName;
|
|
datamap_t *m_pCurrentMap;
|
|
|
|
CUtlVector< CUtlString > m_FieldPath;
|
|
};
|
|
|
|
CDescribeData::CDescribeData( void const *src )
|
|
{
|
|
m_pSrc = src;
|
|
m_nSrcOffsetIndex = TD_OFFSET_NORMAL;
|
|
|
|
m_pCurrentField = NULL;
|
|
m_pCurrentMap = NULL;
|
|
m_pCurrentClassName = NULL;
|
|
}
|
|
|
|
typedescription_t *FindFieldByName( datamap_t *pMap, char const *fn )
|
|
{
|
|
while ( pMap )
|
|
{
|
|
for ( int i = 0; i < pMap->dataNumFields; i++ )
|
|
{
|
|
typedescription_t *current = &pMap->dataDesc[ i ];
|
|
if ( !current->fieldName )
|
|
continue;
|
|
|
|
if ( !Q_stricmp( current->fieldName, fn ) )
|
|
return current;
|
|
}
|
|
|
|
pMap = pMap->baseMap;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
typedescription_t *FindField( datamap_t *pMap, char const *relativePath )
|
|
{
|
|
if ( !Q_strstr( relativePath, "." ) )
|
|
{
|
|
// Simple case, just look up field name
|
|
return FindFieldByName( pMap, relativePath );
|
|
}
|
|
|
|
// Complex case
|
|
|
|
Assert( 0 );
|
|
return NULL;
|
|
}
|
|
|
|
bool CDescribeData::BuildFieldPath( CUtlString& path )
|
|
{
|
|
int c = m_FieldPath.Count();
|
|
if ( c == 0 )
|
|
return false;
|
|
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CUtlString& s = m_FieldPath[ i ];
|
|
if ( i != 0 )
|
|
{
|
|
path += ".";
|
|
}
|
|
path += s;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *fmt -
|
|
// ... -
|
|
//-----------------------------------------------------------------------------
|
|
void CDescribeData::Describe( const char *fmt, ... )
|
|
{
|
|
Assert( m_pCurrentMap );
|
|
Assert( m_pCurrentClassName );
|
|
|
|
const char *fieldname = "empty";
|
|
|
|
if ( m_pCurrentField )
|
|
{
|
|
fieldname = m_pCurrentField->fieldName ? m_pCurrentField->fieldName : "NULL";
|
|
}
|
|
|
|
va_list argptr;
|
|
char data[ 4096 ];
|
|
int len;
|
|
va_start(argptr, fmt);
|
|
len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
|
|
va_end(argptr);
|
|
|
|
CUtlString fp;
|
|
if ( BuildFieldPath( fp ) )
|
|
{
|
|
Msg( "%s.%s%s",
|
|
fp.String(),
|
|
fieldname,
|
|
data );
|
|
}
|
|
else
|
|
{
|
|
Msg( "%s%s",
|
|
fieldname,
|
|
data );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : size -
|
|
// *outdata -
|
|
// *indata -
|
|
//-----------------------------------------------------------------------------
|
|
void CDescribeData::DescribeSimpleString( char const *invalue, int count )
|
|
{
|
|
Describe( "%s\n", invalue ? invalue : "" );
|
|
}
|
|
|
|
|
|
void CDescribeData::DescribeShort( const short *invalue, int count )
|
|
{
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
if ( count == 1 )
|
|
{
|
|
Describe( " short (%i)\n", (int)(invalue[i]) );
|
|
}
|
|
else
|
|
{
|
|
Describe( "[%i] short (%i)\n", i, (int)(invalue[i]) );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CDescribeData::DescribeInt( const int *invalue, int count )
|
|
{
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
if ( count == 1 )
|
|
{
|
|
Describe( " integer (%i)\n", invalue[i] );
|
|
}
|
|
else
|
|
{
|
|
Describe( "[%i] integer (%i)\n", i, invalue[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDescribeData::DescribeBool( const bool *invalue, int count )
|
|
{
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
if ( count == 1 )
|
|
{
|
|
Describe( " bool (%s)\n", (invalue[i]) ? "true" : "false" );
|
|
}
|
|
else
|
|
{
|
|
Describe( "[%i] bool (%s)\n", i, (invalue[i]) ? "true" : "false" );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDescribeData::DescribeFloat( const float *invalue, int count )
|
|
{
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
if ( count == 1 )
|
|
{
|
|
Describe( " float (%f)\n", invalue[ i ] );
|
|
}
|
|
else
|
|
{
|
|
Describe( "[%i] float (%f)\n", i, invalue[ i ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDescribeData::DescribeString( const string_t *instring, int count )
|
|
{
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
if ( count == 1 )
|
|
{
|
|
Describe( " string (%s)\n", instring[ i ] ? instring[ i ] : "" );
|
|
}
|
|
else
|
|
{
|
|
Describe( "[%i] string (%s)\n", i, instring[ i ] ? instring[ i ] : "" );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDescribeData::DescribeColor( const Color *invalue, int count )
|
|
{
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
if ( count == 1 )
|
|
{
|
|
Describe( " color (%i %i %i %i)\n", invalue[ i ].r(), invalue[ i ].g(), invalue[ i ].b(), invalue[ i ].a() );
|
|
}
|
|
else
|
|
{
|
|
Describe( "[%i] color (%i %i %i %i)\n", i, invalue[ i ].r(), invalue[ i ].g(), invalue[ i ].b(), invalue[ i ].a() );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDescribeData::DescribeVector( const Vector *inValue, int count )
|
|
{
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
if ( count == 1 )
|
|
{
|
|
Describe( " vector (%f %f %f)\n",
|
|
inValue[i].x, inValue[i].y, inValue[i].z );
|
|
}
|
|
else
|
|
{
|
|
Describe( "[%i] vector (%f %f %f)\n",
|
|
i,
|
|
inValue[i].x, inValue[i].y, inValue[i].z );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDescribeData::DescribeFields_R( int chain_count, datamap_t *pRootMap, typedescription_t *pFields, int fieldCount )
|
|
{
|
|
int i;
|
|
int flags;
|
|
int fieldOffsetSrc;
|
|
int fieldSize;
|
|
|
|
m_pCurrentMap = pRootMap;
|
|
if ( !m_pCurrentClassName )
|
|
{
|
|
m_pCurrentClassName = pRootMap->dataClassName;
|
|
}
|
|
|
|
for ( i = 0; i < fieldCount; i++ )
|
|
{
|
|
m_pCurrentField = &pFields[ i ];
|
|
flags = m_pCurrentField->flags;
|
|
|
|
// Skip this field
|
|
if ( flags & FTYPEDESC_VIEW_NEVER )
|
|
continue;
|
|
|
|
// Mark any subchains first
|
|
if ( m_pCurrentField->override_field != NULL )
|
|
{
|
|
m_pCurrentField->override_field->override_count = chain_count;
|
|
}
|
|
|
|
// Skip this field?
|
|
if ( m_pCurrentField->override_count == chain_count )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
void const *pInputData;
|
|
|
|
fieldOffsetSrc = m_pCurrentField->fieldOffset[ m_nSrcOffsetIndex ];
|
|
fieldSize = m_pCurrentField->fieldSize;
|
|
|
|
pInputData = (void const *)((char *)m_pSrc + fieldOffsetSrc );
|
|
|
|
switch( m_pCurrentField->fieldType )
|
|
{
|
|
default:
|
|
break;
|
|
case FIELD_EMBEDDED:
|
|
{
|
|
typedescription_t *save = m_pCurrentField;
|
|
void const *saveSrc = m_pSrc;
|
|
const char *saveName = m_pCurrentClassName;
|
|
|
|
m_pCurrentClassName = m_pCurrentField->td->dataClassName;
|
|
|
|
CUtlString str;
|
|
str = m_pCurrentField->fieldName;
|
|
|
|
m_FieldPath.AddToTail( str );
|
|
|
|
m_pSrc = pInputData;
|
|
if ( ( flags & FTYPEDESC_PTR ) && (m_nSrcOffsetIndex == PC_DATA_NORMAL) )
|
|
{
|
|
m_pSrc = *((void**)m_pSrc);
|
|
}
|
|
|
|
DescribeFields_R( chain_count, pRootMap, m_pCurrentField->td->dataDesc, m_pCurrentField->td->dataNumFields );
|
|
|
|
m_FieldPath.Remove( m_FieldPath.Count() - 1 );
|
|
|
|
m_pCurrentClassName = saveName;
|
|
m_pCurrentField = save;
|
|
m_pSrc = saveSrc;
|
|
}
|
|
break;
|
|
case FIELD_FLOAT:
|
|
DescribeFloat( (float const *)pInputData, fieldSize );
|
|
break;
|
|
case FIELD_STRING:
|
|
DescribeString( (const string_t*)pInputData, fieldSize );
|
|
break;
|
|
case FIELD_VECTOR:
|
|
DescribeVector( (const Vector *)pInputData, fieldSize );
|
|
break;
|
|
case FIELD_COLOR32:
|
|
DescribeColor( (const Color *)pInputData, fieldSize );
|
|
break;
|
|
|
|
case FIELD_BOOLEAN:
|
|
DescribeBool( (bool const *)pInputData, fieldSize );
|
|
break;
|
|
case FIELD_INTEGER:
|
|
DescribeInt( (int const *)pInputData, fieldSize );
|
|
break;
|
|
|
|
case FIELD_SHORT:
|
|
DescribeShort( (short const *)pInputData, fieldSize );
|
|
break;
|
|
|
|
case FIELD_CHARACTER:
|
|
DescribeSimpleString( (const char *)pInputData, fieldSize );
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_pCurrentClassName = NULL;
|
|
}
|
|
|
|
static int g_nChainCount = 1;
|
|
extern void ValidateChains_R( datamap_t *dmap );
|
|
|
|
void CDescribeData::DumpDescription( datamap_t *pMap )
|
|
{
|
|
++g_nChainCount;
|
|
|
|
if ( !pMap->chains_validated )
|
|
{
|
|
ValidateChains_R( pMap );
|
|
}
|
|
|
|
while ( pMap )
|
|
{
|
|
DescribeFields_R( g_nChainCount, pMap, pMap->dataDesc, pMap->dataNumFields );
|
|
|
|
pMap = pMap->baseMap;
|
|
}
|
|
}
|
|
|
|
|
|
void CLCD::DumpPlayer()
|
|
{
|
|
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
|
|
if ( !player )
|
|
return;
|
|
|
|
Msg( "(localplayer)\n\n" );
|
|
|
|
{
|
|
CDescribeData helper( player );
|
|
helper.DumpDescription( player->GetPredDescMap() );
|
|
}
|
|
|
|
Msg( "(localteam)\n\n" );
|
|
|
|
C_Team *team = player->GetTeam();
|
|
if ( team )
|
|
{
|
|
CDescribeData helper( team );
|
|
helper.DumpDescription( team->GetPredDescMap() );
|
|
}
|
|
|
|
Msg( "(playerresource)\n\n" );
|
|
|
|
if ( g_PR )
|
|
{
|
|
CDescribeData helper( g_PR );
|
|
helper.DumpDescription( g_PR->GetPredDescMap() );
|
|
}
|
|
|
|
Msg( "(localplayerweapon)\n\n" );
|
|
// Get the player's weapons, too
|
|
C_BaseCombatWeapon *active = player->GetActiveWeapon();
|
|
if ( active )
|
|
{
|
|
CDescribeData helper( active );
|
|
helper.DumpDescription( active->GetPredDescMap() );
|
|
}
|
|
|
|
Msg( "Other replacements:\n\n" );
|
|
|
|
// Global replacements
|
|
for( int i = m_GlobalStats.First() ; i != m_GlobalStats.InvalidIndex(); i = m_GlobalStats.Next( i ) )
|
|
{
|
|
CUtlString& r = m_GlobalStats[ i ];
|
|
|
|
char const *pReplace = r.String();
|
|
char ansi[ 512 ];
|
|
ansi[ 0 ] = 0;
|
|
|
|
if ( pReplace[ 0 ] == '#' )
|
|
{
|
|
const wchar_t *pWString = g_pVGuiLocalize->Find( pReplace );
|
|
if ( pWString )
|
|
{
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( pWString, ansi, sizeof( ansi ) );
|
|
pReplace = ansi;
|
|
}
|
|
}
|
|
|
|
Msg( "'%s' = '%s'\n", m_GlobalStats.GetElementName( i ), pReplace );
|
|
}
|
|
}
|
|
|
|
bool CLCD::ExtractArrayIndex( char *str, size_t bufsize, int *index )
|
|
{
|
|
Assert( index );
|
|
*index = 0;
|
|
|
|
char s[ 2048 ];
|
|
Q_strncpy( s, str, sizeof( s ) );
|
|
|
|
char *pos = Q_strstr( s, "[" );
|
|
if ( !pos )
|
|
return false;
|
|
|
|
char *pos2 = Q_strstr( s, "]" );
|
|
if ( !pos2 )
|
|
return false;
|
|
|
|
char num[ 32 ];
|
|
Q_strncpy( num, pos + 1, pos2 - pos );
|
|
*index = Q_atoi( num );
|
|
|
|
int left = pos - s + 1;
|
|
char o[ 2048 ];
|
|
Q_strncpy( o, s, left );
|
|
Q_strncat( o, pos2 + 1, sizeof( o ), COPY_ALL_CHARACTERS );
|
|
|
|
Q_strncpy( str, o, bufsize );
|
|
return true;
|
|
}
|
|
|
|
void CLCD::LookupToken( char const *in, CUtlString& value )
|
|
{
|
|
value = "";
|
|
|
|
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
|
|
if ( !player )
|
|
{
|
|
return;
|
|
}
|
|
|
|
C_BaseEntity *ref = NULL;
|
|
|
|
char outbuf[ 1024 ];
|
|
char *o = outbuf;
|
|
char const *i = in;
|
|
while ( *i )
|
|
{
|
|
if ( *i == '(' )
|
|
{
|
|
char token[ 512 ];
|
|
char *to = token;
|
|
// swallow everything until matching '%' character
|
|
++i;
|
|
while ( *i && *i != ')' )
|
|
{
|
|
*to++ = *i++;
|
|
}
|
|
|
|
if ( *i )
|
|
++i;
|
|
|
|
*to = 0;
|
|
|
|
if ( !Q_stricmp( token, "localplayer" ) )
|
|
{
|
|
ref = player;
|
|
}
|
|
else if ( !Q_stricmp( token, "localteam" ) )
|
|
{
|
|
ref = player->GetTeam();
|
|
}
|
|
else if ( !Q_stricmp( token, "localplayerweapon" ) )
|
|
{
|
|
ref = player->GetActiveWeapon();
|
|
}
|
|
else if ( !Q_stricmp( token, "playerresource" ) )
|
|
{
|
|
ref = g_PR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*o++ = *i++;
|
|
}
|
|
}
|
|
|
|
*o = '\0';
|
|
|
|
// Fixme, also need to get array reference removed from end and do the . field searching stuff
|
|
|
|
// Outbuf now has the actual field
|
|
if ( !ref )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int iIndex = 0;
|
|
ExtractArrayIndex( outbuf, sizeof( outbuf ), &iIndex );
|
|
|
|
typedescription_t *td = FindField( ref->GetPredDescMap(), outbuf );
|
|
if ( !td )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Not allowed to see this one
|
|
if ( td->flags & FTYPEDESC_VIEW_NEVER )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int fieldOffsetSrc = td->fieldOffset[ TD_OFFSET_NORMAL ];
|
|
// int fieldSize = td->fieldSize;
|
|
|
|
void const *pInputData = (void const *)((char *)ref + fieldOffsetSrc );
|
|
|
|
char sz[ 256 ];
|
|
sz[ 0 ] = 0;
|
|
// Found it, now get the value
|
|
switch ( td->fieldType )
|
|
{
|
|
case FIELD_FLOAT:
|
|
Q_snprintf( sz, sizeof( sz ), "%.2f", *((float *)pInputData + iIndex ) );
|
|
break;
|
|
case FIELD_STRING:
|
|
{
|
|
string_t *pString = (string_t *)((string_t *)pInputData + iIndex );
|
|
Q_snprintf( sz, sizeof( sz ), "%s", pString ? STRING( *pString ) : "" );
|
|
}
|
|
break;
|
|
case FIELD_VECTOR:
|
|
{
|
|
Vector v = *((Vector *)pInputData + iIndex );
|
|
Q_snprintf( sz, sizeof( sz ), "%.2f %.2f %.2f", v.x, v.y, v.z );
|
|
}
|
|
break;
|
|
case FIELD_COLOR32:
|
|
{
|
|
Color c = *(( Color * )pInputData + iIndex );
|
|
Q_snprintf( sz, sizeof( sz ), "%d %d %d %d", c.r(), c.g(), c.b(), c.a() );
|
|
}
|
|
break;
|
|
|
|
case FIELD_BOOLEAN:
|
|
Q_snprintf( sz, sizeof( sz ), "%s", *( ( bool *)pInputData + iIndex ) ? "true" : "false" );
|
|
break;
|
|
case FIELD_INTEGER:
|
|
Q_snprintf( sz, sizeof( sz ), "%i", *( (int *)pInputData + iIndex ));
|
|
break;
|
|
|
|
case FIELD_SHORT:
|
|
Q_snprintf( sz, sizeof( sz ), "%i", *( (short *)pInputData + iIndex ) );
|
|
break;
|
|
|
|
case FIELD_CHARACTER:
|
|
Q_snprintf( sz, sizeof( sz ), "%s", ((const char *)pInputData + iIndex ) );
|
|
break;
|
|
}
|
|
|
|
value = sz;
|
|
}
|
|
|
|
void CLCD::BuildUpdatedText( char const *in, CUtlString& out )
|
|
{
|
|
char outbuf[ 1024 ];
|
|
char *o = outbuf;
|
|
char const *i = in;
|
|
while ( *i )
|
|
{
|
|
if ( *i == '%' )
|
|
{
|
|
char token[ 512 ];
|
|
char *to = token;
|
|
// swallow everything until matching '%' character
|
|
++i;
|
|
while ( *i && *i != '%' )
|
|
{
|
|
*to++ = *i++;
|
|
}
|
|
|
|
if ( *i )
|
|
++i;
|
|
|
|
*to = 0;
|
|
|
|
// Now we have the token, do the lookup
|
|
CUtlString value;
|
|
LookupToken( token, value );
|
|
|
|
to = (char *)value.String();
|
|
while ( *to )
|
|
{
|
|
*o++ = *to++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*o++ = *i++;
|
|
}
|
|
}
|
|
|
|
*o = '\0';
|
|
|
|
out = outbuf;
|
|
}
|
|
|
|
|
|
bool CLCD::Replace( CUtlString& str, char const *search, char const *replace )
|
|
{
|
|
// If search string is part of replacement, this is a bad thing!!!
|
|
Assert( !*replace || !Q_strstr( replace, search ) );
|
|
|
|
bool changed = false;
|
|
if ( !Q_strstr( str.String(), search ) )
|
|
return false;
|
|
|
|
char s[ 2048 ];
|
|
Q_strncpy( s, str.String(), sizeof( s ) );
|
|
|
|
int searchlen = Q_strlen( search );
|
|
while ( true )
|
|
{
|
|
char *pos = Q_strstr( s, search );
|
|
if ( !pos )
|
|
break;
|
|
|
|
char temp[ 4096 ];
|
|
// Found an instance
|
|
int left = pos - s + 1;
|
|
Assert( left < sizeof( temp ) );
|
|
Q_strncpy( temp, s, left );
|
|
Q_strncat( temp, replace, sizeof( temp ), COPY_ALL_CHARACTERS );
|
|
int rightofs = left + searchlen - 1;
|
|
Q_strncat( temp, &s[ rightofs ], sizeof( temp ), COPY_ALL_CHARACTERS );
|
|
|
|
// Replace entire string
|
|
Q_strncpy( s, temp, sizeof( s ) );
|
|
changed = true;
|
|
}
|
|
|
|
str = s;
|
|
|
|
return changed;
|
|
}
|
|
|
|
void CLCD::SetGlobalStat( char const *name, char const *value )
|
|
{
|
|
if ( !m_lcd )
|
|
return;
|
|
|
|
int idx = m_GlobalStats.Find( name );
|
|
if ( idx == m_GlobalStats.InvalidIndex() )
|
|
{
|
|
idx = m_GlobalStats.Insert( name );
|
|
}
|
|
|
|
m_GlobalStats[ idx ] = value;
|
|
}
|
|
|
|
void CLCD::AddChatLine( char const *txt )
|
|
{
|
|
if ( !m_lcd )
|
|
return;
|
|
|
|
while ( m_ChatHistory.Count() >= m_nMaxChatHistory )
|
|
{
|
|
m_ChatHistory.Remove( 0 );
|
|
}
|
|
|
|
m_ChatHistory.AddToTail( CUtlString( txt ) );
|
|
|
|
UpdateChat();
|
|
}
|
|
|
|
void CLCD::UpdateChat()
|
|
{
|
|
for ( int i = 0; i < m_nMaxChatHistory; ++i )
|
|
{
|
|
char name[ 32 ];
|
|
Q_snprintf( name, sizeof( name ), "chat_%d", i + 1 );
|
|
|
|
SetGlobalStat( name, i < m_ChatHistory.Count() ? m_ChatHistory[ i ].String() : " " );
|
|
}
|
|
}
|
|
|
|
void CLCD::DoGlobalReplacements( CUtlString& str )
|
|
{
|
|
// Put some limit to avoid infinite recursion
|
|
int maxChanges = 16;
|
|
|
|
bool changed = false;
|
|
do
|
|
{
|
|
changed = false;
|
|
for ( int i = m_GlobalStats.First(); i != m_GlobalStats.InvalidIndex(); i = m_GlobalStats.Next( i ) )
|
|
{
|
|
CUtlString &r = m_GlobalStats[ i ];
|
|
|
|
char const *pReplace = r.String();
|
|
char ansi[ 512 ];
|
|
ansi[ 0 ] = 0;
|
|
|
|
if ( pReplace[ 0 ] == '#' )
|
|
{
|
|
const wchar_t *pWString = g_pVGuiLocalize->Find( pReplace );
|
|
if ( pWString )
|
|
{
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( pWString, ansi, sizeof( ansi ) );
|
|
pReplace = ansi;
|
|
}
|
|
}
|
|
|
|
if ( Replace( str, m_GlobalStats.GetElementName( i ), pReplace ) )
|
|
{
|
|
changed = true;
|
|
}
|
|
}
|
|
} while ( changed && --maxChanges >= 0 );
|
|
}
|
|
|
|
void CLCD::ReduceParentheses( CUtlString& str )
|
|
{
|
|
char s[ 2048 ];
|
|
Q_strncpy( s, str.String(), sizeof( s ) );
|
|
|
|
while ( true )
|
|
{
|
|
char *pos = Q_strstr( s, "(" );
|
|
if ( !pos )
|
|
break;
|
|
|
|
char *end = Q_strstr( pos, ")" );
|
|
if ( !end )
|
|
break;
|
|
|
|
char temp[ 4096 ];
|
|
// Found an instance
|
|
int left = pos - s + 1;
|
|
Assert( left < sizeof( temp ) );
|
|
Q_strncpy( temp, s, left );
|
|
int rightofs = end - s + 1;
|
|
Q_strncat( temp, &s[ rightofs ], sizeof( temp ), COPY_ALL_CHARACTERS );
|
|
|
|
// Replace entire string
|
|
Q_strncpy( s, temp, sizeof( s ) );
|
|
}
|
|
|
|
str = s;
|
|
}
|
|
|
|
void CLCD::ParseReplacements( KeyValues *kv )
|
|
{
|
|
for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() )
|
|
{
|
|
char const *key = sub->GetName();
|
|
char const *value = sub->GetString();
|
|
|
|
SetGlobalStat( key, value );
|
|
}
|
|
}
|