doc

Tools

Tools Function Library

This is a Blueprint Function Library containing a versatile collection of extra utility functions designed to streamline and simplify common tasks in Unreal Engine game development.

This library is a useful resource for any Unreal Engine project, offering a wide range of functions that provide essential functionality for various game development needs.

Print

Log

Print a message on screen and/or console with control params. (In Development, Debug or Editor mode)

Check your Verbosity setting to select where this message is printed.

Parameters
Message: string
(Omittable) Owner: ref              // Object that called this function.
(Omittable) PrintType: PrintType    [ Log, Success, Warning, Error ]
$ ^Quillscript.Tools.Log Hello
$ ^Quillscript.Tools.Log 'Print this message'
$ ^Quillscript.Tools.Log 'Print this message' {&Script} Error


#include "Utils/Tools.h"
...

UTools::Log("Print this message", MyObject, EPrintType::Error);

Print a message on screen and/or console. (In Development, Debug or Editor mode)

Check your Verbosity setting to select where this message is printed.

Parameters
Message: string
(Omittable) Owner: ref    // Object that called this function.
$ ^Quillscript.Tools.Print Hello
$ ^Quillscript.Tools.Print 'Print this message'
$ ^Quillscript.Tools.Print 'Print this message' {&Script}


#include "Utils/Tools.h"
...

// Macro (Only inside an UObject method. Type cast is NOT required)
PRINT("Print this message")

// Function call.
UTools::Print("Print this message", MyObject)

Success

Print a success message on screen and/or console. (In Development, Debug or Editor mode)

Check your Verbosity setting to select where this message is printed.

Parameters
Message: string
(Omittable) Owner: ref    // Object that called this function.
$ ^Quillscript.Tools.Success Hello
$ ^Quillscript.Tools.Success 'Print this message'
$ ^Quillscript.Tools.Success 'Print this message' {&Script}


#include "Utils/Tools.h"
...

// Macro (Only inside an UObject method. Type cast is NOT required)
SUCCESS("Print this message");

// Function call.
UTools::Success("Print this message", MyObject);

Warning

Print a warning message on screen and/or console. (In Development, Debug or Editor mode)

Check your Verbosity setting to select where this message is printed.

Parameters
Message: string
(Omittable) Owner: ref    // Object that called this function.
$ ^Quillscript.Tools.Warning Hello
$ ^Quillscript.Tools.Warning 'Print this message'
$ ^Quillscript.Tools.Warning 'Print this message' {&Script}


#include "Utils/Tools.h"
...

// Macro (Only inside an UObject method. Type cast is NOT required)
WARNING("Print this message");

// Function call.
UTools::Warning("Print this message", MyObject);

Error

Print an error message on screen and/or console. (In Development, Debug or Editor mode)

Check your Verbosity setting to select where this message is printed.

Parameters
Message: string
(Omittable) Owner: ref    // Object that called this function.
$ ^Quillscript.Tools.Error Hello
$ ^Quillscript.Tools.Error 'Print this message'
$ ^Quillscript.Tools.Error 'Print this message' {&Script}


#include "Utils/Tools.h"
...

// Macro (Only inside an UObject method. Type cast is NOT required)
ERROR("Print this message");

// Function call.
UTools::Error("Print this message", MyObject);

Utilities

Rename Object

Rename the given object.

This function is useful to give a know name to an object and reference it later by name in script like:
$ &ObjName.ObjFunction

Parameters
Object: ref
NewName: string
$ ^Quillscript.Tools.RenameObject {&RefName} NewRefName
$ &NewRefName.MyFunction


#include "Utils/Tools.h"
...

UTools::RenameObject(MyObject, "RefName");

Find Class by Path

Attempts to locate a class by its path, specified as a string. This function is a valuable utility for dynamically finding and accessing classes within your Unreal Engine project based on their defined paths.

Parameters
Path: string
// Store class reference in {&ReturnValue}.
$ ^Quillscript.Tools.FindClassByPath /Game/Path/To/Blueprint.Blueprint
$ ^Quillscript.Tools.FindClassByPath /Game/Path/To/Blueprint.Blueprint_C
$ ^Quillscript.Tools.FindClassByPath Module.ClassName


#include "Utils/Tools.h"
...

// Blueprint class.
TObjectPtr<UClass> BlueprintPath{ UTools::FindClassByPath("/Game/Path/To/My/Blueprint.Blueprint") };
TObjectPtr<UClass> ClassPath{ UTools::FindClassByPath("/Game/Path/To/My/Blueprint.Blueprint_C") };

// C++ class.
TObjectPtr<UClass> CppClass{ UTools::FindClassByPath("Module.ClassName") };
TObjectPtr<UClass> CppClassExample{ UTools::FindClassByPath("Engine.Actor") };

Get Class Default Object

Get the default object from the given class. This function is useful to expose the Default Object to Blueprints.

Parameters
Class: ref[Class]
// Store class reference in {&ReturnValue}.
$ ^Quillscript.Tools.GetClassDefaultObject {&Class}


#include "Utils/Tools.h"
...

TObjectPtr<UClass> DefaultObject{ UTools::GetClassDefaultObject(Class) };

Property Exists


Get Property by Name


Set Property by Name


Find Property by Name


Insert Property by Name


Get Property Object


Call Function by Name

Call a Target's function by name and return its Return Value and Outer Parameters.

This is a simplified general usage version of Interpreter.CallFunctionOnTarget() that do not create Quillscript variables and script references.

Parameters
WorldContextObject: ref
Target: ref
FunctionName: name
Parameters: array[string]
// Store class reference in {&ReturnValue}.
$ ^Quillscript.Tools.CallFunctionByName {&Target} MyFunction '("10","true")'


#include "Utils/Tools.h"
...

TMap<FName, FString> OuterParams{
    UTools::CallFunctionByName(
        WorldContextObject,
        Target,
        "MyFunction",
        TArray<FString>({"10", "true"})
    )
};

Has Authority

Serves as a shortcut utility designed for use inside static methods that have a WorldContextObject parameter. It allows you to determine whether the current execution context possesses authority, using the GetFirstPlayerController, which is often associated with server or authoritative roles in networked multiplayer games.

While this function provides a convenient way to check authority within static methods, it's important to note that if your function already has access to HasAuthority() through other means, it's advisable to use those methods instead.

Parameters
WorldContextObject: ref
// Store result in {&ReturnValue}.
$ ^Quillscript.Tools.HasAuthority


#include "Utils/Tools.h"
...

// Macro (Only inside functions with a 'WorldContextObject' variable)
if (HAS_AUTHORITY())
{
    // Implementation.
}

// Function call.
if (UTools::HasAuthority(WorldContextObject))
{
    // Implementation.
}

Is Module Loaded

Check whether a specific module or plugin is currently loaded within the Unreal Engine project. This function provides a straightforward way to determine if a particular module or plugin is available and active for use in your project.

Parameters
ModuleName: name
// Store result in {&ReturnValue}.
$ ^Quillscript.Tools.IsModuleLoaded ModuleName


#include "Utils/Tools.h"
...

if (UTools::IsModuleLoaded(ModuleName))
{
    // Implementation.
}

Generate Random String

Check whether a specific module or plugin is currently loaded within the Unreal Engine project. This function provides a straightforward way to determine if a particular module or plugin is available and active for use in your project.

Parameters
(Omittable) Size: byte = 8
(Omittable) Letters: bool = true
(Omittable) Numbers: bool = true
(Omittable) Symbols: bool = false
// Store result in {&ReturnValue}.
$ ^Quillscript.Tools.GenerateRandomString
$ ^Quillscript.Tools.GenerateRandomString 8 true true true


#include "Utils/Tools.h"
...

FString RandomString{ UTools::GenerateRandomString() };

Retrieve Option

Fetch a level transition option by providing the option's key. This function is particularly useful when you need to access specific transition options after a level change, allowing you to retrieve and utilize option values as needed.

Parameters
WorldContextObject: ref
Key: string
Value: string
// Store if level option exists in {$ReturnValue}.
// Store level option value in {&Value}.
$ ^Quillscript.Tools.RetrieveOption MyKey


#include "Utils/Tools.h"
...

FString Key, Value;
FString RandomString{ UTools::RetrieveOption(WorldContextObject, Key, Value) };

Sort Strings Alphabetically

Sort an array of strings in alphabetical order. This function allows you to arrange a collection of strings into ascending alphabetical sequence, making it easier to manage and organize string data.

Parameters
Strings: array[string]
// Store result in {&ReturnValue}.
$ MyArray = '("Snowfall","Unreal Engine","Quillscript")'
$ ^Quillscript.Tools.SortStringsAlphabetically {MyArray}


#include "Utils/Tools.h"
...

TArray<FString> SortedArray{ UTools::SortStringsAlphabetically(StringsArray) };

Register String Table

Register a string table by path. This function is useful when a string table is used by path and never referenced, causing it to not be loaded during runtime.

Parameters
StringTablepPath: name
// Store result in {&ReturnValue}.
$ ^Quillscript.Tools.RegisterStringTable /Game/Folder/MyTable.MyTable


#include "Utils/Tools.h"
...

UTools::RegisterStringTable("/Game/Folder/MyTable.MyTable");

Find String Table Key


Get Variables in String


String Table Contains


Get World Type as String


Length


Regex Match


Metadata

Get Project Name

Retrieves the project name that is configured in the Edit > Project Settings > Project > Description > Project Name field. This function allows you to access the project's name programmatically.

// Store result in {&ReturnValue}.
$ ^Quillscript.Tools.GetProjectName


#include "Utils/Tools.h"
...

FString ProjectName{ UTools::GetProjectName() };

Get Project Version

Retrieves the project version that is set in the Edit > Project Settings > Project > Description > Project Version field. You can use this function to access the project's version number within your code.

// Store result in {&ReturnValue}.
$ ^Quillscript.Tools.GetProjectVersion


#include "Utils/Tools.h"
...

FString ProjectVersion{ UTools::GetProjectVersion() };

Get Company Name

Fetches the company name specified in the Edit > Project Settings > Project > Description > Company Name field. This function is useful for obtaining the company name associated with your project.

// Store result in {&ReturnValue}.
$ ^Quillscript.Tools.GetCompanyName


#include "Utils/Tools.h"
...

FString CompanyName{ UTools::GetCompanyName() };

Assets

Mark Asset Dirty


Save Asset


Asset Exists


Load Asset by Path


Files

Get All Save Game Slot Names


Save to Text File


Load Text File


Load Image


Take Screenshot


Directory to String


List Files


List Directories


Launch File


Settings

Get Bool Setting


Set Bool Setting


Get String Setting


Set String Setting


Get Int Setting


Set Int Setting


Get Float Setting


Set Float Setting


Setting File to String


UI

Destroy Widget


Add to Constraint Viewport


Capture Widget


Get Parent Widget of Class


Get Nested Widgets


Get Nested Widgets Of Class


Add Child Widget at


Remove Visible Widgets


Remove Hidden Widgets


Play Typewriter Effect

Return the given string in the 'On Printed Event' character-by-character in the given interval.

Text: text
PrintedDelegate: event
CompletedDelegate: event
(Omittable) Interval: float = 0.02
(Omittable) Sound: ref[Sound Base] = nullptr
(Omittable) bOverlapSound: bool = false
(Omittable) bSanitize: bool = true

 
#include "Utils/Tools.h"
...

FTextPrintedDelegate OnPrinted;
OnPrinted.BindDynamic(this, &UMyObject::Printed);

FTextCompletedDelegate OnCompleted;
OnCompleted.BindDynamic(this, &UMyObject::Completed);

TObjectPtr<ASmartTypewriter> Typewriter{
    UTools::PlayTypewriterEffect(
        WorldContextObject,
        TXT("Hello, world!"),
        OnPrinted,
        OnCompleted
    )
};
On Printed
void UMyObject::Printed(const FText& Text, const FString& Character, const int32& Index)
{
	// Implementation
}
On Completed
void UMyObject::Completed()
{
	// Implementation
}

Pipes

Replace Variables


To Signed Number


To Display Text


Upper First Letter


Text Upper First Letter


Remove Accentuation


Remove Rich Text Tags


To Hash


To Hex


Encrypt


Decrypt


Is Key Value Pair


To Key Value Pair


Has Key Value Tag


Remove Repeated Values


To String


Operators

Null Coalescing Operator


Solve Math Expression


Is Same Unique Net Id


Is Host


© Copyright 2026. All rights reserved.