Added the 'Meta Cheat Manager' plugin to allow customize command names by 'CheatName =' meta for the functions in the Meta Cheat Manager subclass

Author: JanSeliv

Diff for: .gitignore

@@ -421,4 +421,7 @@ Saved/*
 **/Intermediate/*
 
 # Cache files for the editor to use
-DerivedDataCache/*
+DerivedDataCache
+
+# Bomber specific
+Config/DefaultMetaCheatManager.ini

Diff for: Plugins/MetaCheatManager/Binaries/Win64/UnrealEditor-MetaCheatManager.dll

@@ -0,0 +1,7 @@
+{
+	"BuildId": "23058290",
+	"Modules": 
+	{
+		"MetaCheatManager": "UnrealEditor-MetaCheatManager.dll"
+	}
+}

Diff for: Plugins/MetaCheatManager/Binaries/Win64/UnrealEditor-MetaCheatManager.pdb

@@ -0,0 +1,25 @@
+{
+	"FileVersion": 3,
+	"Version": 1,
+	"VersionName": "1.0",
+	"FriendlyName": "Meta Cheat Manager",
+	"Description": "Plugin allows customize command names by 'CheatName =' meta for the functions in the Meta Cheat Manager subclass",
+	"Category": "My Plugins",
+	"CreatedBy": "Yevhenii Selivanov",
+	"CreatedByURL": "https://github.com/JanSeliv/Bomber",
+	"DocsURL": "",
+	"MarketplaceURL": "",
+	"SupportURL": "mailto:[email protected]",
+	"EngineVersion": "5.1.0",
+	"EnabledByDefault": true,
+	"CanContainContent": false,
+	"IsBetaVersion": true,
+	"Installed": false,
+	"Modules": [
+		{
+			"Name": "MetaCheatManager",
+			"Type": "Runtime",
+			"LoadingPhase": "Default"
+		}
+	]
+}

Diff for: Plugins/MetaCheatManager/Binaries/Win64/UnrealEditor.modules

@@ -0,0 +1,25 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class MetaCheatManager : ModuleRules
+{
+	public MetaCheatManager(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+		CppStandard = CppStandardVersion.Latest;
+
+		PublicDependencyModuleNames.AddRange(new[]
+			{
+				"Core"
+			}
+		);
+
+		PrivateDependencyModuleNames.AddRange(new[]
+			{
+				"CoreUObject", "Engine", "Slate", "SlateCore" // Core
+				, "EngineSettings" // UConsoleSettings
+			}
+		);
+	}
+}

Diff for: Plugins/MetaCheatManager/MetaCheatManager.uplugin

@@ -0,0 +1,82 @@
+// Copyright (c) Yevhenii Selivanov
+
+#include "MetaCheatCommand.h"
+//---
+#include "ConsoleSettings.h"
+
+// Contains empty cheat command
+const FMetaCheatCommand FMetaCheatCommand::EmptyCommand = FMetaCheatCommand();
+
+// Returns the Auto Complete Command from this structure object
+FAutoCompleteCommand FMetaCheatCommand::ToAutoCompleteCommand() const
+{
+	FAutoCompleteCommand AutoCompleteCommand;
+	AutoCompleteCommand.Command = CheatName.ToString();
+	AutoCompleteCommand.Desc = CheatDescription.ToString();
+	static FColor AutoCompleteCommandColor = GetDefault<UConsoleSettings>()->AutoCompleteCommandColor;
+	AutoCompleteCommand.Color = AutoCompleteCommandColor;
+	return AutoCompleteCommand;
+}
+
+#if WITH_EDITOR
+// Builds all the data for this command by function ptr
+FMetaCheatCommand FMetaCheatCommand::Create(const UFunction* InFunction)
+{
+	if (!InFunction)
+	{
+		return EmptyCommand;
+	}
+
+	FMetaCheatCommand CheatCommand;
+	CheatCommand.CheatName = FindCheatMetaData(InFunction);
+	if (CheatCommand.CheatName.IsNone())
+	{
+		// No cheat name, so this is not a cheat command
+		return EmptyCommand;
+	}
+
+	CheatCommand.FunctionName = InFunction->GetFName();
+	CheatCommand.CheatDescription = FindCheatDescription(InFunction);
+	return CheatCommand;
+}
+
+// Finds a value of the 'CheatName' meta data for the specified function, none if CheatName is not set
+FName FMetaCheatCommand::FindCheatMetaData(const UFunction* InFunction)
+{
+	static const FName CheatNameMetaKey = TEXT("CheatName");
+	checkf(InFunction, TEXT("%s: 'InFunction' is null"), *FString(__FUNCTION__));
+	const FString* FoundMetaData = InFunction->FindMetaData(CheatNameMetaKey);
+	return FoundMetaData ? FName(*FoundMetaData) : NAME_None;
+}
+
+// Finds the description for the specified function
+FName FMetaCheatCommand::FindCheatDescription(const UFunction* InFunction)
+{
+	checkf(InFunction, TEXT("%s: 'InFunction' is null"), *FString(__FUNCTION__));
+
+	FString Description = TEXT("");
+
+	// Start with description of function param: Name[Type]. E.x: NewLevel[int32]
+	for (TFieldIterator<FProperty> PropIt(InFunction); PropIt && PropIt->PropertyFlags & CPF_Parm; ++PropIt)
+	{
+		if (const FProperty* Prop = *PropIt)
+		{
+			Description += FString::Printf(TEXT("%s[%s] "), *Prop->GetName(), *Prop->GetCPPType());
+		}
+	}
+
+	// Get the first line of the function tooltip
+	static const FString Delimiter = TEXT("\n");
+	FString FunctionToolTip = InFunction->GetToolTipText().ToString();
+	TArray<FString> SeparatedStrings;
+	FunctionToolTip.ParseIntoArray(SeparatedStrings, *Delimiter);
+	if (!FunctionToolTip.IsEmpty())
+	{
+		FunctionToolTip = SeparatedStrings[0];
+	}
+
+	// Add function tooltip to the total description
+	Description.Append(FunctionToolTip);
+	return FName(*Description);
+}
+#endif // WITH_EDITOR

Diff for: Plugins/MetaCheatManager/Resources/Icon128.png

@@ -0,0 +1,113 @@
+// Copyright (c) Yevhenii Selivanov
+
+#include "MetaCheatManager.h"
+//---
+#include "Engine/Console.h"
+
+// Returns the cheat command associated with specified CheatName meta value
+const FMetaCheatCommand& UMetaCheatManager::GetCheatCommandByCheatName(const FName& CheatName) const
+{
+	for (const FMetaCheatCommand& CheatCommandIt : AllCheatCommands)
+	{
+		if (CheatCommandIt.CheatName.IsEqual(CheatName))
+		{
+			return CheatCommandIt;
+		}
+	}
+
+	return FMetaCheatCommand::EmptyCommand;
+}
+
+// Is overridden to initialize all cheat commands on editor startup
+void UMetaCheatManager::PostInitProperties()
+{
+	Super::PostInitProperties();
+
+	InitAllCheatCommands();
+}
+
+// Called when CheatManager is created to allow any needed initialization
+void UMetaCheatManager::InitCheatManager()
+{
+	Super::InitCheatManager();
+
+	if (!UConsole::RegisterConsoleAutoCompleteEntries.IsBoundToObject(this))
+	{
+		UConsole::RegisterConsoleAutoCompleteEntries.AddUObject(this, &ThisClass::RegisterAutoCompleteEntries);
+	}
+}
+
+// Is overridden to convert meta CheatName Your.Cheat.Name to the function name YourCheatFunction whenever user enters the command
+bool UMetaCheatManager::ProcessConsoleExec(const TCHAR* Cmd, FOutputDevice& Ar, UObject* Executor)
+{
+	constexpr bool bUseEscape = true;
+	const FString OriginalCmd = Cmd;
+	FString CommandName = TEXT("");
+	if (FParse::Token(/*InOut*/Cmd, /*Out*/CommandName, bUseEscape))
+	{
+		// CommandName: is the CheatName (Your.Cheat.Name)
+		// Cmd: is the value (if any) that was passed to the cheat
+		const FMetaCheatCommand& CheatCommand = GetCheatCommandByCheatName(*CommandName);
+		if (CheatCommand.IsValid())
+		{
+			// Get the function name (YourCheatFunction) from the CheatName (Your.Cheat.Name)
+			// and append it with the value that was passed to the cheat to process the call
+			// YourFunctionCheat Value
+			constexpr bool bForceCallWithNonExec = true;
+			const FString CmdString = CheatCommand.FunctionName.ToString() + Cmd;
+			return CallFunctionByNameWithArguments(*CmdString, Ar, Executor, bForceCallWithNonExec);
+		}
+	}
+
+	return Super::ProcessConsoleExec(*OriginalCmd, Ar, Executor);
+}
+
+// Garbage things before destroying the Cheat Manager
+void UMetaCheatManager::BeginDestroy()
+{
+	UConsole::RegisterConsoleAutoCompleteEntries.RemoveAll(this);
+
+	Super::BeginDestroy();
+}
+
+// Is bound to return all initialized meta cheat commands to see them in the console
+void UMetaCheatManager::RegisterAutoCompleteEntries(TArray<FAutoCompleteCommand>& Commands) const
+{
+	for (const FMetaCheatCommand& CheatCommandIt : AllCheatCommands)
+	{
+		Commands.Emplace(CheatCommandIt.ToAutoCompleteCommand());
+	}
+}
+
+// Finds and saves all cheat commands marked with 'CheatName' metadata
+void UMetaCheatManager::InitAllCheatCommands()
+{
+#if WITH_EDITOR
+	// It automatically adds DefaultMetaCheatManager.ini config on the editor startup to the Config folder on your project
+	// to have your cheat commands with custom Cheat Names in the packaged build as well, you don't need to do anything specific about it.
+	// Such solution is used because any metadata can be obtained only in the Editor, so we store it in the config file for the build.
+
+	if (!HasAllFlags(RF_ClassDefaultObject))
+	{
+		// Do not init cheat commands for instances since we save them as default values into config file
+		return;
+	}
+
+	if (!AllCheatCommands.IsEmpty())
+	{
+		AllCheatCommands.Empty();
+	}
+
+	// Find all cheat commands
+	for (TFieldIterator<UFunction> FunctionIt(GetClass(), EFieldIteratorFlags::ExcludeSuper); FunctionIt; ++FunctionIt)
+	{
+		FMetaCheatCommand CheatCommand = FMetaCheatCommand::Create(*FunctionIt);
+		if (CheatCommand.IsValid())
+		{
+			AllCheatCommands.Emplace(MoveTemp(CheatCommand));
+		}
+	}
+
+	TryUpdateDefaultConfigFile();
+#endif // WITH_EDITOR
+}

Diff for: Plugins/MetaCheatManager/Source/MetaCheatManager/MetaCheatManager.Build.cs

@@ -0,0 +1,22 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "MetaCheatManagerModule.h"
+
+#define LOCTEXT_NAMESPACE "FMetaCheatManagerModule"
+
+// Called right after the module DLL has been loaded and the module object has been created
+void FMetaCheatManagerModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+}
+
+// Called before the module is unloaded, right before the module object is destroyed
+void FMetaCheatManagerModule::ShutdownModule()
+{
+	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
+	// we call this function before unloading the module.
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FMetaCheatManagerModule, MetaCheatManager)

Diff for: Plugins/MetaCheatManager/Source/MetaCheatManager/Private/MetaCheatCommand.cpp

@@ -0,0 +1,57 @@
+// Copyright (c) Yevhenii Selivanov
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MetaCheatCommand.generated.h"
+
+struct FAutoCompleteCommand;
+
+/**
+ * Describes a cheat command.
+ */
+USTRUCT(BlueprintType)
+struct METACHEATMANAGER_API FMetaCheatCommand
+{
+	GENERATED_BODY()
+
+	/** Contains empty cheat command. */
+	static const FMetaCheatCommand EmptyCommand;
+
+	/** The name of command that will be displayed in console. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "C++")
+	FName CheatName = NAME_None;
+
+	/** The original name of function. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "C++")
+	FName FunctionName = NAME_None;
+
+	/** The description of the command. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "C++")
+	FName CheatDescription = NAME_None;
+
+	/** Returns true if this command contains correct data */
+	FORCEINLINE bool IsValid() const
+	{
+		return CheatName != NAME_None
+			&& CheatDescription != NAME_None
+			&& FunctionName != NAME_None;
+	}
+
+	/** Returns the Auto Complete Command from this structure object. */
+	FAutoCompleteCommand ToAutoCompleteCommand() const;
+
+#if WITH_EDITOR
+	/** Builds all the data for this command by function ptr.
+	 * Is editor-only since the meta data is not available in the build.*/
+	static FMetaCheatCommand Create(const UFunction* InFunction);
+
+	/** Finds a value of the 'CheatName' meta data for the specified function, none if CheatName is not set.
+	 * Is editor-only since the meta data is not available in the build.*/
+	static FName FindCheatMetaData(const UFunction* InFunction);
+
+	/** Finds the description for the specified function.
+	 * Is editor-only since the meta data is not available in the build.*/
+	static FName FindCheatDescription(const UFunction* InFunction);
+#endif // WITH_EDITOR
+};