funnygame/engine/console.cpp

#include "console.h"
#include "fgui/rect.h"
#include "fgui/widget.h"
#include "fgui/label.h"
#include "filesystem.h"
#include "interface.h"
#include "rendering.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
#include "stdarg.h"


enum EConsoleMessageType
{
	CONSOLE_MESSAGE_TYPE_MESSAGE,
	CONSOLE_MESSAGE_TYPE_WARNING,
	CONSOLE_MESSAGE_TYPE_ERROR,
};

struct ConsoleMessage_t
{
	EConsoleMessageType type;
	CUtlString szMessage;
};

void Msg( const char* message )
{
	printf(message);

}

void Warning( const char* message )
{

}

void Error( const char* message )
{

}

interface CConsole: public IConsole 
{
public:
	virtual void Init() override;
	virtual void Frame() override;
	virtual void Deinit() override;

	// Variables
	virtual void RegisterVar( ConVar *cvar ) override;
	virtual void UnRegisterVar( ConVar *cvar ) override;
	virtual ConVar *FindVar( const char *pName ) override;

	// Commands
	virtual void RegisterCommand( ConCommand *cvar ) override;
	virtual void UnRegisterCommand( ConCommand *cvar ) override;
	virtual ConCommand *FindCommand( const char *pName ) override;

	// Command buffer 
	virtual void Execute( void ) override;
	virtual void ExecuteArguments( CUtlVector<CUtlString> &args ) override;
	virtual CUtlVector<CUtlVector<CUtlString>> ParseCommandLine( CUtlString psz ) override;

	virtual void AddCommand( const char *psz ) override;
	virtual void InsertCommand( const char *psz ) override;
};

DECLARE_ENGINE_INTERFACE(Console, CConsole)

void CConsole::Init()
{
}

void CConsole::Frame()
{

}

void CConsole::Deinit()
{

}


void CConsole::RegisterVar( ConVar *cvar )
{
	m_convars.AppendTail(cvar);
}
void CConsole::UnRegisterVar( ConVar *cvar )
{

}
ConVar *CConsole::FindVar( const char *pName )
{
	for (auto &var: m_convars)
	{
		if (!V_strcmp(var->GetName(), pName))
			return var;
	}
	return NULL;
}

void CConsole::RegisterCommand( ConCommand *cvar )
{
	m_commands.AppendTail(cvar);
}
void CConsole::UnRegisterCommand( ConCommand *cvar )
{

}
ConCommand *CConsole::FindCommand( const char *pName )
{
	for (auto &var: m_commands)
	{
		if (!V_strcmp(var->GetName(), pName))
			return var;
	}
	return NULL;
}
CUtlString g_commandBuffer;

//-----------------------------------------------------------------------------
// Executes arguments from CConsole::Execute 
//-----------------------------------------------------------------------------
void CConsole::ExecuteArguments( CUtlVector<CUtlString> &args )
{
	if (args.GetSize()<1)
		return;

	ConCommand *cmd = CConsole::FindCommand(args[0]);
	if (!cmd)
	{
		V_printf("%s not found\n", args[0].GetString());
		return;
	}
	CUtlBuffer<char*> strbuffer(args.GetSize());
	for ( size_t i = 0; i < args.GetSize(); i++)
	{
		strbuffer[i] = args[i].GetString();
	};
	(cmd->GetCallback())(args.GetSize(), strbuffer);
}

void CConsole::Execute( void )
{
	CUtlVector<CUtlVector<CUtlString>> commands = ParseCommandLine(g_commandBuffer);
	g_commandBuffer = 0;
	for (auto &command: commands)
	{
		ExecuteArguments(command);
	}
}

//-----------------------------------------------------------------------------
// Parses command buffer. 
//-----------------------------------------------------------------------------
CUtlVector<CUtlVector<CUtlString>> CConsole::ParseCommandLine( CUtlString psz )
{	
	CUtlVector<CUtlString> arguments;
	CUtlVector<CUtlVector<CUtlString>> commands;
	CUtlString szArgument;
	bool bIsQuote = false;
	for ( auto &c: (CUtlVector<char>&)psz )
	{
		if ( c == '\"' )
		{
			bIsQuote = !bIsQuote;
			continue;
		}

		if ( c == ';' || c == '\n' )
		{
			if (bIsQuote)
			{
				continue;
			}
			if (szArgument != 0)
				arguments.AppendTail(szArgument);
			if ( arguments.GetSize() > 0 )
				commands.AppendTail(arguments);
			szArgument = 0;
			arguments = {};
			continue;
		}
		if ( c == '\t' || c == ' ' )
		{
			if (bIsQuote)
			{
				szArgument.AppendTail(c);
				continue;
			}

			if (szArgument != 0)
				arguments.AppendTail(szArgument);
			szArgument = 0;
			continue;
		}
		szArgument.AppendTail(c);
	};
	if (szArgument != 0)
		arguments.AppendTail(szArgument);
	if ( arguments.GetSize() > 0 )
		commands.AppendTail(arguments);
	return commands;
}

void CConsole::AddCommand( const char *psz )
{
	g_commandBuffer.AppendTail(psz);
}

void CConsole::InsertCommand( const char *psz )
{
	g_commandBuffer.AppendHead(psz);
};

ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags ) 
	: ConVar(pName, pDefaultValue, flags, 0)
{
		
}
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags,
	const char *pHelpString ) 
	: ConVar(pName, pDefaultValue, flags, pHelpString, 0)
{
}
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags,
	const char *pHelpString, ConCommandFn callback )
{
	m_szName = pName;
	m_flags = flags;
	m_szValue = pDefaultValue;
	m_fValue = V_atof(pDefaultValue);
	m_nValue = V_atoi(pDefaultValue);
	Console()->RegisterVar(this);
}

bool ConVar::IsFlagSet( int flag )
{

}
const char *ConVar::GetHelpText( void )
{
	return m_szHelpString;
}
bool ConVar::IsRegistered( void )
{

}
const char *ConVar::GetName( void )
{
	return m_szName;
}
void ConVar::AddFlags( int flags )
{

}
bool ConVar::IsCommand( void )
{

}

void ConVar::InstallChangeCallback( ConCommandFn )
{

}

float ConVar::GetFloat( void )
{
	return m_fValue; 
}
int ConVar::GetInt( void )
{
	return m_nValue; 
}
bool ConVar::GetBool( void )
{
	return m_nValue;
}
const char *ConVar::GetString( void ) 
{

}

void ConVar::SetValue( const char *szValue )
{
	if (!szValue)
		return;
	m_szValue = szValue;
	m_fValue = V_atof(szValue);
	m_nValue = V_atoi(szValue);
}
void ConVar::SetValue( float fValue )
{
	m_fValue = fValue;
	m_nValue = fValue;
	m_szValue = CUtlString("%f\n",fValue);
}
void ConVar::SetValue( int iValue )
{
	m_fValue = iValue;
	m_nValue = iValue;
	m_szValue = CUtlString("%i\n",iValue);
}

ConCommand::ConCommand(const char *pName, ConCommandFn callback, 
	const char *pHelpString, int flags)
{
	m_szName = pName;
	m_callback = callback;
	m_flags = flags;
	Console()->RegisterCommand(this);
};
const char *ConCommand::GetHelpText( void )
{
	return m_szHelpString;
}
const char *ConCommand::GetName( void )
{
	return m_szName;
}
ConCommandFn ConCommand::GetCallback( void )
{
	return m_callback;
}



void IConsole_Exec( int argc, char **argv)
{
	if (argc != 2)
		return;

	FileHandle_t f = FileSystem()->Open(argv[1], IFILE_READ);
	if (!f)
		return;
	CUtlBuffer<char> b(FileSystem()->Size(f)+1);
	FileSystem()->Read(f, b, b.GetSize());
	b[FileSystem()->Size(f)] = 0;
	Console()->AddCommand(b);
	Console()->AddCommand(";");
	Console()->Execute();
}

ConCommand IConsole_ExecCmd("exec", IConsole_Exec);

class CConsoleGUI: public CFGUI_Widget 
{
public:
	CConsoleGUI();
	virtual void Event( FGUI_Event_t event ) override;
	virtual void Draw() override;
	virtual void Frame() override;
private:
	CFGUI_Rect *m_pBackground = 0;
	CFGUI_Label *m_pLog = 0;
};

bool console_bDrawUI = false;

CConsoleGUI::CConsoleGUI()
{
	m_pBackground = new CFGUI_Rect();
	m_pBackground->SetBoxColor(0.13, 0.13, 0.13, 1);
	m_pBackground->SetSize(200, 200);
	m_pBackground->SetPosition(0, 0);
	m_pBackground->SetParent(this);

	m_pLog = new CFGUI_Label();
	m_pLog->SetFont("fonts/IBMPlexMono-Regular");
	m_pLog->SetLabel("CONSOLE");
	m_pLog->SetPosition(0, 0);
	m_pLog->SetGlyphSize(24);
	m_pLog->SetParent(this);
};

void CConsoleGUI::Event( FGUI_Event_t event )
{

}

void CConsoleGUI::Draw()
{
	SetPosition(20, 20);
	m_pBackground->SetSize(g_nWindowWidth-40, g_nWindowHeight-40);	
	m_pBackground->SetSize(g_nWindowWidth-40, g_nWindowHeight-40);	
}

void CConsoleGUI::Frame()
{
	SetVisibility(console_bDrawUI);
}

void IConsoleUI::Init()
{
	new CConsoleGUI;
};

void IConsoleUI::SetVisibility( bool bIsVisisble )
{
	console_bDrawUI = bIsVisisble;
}

bool IConsoleUI::IsVisibile()
{
	return console_bDrawUI;
}