From f5ab6fb5e8be7b73e6003d4145081d5e0c0ce287 Mon Sep 17 00:00:00 2001 From: Jack <66967891+ASpoonPlaysGames@users.noreply.github.com> Date: Wed, 27 Dec 2023 00:32:01 +0000 Subject: Folder restructuring from primedev (#624) Copies of over the primedev folder structure for easier cherry-picking of further changes Co-authored-by: F1F7Y --- primedev/util/printcommands.cpp | 285 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 285 insertions(+) create mode 100644 primedev/util/printcommands.cpp (limited to 'primedev/util/printcommands.cpp') diff --git a/primedev/util/printcommands.cpp b/primedev/util/printcommands.cpp new file mode 100644 index 00000000..34d56666 --- /dev/null +++ b/primedev/util/printcommands.cpp @@ -0,0 +1,285 @@ +#include "printcommands.h" +#include "core/convar/cvar.h" +#include "core/convar/convar.h" +#include "core/convar/concommand.h" + +void PrintCommandHelpDialogue(const ConCommandBase* command, const char* name) +{ + if (!command) + { + spdlog::info("unknown command {}", name); + return; + } + + // temp because command->IsCommand does not currently work + ConVar* cvar = g_pCVar->FindVar(command->m_pszName); + + // build string for flags if not FCVAR_NONE + std::string flagString; + if (command->GetFlags() != FCVAR_NONE) + { + flagString = "( "; + + for (auto& flagPair : g_PrintCommandFlags) + { + if (command->GetFlags() & flagPair.first) + { + // special case, slightly hacky: PRINTABLEONLY is for commands, GAMEDLL_FOR_REMOTE_CLIENTS is for concommands, both have the + // same value + if (flagPair.first == FCVAR_PRINTABLEONLY) + { + if (cvar && !strcmp(flagPair.second, "GAMEDLL_FOR_REMOTE_CLIENTS")) + continue; + + if (!cvar && !strcmp(flagPair.second, "PRINTABLEONLY")) + continue; + } + + flagString += flagPair.second; + flagString += " "; + } + } + + flagString += ") "; + } + + if (cvar) + spdlog::info("\"{}\" = \"{}\" {}- {}", cvar->GetBaseName(), cvar->GetString(), flagString, cvar->GetHelpText()); + else + spdlog::info("\"{}\" {} - {}", command->m_pszName, flagString, command->GetHelpText()); +} + +void TryPrintCvarHelpForCommand(const char* pCommand) +{ + // try to display help text for an inputted command string from the console + int pCommandLen = strlen(pCommand); + char* pCvarStr = new char[pCommandLen]; + strcpy(pCvarStr, pCommand); + + // trim whitespace from right + for (int i = pCommandLen - 1; i; i--) + { + if (isspace(pCvarStr[i])) + pCvarStr[i] = '\0'; + else + break; + } + + // check if we're inputting a cvar, but not setting it at all + ConVar* cvar = g_pCVar->FindVar(pCvarStr); + if (cvar) + PrintCommandHelpDialogue(&cvar->m_ConCommandBase, pCvarStr); + + delete[] pCvarStr; +} + +void ConCommand_help(const CCommand& arg) +{ + if (arg.ArgC() < 2) + { + spdlog::info("Usage: help "); + return; + } + + PrintCommandHelpDialogue(g_pCVar->FindCommandBase(arg.Arg(1)), arg.Arg(1)); +} + +void ConCommand_find(const CCommand& arg) +{ + if (arg.ArgC() < 2) + { + spdlog::info("Usage: find [...]"); + return; + } + + char pTempName[256]; + char pTempSearchTerm[256]; + + ConCommandBase* var; + CCVarIteratorInternal* itint = g_pCVar->FactoryInternalIterator(); + std::map sorted; + for (itint->SetFirst(); itint->IsValid(); itint->Next()) + { + var = itint->Get(); + if (!var->IsFlagSet(FCVAR_DEVELOPMENTONLY) && !var->IsFlagSet(FCVAR_HIDDEN)) + { + sorted.insert({var->m_pszName, var}); + } + } + delete itint; + + for (auto& map : sorted) + { + bool bPrintCommand = true; + for (int i = 0; i < arg.ArgC() - 1; i++) + { + // make lowercase to avoid case sensitivity + strncpy_s(pTempName, sizeof(pTempName), map.second->m_pszName, sizeof(pTempName) - 1); + strncpy_s(pTempSearchTerm, sizeof(pTempSearchTerm), arg.Arg(i + 1), sizeof(pTempSearchTerm) - 1); + + for (int i = 0; pTempName[i]; i++) + pTempName[i] = tolower(pTempName[i]); + + for (int i = 0; pTempSearchTerm[i]; i++) + pTempSearchTerm[i] = tolower(pTempSearchTerm[i]); + + if (!strstr(pTempName, pTempSearchTerm)) + { + bPrintCommand = false; + break; + } + } + + if (bPrintCommand) + PrintCommandHelpDialogue(map.second, map.second->m_pszName); + } +} + +void ConCommand_findflags(const CCommand& arg) +{ + if (arg.ArgC() < 2) + { + spdlog::info("Usage: findflags "); + for (auto& flagPair : g_PrintCommandFlags) + spdlog::info(" - {}", flagPair.second); + + return; + } + + // convert input flag to uppercase + char* upperFlag = new char[strlen(arg.Arg(1))]; + strcpy(upperFlag, arg.Arg(1)); + + for (int i = 0; upperFlag[i]; i++) + upperFlag[i] = toupper(upperFlag[i]); + + // resolve flag name => int flags + int resolvedFlag = FCVAR_NONE; + for (auto& flagPair : g_PrintCommandFlags) + { + if (!strcmp(flagPair.second, upperFlag)) + { + resolvedFlag |= flagPair.first; + break; + } + } + + ConCommandBase* var; + CCVarIteratorInternal* itint = g_pCVar->FactoryInternalIterator(); + std::map sorted; + for (itint->SetFirst(); itint->IsValid(); itint->Next()) + { + var = itint->Get(); + if (!var->IsFlagSet(FCVAR_DEVELOPMENTONLY) && !var->IsFlagSet(FCVAR_HIDDEN)) + { + sorted.insert({var->m_pszName, var}); + } + } + delete itint; + + for (auto& map : sorted) + { + if (map.second->m_nFlags & resolvedFlag) + PrintCommandHelpDialogue(map.second, map.second->m_pszName); + } + + delete[] upperFlag; +} + +void ConCommand_list(const CCommand& arg) +{ + ConCommandBase* var; + CCVarIteratorInternal* itint = g_pCVar->FactoryInternalIterator(); + std::map sorted; + for (itint->SetFirst(); itint->IsValid(); itint->Next()) + { + var = itint->Get(); + if (!var->IsFlagSet(FCVAR_DEVELOPMENTONLY) && !var->IsFlagSet(FCVAR_HIDDEN)) + { + sorted.insert({var->m_pszName, var}); + } + } + delete itint; + + for (auto& map : sorted) + { + PrintCommandHelpDialogue(map.second, map.second->m_pszName); + } + spdlog::info("{} total convars/concommands", sorted.size()); +} + +void ConCommand_differences(const CCommand& arg) +{ + CCVarIteratorInternal* itint = g_pCVar->FactoryInternalIterator(); + std::map sorted; + + for (itint->SetFirst(); itint->IsValid(); itint->Next()) + { + ConCommandBase* var = itint->Get(); + if (!var->IsFlagSet(FCVAR_DEVELOPMENTONLY) && !var->IsFlagSet(FCVAR_HIDDEN)) + { + sorted.insert({var->m_pszName, var}); + } + } + delete itint; + + for (auto& map : sorted) + { + ConVar* cvar = g_pCVar->FindVar(map.second->m_pszName); + + if (!cvar) + { + continue; + } + + if (strcmp(cvar->GetString(), "FCVAR_NEVER_AS_STRING") == NULL) + { + continue; + } + + if (strcmp(cvar->GetString(), cvar->m_pszDefaultValue) == NULL) + { + continue; + } + + std::string formatted = + fmt::format("\"{}\" = \"{}\" ( def. \"{}\" )", cvar->GetBaseName(), cvar->GetString(), cvar->m_pszDefaultValue); + + if (cvar->m_bHasMin) + { + formatted.append(fmt::format(" min. {}", cvar->m_fMinVal)); + } + + if (cvar->m_bHasMax) + { + formatted.append(fmt::format(" max. {}", cvar->m_fMaxVal)); + } + + formatted.append(fmt::format(" - {}", cvar->GetHelpText())); + spdlog::info(formatted); + } +} + +void InitialiseCommandPrint() +{ + RegisterConCommand( + "convar_find", ConCommand_find, "Find convars/concommands with the specified string in their name/help text.", FCVAR_NONE); + + // these commands already exist, so we need to modify the preexisting command to use our func instead + // and clear the flags also + ConCommand* helpCommand = g_pCVar->FindCommand("help"); + helpCommand->m_nFlags = FCVAR_NONE; + helpCommand->m_pCommandCallback = ConCommand_help; + + ConCommand* findCommand = g_pCVar->FindCommand("convar_findByFlags"); + findCommand->m_nFlags = FCVAR_NONE; + findCommand->m_pCommandCallback = ConCommand_findflags; + + ConCommand* listCommand = g_pCVar->FindCommand("convar_list"); + listCommand->m_nFlags = FCVAR_NONE; + listCommand->m_pCommandCallback = ConCommand_list; + + ConCommand* diffCommand = g_pCVar->FindCommand("convar_differences"); + diffCommand->m_nFlags = FCVAR_NONE; + diffCommand->m_pCommandCallback = ConCommand_differences; +} -- cgit v1.2.3