d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
38 Commits
25 Branches
6 Tags
221 MiB
Tree: d4c9ed338f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd4c9ed338f'
${ noResults }
source-engine/game/shared/tf/tf_quest_editor_panel.cpp

2456 lines
78 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_quest_editor_panel.h"
#include "econ_item_tools.h"
#include "tier2/p4helpers.h"
#include "tier2/fileutils.h"
#include "vgui/IInput.h"
#ifdef STAGING_ONLY
using namespace vgui;
ConVar tf_quest_editor_element_height( "tf_quest_editor_element_height", "20", FCVAR_ARCHIVE );
ConVar tf_quest_editor_indent_width( "tf_quest_editor_indent_width", "20", FCVAR_ARCHIVE );
ConVar tf_quest_editor_entry_inset( "tf_quest_editor_entry_inset", "120" );
static const char *g_skItemNameFormat = "quest%d";
static const char *g_skNameTokenFormat = "#quest%dname%d";
static const char *g_skDescTokenFormat = "#quest%ddesc%d";
static const char *g_skObjectiveDescTokenFormat = "#quest%dobjectivedesc%d";
static const char *g_skLocalizationFile = "resource/tf_quests_english.txt";
static const char *g_skQuestDefFile = "tf/scripts/items/unencrypted/_items_quests.txt";
static const char *g_skQuestObjectivesConditionsDefFile = "tf/scripts/items/unencrypted/_items_quest_objective_definitions.txt";
static const char *g_skQuestObjectivesHouseKeepingFile = "items_quest_objective_housekeeping.csv";
static const int g_nkFirstQuestDef = 25000;
static const char* g_skQuestPrefabs[] = { "quest_prefab_1st_operation_pauling"
, "quest_prefab_halloween_2015"
, "quest_prefab_2nd_operation_pauling" };
#define FLAGS_NONE 0
#define FLAG_HIDDEN 1<<0
#define FLAG_COLLAPSED 1<<1
#define FLAG_COLLAPSABLE 1<<2
#define FLAG_MUST_BE_LAST 1<<3
#define FLAG_NOT_DELETABLE 1<<4
#define FLAG_OUTPUT_LAST 1<<5
#define FLAG_DELETED 1<<6
#define FLAG_HIGHLIGHT_MOUSEOVER 1<<7
#define FLAG_DONT_EXPORT 1<<8
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static CQuestEditorPanel* g_pQuestEditor = NULL;
static void cc_tf_quest_editor()
{
g_pQuestEditor = new CQuestEditorPanel( NULL, "QuestEditor" );
g_pQuestEditor->MakeReadyForUse();
g_pQuestEditor->Deploy();
}
ConCommand tf_quest_editor( "tf_quest_editor", cc_tf_quest_editor );
//-----------------------------------------------------------------------------
// Purpose: Writes out all of the localization data for each quest intro "resource/tf_quests_english.txt"
//-----------------------------------------------------------------------------
void WriteLocalizationData()
{
char szQuestEnglishFile[MAX_PATH];
if ( !GenerateFullPath( g_skLocalizationFile, "MOD", szQuestEnglishFile, ARRAYSIZE( szQuestEnglishFile ) ) )
{
Warning( "Failed to GenerateFullPath %s\n", g_skLocalizationFile );
return;
}
FOR_EACH_VEC( ILocalizationEditorParamAutoList::AutoList(), i )
{
CLocalizationEditorParam* pLocalizationEntry = static_cast< CLocalizationEditorParam* >( ILocalizationEditorParamAutoList::AutoList()[i] );
// We set the filename to "deleted" for deleted entries so that they don't get written out
// into tf_quests_english.txt
const char* pszFile = pLocalizationEntry->IsFlagSet( FLAG_DELETED, true ) ? "deleted" : szQuestEnglishFile;
wchar_t wszLocalizedValue[MAX_QUEST_DESC_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( pLocalizationEntry->GetLocalizationValue(), wszLocalizedValue, sizeof( wszLocalizedValue ) );
const char *pszTokenName = pLocalizationEntry->GetValue();
if ( pszTokenName[0] == '#' )
{
pszTokenName++;
}
g_pVGuiLocalize->AddString( pszTokenName, wszLocalizedValue, pszFile );
}
// Get the name of the file and p4 check it out
char szCorrectCaseFilePath[MAX_PATH];
g_pFullFileSystem->GetCaseCorrectFullPath( szQuestEnglishFile, szCorrectCaseFilePath );
CP4AutoEditFile a( szCorrectCaseFilePath );
g_pVGuiLocalize->SaveToFile( szQuestEnglishFile );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditorObject::IEditorObject( EditorObjectInitStruct init )
: EditablePanel( init.pParent, init.m_pszKeyName )
, m_Flags( init.nFlags )
, m_pOwningEditable( NULL )
, m_bHasChanges( false )
{
memset( m_szKeyName, 0, sizeof( m_szKeyName ) );
if ( init.m_pszKeyName )
{
V_sprintf_safe( m_szKeyName, "%s", init.m_pszKeyName );
}
SetWide( init.pParent->GetWide() );
SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_RIGHT, 6, 6, -6, -6 );
}
void IEditorObject::PerformLayout()
{
BaseClass::PerformLayout();
SetTall( GetContentTall() );
}
void IEditorObject::OnSizeChanged( int newWide, int newTall )
{
BaseClass::OnSizeChanged( newWide, newTall );
GetParent()->InvalidateLayout();
}
bool IEditorObject::IsFlagSet( int nFlag, bool bCheckUpTree ) const
{
bool bIsFlagSet = m_Flags & nFlag;
if ( !bIsFlagSet && bCheckUpTree )
{
IEditorObject* pParent = dynamic_cast< IEditorObject* >( const_cast<IEditorObject*>(this)->GetParent() );
if ( pParent )
{
bIsFlagSet |= pParent->IsFlagSet( nFlag, bCheckUpTree );
}
}
return bIsFlagSet;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditorObject::ESerializeAction IEditorObject::ShouldWrite( const IEditableDataType* pCallingEditable ) const
{
if ( IsFlagSet( FLAG_DONT_EXPORT ) )
return SKIP_THIS_AND_CHILDREN;
if ( IsFlagSet( FLAG_DELETED ) )
return SKIP_THIS_AND_CHILDREN;
if ( GetOwningEditable() != pCallingEditable )
return SKIP_THIS_AND_CONTINUE;
return WRITE_THIS_AND_CONTINUE;
}
//-----------------------------------------------------------------------------
// Purpose: If we're set to highlight on mouseover, do so!
//-----------------------------------------------------------------------------
void IEditorObject::OnThink()
{
if ( IsFlagSet( FLAG_HIGHLIGHT_MOUSEOVER, false ) )
{
if ( IsCursorOver() )
{
SetBgColor( Color( 100, 150, 100, 30 ) );
}
else
{
SetBgColor( Color( 235, 226, 202, 2 ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEditorObjectNode::CEditorObjectNode( EditorObjectInitStruct init )
: BaseClass( init )
{
m_pToggleCollapseButton = new Button( this, "togglecollapse", "-", this, "togglecollapse" );
m_pToggleCollapseButton->SetVisible( false );
m_pToggleCollapseButton->SetWide( 20 );
m_pToggleCollapseButton->SetZPos( 100 );
m_pDeleteButton = new Button( this, "deletebutton", "x", this, "delete" );
m_pDeleteButton->SetWide( 20 );
m_pDeleteButton->SetTall( 20 );
CEditorObjectNode* pNode = dynamic_cast< CEditorObjectNode* >( init.pParent );
if ( pNode )
{
pNode->AddChild( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEditorObjectNode::~CEditorObjectNode()
{
CEditorObjectNode* pEditorPanel = dynamic_cast<CEditorObjectNode*>( GetParent() );
if ( pEditorPanel )
{
pEditorPanel->RemoveChild( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const IEditableDataType* IEditorObject::GetOwningEditable() const
{
const IEditableDataType* pOwningEditable = NULL;
const IEditorObject* pPanel = this;
do
{
pOwningEditable = pPanel->m_pOwningEditable;
pPanel = dynamic_cast< const IEditorObject* >( const_cast< IEditorObject* >( pPanel )->GetParent() ); // Good lord, VGUI. GetParent() isn't const? Really?
}
while ( pOwningEditable == NULL && pPanel != NULL );
Assert( pOwningEditable != NULL );
return pOwningEditable;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObject::InvalidateChain()
{
InvalidateLayout();
Panel* pParent = this;
do
{
pParent = pParent->GetParent();
pParent->InvalidateLayout();
}
while( dynamic_cast< IEditorObject* >( pParent ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObject::ClearPendingChangesFlag()
{
m_bHasChanges = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::AddChild( IEditorObject* pChild )
{
m_bHasChanges = true;
m_vecChildren.AddToTail( pChild );
if ( !IsFlagSet( FLAG_HIDDEN ) && IsFlagSet( FLAG_COLLAPSABLE ) )
{
m_pToggleCollapseButton->SetVisible( true );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::RemoveChild( IEditorObject* pChild )
{
FOR_EACH_VEC( m_vecChildren, i )
{
if ( m_vecChildren[i] == pChild )
{
m_vecChildren.Remove( i );
if ( m_vecChildren.Count() == 0 )
{
m_pToggleCollapseButton->SetVisible( false );
}
m_bHasChanges = true;
return;
}
}
Assert( !"Couldn't find child to remove!" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CEditorObjectNode::GetNextAvailableKeyNumber() const
{
int nNextAvailable = 0;
FOR_EACH_VEC( m_vecChildren, i )
{
if ( !m_vecChildren[i]->IsFlagSet( FLAG_DONT_EXPORT ) )
{
nNextAvailable = Max( nNextAvailable, atoi( m_vecChildren[i]->GetName() ) );
}
}
return nNextAvailable;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEditorObjectNode::HasChanges( bool bCheckChildren ) const
{
bool bHasChanges = m_bHasChanges;
if ( bCheckChildren )
{
FOR_EACH_VEC( m_vecChildren, i )
{
bHasChanges |= m_vecChildren[i]->HasChanges( bCheckChildren );
}
}
return bHasChanges;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CEditorObjectNode::GetContentTall() const
{
// Hidden panels have 0 height
int nTall = IsFlagSet( FLAG_HIDDEN ) ? 0 : tf_quest_editor_element_height.GetInt();
// Collapsed panels just return their height.
if ( IsFlagSet( FLAG_COLLAPSED ) )
return nTall;
FOR_EACH_VEC( m_vecChildren, i )
{
nTall += m_vecChildren[i]->GetContentTall();
}
return nTall;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::SerializeToKVs( KeyValues* pKV, const IEditableDataType* pCallingEditable ) const
{
m_bHasChanges = false;
// End of the Line if deleted
if ( IsFlagSet( FLAG_DELETED ) )
return;
ESerializeAction action = ShouldWrite( pCallingEditable );
if ( action == SKIP_THIS_AND_CHILDREN )
return;
if ( action != SKIP_THIS_AND_CONTINUE )
{
pKV = pKV->CreateNewKey();
pKV->SetName( GetKeyName() );
}
CUtlVector< IEditorObject* > vecLastOutputs;
FOR_EACH_VEC( m_vecChildren, i )
{
if ( m_vecChildren[ i ]->IsFlagSet( FLAG_OUTPUT_LAST ) )
{
vecLastOutputs.AddToTail( m_vecChildren[i] );
continue;
}
m_vecChildren[i]->SerializeToKVs( pKV, pCallingEditable );
}
FOR_EACH_VEC( vecLastOutputs, i )
{
vecLastOutputs[ i ]->SerializeToKVs( pKV, pCallingEditable );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::PerformLayout()
{
m_pDeleteButton->SetVisible( m_vecChildren.Count() > 0 && !IsFlagSet( FLAG_HIDDEN ) && !IsFlagSet( FLAG_NOT_DELETABLE ) );
m_pDeleteButton->SetPos( 470, 0 );
BaseClass::PerformLayout();
int nTall = IsFlagSet( FLAG_HIDDEN ) ? 0 : tf_quest_editor_element_height.GetInt();
CUtlVector< IEditorObject* > vecLastParams;
FOR_EACH_VEC( m_vecChildren, i )
{
if ( IsFlagSet( FLAG_MUST_BE_LAST ) )
{
vecLastParams.AddToTail( m_vecChildren[i] );
continue;
}
m_vecChildren[i]->SetPos( IsFlagSet( FLAG_HIDDEN ) ? 0 : tf_quest_editor_indent_width.GetInt(), nTall );
nTall += m_vecChildren[i]->GetContentTall();
}
FOR_EACH_VEC( vecLastParams, i )
{
vecLastParams[i]->SetPos( IsFlagSet( FLAG_HIDDEN ) ? 0 : tf_quest_editor_indent_width.GetInt(), nTall );
nTall += vecLastParams[i]->GetContentTall();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::OnCommand( const char *command )
{
if ( V_stricmp( "togglecollapse", command ) == 0 )
{
if ( IsFlagSet( FLAG_COLLAPSED ) )
{
m_pToggleCollapseButton->SetText( "-" );
}
else
{
m_pToggleCollapseButton->SetText( "+" );
}
SetFlag( FLAG_COLLAPSED, !IsFlagSet( FLAG_COLLAPSED ) );
InvalidateChain();
return;
}
if ( V_stricmp( command, "delete" ) == 0 )
{
RemoveNode();
return;
}
BaseClass::OnCommand( command );
}
void CEditorObjectNode::MarkForDeletion()
{
BaseClass::MarkForDeletion();
FOR_EACH_VEC( m_vecChildren, i )
{
m_vecChildren[i]->MarkForDeletion();
}
}
void CEditorObjectNode::RemoveNode()
{
MarkForDeletion();
InvalidateChain();
}
void CEditorObjectNode::ClearPendingChangesFlag()
{
BaseClass::ClearPendingChangesFlag();
FOR_EACH_VEC( m_vecChildren, i )
{
m_vecChildren[ i ]->ClearPendingChangesFlag();
}
}
IEditorObjectParameter::IEditorObjectParameter( EditorObjectInitStruct init, const char *pszLabelText )
: BaseClass( init )
{
memset( m_szSavedValueBuff, 0, sizeof( m_szSavedValueBuff ) );
SetTall( tf_quest_editor_element_height.GetInt() );
m_pLabel = new Label( this, "paramlabel", pszLabelText );
m_pLabel->SetWide( 100 );
m_pLabel->SetPos( 20, 0 );
m_pLabel->SetVisible( pszLabelText != NULL );
CEditorObjectNode* pNode = dynamic_cast< CEditorObjectNode* >( init.pParent );
if ( pNode )
{
pNode->AddChild( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditorObjectParameter::~IEditorObjectParameter()
{
CEditorObjectNode* pEditorPanel = dynamic_cast<CEditorObjectNode*>( GetParent() );
if ( pEditorPanel )
{
pEditorPanel->RemoveChild( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObjectParameter::PerformLayout()
{
BaseClass::PerformLayout();
m_pLabel->SetPos( 20, 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObjectParameter::SerializeToKVs( KeyValues* pKV, const IEditableDataType* pCallingEditable ) const
{
m_bHasChanges = false;
if ( ShouldWrite( pCallingEditable ) == WRITE_THIS_AND_CONTINUE )
{
KeyValues* pKVStomp = pKV->FindKey( GetKeyName() );
if ( pKVStomp )
{
AssertMsg2( false, "STOMPING existing key: %s with %s\n", pKVStomp->GetName(), GetValue() );
KeyValuesDumpAsDevMsg( pKVStomp );
}
pKV->SetString( GetKeyName(), GetValue() );
UpdateSavedValue( GetValue() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObjectParameter::UpdateSavedValue( const char* pszNewValue ) const
{
// Update saved string
memset( m_szSavedValueBuff, 0, sizeof( m_szSavedValueBuff ) );
V_sprintf_safe( m_szSavedValueBuff, "%s", pszNewValue );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObjectParameter::OnTextChanged( KeyValues *data )
{
m_bHasChanges = CheckForChanges();
IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
Color labelNormalFGColor = GetSchemeColor("Label.TextColor", Color(0, 0, 0, 255), pScheme);
Color labelChangesFGColor = GetSchemeColor("RichText.SelectedBgColor", Color(0, 0, 0, 255), pScheme);
m_pLabel->SetFgColor( m_bHasChanges ? labelChangesFGColor : labelNormalFGColor );
g_pQuestEditor->CheckForChanges();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool IEditorObjectParameter::CheckForChanges() const
{
return !FStrEq( GetValue(), m_szSavedValueBuff );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTextEntryEditorParam::CTextEntryEditorParam( EditorObjectInitStruct init, const char *pszLabelText, const char *pszValue )
: BaseClass( init, pszLabelText )
{
UpdateSavedValue( pszValue );
SetTall( tf_quest_editor_element_height.GetInt() );
m_pTextEntry = new TextEntry( this, "entry" );
m_pTextEntry->SetPos( tf_quest_editor_entry_inset.GetInt(), 0 );
m_pTextEntry->SetWide( 400 );
m_pTextEntry->SetTall( tf_quest_editor_element_height.GetInt() );
m_pTextEntry->SetMultiline( true );
m_pTextEntry->SetCatchEnterKey( true );
SetTextEntryValue( pszValue );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTextEntryEditorParam::PerformLayout()
{
BaseClass::PerformLayout();
m_pTextEntry->SetPos( tf_quest_editor_entry_inset.GetInt(), 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTextEntryEditorParam::GetContentTall() const
{
return IsFlagSet( FLAG_HIDDEN ) ? 0 : m_pTextEntry->GetTall();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTextEntryEditorParam::SetTextEntryValue( const char* pszValue )
{
m_pTextEntry->SetText( pszValue );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CTextEntryEditorParam::GetValue() const
{
m_pTextEntry->GetText( m_szValueBuff, sizeof( m_szValueBuff ) );
return m_szValueBuff;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IMPLEMENT_AUTO_LIST( ILocalizationEditorParamAutoList );
CLocalizationEditorParam::CLocalizationEditorParam( EditorObjectInitStruct init, const char *pszLabelText, const char *pszLocalizationToken )
: BaseClass( init, pszLabelText, NULL )
{
char szBuff[MAX_QUEST_DESC_LENGTH];
memset( szBuff, 0, sizeof( szBuff ) );
g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pszLocalizationToken ), szBuff, sizeof( szBuff ) );
SetTextEntryValue( szBuff );
UpdateSavedValue( szBuff );
V_sprintf_safe( m_szLocalizationToken, "%s", pszLocalizationToken );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CLocalizationEditorParam::GetValue() const
{
// Always return the localization token
return m_szLocalizationToken;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CLocalizationEditorParam::GetLocalizationValue() const
{
return BaseClass::GetValue();
}
bool CLocalizationEditorParam::CheckForChanges() const
{
return !FStrEq( m_szSavedValueBuff, GetLocalizationValue() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CComboBoxEditorParam::CComboBoxEditorParam( EditorObjectInitStruct init, const char *pszLabelText )
: BaseClass( init, pszLabelText )
, m_pComboBox( NULL )
{
m_pComboBox = new ComboBox( this, "combobox", 10, false );
m_pComboBox->AddActionSignalTarget( this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CComboBoxEditorParam::PerformLayout()
{
BaseClass::PerformLayout();
m_pComboBox->SetWide( 350 );
m_pComboBox->SetPos( tf_quest_editor_entry_inset.GetInt(), 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CComboBoxEditorParam::GetContentTall() const
{
return IsFlagSet( FLAG_HIDDEN ) ? 0 : m_pComboBox->GetTall();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CComboBoxEditorParam::GetValue() const
{
return m_pComboBox->GetActiveItemUserData()->GetString( "write" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CComboBoxEditorParam::AddComboBoxEntry( const char* pszText, bool bSelected, const char* pszWriteValue, const char* pszCommand )
{
KeyValues *pKVData = new KeyValues( "data" );
pKVData->SetString( "write", pszWriteValue );
pKVData->SetString( "command", pszCommand );
int nIndex = m_pComboBox->AddItem( pszText, pKVData );
if ( bSelected )
{
m_pComboBox->SilentActivateItemByRow( nIndex );
UpdateSavedValue( pszWriteValue );
}
if ( pszWriteValue == NULL )
{
pszWriteValue = pszText;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CComboBoxEditorParam::OnTextChanged( KeyValues *data )
{
Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
vgui::ComboBox *pComboBox = dynamic_cast<vgui::ComboBox *>( pPanel );
if ( pComboBox == m_pComboBox )
{
CQuestObjectiveRestrictionNode* pParent = dynamic_cast< CQuestObjectiveRestrictionNode* >( GetParent() );
if ( pParent )
{
// What to do
const char* pszCommand = m_pComboBox->GetActiveItemUserData()->GetString( "command" );
// What to write
const char* pszWriteValue = m_pComboBox->GetActiveItemUserData()->GetString( "write" );
if ( V_stricmp( pszCommand, "changetype" ) == 0 )
{
pParent->SetNewType( pszWriteValue );
}
else if ( V_stricmp( pszCommand, "changeevent" ) == 0 )
{
pParent->SetNewEvent( pszWriteValue );
}
}
}
BaseClass::OnTextChanged( data );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CNewQuestObjectiveParam::CNewQuestObjectiveParam( EditorObjectInitStruct init, const char *pszLabelText )
: BaseClass( init, NULL )
{
SetFlag( FLAG_DONT_EXPORT, true );
m_pAddButton = new Button( this, "add", "Add New Filter", this, "add" );
m_pAddButton->SetTall( 20 );
m_pComboBox->SetVisible( false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNewQuestObjectiveParam::PerformLayout()
{
BaseClass::PerformLayout();
m_pAddButton->SetWide( 200 );
m_pAddButton->SetPos( tf_quest_editor_indent_width.GetInt(), 0 );
m_pAddButton->SetContentAlignment( Label::a_center );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNewQuestObjectiveParam::OnCommand( const char *command )
{
if ( FStrEq( command, "add" ) )
{
CQuestObjectiveRestrictionNode *pObjectiveParent = dynamic_cast< CQuestObjectiveRestrictionNode* >( GetParent() );
Assert( pObjectiveParent );
if ( pObjectiveParent )
{
const char *pszWriteValue = m_pComboBox->GetActiveItemUserData()->GetString( "write" );
CTFQuestCondition *pNewCondition = pObjectiveParent->GetCondition()->AddChildByName( pszWriteValue );
if ( pNewCondition )
{
new CQuestObjectiveRestrictionNode( { GetParent(), CFmtStr( "%d", pObjectiveParent->GetNextAvailableKeyNumber() ), FLAGS_NONE }, pNewCondition );
InvalidateChain();
}
}
}
BaseClass::OnCommand( command );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IOptionalExpandableBlock::IOptionalExpandableBlock( EditorObjectInitStruct init, const char* pszButtonText )
: BaseClass( init )
{
m_pAddButton = new Button( this, "add", pszButtonText, this, "add" );
}
void IOptionalExpandableBlock::InitControls( KeyValues* pKVBlock )
{
int nNumControlsCreated = 0;
if ( pKVBlock )
{
FOR_EACH_TRUE_SUBKEY( pKVBlock, pKVKey )
{
CreateNewControl( pKVKey );
++nNumControlsCreated;
}
}
while( nNumControlsCreated < GetMinCount() )
{
CreateNewDefaultControl();
++nNumControlsCreated;
}
InvalidateChain();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IOptionalExpandableBlock::PerformLayout()
{
BaseClass::PerformLayout();
m_pAddButton->SetPos( 0, 0 );
m_pAddButton->SetWide( 200 );
m_pAddButton->SetContentAlignment(Label::a_center);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IOptionalExpandableBlock::OnCommand( const char *command )
{
if ( FStrEq( "add", command ) )
{
CreateNewDefaultControl();
InvalidateChain();
return;
}
BaseClass::OnCommand( command );
}
void IOptionalExpandableBlock::CreateNewControl( KeyValues* pKV )
{
SetFlag( FLAG_DONT_EXPORT, false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CQuestObjectiveNode::CQuestObjectiveNode( CEditorObjectNode* pParentNode, KeyValues* pKVObjective )
: BaseClass( { pParentNode, pKVObjective->GetName(), FLAG_COLLAPSABLE } )
, m_pDefIndexComboBox( NULL )
, m_pSelectObjectiveButton( NULL )
{
// Create the description field
new CLocalizationEditorParam( { this, "description_string", FLAGS_NONE }, "Objective Desc:", pKVObjective->GetString( "description_string" ) );
new CTextEntryEditorParam( { this, "defindex", FLAG_HIDDEN }, "Defindex", pKVObjective->GetString( "defindex" ) );
CComboBoxEditorParam * pOptionalComboBox = new CComboBoxEditorParam( { this, "optional", FLAGS_NONE }, "Optional:" );
pOptionalComboBox->AddComboBoxEntry( "False", !pKVObjective->GetBool( "optional", false ), "0", NULL );
pOptionalComboBox->AddComboBoxEntry( "True", pKVObjective->GetBool( "optional", false ), "1", NULL );
CComboBoxEditorParam * pAdvancedComboBox = new CComboBoxEditorParam( { this, "advanced", FLAGS_NONE }, "Advanced:" );
pAdvancedComboBox->AddComboBoxEntry( "False", !pKVObjective->GetBool( "advanced", false ), "0", NULL );
pAdvancedComboBox->AddComboBoxEntry( "True", pKVObjective->GetBool( "advanced", false ), "1", NULL );
CTextEntryEditorParam *pPointsNode = new CTextEntryEditorParam( { this, "points", FLAGS_NONE }, "Points:", CFmtStr( "%d", pKVObjective->GetInt( "points", 1 ) ) );
pPointsNode->GetTextEntry()->SetAllowNumericInputOnly( true );
// The condition def index this objective wants to use
ObjectiveConditionDefIndex_t nConditionsDefIndex = pKVObjective->GetInt( "conditions_def_index", INVALID_QUEST_OBJECTIVE_CONDITIONS_INDEX );
Assert( nConditionsDefIndex != INVALID_QUEST_OBJECTIVE_CONDITIONS_INDEX );
m_pDefIndexComboBox = new CComboBoxEditorParam( { this, "conditions_def_index", FLAGS_NONE }, "Conditions:" );
m_pDefIndexComboBox->GetComboBox()->AddActionSignalTarget( this );
m_pSelectObjectiveButton = new Button( m_pDefIndexComboBox, "selectobjective", "Pick", this, "selectobjective" );
m_pSelectObjectiveButton->AddActionSignalTarget( this );
PopulateAndSelectConditionsCombobox( nConditionsDefIndex );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::PerformLayout()
{
BaseClass::PerformLayout();
m_pSelectObjectiveButton->SetPos( m_pDefIndexComboBox->GetComboBox()->GetXPos() + m_pDefIndexComboBox->GetComboBox()->GetWide(), 0 );
m_pSelectObjectiveButton->SetWide( 36 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::PopulateAndSelectConditionsCombobox( int nSelectedDefIndex )
{
// Clean out oldies
m_pDefIndexComboBox->GetComboBox()->RemoveAll();
// Go through all of the current data and fill out our combo box with all of the objective conditions
const CUtlVector< IEditableDataType* >& vecEditableData = g_pQuestEditor->GetEditableData();
FOR_EACH_VEC( vecEditableData, i )
{
IEditableDataType* pEditable = vecEditableData[i];
if ( pEditable->GetType() == IEditableDataType::TYPE_OBJECTIVE_CONDITIONS && !g_pQuestEditor->IsOpenForEdit( pEditable ) )
{
KeyValues* pKVData = pEditable->GetLiveData();
bool bSelected = atoi( pKVData->GetName() ) == nSelectedDefIndex;
m_pDefIndexComboBox->AddComboBoxEntry( CFmtStr( "\t%s", pKVData->GetString( "name", "ERROR" ) ), bSelected, pKVData->GetName(), NULL );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::OnCommand( const char *command )
{
if ( FStrEq( "selectobjective", command ) )
{
KeyValues* pKV = new KeyValues( "SelectQuestObjective" );
pKV->SetPtr( "panel", this );
PostMessage( g_pQuestEditor, pKV );
}
BaseClass::OnCommand( command );
}
//-----------------------------------------------------------------------------
// Purpose: Pump the command from the menu panel into us as a command
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::OnTextChanged( KeyValues *data )
{
Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
ComboBox *pComboBox = dynamic_cast<ComboBox*>( pPanel );
if ( pComboBox )
{
if ( pComboBox == m_pDefIndexComboBox->GetComboBox() )
{
KeyValues* pKVUserData = pComboBox->GetActiveItemUserData();
OnCommand( pKVUserData->GetString( "command" ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::OnObjectiveSelected( KeyValues *data )
{
int nDesiredDefIndex = data->GetInt( "defindex", INVALID_ITEM_DEF_INDEX );
Assert( nDesiredDefIndex != INVALID_ITEM_DEF_INDEX );
ComboBox* pComboBox = m_pDefIndexComboBox->GetComboBox();
if ( pComboBox )
{
for( int i=0; i < pComboBox->GetItemCount(); ++i )
{
KeyValues* pKVUserData = pComboBox->GetItemUserData( i );
int nDefIndex = pKVUserData->GetInt( "write", INVALID_ITEM_DEF_INDEX );
if ( nDefIndex == nDesiredDefIndex )
{
pComboBox->ActivateItemByRow( i );
return;
}
}
}
// Didn't find the matching defindex!
Assert( false );
}
void CQuestDescriptionNode::CreateNewControl( KeyValues* pKV )
{
CEditorObjectNode* pNode = new CEditorObjectNode( EditorObjectInitStruct{ this, pKV->GetName(), FLAGS_NONE } );
CLocalizationEditorParam *pLocParam = new CLocalizationEditorParam( { pNode, "token", FLAGS_NONE }, "Description:", pKV->GetString( "token" ) );
pLocParam->GetTextEntry()->SetTall( 200 );
pLocParam->SetTall( 200 );
pLocParam->GetTextEntry()->SetVerticalScrollbar( true );
BaseClass::CreateNewControl( pKV );
}
void CQuestDescriptionNode::CreateNewDefaultControl()
{
int nDefindex = GetNextAvailableKeyNumber() + 1;
int nObjectDefIndex = atoi( GetOwningEditable()->GetLiveData()->GetName() );
KeyValuesAD pKVDesc( CFmtStr( "%d", nDefindex ) );
pKVDesc->SetString( "token", CFmtStr( g_skDescTokenFormat, nObjectDefIndex, nDefindex ) );
CreateNewControl( pKVDesc );
}
void CQuestNameNode::CreateNewControl( KeyValues* pKV )
{
CEditorObjectNode* pNode = new CEditorObjectNode( EditorObjectInitStruct{ this, pKV->GetName(), FLAGS_NONE } );
new CLocalizationEditorParam( { pNode, "token", FLAGS_NONE }, "Name:", pKV->GetString( "token" ) );
BaseClass::CreateNewControl( pKV );
}
void CQuestNameNode::CreateNewDefaultControl()
{
int nDefindex = GetNextAvailableKeyNumber() + 1;
int nObjectDefIndex = atoi( GetOwningEditable()->GetLiveData()->GetName() );
KeyValuesAD pKVName( CFmtStr( "%d", nDefindex ) );
pKVName->SetString( "token", CFmtStr( g_skNameTokenFormat, nObjectDefIndex, nDefindex ) );
CreateNewControl( pKVName );
}
CComboBoxEditorParam* CreateWeaponComboBox( EditorObjectInitStruct init, const char* pszLabelText, item_definition_index_t defIndexSelect )
{
CComboBoxEditorParam* pCombo = new CComboBoxEditorParam( init, pszLabelText );
pCombo->GetComboBox()->SetEditable( true ); // Allow for typing in the combo box. There's a lot of stuff
CUtlDict< item_definition_index_t > weaponDict;
const CEconItemSchema::SortedItemDefinitionMap_t& mapItemDefs = GetItemSchema()->GetSortedItemDefinitionMap();
FOR_EACH_MAP( mapItemDefs, i )
{
CTFItemDefinition* pDef = (CTFItemDefinition*)mapItemDefs[i];
int iSlot = pDef->GetDefaultLoadoutSlot();
if ( pDef->GetEquipType() == EEquipType_t::EQUIP_TYPE_ACCOUNT )
continue;
if ( !( iSlot == LOADOUT_POSITION_PRIMARY
|| iSlot == LOADOUT_POSITION_SECONDARY
|| iSlot == LOADOUT_POSITION_MELEE
|| iSlot == LOADOUT_POSITION_PDA
|| iSlot == LOADOUT_POSITION_PDA2
|| iSlot == LOADOUT_POSITION_BUILDING ) )
continue;
// sort weapon by name by adding to weaponDict
weaponDict.Insert( pDef->GetDefinitionName(), pDef->GetDefinitionIndex() );
}
// add sorted weapon to the combobox
FOR_EACH_DICT( weaponDict, i )
{
item_definition_index_t weaponDefIndex = weaponDict.Element( i );
bool bSelect = defIndexSelect == weaponDefIndex;
pCombo->AddComboBoxEntry( weaponDict.GetElementName( i ), bSelect, CFmtStr( "%d", weaponDefIndex ), NULL );
}
return pCombo;
}
void CRequiredItemsParam::CreateNewControl( KeyValues* pKV )
{
CEditorObjectNode* pRoot = new CEditorObjectNode( EditorObjectInitStruct{ this, pKV->GetName(), FLAGS_NONE } );
item_definition_index_t defIndexCurrent = (item_definition_index_t)pKV->GetInt( "loaner_defindex", INVALID_ITEM_DEF_INDEX );
CreateWeaponComboBox( { pRoot, "loaner_defindex", FLAG_NOT_DELETABLE }, "Loaner Item:", defIndexCurrent );
CQualifyingItemsParam* pQualifying = new CQualifyingItemsParam( EditorObjectInitStruct{ pRoot, "qualifying_items", FLAG_NOT_DELETABLE } );
pQualifying->InitControls( pKV->FindKey( "qualifying_items" ) );
BaseClass::CreateNewControl( pKV );
}
void CRequiredItemsParam::CreateNewDefaultControl()
{
int nDefindex = GetNextAvailableKeyNumber() + 1;
int nObjectDefIndex = atoi( GetOwningEditable()->GetLiveData()->GetName() );
KeyValuesAD pKVName( CFmtStr( "%d", nDefindex ) );
pKVName->SetString( "token", CFmtStr( g_skNameTokenFormat, nObjectDefIndex, nDefindex ) );
CreateNewControl( pKVName );
}
void CQualifyingItemsParam::CreateNewControl( KeyValues* pKV )
{
CEditorObjectNode* pNode = new CEditorObjectNode( EditorObjectInitStruct{ this, pKV->GetName(), FLAGS_NONE } );
item_definition_index_t defIndexCurrent = (item_definition_index_t)pKV->GetInt( "defindex", INVALID_ITEM_DEF_INDEX );
CreateWeaponComboBox( { pNode, "defindex", FLAGS_NONE }, "Qualifying Item:", defIndexCurrent );
BaseClass::CreateNewControl( pKV );
}
void CQualifyingItemsParam::CreateNewDefaultControl()
{
int nDefindex = GetNextAvailableKeyNumber() + 1;
KeyValuesAD pKVQualifying( CFmtStr( "%d", nDefindex ) );
pKVQualifying->SetInt( "defindex", 0 );
CreateNewControl( pKVQualifying );
}
void CObjectiveExpandable::CreateNewControl( KeyValues* pKV )
{
new CQuestObjectiveNode( this, pKV );
}
void CObjectiveExpandable::CreateNewDefaultControl()
{
int nDefindex = GetNextAvailableKeyNumber() + 1;
KeyValuesAD pKVObjective( CFmtStr( "%d", nDefindex ) );
pKVObjective->SetInt( "description_string", 0 );
const int nQuestDefIndex = atoi( GetOwningEditable()->GetLiveData()->GetName() );
const int nObjDefIndex = ( ( nQuestDefIndex - g_nkFirstQuestDef ) + 1 ) * 100 + nDefindex;
pKVObjective->SetInt( "defindex", nObjDefIndex );
pKVObjective->SetString( "description_string", CFmtStr( g_skObjectiveDescTokenFormat, nQuestDefIndex, nDefindex ) );
pKVObjective->SetBool( "optional", false );
pKVObjective->SetInt( "conditions_def_index", INVALID_QUEST_OBJECTIVE_CONDITIONS_INDEX );
pKVObjective->SetInt( "advanced", 0 );
CreateNewControl( pKVObjective );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CQuestObjectiveRestrictionNode::CQuestObjectiveRestrictionNode( EditorObjectInitStruct init, CTFQuestCondition *pCondition )
: BaseClass( { init.pParent, init.m_pszKeyName, init.nFlags | FLAG_HIGHLIGHT_MOUSEOVER } )
, m_pCondition( pCondition )
, m_pNewCondition( NULL )
{
CreateControlsForCondition();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::CreateControlsForCondition()
{
CComboBoxEditorParam* pTypeParam = new CComboBoxEditorParam( { this, "type", FLAGS_NONE }, "Type:" );
CUtlVector< const char* > vecValidChildren;
m_pCondition->GetValidTypes( vecValidChildren );
FOR_EACH_VEC( vecValidChildren, i )
{
bool bSelected = FStrEq( m_pCondition->GetConditionName(), vecValidChildren[ i ] );
pTypeParam->AddComboBoxEntry( vecValidChildren[ i ], bSelected, vecValidChildren[ i ], "changetype" );
}
// Parameters for this node
KeyValuesAD KVParams( "params" );
m_pCondition->GetRequiredParamKeys( KVParams );
KeyValuesAD outputKey( "output" );
m_pCondition->GetOutputKeyValues( outputKey );
FOR_EACH_TRUE_SUBKEY( KVParams, params )
{
const char *pszParamEnglishName = params->GetString( "english_name", NULL );
const char *pszParamName = params->GetName();
const char *pszLabelText = pszParamEnglishName ? pszParamEnglishName : pszParamName;
const char *pszAction = FStrEq( pszParamName, "event_name" ) ? "changeevent" : NULL;
const char* pszControlType = params->GetString( "control_type", "combo_box" ); // Default to combobox
if ( FStrEq( "text_entry", pszControlType ) )
{
const char *pszOutput = outputKey->GetString( pszParamName, "" );
new CTextEntryEditorParam( { this, params->GetName(), FLAGS_NONE }, pszLabelText, pszOutput );
}
else if ( FStrEq( "combo_box", pszControlType ) )
{
CComboBoxEditorParam* pNewParam = new CComboBoxEditorParam( { this, params->GetName(), FLAGS_NONE }, pszLabelText );
const char *pszOutput = outputKey->GetString( pszParamName, "" );
pNewParam->ClearComboBoxEntries();
FOR_EACH_TRUE_SUBKEY( params, pChoiceKey )
{
const char *pszChoiceName = pChoiceKey->GetName();
const char *pszChoiceEnglishName = pChoiceKey->GetString( "english_name", NULL );
bool bSelect = FStrEq( pszOutput, pszChoiceName ) || pChoiceKey == params->GetFirstTrueSubKey();
pNewParam->AddComboBoxEntry( pszChoiceEnglishName ? pszChoiceEnglishName : pszChoiceName, bSelect, pszChoiceName, pszAction );
}
// Hide parameters where there's only 1 option
pNewParam->SetFlag( FLAG_HIDDEN, pNewParam->GetComboBox()->GetItemCount() <= 1 );
}
}
// Children of this node
CUtlVector< CTFQuestCondition* > vecChildConditions;
m_pCondition->GetChildren( vecChildConditions );
FOR_EACH_VEC( vecChildConditions, iChild )
{
CTFQuestCondition* pChildCondition = vecChildConditions[ iChild ];
new CQuestObjectiveRestrictionNode( { this, CFmtStr( "%d", iChild ), FLAGS_NONE }, pChildCondition );
}
CreateAddOpportunityParam();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::CreateAddOpportunityParam()
{
int nChildCount = 0;
FOR_EACH_VEC( GetChildren(), i )
{
if ( dynamic_cast< CQuestObjectiveRestrictionNode* >( GetChildren()[i] ) )
{
++nChildCount;
}
}
bool bShowAddOpportunity = m_pCondition && nChildCount < m_pCondition->GetMaxInputCount() ;
if ( m_pNewCondition && !bShowAddOpportunity )
{
delete m_pNewCondition;
m_pNewCondition = NULL;
}
else if ( !m_pNewCondition && bShowAddOpportunity )
{
// Add empty potential node
CUtlVector< const char* > vecValidChildren;
m_pCondition->GetValidChildren( vecValidChildren );
if ( vecValidChildren.Count() )
{
m_pNewCondition = new CNewQuestObjectiveParam( { this, NULL, FLAGS_NONE }, NULL );
FOR_EACH_VEC( vecValidChildren, i )
{
m_pNewCondition->AddComboBoxEntry( vecValidChildren[ i ], false, vecValidChildren [ i ], NULL );
}
}
}
}
void CQuestObjectiveRestrictionNode::RemoveNode()
{
// tell parent to remove me and my children
if ( m_pCondition )
{
CTFQuestCondition *pParentCondition = m_pCondition->GetParent();
if ( pParentCondition )
{
pParentCondition->RemoveAndDeleteChild( m_pCondition );
}
}
m_pCondition = NULL;
BaseClass::RemoveNode();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::SetNewType( const char *pszType )
{
// Delete all children
FOR_EACH_VEC_BACK( m_vecChildren, i )
{
m_vecChildren[i]->MarkForDeletion();
}
m_pNewCondition = NULL;
// Create new restriction
CTFQuestCondition* pParent = m_pCondition->GetParent();
if ( pParent && pParent->RemoveAndDeleteChild( m_pCondition ) )
{
m_pCondition = pParent->AddChildByName( pszType );
}
else
{
delete m_pCondition;
m_pCondition = CreateEvaluatorByName( pszType, NULL );
}
CreateControlsForCondition();
InvalidateChain();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::SetNewEvent( const char *pszEvent )
{
// We only have to blow up everything if we're an evaluator
if ( !m_pCondition->IsEvaluator() )
{
return;
}
// Delete all children
FOR_EACH_VEC_BACK( m_vecChildren, i )
{
m_vecChildren[i]->MarkForDeletion();
}
m_pNewCondition = NULL;
char szType[256];
V_sprintf_safe( szType, "%s", m_pCondition->GetConditionName() );
// Create new restriction
CTFQuestCondition* pParent = m_pCondition->GetParent();
if ( pParent && pParent->RemoveAndDeleteChild( m_pCondition ) )
{
m_pCondition = pParent->AddChildByName( szType );
}
else
{
delete m_pCondition;
m_pCondition = CreateEvaluatorByName( szType, NULL );
}
V_sprintf_safe( m_szEventName, "%s", pszEvent );
m_pCondition->SetEventName( m_szEventName );
CreateControlsForCondition();
InvalidateChain();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::PerformLayout()
{
BaseClass::PerformLayout();
CreateAddOpportunityParam();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEditorQuest::CEditorQuest( KeyValues *pKV, Panel* pParent, const IEditableDataType* pEditable )
: CEditorObjectNode( EditorObjectInitStruct{ pParent, pKV->GetName(), FLAGS_NONE } )
{
SetOwningEditable( pEditable );
new CTextEntryEditorParam( { this, "name", FLAG_HIDDEN }, "Item Def Name:", pKV->GetString( "name" ) );
new CLocalizationEditorParam( { this, "item_name", FLAGS_NONE }, "Item Name:", pKV->GetString( "item_name" ) );
CComboBoxEditorParam *pPrefabParam = new CComboBoxEditorParam( { this, "prefab", FLAGS_NONE }, "Prefab:" );
int nChosenIndex = -1;
for( int i=0; i < ARRAYSIZE( g_skQuestPrefabs ); ++i )
{
if ( FStrEq( g_skQuestPrefabs[i], pKV->GetString( "prefab" ) ) )
{
nChosenIndex = i;
}
bool bSelect = nChosenIndex == i || ( nChosenIndex == -1 && i == 0 );
pPrefabParam->AddComboBoxEntry( g_skQuestPrefabs[i], bSelect, g_skQuestPrefabs[i], NULL );
}
// Get the quest keys
KeyValues *pKVQuest = pKV->FindKey( "quest" );
// Create the panels to hold the quest def
CEditorObjectNode *pQuestNode = new CEditorObjectNode( EditorObjectInitStruct{ this, "quest", FLAG_HIDDEN } );
CQuestNameNode* pNameNode = new CQuestNameNode( EditorObjectInitStruct{ pQuestNode, "names", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE } );
pNameNode->InitControls( pKVQuest->FindKey( "names" ) );
new CTextEntryEditorParam( { pQuestNode, "max_standard_points", FLAGS_NONE }, "Max Standard Points:", pKVQuest->GetString( "max_standard_points" ) );
new CTextEntryEditorParam( { pQuestNode, "max_bonus_points", FLAGS_NONE }, "Max Bonus Points:", pKVQuest->GetString( "max_bonus_points" ) );
new CTextEntryEditorParam( { pQuestNode, "reward", FLAGS_NONE }, "Reward:", pKVQuest->GetString( "reward" ) );
new CTextEntryEditorParam( { pQuestNode, "objectives_to_roll", FLAGS_NONE }, "Objectives to roll:", pKVQuest->GetString( "objectives_to_roll" ) );
new CTextEntryEditorParam( { pQuestNode, "mm_map", FLAGS_NONE }, "Casual MM Map:", pKVQuest->GetString( "mm_map" ) );
CComboBoxEditorParam *pThemeParam = new CComboBoxEditorParam( { pQuestNode, "theme", FLAGS_NONE }, "Theming:" );
nChosenIndex = -1;
{
const auto& mapThemes = GetItemSchema()->GetQuestThemes();
FOR_EACH_MAP( mapThemes, i )
{
if ( FStrEq( mapThemes[i]->GetName(), pKVQuest->GetString( "theme" ) ) )
{
nChosenIndex = i;
}
bool bSelect = nChosenIndex == i || ( nChosenIndex == -1 && i == 0 );
pThemeParam->AddComboBoxEntry( mapThemes[i]->GetName(), bSelect, mapThemes[i]->GetName(), NULL );
}
}
CComboBoxEditorParam *pCorrespondingOperation = new CComboBoxEditorParam( { pQuestNode, "operation", FLAGS_NONE }, "Operation:" );
nChosenIndex = -1;
{
const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
FOR_EACH_MAP( mapOperations, i )
{
if ( FStrEq( mapOperations[i]->GetName(), pKVQuest->GetString( "operation" ) ) )
{
nChosenIndex = i;
}
bool bSelect = nChosenIndex == i || ( nChosenIndex == -1 && i == 0 );
pCorrespondingOperation->AddComboBoxEntry( mapOperations[i]->GetName(), bSelect, mapOperations[i]->GetName(), NULL );
}
}
CQuestDescriptionNode* pDescNode = new CQuestDescriptionNode( EditorObjectInitStruct{ pQuestNode, "descriptions", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE | FLAG_COLLAPSED } );
pDescNode->InitControls( pKVQuest->FindKey( "descriptions" ) );
CRequiredItemsParam* pRequiredExpandable = new CRequiredItemsParam( EditorObjectInitStruct{ pQuestNode, "required_items", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE | FLAG_DONT_EXPORT } );
pRequiredExpandable->InitControls( pKVQuest->FindKey( "required_items" ) );
CObjectiveExpandable* pObjectiveExpandable = new CObjectiveExpandable( EditorObjectInitStruct{ pQuestNode, "objectives", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE } );
pObjectiveExpandable->InitControls( pKVQuest->FindKey( "objectives" ) );
// Gets the scrollbar to be the right height
pParent->InvalidateLayout();
}
CEditorQuest::~CEditorQuest()
{}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditableDataType::IEditableDataType( KeyValues* pKVData )
: m_pKVLiveData( pKVData->MakeCopy() )
, m_pKVSavedData( pKVData->MakeCopy() )
, m_pCurrentObject( NULL )
, m_bHasUnsavedChanges( false )
{}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditableDataType::~IEditableDataType()
{
// We own the keys
if ( m_pKVLiveData )
{
m_pKVLiveData->deleteThis();
}
}
//-----------------------------------------------------------------------------
// Purpose: Create the panels and store a pointer to them
//-----------------------------------------------------------------------------
void IEditableDataType::CreatePanels( Panel* pParent )
{
Assert( m_pCurrentObject == NULL );
m_pCurrentObject = CreateEditableObject_Internal( pParent );
m_pCurrentObject->ClearPendingChangesFlag();
UpdateButton();
}
void IEditableDataType::DestroyPanels()
{
if ( m_pCurrentObject )
{
m_pCurrentObject->MarkForDeletion();
m_pCurrentObject = NULL;
}
UpdateButton();
}
//-----------------------------------------------------------------------------
// Purpose: Given a type and a name, see if we match
//-----------------------------------------------------------------------------
bool IEditableDataType::MatchesCriteria( EType type, const char* pszName ) const
{
return GetType() == type && FStrEq( pszName, m_pKVLiveData->GetName() );
}
class CKeyValuesDumpToString : public IKeyValuesDumpContextAsText
{
public:
// Overrides developer level to dump in DevMsg, zero to dump as Msg
CKeyValuesDumpToString() {}
public:
virtual bool KvWriteValue( KeyValues *val, int nIndentLevel ) OVERRIDE
{
if ( !val )
{
return
KvWriteIndent( nIndentLevel ) &&
KvWriteText( "<< NULL >>\n" );
}
if ( !KvWriteIndent( nIndentLevel ) )
return false;
if ( !KvWriteText( val->GetName() ) )
return false;
if ( !KvWriteText( " " ) )
return false;
if ( !KvWriteText( val->GetString() ) )
return false;
return KvWriteText( "\n" );
}
virtual bool KvWriteText( char const *szText ) OVERRIDE
{
m_strDump.Append( szText );
return true;
}
CUtlString m_strDump;
};
//-----------------------------------------------------------------------------
// Purpose: Saves any changes that have been made with the controls. Does NOT write to disk.
//-----------------------------------------------------------------------------
void IEditableDataType::SaveEdits()
{
// Get the new keys
KeyValues* tempKV = new KeyValues( "edits" );
tempKV->AddSubKey( m_pKVLiveData->MakeCopy() );
WriteObjectToKeyValues( false, tempKV );
// Update the live keys
m_pKVLiveData->deleteThis();
m_pKVLiveData = tempKV->GetFirstTrueSubKey()->MakeCopy();
CKeyValuesDumpToString dumpOrig;
CKeyValuesDumpToString dumpNew;
// Dump into strings
m_pKVLiveData->Dump( &dumpNew, 0, true );
m_pKVSavedData->Dump( &dumpOrig, 0, true );
// Compare the strings to check for a difference
m_bHasUnsavedChanges = !FStrEq( dumpOrig.m_strDump, dumpNew.m_strDump );
if ( m_bHasUnsavedChanges )
{
ConColorMsg( Color( 0, 173, 53, 255 ), "Old:\n%s", dumpOrig.m_strDump.String() );
ConColorMsg( Color( 218, 128, 56, 255 ), "New:\n%s", dumpNew.m_strDump.String() );
}
tempKV->deleteThis();
UpdateButton();
}
void IEditableDataType::UpdateButton()
{
Button* pButton = g_pQuestEditor->GetButtonForEditable( this );
if ( pButton )
{
IScheme *pScheme = vgui::scheme()->GetIScheme( pButton->GetScheme() );
Color buttonBGColor = pButton->GetSchemeColor("Button.BgColor", Color(0, 0, 0, 255), pScheme);
Color buttonFGColor = pButton->GetSchemeColor("Button.FGColor", Color(0, 0, 0, 255), pScheme);
if ( m_pCurrentObject )
{
buttonBGColor[0] = Min( buttonBGColor[0] + 70, 255 );
buttonBGColor[1] = Min( buttonBGColor[1] + 70, 255 );
buttonBGColor[2] = Min( buttonBGColor[2] + 70, 255 );
}
if ( m_bHasUnsavedChanges )
{
buttonFGColor[0] = Min( buttonFGColor[0] + 150, 255 ); // Lil more red
}
pButton->SetDefaultColor( buttonFGColor, buttonBGColor );
pButton->SetArmedColor( buttonFGColor, pButton->GetButtonArmedBgColor() );
if ( GetType() == IEditableDataType::TYPE_QUEST )
{
char szItemName[256];
g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( m_pKVLiveData->GetString( "item_name" ) ), szItemName, sizeof( szItemName ) );
pButton->SetText( CFmtStr( "%s: %s", m_pKVLiveData->GetName(), szItemName ) );
}
else
{
pButton->SetText( CFmtStr( "%s: %s", m_pKVLiveData->GetName(), m_pKVLiveData->GetString( "name" ) ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Serialize our object and save changes to disk
//-----------------------------------------------------------------------------
void IEditableDataType::SaveChangesToDisk()
{
SaveEdits();
WriteDataToDisk( false );
// Clean out old save data and copy the new keys
if ( m_pKVSavedData )
{
m_pKVSavedData->deleteThis();
}
m_pKVSavedData = m_pKVLiveData->MakeCopy();
UpdateButton();
}
//-----------------------------------------------------------------------------
// Purpose: Remove our entry from any file we exist in. Remove our panels.
// Delete our button that activates us.
//-----------------------------------------------------------------------------
void IEditableDataType::DeleteEntry()
{
WriteDataToDisk( true );
if ( m_pCurrentObject )
{
m_pCurrentObject->SetFlag( FLAG_DELETED, true );
WriteLocalizationData();
}
UpdateButton();
}
void IEditableDataType::RevertChanges()
{
Assert( m_pCurrentObject );
if ( !m_pCurrentObject )
return;
// Delete old panels
Panel* pCurrentParent = m_pCurrentObject->GetParent();
m_pCurrentObject->MarkForDeletion();
m_pCurrentObject = NULL;
// Delete live keys, and copy over the saved ones to live
m_pKVLiveData->deleteThis();
m_pKVLiveData = m_pKVSavedData->MakeCopy();
// Recreate panels
CreatePanels( pCurrentParent );
CheckForChanges();
}
void IEditableDataType::CheckForChanges()
{
if ( m_pCurrentObject )
{
m_bHasUnsavedChanges = m_pCurrentObject->HasChanges( true );
UpdateButton();
}
}
void IEditableDataType::WriteObjectToKeyValues( bool bDelete, KeyValues* pKVExistingFileData )
{
KeyValuesAD tempKV( "temp" );
m_pCurrentObject->SerializeToKVs( tempKV, this );
FOR_EACH_SUBKEY( tempKV, pNewObjectKey )
{
KeyValues *pCurrentObjectKey = pKVExistingFileData->FindKey( pNewObjectKey->GetName() );
if ( pCurrentObjectKey )
{
if ( bDelete )
{
pCurrentObjectKey->deleteThis();
}
else
{
// copy all elems
pCurrentObjectKey->Clear();
FOR_EACH_SUBKEY( pNewObjectKey, pElem )
{
pCurrentObjectKey->AddSubKey( pElem->MakeCopy() );
}
}
}
else
{
pKVExistingFileData->AddSubKey( pNewObjectKey->MakeCopy() );
}
}
}
int Sort_DefIndex( KeyValues* const* p1, KeyValues* const* p2 )
{
int n1 = atoi( (*p1)->GetName() );
int n2 = atoi( (*p2)->GetName() );
return n1 - n2;
}
//-----------------------------------------------------------------------------
// Purpose: Write quest data to "tf/scripts/items/unencrypted/_items_quests.txt"
//-----------------------------------------------------------------------------
void CEditableQuestDataType::WriteDataToDisk( bool bDelete )
{
// Wrap all of the quest in a "quests" keyvalue
CUtlBuffer bufRawData;
bufRawData.SetBufferType( true, true );
bufRawData.PutString( CFmtStr( "\"%s\"\n{\n", "quests") );
bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestDefFile, NULL, bufRawData );
if ( !bReadFileOK )
{
AssertMsg1( false, "Couldn't load file %s for saving!", g_skQuestDefFile );
return;
}
bufRawData.PutString( "\n}" );
// Load the buffer into keyvalues
KeyValuesAD pKVQuestItemData( "quests" );
pKVQuestItemData->LoadFromBuffer( NULL, bufRawData );
WriteObjectToKeyValues( bDelete, pKVQuestItemData );
// Sort by defindex
CUtlVector< KeyValues* > vecQuests;
FOR_EACH_SUBKEY( pKVQuestItemData, pItemKey )
{
vecQuests.AddToTail( pItemKey );
}
vecQuests.Sort( &Sort_DefIndex );
// Write housekeeping CSV file
FileHandle_t fileHandle = g_pFullFileSystem->Open( g_skQuestObjectivesHouseKeepingFile, "wt" );
// Write them out in order
CUtlBuffer buffer;
FOR_EACH_VEC( vecQuests, i )
{
// Write a row as we go through each quest item
KeyValues* pKVQuestBlock = vecQuests[i]->FindKey( "quest" );
if ( pKVQuestBlock )
{
KeyValues* pKVObjectives = pKVQuestBlock->FindKey( "objectives" );
if ( pKVObjectives )
{
FOR_EACH_TRUE_SUBKEY( pKVObjectives, pKVEntry )
{
char szDesc[256];
g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pKVEntry->GetString( "description_string" ) ), szDesc, sizeof( szDesc ) );
g_pFullFileSystem->FPrintf( fileHandle, "%d,%d,%d,%s,\n", pKVEntry->GetInt( "DefIndex" ), pKVEntry->GetInt( "points" ), pKVEntry->GetInt( "advanced" ), szDesc );
}
}
}
vecQuests[i]->RecursiveSaveToFile( buffer, 0, false, true );
}
g_pFullFileSystem->Close( fileHandle );
char szCorrectCaseFilePath[MAX_PATH];
g_pFullFileSystem->GetCaseCorrectFullPath( g_skQuestDefFile, szCorrectCaseFilePath );
CP4AutoEditFile a( szCorrectCaseFilePath );
if ( !g_pFullFileSystem->WriteFile( szCorrectCaseFilePath, NULL, buffer ) )
{
Warning( "Failed to write data to %s", g_skQuestDefFile );
}
}
IEditorObject* CEditableQuestDataType::CreateEditableObject_Internal( Panel* pParent ) const
{
CEditorQuest* pNewQuest = new CEditorQuest( m_pKVLiveData, pParent, this );
return pNewQuest;
}
//-----------------------------------------------------------------------------
// Purpose: Write quest data to "tf/scripts/items/unencrypted/_items_quest_objective_definitions.txt"
//-----------------------------------------------------------------------------
void CEditableObjectiveConditionDataType::WriteDataToDisk( bool bDelete )
{
// Wrap all of the quest in a "quests" keyvalue
CUtlBuffer bufRawData;
bufRawData.SetBufferType( true, true );
bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestObjectivesConditionsDefFile, NULL, bufRawData );
if ( !bReadFileOK )
{
AssertMsg1( false, "Couldn't load file %s for saving!", g_skQuestObjectivesConditionsDefFile );
return;
}
// Load the buffer into keyvalues
KeyValuesAD pKVQuestObjectivesData( "quest_objective_conditions" );
pKVQuestObjectivesData->LoadFromBuffer( NULL, bufRawData );
WriteObjectToKeyValues( bDelete, pKVQuestObjectivesData );
// Sort by defindex
CUtlVector< KeyValues* > vecQuestObjectives;
FOR_EACH_SUBKEY( pKVQuestObjectivesData, pItemKey )
{
vecQuestObjectives.AddToTail( pItemKey );
}
vecQuestObjectives.Sort( &Sort_DefIndex );
KeyValuesAD pKVSorted( "quest_objective_conditions" );
// Write them out in order
FOR_EACH_VEC( vecQuestObjectives, i )
{
pKVSorted->AddSubKey( vecQuestObjectives[i]->MakeCopy() );
}
// Write the definitions
{
CUtlBuffer buffer;
pKVSorted->RecursiveSaveToFile( buffer, 0, false, true );
char szCorrectCaseFilePath[MAX_PATH];
g_pFullFileSystem->GetCaseCorrectFullPath( g_skQuestObjectivesConditionsDefFile, szCorrectCaseFilePath );
CP4AutoEditFile a( szCorrectCaseFilePath );
if ( !g_pFullFileSystem->WriteFile( szCorrectCaseFilePath, NULL, buffer ) )
{
Warning( "Failed to write data to %s", g_skQuestObjectivesConditionsDefFile );
}
}
}
IEditorObject* CEditableObjectiveConditionDataType::CreateEditableObject_Internal( Panel* pParent ) const
{
CEditorObjectNode *pConditionDef = new CEditorObjectNode( EditorObjectInitStruct{ pParent, m_pKVLiveData->GetName(), FLAG_HIDDEN } );
pConditionDef->SetOwningEditable( this );
new CTextEntryEditorParam( { pConditionDef, "name", FLAGS_NONE }, "Conditions name:", m_pKVLiveData->GetString( "name" ) );
CRequiredItemsParam* pRequiredExpandable = new CRequiredItemsParam( EditorObjectInitStruct{ pConditionDef, "required_items", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE | FLAG_DONT_EXPORT } );
pRequiredExpandable->InitControls( m_pKVLiveData->FindKey( "required_items" ) );
KeyValues* pKVConditionLogic = m_pKVLiveData->FindKey( "condition_logic" );
const char *pszType = pKVConditionLogic->GetString( "type" );
CTFQuestCondition *pCondition = CreateEvaluatorByName( pszType, NULL );
if ( !pCondition->BInitFromKV( pKVConditionLogic, NULL ) )
{
Assert( false );
}
new CQuestObjectiveRestrictionNode( { pConditionDef, "condition_logic", FLAGS_NONE }, pCondition );
return pConditionDef;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CQuestEditorPanel::CQuestEditorPanel( Panel *pParent, const char *pszName )
: Frame( pParent, pszName )
, m_pCurrentOpenEdit( NULL )
, m_eCurrentSelectionMode( SELECTION_MODE_NONE )
{
SetTitle( "Quest Editor", true );
memset( m_pButtonsFilterTextEntry, NULL, sizeof( m_pButtonsFilterTextEntry ) );
m_pEditingPanel = new CExScrollingEditablePanel( this, "EditingPanel" );
m_pButtonsContainers[ IEditableDataType::TYPE_QUEST ] = new CExScrollingEditablePanel( this, "QuestListContainer" );
m_pButtonsContainers[ IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ] = new CExScrollingEditablePanel( this, "QuestObjectiveConditionsContainer" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::Deploy()
{
PopulateExistingQuests();
SetVisible( true );
MakePopup();
MoveToFront();
SetKeyBoardInputEnabled(true);
SetMouseInputEnabled(true);
InvalidateLayout( true, true );
// Center it, keeping requested size
int x, y, ww, wt, wide, tall;
vgui::surface()->GetWorkspaceBounds( x, y, ww, wt );
GetSize(wide, tall);
SetPos(x + ((ww - wide) / 2), y + ((wt - tall) / 2));
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "Resource/UI/econ/QuestEditor.res" );
m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_QUEST ] = FindControl< TextEntry >( "QuestsFilter" );
if ( m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_QUEST ] )
{
m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_QUEST ]->AddActionSignalTarget( this );
}
m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ] = FindControl< TextEntry >( "ConditionsFilter" );
if ( m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ] )
{
m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ]->AddActionSignalTarget( this );
}
Label *pP4Warning = FindControl< Label >( "P4Warning" );
if ( pP4Warning )
{
pP4Warning->SetVisible( p4 == NULL );
}
Button* pSaveButton = FindControl< Button >( "SaveButton" );
if ( pSaveButton )
{
pSaveButton->SetEnabled( p4 != NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::PerformLayout()
{
BaseClass::PerformLayout();
for ( int nType = 0; nType < IEditableDataType::NUM_TYPES; ++nType )
{
UpdateButtons( (IEditableDataType::EType)nType );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::UpdateButtons( IEditableDataType::EType eType )
{
m_pButtonsContainers[ eType ]->ResetScrollAmount();
// Get the text out of the text entry
char szFilterText[256];
m_pButtonsFilterTextEntry[ eType ]->GetText( szFilterText, sizeof( szFilterText ) );
Q_strlower( szFilterText );
int yPos = 5;
FOR_EACH_VEC( m_vecEditableButtons[ eType ], i )
{
Button* pButton = m_vecEditableButtons[ eType ][ i ];
// Get the text out of the button
char szButtonText[256];
pButton->GetText( szButtonText, sizeof( szButtonText ) );
Q_strlower( szButtonText );
// Substring search for the text entry text in the button text
if ( V_strstr( szButtonText, szFilterText ) == NULL )
{
pButton->SetVisible( false );
continue;
}
pButton->SetVisible( true );
float flWideScale = 1.f;
pButton->SetWide( pButton->GetParent()->GetWide() * flWideScale );
pButton->SetTall( 20 );
pButton->SetPos( 0, yPos );
yPos += pButton->GetTall() + 5 ;
}
m_pButtonsContainers[ eType ]->InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::OnCommand( const char *command )
{
if ( Q_strnicmp( "select", command, 6 ) == 0 )
{
// comes in the form "select(type) (name)"
const char* pszType = command + 6;
IEditableDataType::EType eType = (IEditableDataType::EType)atoi( pszType );
// Jump past the first ' ' and grab whatever is left as the name
const char* pszName = strchr( pszType, ' ' ) + 1;
if ( m_eCurrentSelectionMode == SELECTION_MODE_QUEST_OBJECTIVE && eType == IEditableDataType::TYPE_OBJECTIVE_CONDITIONS )
{
m_eCurrentSelectionMode = SELECTION_MODE_NONE;
Panel* pSelectionpanel = m_hSelectionPanel.Get();
if ( pSelectionpanel )
{
PostMessage( pSelectionpanel, new KeyValues( "ObjectiveSelected", "defindex", pszName ) );
}
}
else
{
if ( m_pCurrentOpenEdit )
{
// This the one that's already open? Don't do anything
if ( FStrEq( pszName, m_pCurrentOpenEdit->GetLiveData()->GetName() ) )
{
return;
}
// We have something open. Close it down, saving live edits
CloseEdit( m_pCurrentOpenEdit );
m_pCurrentOpenEdit = NULL;
}
m_pEditingPanel->ResetScrollAmount();
m_pCurrentOpenEdit = OpenForEdit( eType, pszName, m_pEditingPanel );
m_pEditingPanel->InvalidateLayout();
}
return;
}
else if ( Q_stricmp( "revert", command ) == 0 )
{
if ( m_pCurrentOpenEdit )
{
m_pCurrentOpenEdit->RevertChanges();
}
ResetQuestSelectionState();
}
else if ( Q_stricmp( "save", command ) == 0 )
{
WriteLocalizationData();
FOR_EACH_VEC( m_vecOpenEdits, i )
{
m_vecOpenEdits[ i ]->SaveChangesToDisk();
}
ResetQuestSelectionState();
return;
}
else if ( Q_stricmp( "newquest", command ) == 0 )
{
CloseEdit( m_pCurrentOpenEdit );
m_pEditingPanel->ResetScrollAmount();
IEditableDataType* pNewEditable = CreateNewQuest();
m_pCurrentOpenEdit = OpenForEdit( IEditableDataType::TYPE_QUEST, CFmtStr( "%s", pNewEditable->GetLiveData()->GetName() ), m_pEditingPanel );
ResetQuestSelectionState();
}
else if ( Q_stricmp( "newobjcond", command ) == 0 )
{
CloseEdit( m_pCurrentOpenEdit );
m_pEditingPanel->ResetScrollAmount();
IEditableDataType* pNewEditable = CreateNewObjectiveCondition();
m_pCurrentOpenEdit = OpenForEdit( IEditableDataType::TYPE_OBJECTIVE_CONDITIONS, CFmtStr( "%s", pNewEditable->GetLiveData()->GetName() ), m_pEditingPanel );
ResetQuestSelectionState();
}
else if ( Q_stricmp( "delete", command ) == 0 )
{
if ( m_pCurrentOpenEdit )
{
m_pCurrentOpenEdit->DeleteEntry();
CloseEdit( m_pCurrentOpenEdit );
Button* pButton = GetButtonForEditable( m_pCurrentOpenEdit );
Assert( pButton );
// Delete the button associated with this editable
if( pButton )
{
if ( !m_vecEditableButtons[ m_pCurrentOpenEdit->GetType() ].FindAndRemove( pButton ) )
{
AssertMsg( false, "Could not find button to remove when deleting editable!" );
}
pButton->MarkForDeletion();
InvalidateLayout();
}
// Remove this editable from the list
if ( !m_vecEditableData.FindAndRemove( m_pCurrentOpenEdit ) )
{
AssertMsg( false, "Could not find editable to remove when deleting editable!" );
}
delete m_pCurrentOpenEdit;
m_pCurrentOpenEdit = NULL;
}
ResetQuestSelectionState();
}
else if ( Q_stricmp( "open_edit_context", command ) == 0 )
{
OpenEditContextMenu();
ResetQuestSelectionState();
}
BaseClass::OnCommand( command );
}
void CQuestEditorPanel::OnThink()
{
FOR_EACH_VEC( m_vecOpenEdits, i )
{
engine->Con_NPrintf( i, CFmtStr( "%s %s", m_vecOpenEdits[i]->GetType() == IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ? "Condition" : "Quest", m_vecOpenEdits[i]->GetLiveData()->GetName() ) );
}
BaseClass::OnThink();
}
//-----------------------------------------------------------------------------
// Purpose: Try to find the right editable to open
//-----------------------------------------------------------------------------
IEditableDataType* CQuestEditorPanel::OpenForEdit( IEditableDataType::EType type, const char* pszName, Panel* pParent )
{
FOR_EACH_VEC( m_vecEditableData, i )
{
if ( m_vecEditableData[i]->MatchesCriteria( type, pszName ) )
{
m_vecEditableData[i]->CreatePanels( pParent );
FOR_EACH_VEC( m_vecOpenEdits, j )
{
if ( m_vecOpenEdits[j] == m_vecEditableData[i] )
{
AssertMsg1( false, "Editable with name %s was already open for edit!", m_vecEditableData[i]->GetLiveData()->GetName() );
m_vecOpenEdits.Remove( j );
}
}
m_vecOpenEdits.AddToTail( m_vecEditableData[i] );
return m_vecEditableData[i];
}
}
Assert( !"Failed to find editable for edit!" );
return NULL;
}
void CQuestEditorPanel::CloseEdit( IEditableDataType* pEditable )
{
if ( !pEditable )
return;
FOR_EACH_VEC( m_vecOpenEdits, i )
{
if ( m_vecOpenEdits[i] == pEditable )
{
m_vecOpenEdits.Remove( i );
pEditable->SaveEdits();
pEditable->DestroyPanels();
return;
}
}
AssertMsg1( false, "Editable with name %s wasn't open for edit!", pEditable->GetLiveData()->GetName() );
}
bool CQuestEditorPanel::IsOpenForEdit( const IEditableDataType* pEditable ) const
{
Assert( pEditable );
if ( !pEditable )
return false;
FOR_EACH_VEC( m_vecOpenEdits, i )
{
if ( m_vecOpenEdits[i] == pEditable )
{
return true;
}
}
return false;
}
Button* CQuestEditorPanel::GetButtonForEditable( const IEditableDataType* pEditable ) const
{
IEditableDataType::EType eType = pEditable->GetType();
auto& vecButtons = m_vecEditableButtons[ eType ];
FOR_EACH_VEC( vecButtons, i )
{
if ( vecButtons[i] == pEditable->GetButton() )
{
return vecButtons[i];
}
}
return NULL;
}
template< typename T >
IEditableDataType* CQuestEditorPanel::AddNewEditableKVData( KeyValues* pKVData, const char* pszName )
{
IEditableDataType* pNewEditable = new T( pKVData );
IEditableDataType::EType eType = pNewEditable->GetType();
m_vecEditableData.AddToTail( pNewEditable );
Button *pButton = new Button( m_pButtonsContainers[ eType ]
, "objectivebutton"
, CFmtStr( "%s: %s", pKVData->GetName(), pszName )
, this
, CFmtStr( "select%d %s", eType, pKVData->GetName() ) );
pNewEditable->SetButton( pButton );
m_vecEditableButtons[ eType ].AddToTail( pButton );
InvalidateLayout();
return pNewEditable;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::PopulateExistingQuests()
{
m_vecEditableData.PurgeAndDeleteElements();
// Quest data
{
// Quests are a little strange. In the quest file, there is no root key because quests
// are items and are spliced right into the middle of all the other items. To handle this
// We add "quests"
// {
// << all the stuff from the file >>
// }
// To make parsing easier
CUtlBuffer bufRawData;
bufRawData.SetBufferType( true, true );
bufRawData.PutString( "\"quests\"\n{\n" );
bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestDefFile, NULL, bufRawData );
if ( !bReadFileOK )
{
AssertMsg1( false, "Couldn't load quest file %s for saving!", g_skQuestDefFile );
return;
}
bufRawData.PutString( "\n}" );
// Load quest data from file
KeyValuesAD pKVQuestDefinitions( "quests" );
pKVQuestDefinitions->LoadFromBuffer( NULL, bufRawData );
// Create editable objects and buttons for each
FOR_EACH_TRUE_SUBKEY( pKVQuestDefinitions, pKVQuest )
{
char szItemName[256];
g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pKVQuest->GetString( "item_name" ) ), szItemName, sizeof( szItemName ) );
AddNewEditableKVData< CEditableQuestDataType >( pKVQuest, szItemName );
}
}
// Objective data
{
CUtlBuffer bufRawData;
bufRawData.SetBufferType( true, true );
// Now go read the objective conditions file
bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestObjectivesConditionsDefFile, NULL, bufRawData );
if ( !bReadFileOK )
{
AssertMsg1( false, "Couldn't load quest file %s for saving!", g_skQuestObjectivesConditionsDefFile );
return;
}
// Load objective data from file
KeyValuesAD pKVObjectiveConditions( "objectives" );
pKVObjectiveConditions->LoadFromBuffer( NULL, bufRawData );
// Create editable objects and buttons for each
FOR_EACH_TRUE_SUBKEY( pKVObjectiveConditions, pKVCondition )
{
AddNewEditableKVData< CEditableObjectiveConditionDataType >( pKVCondition, pKVCondition->GetString( "name" ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Create a new quest with the next available itemdefindex
//-----------------------------------------------------------------------------
IEditableDataType* CQuestEditorPanel::CreateNewQuest()
{
// Find the next item def to use
int nNextQuestDefIndex = 0;
FOR_EACH_VEC( m_vecEditableData, i )
{
IEditableDataType* pData = m_vecEditableData[ i ];
if ( pData->GetType() == IEditableDataType::TYPE_QUEST )
{
nNextQuestDefIndex = Max( nNextQuestDefIndex, atoi( pData->GetLiveData()->GetName() ) );
}
}
++nNextQuestDefIndex;
// Create keyvalues to describe a default quest
KeyValuesAD pKVNewQuest( CFmtStr( "%d", nNextQuestDefIndex ) );
pKVNewQuest->SetString( "name", CFmtStr( g_skItemNameFormat, nNextQuestDefIndex ) );
pKVNewQuest->SetString( "item_name", CFmtStr( g_skNameTokenFormat, nNextQuestDefIndex ) );
pKVNewQuest->SetString( "prefab", g_skQuestPrefabs[0] );
// Tool keys
KeyValues *pKeyQuestBlock = pKVNewQuest->CreateNewKey(); pKeyQuestBlock->SetName( "quest" );
pKeyQuestBlock->SetInt( "max_standard_points", 100 );
pKeyQuestBlock->SetInt( "max_bonus_points", 30 );
pKeyQuestBlock->SetInt( "objectives_to_roll", 1 );
pKeyQuestBlock->SetString( "reward", "contract_lootlist_1" );
pKeyQuestBlock->SetString( "theme", GetItemSchema()->GetQuestThemes()[0]->GetName() );
KeyValues *pKeyObjectiveBlock = pKeyQuestBlock->CreateNewKey(); pKeyObjectiveBlock->SetName( "objectives" );
return AddNewEditableKVData< CEditableQuestDataType >( pKVNewQuest, pKVNewQuest->GetString( "name" ) );
}
//-----------------------------------------------------------------------------
// Purpose: Create a new conditions with the next available defindex
//-----------------------------------------------------------------------------
IEditableDataType* CQuestEditorPanel::CreateNewObjectiveCondition()
{
int nNextDefIndex = 0;
FOR_EACH_VEC( m_vecEditableData, i )
{
IEditableDataType* pData = m_vecEditableData[ i ];
if ( pData->GetType() == IEditableDataType::TYPE_OBJECTIVE_CONDITIONS )
{
nNextDefIndex = Max( nNextDefIndex, atoi( pData->GetLiveData()->GetName() ) );
}
}
++nNextDefIndex;
KeyValuesAD pKVNewObjCond( CFmtStr( "%d", nNextDefIndex ) );
pKVNewObjCond->SetString( "name", "*** New Objective ***" );
KeyValues* pKVConditionsBlock = pKVNewObjCond->CreateNewKey();
pKVConditionsBlock->SetName( "condition_logic" );
pKVConditionsBlock->SetString( "event_name", "player_score_changed" );
pKVConditionsBlock->SetString( "score_key_name", "delta" );
pKVConditionsBlock->SetString( "type", "event_listener" );
return AddNewEditableKVData< CEditableObjectiveConditionDataType >( pKVNewObjCond, pKVNewObjCond->GetString( "name" ) );
}
//-----------------------------------------------------------------------------
// Purpose: Open up a context menu with actions for the editing item
//-----------------------------------------------------------------------------
void CQuestEditorPanel::OpenEditContextMenu()
{
Menu *pContextMenu = new Menu( this, "ContextMenu" );
pContextMenu->AddMenuItem( "Save", this, new KeyValues( "save" ) );
pContextMenu->AddMenuItem( "Revert", this, new KeyValues( "revert" ) );
pContextMenu->AddSeparator();
pContextMenu->AddMenuItem( "Delete", this, new KeyValues( "delete" ) );
// Position to the cursor's position
int nX, nY;
g_pVGuiInput->GetCursorPosition( nX, nY );
pContextMenu->SetPos( nX - 1, nY - 1 );
pContextMenu->SetVisible(true);
pContextMenu->AddActionSignalTarget(this);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::OnTextChanged( KeyValues *data )
{
Panel *pPanel = reinterpret_cast< vgui::Panel* >( data->GetPtr( "panel" ) );
for ( int nType = 0; nType < IEditableDataType::NUM_TYPES; ++nType )
{
if ( pPanel == m_pButtonsFilterTextEntry[ nType ] )
{
UpdateButtons( (IEditableDataType::EType)nType );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::OnSelectQuestObjective( KeyValues *data )
{
m_hSelectionPanel = reinterpret_cast< vgui::Panel* >( data->GetPtr( "panel" ) );
m_eCurrentSelectionMode = SELECTION_MODE_QUEST_OBJECTIVE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::CheckForChanges()
{
FOR_EACH_VEC( m_vecEditableData, i )
{
m_vecEditableData[i]->CheckForChanges();
}
}
#endif // STAGING_ONLY