UnrealSharp

https://www.unrealsharp.com
Admin
UnrealSharp is a free and open-source plugin for Unreal Engine 5 that enables game developers to...
Tokens:18,545
Snippets:205
Trust Score:5.4
Update:8 months ago
Show doc for...
Tokens:
Raw
### Example Project Packaging Command (Batch)

Source: https://www.unrealsharp.com/getting-started-and-fundamentals/packaging

An example of the UnrealSharp project packaging command, demonstrating how to specify paths for a project named 'MyGame'. This command assumes the UnrealSharp plugin is in the project's 'Plugins' folder and archives the output to the desktop.

```batch
dotnet UnrealSharpBuildTool.dll --Action PackageProject --ProjectDirectory "C:/Users/CoolName/Documents/Unreal Projects/MyGame/" --ProjectName "MyGame" --PluginDirectory "C:/Users/CoolName/Documents/Unreal Projects/MyGame/Plugins/UnrealSharp" --AdditionalArgs BuildConfig=Release ArchiveDirectory="C:/Users/CoolName/Desktop/Windows"
```

--------------------------------

### World Subsystem Implementation Example in UnrealSharp

Source: https://www.unrealsharp.com/unreal-framework/subsystems

An example of implementing a world subsystem in UnrealSharp. This class inherits from UCSWorldSubsystem and overrides methods like DoesSupportWorldType, Initialize, and OnWorldBeginPlay to define its behavior and lifecycle.

```csharp
[UClass]
public partial class UMyWorldSubsystem : UCSWorldSubsystem
{
    public override bool DoesSupportWorldType(ECSWorldType worldType)
    {
        return worldType == ECSWorldType.Game || worldType == ECSWorldType.PIE;
    }

    public override void Initialize(FSubsystemCollectionBaseRef collection)
    {
        
    }

    public override void OnWorldBeginPlay()
    {
        
    }
}
```

--------------------------------

### Clone UnrealSharp Repository (Bash)

Source: https://www.unrealsharp.com/getting-started-and-fundamentals/quickstart

This command clones the UnrealSharp repository from GitHub. Ensure you have Git installed and are in your Unreal Engine project's root directory, specifically within the 'Plugins' folder (create it if it doesn't exist).

```bash
git clone https://github.com/UnrealSharp/UnrealSharp.git
```

--------------------------------

### Delegate API Usage Example in C#

Source: https://www.unrealsharp.com/unreal-framework/delegates

Provides an example of using the delegate API in UnrealSharp, including subscribing to a delegate, invoking it, checking for callbacks, and unsubscribing. Callbacks for Unreal Engine exposed delegates must be UFunctions.

```csharp
public override void BeginPlay()
{
    // Subscribe to the delegate with a callback
    MyMulticastDelegate += MyFunctionCallback;
    
    // Invoke the delegate
    MyMulticastDelegate.Invoke(1337);

    // Check if the delegate contains the callback
    if (MyMulticastDelegate.Contains(MyCallback))
    {
        PrintString("Delegate contains MyCallback");
    }
    
    // Unsubscribe from the delegate
    MyMulticastDelegate -= MyCallback;

    base.BeginPlay();
}

// A callback to an Unreal Engine exposed delegate must be a UFunction.
[UFunction]
public void MyFunctionCallback(int a)
{
    PrintString($"MyCallback invoked with {a}");
}
```

--------------------------------

### Create and Display Widget in UnrealSharp

Source: https://www.unrealsharp.com/ui/widgets/show-widget-on-screen

This C# code demonstrates how to create an instance of a widget using the previously defined MyWidgetClass and then add it to the viewport. It also includes an example of calling a custom initialization function on the created widget.

```csharp
[UClass]
public partial class AMyCharacter : ACharacter
{
    [UProperty(PropertyFlags.EditDefaultsOnly)]
    protected partial TSubclassOf<UMyWidget> MyWidgetClass { get; set; }
    
    public override void BeginPlay()
    {
        // CreateWidget is available in any UObject class.
        UMyWidget myWidget = CreateWidget(MyWidgetClass);
        myWidget.AddToViewport();
        
        // Custom initialization function that I created
        myWidget.InitializeFrom(this);
    }
}
```

--------------------------------

### Creating C# Plugins for Unreal Engine

Source: https://www.unrealsharp.com/faq

Indicates that it is possible to create C# plugins for Unreal Engine using UnrealSharp. It directs users to guides for further instructions on how to proceed with plugin development.

```csharp
// Follow the guides here to create a C# plugin.
// Example placeholder for where plugin creation logic would go.
```

--------------------------------

### BlueprintPure Function Example in C#

Source: https://www.unrealsharp.com/unreal-framework/classes/functions/specifiers

Demonstrates how to declare a BlueprintPure function in C# using the UFunction attribute. Pure functions do not modify the owning object and can be called from Blueprints. Be cautious with complex operations as results are not cached.

```csharp
[UFunction(FunctionFlags.BlueprintPure)]
public int BlueprintPureFunction()
{
  return 1;
}
```

```csharp
[UFunction(FunctionFlags.BlueprintCallable)]
public int BlueprintCallableFunction()
{
return 1;
}
```

--------------------------------

### Register Replicated UObject with AActor in C#

Source: https://www.unrealsharp.com/gameplay-systems/multiplayer/replicated-uobjects

This example demonstrates how to use a replicated UObject within an AActor. It shows how to declare a replicated property of the UObject type and register it using AddReplicatedSubObject within the BeginPlay method, ensuring it's handled by Unreal's replication system.

```csharp
[UClass]
public partial class AMyReplicatedActor : AActor
{
    [UProperty(PropertyFlags.Replicated)]
    public partial UMyReplicatedUObject ReplicatedObject { get; set; }

    public override void BeginPlay()
    {
        base.BeginPlay();

        if (HasAuthority())
        {
            ReplicatedObject = NewObject<UMyReplicatedUObject>(this);
            
            // Register the new replicated UObject
            AddReplicatedSubObject(ReplicatedObject);
        }
    }
}
```

--------------------------------

### Use Custom Log Categories in C#

Source: https://www.unrealsharp.com/getting-started-and-fundamentals/logging

Log messages using the generated methods of your custom log categories within your Unreal Engine C# classes. This example demonstrates logging within the constructor and `BeginPlay` method of an `AActor` subclass.

```csharp
[UClass]
public partial class ALogShowcase : AActor
{
    public ALogShowcase()
    {
        LogMyFirstLog.Log("ALogShowcase constructor executed");
    }

    public override void BeginPlay()
    {
        LogMyFirstLog.Log("BeginPlay executed");
        base.BeginPlay();
    }
}
```

--------------------------------

### Retrieving Subsystems in UnrealSharp

Source: https://www.unrealsharp.com/unreal-framework/subsystems

Demonstrates the methods for obtaining instances of different types of subsystems in UnrealSharp. The specific method used depends on the type of subsystem you need to access.

```csharp
GetWorldSubsystem<UMyWorldSubsystem>();
GetGameInstanceSubsystem<UMyGameInstanceSubsystem>();
GetLocalPlayerSubsystem<UMyLocalPlayerSubsystem>(OwningPlayerController);
GetEngineSubsystem<UMyEngineSubsystem>();
```

--------------------------------

### Constructing UObjects in UnrealSharp

Source: https://www.unrealsharp.com/faq

Demonstrates the correct method for instantiating objects that inherit from 'UObject' in UnrealSharp. It highlights the difference between `NewObject<T>()` and the incorrect use of `new T()`, which fails for UObjects.

```csharp
NewObject<T>()
```

--------------------------------

### Manage Actor Components (C#)

Source: https://www.unrealsharp.com/unreal-framework/classes/helper-methods

Demonstrates methods for retrieving and constructing ActorComponent classes. This includes fetching existing components from an actor and creating new instances of various mesh components.

```csharp
UStaticMeshComponent? Mesh = UStaticMeshComponent.Get(actor);
UStaticMeshComponent MyNewMesh = UStaticMeshComponent.Construct(owner);
USkeletalMeshComponent MyNewMesh2 = USkeletalMeshComponent.Construct(owner, manualAttachment, new Transform());
USplineMeshComponent MyNewMesh3 = USplineMeshComponent.Construct(owner, MyComponentClass, manualAttachment, new Transform());
```

--------------------------------

### Access and Modify TNativeArray Elements in C#

Source: https://www.unrealsharp.com/data-and-asset-management/collections/tnativearray

Shows how to access and modify individual elements of a TNativeArray<int> in C# during the Tick function of an Unreal Engine Actor. It uses AsSpan() to get a reference to the array's elements.

```csharp
using UnrealSharp;

public partial class AActorTest : ACharacter
{
    // ... (previous code)

    public override void Tick(float deltaSeconds)
    {
        base.Tick(deltaSeconds);

        ref int MyNumber = ref NativeArrayTest.AsSpan()[0];
        MyNumber++;
    }
}
```

--------------------------------

### Package Project via Command Prompt (Batch)

Source: https://www.unrealsharp.com/getting-started-and-fundamentals/packaging

This batch script utilizes the UnrealSharpBuildTool.dll to package a project. It requires specifying actions, project directories, project name, plugin directory, and additional arguments like build configuration and archive directory. Ensure the dotnet CLI is available in your environment.

```batch
dotnet UnrealSharpBuildTool.dll --Action PackageProject --ProjectDirectory "<YourProjectDirectory>" --ProjectName "<YourProjectName>" --PluginDirectory "<YourPluginDirectory>" --AdditionalArgs BuildConfig=Release ArchiveDirectory="<YourArchiveDirectory>"
```

--------------------------------

### Spawn Actor Instance (C#)

Source: https://www.unrealsharp.com/unreal-framework/classes/helper-methods

Provides methods for spawning instances of Actor classes. These methods allow for basic spawning, spawning at a specific transform, and spawning with detailed collision handling, instigator, and owner.

```csharp
AStaticMeshActor.Spawn(worldContextObject, MyActorClass);
AStaticMeshActor.Spawn(worldContextObject, MyActorClass, GetActorTransform());
SpawnActorCollisionHandlingMethod method = SpawnActorCollisionHandlingMethod.AlwaysSpawn;
AStaticMeshActor.Spawn(worldContextObject, MyActorClass, GetActorTransform(), method, instigator, owner);
```

--------------------------------

### Enable UnrealSharp Code Generation (XML)

Source: https://www.unrealsharp.com/unreal-framework/classes/helper-methods

Instructions for enabling source generation for custom classes in UnrealSharp by adding a reference to the extension DLL in the project's csproj file.

```xml
<ItemGroup>
    <Analyzer Include="..\..\Plugins\UnrealSharp\Binaries\Managed\netstandard2.0\UnrealSharp.ExtensionSourceGenerators.dll" />
</ItemGroup>
```

--------------------------------

### Create Basic UnrealSharp Actor Class in C#

Source: https://www.unrealsharp.com/getting-started-and-fundamentals/your-first-script

Demonstrates the creation of a fundamental UnrealSharp class inheriting from AActor. It includes setting up a UClass attribute, a UProperty for Blueprint readability, and implementing BeginPlay and a UFunction callable from Blueprints. This script requires the UnrealSharp library and is intended for use within an Unreal Engine project.

```csharp
using UnrealSharp.Attributes;
using UnrealSharp.Engine;

namespace ManagedTestCSharp;

[UClass]
public partial class AMyTestClass : AActor
{
    [UProperty(PropertyFlags.BlueprintReadOnly)]
    public partial int MyInt { get; set; }

    public override void BeginPlay()
    {
        PrintString("Hello from C#!");

        base.BeginPlay();
    }

    [UFunction(FunctionFlags.BlueprintCallable)]
    public void MyFunction(int myInt)
    {
        MyInt = myInt;
        PrintString($"MyInt set to {MyInt}");
    }
}
```

--------------------------------

### Expose Async Task to Blueprint with UnrealContext

Source: https://www.unrealsharp.com/gameplay-systems/async

Demonstrates how to expose an asynchronous C# method to Unreal Engine Blueprints. The method returns a `Task` and uses `await Task.Delay().ConfigureWithUnrealContext()` to ensure execution on the correct Unreal thread. It also includes optional cancellation token support and checks for cancellation or actor destruction.

```csharp
[UClass]
public partial class AAsyncActor : AActor
{
    // Cancellation token is optional.
    [UFunction(FunctionFlags.BlueprintCallable)]
    public async Task<int> SlowAdd(int lhs, int rhs, CancellationToken cancellationToken)
    {
        PrintString($"Commencing the world's slowest addition...");

        await Task.Delay(1000, cancellationToken).ConfigureWithUnrealContext();
        if (cancellationToken.IsCancellationRequested || IsDestroyed) { return default; }

        int result = lhs + rhs;
        PrintString($"{lhs} + {rhs} = {result}!");

        return result;
    }
}
```

--------------------------------

### Construct FGameplayTagContainer in C#

Source: https://www.unrealsharp.com/gameplay-systems/gameplay-tags/gameplay-tag-container

Demonstrates two methods for constructing an FGameplayTagContainer: using a List of FGameplayTag objects or directly passing FGameplayTag parameters. This requires the GameplayTags module to be accessible.

```csharp
List<FGameplayTag> tags = new List<FGameplayTag>
{
    GameplayTags.MyGameplayTag,
    GameplayTags.MyGameplayTag_MySubTag
};

FGameplayTagContainer containerInitWithList = new FGameplayTagContainer(tags);

FGameplayTagContainer containerInitWithArrayParams = new FGameplayTagContainer(
    GameplayTags.MyGameplayTag,
    GameplayTags.MyGameplayTag_MySubTag
);
```

--------------------------------

### Load All Primary Assets by Type in C#

Source: https://www.unrealsharp.com/data-and-asset-management/primary-data-assets/loading-assets

Loads all primary assets of a specified type using the AssetManager. Requires access to the UAssetManager and the AssetTypes class. Returns a list of loaded assets.

```csharp
UAssetManager assetManager = UAssetManager.Get();

// Optional list of asset bundles to load
List<FName> bundles = new List<FName>();

// Load all primary assets of type ItemRecipe
IList<UItemRecipe> loadedItems = await assetManager.LoadPrimaryAssets<UItemRecipe>(AssetTypes.ItemRecipe.PrimaryAssetList, bundles);
```

--------------------------------

### Using UnrealSharp Extension Methods in C#

Source: https://www.unrealsharp.com/glue-generation/extension-methods

Demonstrates how to invoke the generated C# extension methods on an actor instance within a C# script. This showcases the convenience of calling extension methods as if they were part of the original class.

```csharp
public override void BeginPlay()
{
    MyActorReference.ExtensionMethod1(20);
    base.BeginPlay();
}

```

--------------------------------

### Create C# Primary Data Asset with UnrealSharp

Source: https://www.unrealsharp.com/data-and-asset-management/primary-data-assets

Demonstrates the creation of a `UItemPrimaryDataAsset` by inheriting from `UCSPrimaryDataAsset`. It shows how to set the `AssetName` and define a `UProperty` for `ItemName`. Ensure `AssetName` matches project settings.

```csharp
[UClass]
public partial class UItemPrimaryDataAsset : UCSPrimaryDataAsset
{
    public UItemPrimaryDataAsset()
    {
        AssetName = "Item";
    }
    
    [UProperty(PropertyFlags.EditDefaultsOnly)]
    public partial FText ItemName { get; set; }
}
```

--------------------------------

### Access Developer Settings in C# at Runtime

Source: https://www.unrealsharp.com/data-and-asset-management/developer-settings

This C# code snippet shows how to retrieve the default instance of custom developer settings (`UMyDeveloperSettings`) at runtime using `GetDefault<T>()`. It includes a check for the validity of a soft object pointer before attempting to use it.

```csharp
public override void BeginPlay()
{
    UMyDeveloperSettings settings = GetDefault<UMyDeveloperSettings>();
    if (settings.MyConfigMaterial.IsValid)
    {
        // Do something with the material
    }
}
```

--------------------------------

### Subsystem Name Mapping in UnrealSharp

Source: https://www.unrealsharp.com/unreal-framework/subsystems

This snippet shows the mapping between Unreal Engine's subsystem classes and their corresponding CS wrappers in UnrealSharp. These wrappers are necessary due to the limited reflection capabilities for subsystem classes in the engine.

```csharp
UWorldSubsystem => UCSWorldSubsystem

UGameInstanceSubsystem => UCSGameInstanceSubsystem

UEngineSubsystem => UCSEngineSubsystem

ULocalPlayerSubsystem => UCSLocalPlayerSubsystem
```

--------------------------------

### C# Module Class Implementation for UnrealSharp

Source: https://www.unrealsharp.com/getting-started-and-fundamentals/module-lifecycle

Demonstrates the structure of a C# module class implementing the IModuleInterface in UnrealSharp. This class handles module startup and shutdown logic, essential for engine integration and hot reloading.

```csharp
using UnrealSharp.Engine.Core.Modules;

namespace ModuleShowcase;

public class FModuleShowcase : IModuleInterface
{
    // Called when opening the engine or reloading an assembly during hot reload
    public void StartupModule()
    {
    }

    // Called when the engine is closing or reloading an assembly during hot reload
    public void ShutdownModule()
    {
    }
}
```

--------------------------------

### Expose Delegates as Class Members in C#

Source: https://www.unrealsharp.com/unreal-framework/delegates

Shows how to expose delegates as class members in UnrealSharp. It illustrates using UProperty with BlueprintAssignable for multicast delegates and UFunction for callbacks, noting limitations for single delegates in Blueprint exposure.

```csharp
[UClass]
public class ADelegateShowcaseClass : AActor
{
    [UProperty(PropertyFlags.BlueprintAssignable)]
    public partial TMulticastDelegate<FMyShowcaseMulticastDelegate> MyMulticastDelegate { get; set; }
    
    [UFunction(FunctionFlags.BlueprintCallable)]
    public void MyFunctionWithCallback(TDelegate<MyShowcaseDelegate> singleDelegate)
    {
        
    }

    // Single delegates as properties can't be Blueprint exposed, but reflection exposed. Unreal Engine limitation.
    [UProperty]
    public partial TDelegate<FMyShowcaseDelegate> MySingleDelegate { get; set; }
}
```

--------------------------------

### Execute Function on Owning Client with UnrealSharp

Source: https://www.unrealsharp.com/gameplay-systems/multiplayer/rpcs-remote-procedure-calls

Employ the [UFunction] attribute with FunctionFlags.RunOnClient to direct a method's execution to the owning client. The _Implementation method houses the client-side code. Reliability is default unless FunctionFlags.Reliable is omitted.

```csharp
[UFunction(FunctionFlags.RunOnClient | FunctionFlags.Reliable)]
public partial void ClientFunction();
public partial void ClientFunction_Implementation();
{
    // Client-side code
}
```

--------------------------------

### Mapping C++ Meta Data to C# Attributes

Source: https://www.unrealsharp.com/unreal-framework/metadata

Demonstrates how C++ UPROPERTY meta data like 'Category' is translated into C# attributes in UnrealSharp. It shows two alternative ways to achieve the same result, highlighting the flexibility of the system.

```csharp
// Alternative 1
[UProperty(PropertyFlags.EditDefaultsOnly), Category("MyCategory")]
public partial UMyObject MyObject { get; set; }
```

```csharp
// Alternative 2
[UProperty(PropertyFlags.EditDefaultsOnly), UMetaData("Category", "MyCategory")]
public partial UMyObject MyObject { get; set; }
```

--------------------------------

### Execute Function on Server with UnrealSharp

Source: https://www.unrealsharp.com/gameplay-systems/multiplayer/rpcs-remote-procedure-calls

Use the [UFunction] attribute with FunctionFlags.RunOnServer to designate a method for server-side execution. The _Implementation method contains the server-side logic. RPCs are reliable by default unless FunctionFlags.Reliable is omitted.

```csharp
[UFunction(FunctionFlags.RunOnServer | FunctionFlags.Reliable)]
public partial void ServerFunction();
public partial void ServerFunction_Implementation();
{
    // Server-side code
}
```

--------------------------------

### Execute Function on Server and All Clients (Multicast) with UnrealSharp

Source: https://www.unrealsharp.com/gameplay-systems/multiplayer/rpcs-remote-procedure-calls

Utilize FunctionFlags.Multicast within the [UFunction] attribute to ensure a function executes on both the server and all connected clients. The _Implementation method contains the shared logic. Reliability is the default behavior.

```csharp
[UFunction(FunctionFlags.Multicast | FunctionFlags.Reliable)]
public partial void MulticastFunction();
public partial void MulticastFunction_Implementation();
{
    // Code executed on both server and clients
}
```

--------------------------------

### Define a Base Widget Class in C# (UnrealSharp)

Source: https://www.unrealsharp.com/ui/widgets/create-compose-widgets

This snippet shows how to define a basic custom widget class by inheriting from UUserWidget. This is the foundational step for creating any new UI element in UnrealSharp.

```csharp
[UClass]
public partial class UMyWidget : UUserWidget
{
}
```

--------------------------------

### Replicate Property with Lifetime Condition in C#

Source: https://www.unrealsharp.com/gameplay-systems/multiplayer/replicated-properties

Explains how to set a LifetimeCondition for a replicated property in C#. This allows for conditional replication, such as only replicating the property to the owning player.

```csharp
[UProperty(PropertyFlags.Replicated, LifetimeCondition = LifetimeCondition.OwnerOnly)]
public partial string MyReplicatedString { get; set; }
```

--------------------------------

### Exposing Unreal Properties with UProperty in C#

Source: https://www.unrealsharp.com/unreal-framework/classes/properties

This snippet demonstrates how to declare C# properties that are exposed to Unreal Engine using the [UProperty] attribute. It showcases common property types such as UStaticMeshComponent, TMap, and TWeakObjectPtr, and their usage within the BeginPlay method. Note that TMap and TArray cannot be directly constructed with 'new' in C# and rely on the engine for initialization.

```csharp
[UClass]
public partial class AMyShowcaseClass : AActor
{
    // Declares a default component which is automatically created and assigned
    // when the actor is constructed. Marking it as RootComponent makes it the root.
    [UProperty(DefaultComponent = true, RootComponent = true)]
    public partial UStaticMeshComponent MyMesh { get; set; }
 
    // Exposes a map to the editor and Blueprint.
    // Note: TMap itself cannot currently be constructed with 'new' in C#.
    [UProperty(PropertyFlags.EditAnywhere | PropertyFlags.BlueprintReadWrite)]
    public partial TMap<int, string> MyMap { get; set; }

    [UProperty(PropertyFlags.EditAnywhere | PropertyFlags.BlueprintReadWrite)]
    public partial TWeakObjectPtr<AMyShowcaseClass> MyWeakObject { get; set; }

    public override void BeginPlay()
    {
        base.BeginPlay();

        PrintString("BeginPlay called!");

        // Assuming the enginehas initialized MyMap for you,
        // you can use it like a normal map:
        MyMap.Add(1, "First Value");
        MyMap.Add(2, "Second Value");

        MyWeakObject = this;

        UpdateMapWithKey(2, "Updated Second Value");
    }    
}
```

--------------------------------

### OnRep Function with Old Value in C#

Source: https://www.unrealsharp.com/gameplay-systems/multiplayer/replicated-properties

Illustrates how to define an OnRep function in C# that accepts the previous value of a replicated property as a parameter. This is useful for logic that needs to compare the old and new values.

```csharp
[UFunction]
void OnRep_MyReplicatedBoolWithOldValue(bool oldValue)
{
    PrintString($"MyReplicatedBool has been updated from {oldValue} to {MyReplicatedBool}");
}
```

--------------------------------

### Register C# Gameplay Tags on Module Startup

Source: https://www.unrealsharp.com/gameplay-systems/gameplay-tags/c-created-gameplay-tags

Registers custom Gameplay Tags by ensuring their static constructor is run during the module's `StartupModule` phase. This is crucial for making tags available before other systems access them, especially in the editor. It uses `RuntimeHelpers.RunClassConstructor` to trigger tag initialization.

```csharp
public class FIslandGen : IModuleInterface
{
    public void StartupModule()
    {
        // Runs the static constructor and registers the gameplay tags
        RuntimeHelpers.RunClassConstructor(typeof(IslandGenTags).TypeHandle);
    }

    public void ShutdownModule()
    {
    }
}
```

--------------------------------

### Bind Child Widgets in C# (UnrealSharp)

Source: https://www.unrealsharp.com/ui/widgets/create-compose-widgets

Demonstrates how to declare child widgets within a custom UUserWidget class using UProperty and BindWidget attributes. These attributes are crucial for the Unreal Editor to automatically bind UI elements defined in the Blueprint editor to your C# code.

```csharp
[UClass]
public partial class UMyWidget : UUserWidget
{
    [UProperty, BindWidget]
    public partial UImage MyImage { get; set; }
    
    [UProperty, BindWidget]
    public partial UTextBlock MyTextBlock { get; set; }
}
```

--------------------------------

### Defining Custom Meta Data Attributes in C#

Source: https://www.unrealsharp.com/unreal-framework/metadata

Illustrates how to create custom meta data attributes in C# that UnrealSharp's source generator can recognize. The 'CustomMetaData' attribute is used, and the attribute name and constructor arguments determine the meta data key and value.

```csharp
[AttributeUsage(AttributeTargets.All), CustomMetaData]
public sealed class CategoryAttribute(string categoryName) : Attribute { }
```

--------------------------------

### Define Custom Developer Settings in C#

Source: https://www.unrealsharp.com/data-and-asset-management/developer-settings

This C# code defines a custom developer settings class `UMyDeveloperSettings` that derives from `UDeveloperSettings`. It demonstrates how to assign a configuration category and mark properties for editing and saving to configuration files. Object references are handled using `TSoftObjectPtr`.

```csharp
[UClass(config: "Game")]
public partial class UMyDeveloperSettings : UDeveloperSettings
{
    [UProperty(PropertyFlags.EditAnywhere | PropertyFlags.Config)]
    public partial float MyConfigFloat { get; set; }
    
    [UProperty(PropertyFlags.EditAnywhere | PropertyFlags.Config)]
    public partial TSoftObjectPtr<UMaterialInterface> MyConfigMaterial { get; set; }
}
```

--------------------------------

### Append Tags to FGameplayTagContainer in C#

Source: https://www.unrealsharp.com/gameplay-systems/gameplay-tags/gameplay-tag-container

Illustrates various ways to append tags to an existing FGameplayTagContainer: appending a list of tags, appending individual tags, or appending another FGameplayTagContainer. Ensure the container and tags are properly initialized.

```csharp
gameplayTagContainer.AppendTags(tags);

gameplayTagContainer.AppendTags(
    GameplayTags.MyGameplayTag,
    GameplayTags.MyGameplayTag_MySubTag
);

gameplayTagContainer.AppendTags(containerInitWithList);
```

--------------------------------

### Declare Unreal Engine Delegates in C#

Source: https://www.unrealsharp.com/unreal-framework/delegates

Demonstrates how to declare multicast and single delegates for Unreal Engine integration using specific attributes. Delegates exposed to Unreal Engine require parameters supported by reflection.

```csharp
// Delegates need the attribute to generate the correct glue for the type.

// Multicast delegates.
[UMultiDelegate]
public delegate void FMyShowcaseMulticastDelegate(int a);

// Single delegates.
[USingleDelegate]
public delegate void FMyShowcaseDelegate(int a);
```

--------------------------------

### Access Gameplay Tags in C#

Source: https://www.unrealsharp.com/gameplay-systems/gameplay-tags

Demonstrates how to retrieve specific FGameplayTags from the GameplayTags static class in C#. This allows for easy access to predefined tags within your UnrealSharp project. The GameplayTags class automatically updates as new tags are added.

```csharp
FGameplayTag myGameplayTag = GameplayTags.MyGameplayTag;
FGameplayTag myGameplayTagMySubTag = GameplayTags.MyGameplayTag_MySubTag;
```

--------------------------------

### Implement Cheat Command in C#

Source: https://www.unrealsharp.com/gameplay-systems/cheats-debug-commands

This C# code snippet demonstrates how to create a cheat manager extension class in UnrealSharp. Methods marked with `UFunction(FunctionFlags.Exec)` are automatically exposed as console commands, allowing for custom cheat logic to be executed from the in-game console.

```csharp
using UnrealSharp;

[UClass]
public partial class UMyCheatManagerExtension : UCSCheatManagerExtension
{
    [UFunction(FunctionFlags.Exec)]
    public void KillAllEnemies()
    {
        // Your cheat logic here
        UEngine.GetEngine().Console.WriteLine("All enemies killed!");
    }
}
```

--------------------------------

### Declare and Add to TArray in C#

Source: https://www.unrealsharp.com/data-and-asset-management/collections/tarray

Demonstrates how to declare a TArray property in a UClass and add elements to it during gameplay. This requires the UnrealSharp framework and basic C# knowledge.

```csharp
using UnrealSharp;

[UClass]
public partial class AMyShowcaseClass : AActor
{
    [UProperty(PropertyFlags.EditAnywhere | PropertyFlags.BlueprintReadWrite)]
    public partial TArray<int> Array { get; set; }

    public override void BeginPlay()
    {
        base.BeginPlay();

        Array.Add(1);
    }
}
```

--------------------------------

### Expose C# Struct to Unreal Engine

Source: https://www.unrealsharp.com/unreal-framework/structs

Demonstrates how to declare a C# struct for exposure to Unreal Engine. The struct must be marked as `partial` and have the `[UStruct]` attribute. Properties are exposed using `[UProperty]` attributes, supporting various data types including primitives, UObjects, arrays, and dictionaries.

```csharp
using UnrealSharp;
using System.Collections.Generic;

[UStruct]
public partial struct FMyStruct
{
    [UProperty(PropertyFlags.BlueprintReadOnly)]
    public int MyInt { get; private set; }
    
    [UProperty(PropertyFlags.BlueprintReadOnly)]
    public float MyFloat;
    
    [UProperty(PropertyFlags.BlueprintReadOnly)]
    public string MyString;
    
    [UProperty(PropertyFlags.BlueprintReadOnly)]
    public bool MyBool;
    
    [UProperty(PropertyFlags.BlueprintReadOnly)]
    public UObject MyObject;

    [UProperty(PropertyFlags.BlueprintReadOnly)]
    public IList<bool> MyArray;

    [UProperty(PropertyFlags.BlueprintReadOnly)]
    public IDictionary<string, string> MyMap;
}
```

--------------------------------

### Use OnRep Function for Replicated Property Changes in C#

Source: https://www.unrealsharp.com/gameplay-systems/multiplayer/replicated-properties

Shows how to associate a callback function (OnRep) with a replicated property in C#. This function is automatically invoked on clients when the replicated property's value changes, allowing for custom update logic.

```csharp
[UProperty(ReplicatedUsing = nameof(OnRep_MyReplicatedBool))]
public partial bool MyReplicatedBool { get; set; }

[UFunction]
void OnRep_MyReplicatedBool()
{
    PrintString($"MyReplicatedBool has been updated to {MyReplicatedBool}");
}
```

--------------------------------

### Load Specific Primary Asset by ID or Property in C#

Source: https://www.unrealsharp.com/data-and-asset-management/primary-data-assets/loading-assets

Loads a specific primary asset using its ID or a UProperty assigned in the editor. Requires the UAssetManager and either AssetIds or a UPROPERTY of type FPrimaryAssetId. Returns the loaded asset.

```csharp
UAssetManager assetManager = UAssetManager.Get();

// Optional list of asset bundles to load
List<FName> bundles = new List<FName>();

// Loads Item_Axe primary asset.
UItem loadedItem = await assetManager.LoadPrimaryAsset<UItem>(AssetIds.Item_Item_Axe, bundles);

// Loads Item_Axe primary asset through assigned property.
UItem loadedItem = await assetManager.LoadPrimaryAsset<UItem>(AxeRecipeId, bundles);
```

--------------------------------

### Initialize and Copy Data with TNativeArray in C#

Source: https://www.unrealsharp.com/data-and-asset-management/collections/tnativearray

Demonstrates how to declare, initialize, and copy data into a TNativeArray<int> within an Unreal Engine Actor using C#. It utilizes Span<int> for efficient data transfer.

```csharp
using UnrealSharp;

[UClass]
public partial class AActorTest : ACharacter
{
    [UProperty(PropertyFlags.EditAnywhere)]
    public partial TNativeArray<int> NativeArrayTest { get; set; }

    [UProperty(PropertyFlags.EditAnywhere)]
    public partial TNativeArray<int> NativeArrayTest2 { get; set; }

    public override void BeginPlay()
    {
        base.BeginPlay();

        Span<int> test = [5, 6, 7, 8];
        NativeArrayTest.CopyFrom(test);

        Span<int> test2 = stackalloc int[NativeArrayTest.Length];
        NativeArrayTest.CopyTo(test2);

        NativeArrayTest2.CopyFrom(test2);
    }
}
```

--------------------------------

### C++ Extension Method Definition for UnrealSharp

Source: https://www.unrealsharp.com/glue-generation/extension-methods

Defines static C++ methods within a BlueprintFunctionLibrary that can be recognized as extension methods in C#. Requires the `meta=(ExtensionMethod)` attribute and the first parameter to be the type being extended.

```cpp
UCLASS()
class UCSTestExtensions : public UBlueprintFunctionLibrary
{
    GENERATED_BODY()
public:

    // Example of an extension method that takes an int parameter
    // public static void ExtensionMethod1(this Actor actor, int value)
    UFUNCTION(meta=(ExtensionMethod, ScriptMethod))
    static void ExtensionMethod1(AActor* Actor, int32 Value) {};

    // Example of an extension method that takes a float parameter
    // public static void ExtensionMethod2(this Actor actor, float value)
    UFUNCTION(meta=(ExtensionMethod, ScriptMethod))
    static void ExtensionMethod2(AActor* Actor, float Value) {};
};

```

--------------------------------

### Pass ReadOnlySpan to UFunction in C#

Source: https://www.unrealsharp.com/data-and-asset-management/collections/tnativearray

Illustrates how to define a UFunction in C# that accepts a ReadOnlySpan<byte> as a parameter. This is useful for passing data efficiently to Unreal Engine functions from C#.

```csharp
using UnrealSharp;

public partial class AActorTest : ACharacter
{
    // ... (previous code)

    [UFunction(FunctionFlags.BlueprintCallable)]
    public void TestSpanCall(ReadOnlySpan<byte> span)
    {
        PrintString($"Span Length: {span.Length}");
    }
}
```

--------------------------------

### Convert ETraceChannel to ETraceTypeQuery for Line Tracing in C#

Source: https://www.unrealsharp.com/gameplay-systems/trace-channels

Demonstrates converting an ETraceChannel enum value to an ETraceTypeQuery for use with the LineTraceByChannel function. This allows for more readable and maintainable collision detection code in C#.

```csharp
ETraceTypeQuery traceChannel = ETraceChannel.Camera.ToQuery();
SystemLibrary.LineTraceByChannel(this, start, end, traceChannel, false, actors, EDrawDebugTrace.None, out FHitResult hit, true);
```

--------------------------------

### Async Load List of Soft References (C#)

Source: https://www.unrealsharp.com/data-and-asset-management/loading-soft-references

Loads a list of soft object or class references asynchronously. Each reference is loaded in the background and returned once ready. Handles null references by throwing an exception.

```csharp
var loadedReferences = await softReferences.LoadAsync();
```

--------------------------------

### Include UnrealSharp.StaticVars in C# Project

Source: https://www.unrealsharp.com/gameplay-systems/static-variables

This XML snippet shows how to reference the UnrealSharp.StaticVars assembly in your C# project file (.csproj). This is necessary to enable the use of UnrealSharp's static variable management classes.

```xml
<Reference Include="UnrealSharp.StaticVars">
  <HintPath>..\..\Plugins\UnrealSharp\Binaries\Managed\$(TargetFramework)\UnrealSharp.StaticVars.dll</HintPath>
</Reference>
```

--------------------------------

### Generated C# Extension Methods for UnrealSharp

Source: https://www.unrealsharp.com/glue-generation/extension-methods

Shows the C# code generated by UnrealSharp from the C++ extension method definitions. These methods are static and use the `this` keyword for the extended type, allowing them to be called as instance methods.

```csharp
public static class CSharpForUEExtensions
{
    
    /// <summary>
    /// Example of an extension method that takes a float parameter
    /// public static void ExtensionMethod2(this Actor actor, float value)
    /// </summary>
    public static void ExtensionMethod2(this UnrealSharp.Engine.Actor actor, float value)
    {
        UnrealSharp.CSharpForUE.CSTestExtensions.ExtensionMethod2(actor, value);
    }
    
    /// <summary>
    /// Example of an extension method that takes an int parameter
    /// public static void ExtensionMethod1(this Actor actor, int value)
    /// </summary>
    public static void ExtensionMethod1(this UnrealSharp.Engine.Actor actor, int value)
    {
        UnrealSharp.CSharpForUE.CSTestExtensions.ExtensionMethod1(actor, value);
    }
}

```

--------------------------------

### Use IList as TArray in UFunction (C#)

Source: https://www.unrealsharp.com/data-and-asset-management/collections/tarray

Shows how to use an IList as a TArray within a UFunction in UnrealSharp. This allows Blueprint to interact with array-like structures. The function takes an IList of strings and prints its count.

```csharp
using UnrealSharp;
using System.Collections.Generic;

[UFunction(FunctionFlags.BlueprintCallable)]
public void TestList(IList<string> myList)
{
    PrintString($"List Count: {myList.Count}");
}
```

--------------------------------

### Expose C# Record Struct to Unreal Engine

Source: https://www.unrealsharp.com/unreal-framework/structs

Illustrates exposing a C# record struct to Unreal Engine. Similar to regular structs, record structs require the `[UStruct]` attribute and `partial` declaration. Properties can be defined directly in the record's primary constructor using field attributes.

```csharp
using UnrealSharp;

[UStruct]
public partial record struct FMyDemoStruct([field: UProperty(PropertyFlags.EditAnywhere)] int MyInt, 
                                   [field: UProperty(PropertyFlags.EditAnywhere)] string MyString)
```

--------------------------------

### Declare Replicated Property in C#

Source: https://www.unrealsharp.com/gameplay-systems/multiplayer/replicated-properties

Demonstrates how to declare a property as replicated in C# using the [UProperty] attribute with the PropertyFlags.Replicated flag. This ensures the property's value is synchronized from the server to all clients.

```csharp
[UProperty(PropertyFlags.Replicated)]
public partial int MyReplicatedInteger { get; set; }
```

--------------------------------

### Async Load Single Soft Reference (C#)

Source: https://www.unrealsharp.com/data-and-asset-management/loading-soft-references

Loads a single soft object or class reference asynchronously. If the reference is null, an exception is thrown. If already loaded, it returns immediately; otherwise, it loads in the background.

```csharp
var loadedReference = await softReference.LoadAsync();
```

--------------------------------

### Generate C# Property from C++ Getters/Setters

Source: https://www.unrealsharp.com/unreal-framework/classes/properties/c%2B%2B-functions-as-c-properties

Demonstrates how UnrealSharp converts C++ getter and setter functions into a C# property. The C++ functions define the underlying logic, while the generated C# property provides a more idiomatic way to access and modify values.

```csharp
/** Returns the game instance object  */
UFUNCTION(BlueprintPure, Category="Game", meta=(WorldContext="WorldContextObject"))
static ENGINE_API class UGameInstance* GetGameInstance(const UObject* WorldContextObject);
```

```cpp
UFUNCTION(BlueprintCallable)
void SetTestValue(int32 Value);

UFUNCTION(BlueprintCallable)
int32 GetTestValue();
```

```csharp
public int TestValue
{
    get
    {
        unsafe
        {
            byte* ParamsBufferAllocation = stackalloc byte[GetTestValue_ParamsSize];
            nint ParamsBuffer = (nint) ParamsBufferAllocation;
            UStructExporter.CallInitializeStruct(GetTestValue_NativeFunction, ParamsBuffer);
            
            UObjectExporter.CallInvokeNativeFunction(NativeObject, GetTestValue_NativeFunction, ParamsBuffer);
            
            int returnValue;
            returnValue = BlittableMarshaller<int>.FromNative(IntPtr.Add(ParamsBuffer, GetTestValue_ReturnValue_Offset), 0);
            
            return returnValue;
        }
    }
    set
    {
        unsafe
        {
            byte* ParamsBufferAllocation = stackalloc byte[SetTestValue_ParamsSize];
            nint ParamsBuffer = (nint) ParamsBufferAllocation;
            UStructExporter.CallInitializeStruct(SetTestValue_NativeFunction, ParamsBuffer);
            BlittableMarshaller<int>.ToNative(IntPtr.Add(ParamsBuffer, SetTestValue_Value_Offset), 0, value);
            
            UObjectExporter.CallInvokeNativeFunction(NativeObject, SetTestValue_NativeFunction, ParamsBuffer);
            
        }
    }
}
```

--------------------------------

### Declare TSet as UProperty in C#

Source: https://www.unrealsharp.com/data-and-asset-management/collections/tset

Demonstrates declaring a TSet as a UProperty in UnrealSharp. This allows the set to be visible and editable in the Unreal Engine editor and accessible via Blueprints. It requires the `UClass` and `UProperty` attributes.

```csharp
[UClass]
public partial class AMyShowcaseClass : AActor
{
    [UProperty(PropertyFlags.EditAnywhere | PropertyFlags.BlueprintReadWrite)]
    public partial TSet<int> MySet { get; set; }

    public override void BeginPlay()
    {
        base.BeginPlay();

        MySet.Add(1);
        MySet.Add(2);
    }    
}
```

--------------------------------

### Use TSet as ISet in UFunction in C#

Source: https://www.unrealsharp.com/data-and-asset-management/collections/tset

Illustrates how to use a TSet as an ISet within a UFunction in UnrealSharp. This enables passing set data to functions that can be called from Blueprints. The function takes an `ISet<int>` as a parameter and prints its count.

```csharp
[UFunction(FunctionFlags.BlueprintCallable)]
public void TestSet(ISet<int> MySet)
{
    PrintString($"Set Count: {MySet.Count}");
}
```

--------------------------------

### C# Property Getter Implementation (UnrealSharp)

Source: https://www.unrealsharp.com/unreal-framework/classes/properties/c%2B%2B-properties-with-getters-setters

This C# code demonstrates how UnrealSharp implements a property getter that calls a native C++ function. It uses unsafe code and stack allocation for efficient parameter passing and function invocation, retrieving the value via a native marshaller.

```csharp
public UnrealSharp.Engine.USceneComponent RootComponent
{
    get
    {
        unsafe
        {
            byte* ParamsBufferAllocation = stackalloc byte[K2_GetRootComponent_ParamsSize];
            nint ParamsBuffer = (nint) ParamsBufferAllocation;
            UStructExporter.CallInitializeStruct(K2_GetRootComponent_NativeFunction, ParamsBuffer);
            
            UObjectExporter.CallInvokeNativeFunction(NativeObject, K2_GetRootComponent_NativeFunction, ParamsBuffer);
            
            UnrealSharp.Engine.USceneComponent returnValue;
            returnValue = ObjectMarshaller<UnrealSharp.Engine.USceneComponent>.FromNative(IntPtr.Add(ParamsBuffer, K2_GetRootComponent_ReturnValue_Offset), 0);
            
            return (UnrealSharp.Engine.USceneComponent)returnValue;
        }
    }
}
```

--------------------------------

### Define Custom Log Categories in C#

Source: https://www.unrealsharp.com/getting-started-and-fundamentals/logging

Use the `[CustomLog]` attribute on a partial static class to define custom log categories for the Unreal Engine output log. This automatically generates logging methods like `Log`, `LogWarning`, `LogError`, and `LogFatal`. The default verbosity is `ELogVerbosity.Display` unless specified otherwise.

```csharp
[CustomLog]
public static partial class LogMyFirstLog;

[CustomLog(ELogVerbosity.Verbose)]
public static partial class LogMySecondLog;
```

--------------------------------

### Define C# Interface with UInterface and UFunction in UnrealSharp

Source: https://www.unrealsharp.com/unreal-framework/interfaces

This snippet demonstrates how to define an interface in C# for UnrealSharp. It uses the `UInterface` attribute to mark the interface and `UFunction` with `BlueprintEvent` flags for methods intended to be callable from Blueprints. The interface `IInteractable` includes methods for interaction.

```csharp
[UInterface]
public interface IInteractable
{
    [UFunction(FunctionFlags.BlueprintEvent)]
    public bool OnInteract();

    [UFunction(FunctionFlags.BlueprintEvent)]
    public bool StopInteract();
}
```

--------------------------------

### Declare Widget Class Reference in UnrealSharp

Source: https://www.unrealsharp.com/ui/widgets/show-widget-on-screen

This C# code snippet shows how to declare a UProperty of type TSubclassOf<UMyWidget>. This allows you to select a specific Widget Blueprint class from a dropdown in the Unreal Editor, serving as a reference for spawning widgets.

```csharp
[UClass]
public partial class AMyCharacter : ACharacter
{
    [UProperty(PropertyFlags.EditDefaultsOnly)]
    protected partial TSubclassOf<UMyWidget> MyWidgetClass { get; set; }
}
```

--------------------------------

### Use TMap as IDictionary in UFunction C#

Source: https://www.unrealsharp.com/data-and-asset-management/collections/tmap

Shows how to use a TMap as an IDictionary within a UFunction in UnrealSharp. This enables passing and manipulating map-like data structures through Unreal Engine's function call system, particularly useful for Blueprint integration. Requires the `UFunction` attribute.

```csharp
using UnrealSharp;
using UnrealSharp.CoreUObject;
using System.Collections.Generic;

// Assuming this is part of a UClass
public partial class AMyShowcaseClass : AActor
{
    [UFunction(FunctionFlags.BlueprintCallable)]
    public void TestDictionary(IDictionary<string, string> MyDict)
    {
        PrintString($"Dictionary Key Count: {MyDict.Keys.Count}");
    }

    // Helper function to simulate PrintString if not available in this context
    private void PrintString(string message)
    {
        // In a real Unreal Engine context, this would use UE's logging mechanism.
        // For demonstration, we can just log to console or a placeholder.
        System.Console.WriteLine(message);
    }
}
```

--------------------------------

### C# Custom Getter/Setter with UProperty

Source: https://www.unrealsharp.com/unreal-framework/classes/properties/custom-c-getter-setter

This snippet demonstrates how to implement custom getter and setter logic for a C# property using the UProperty attribute. The property 'Score' is marked as BlueprintReadOnly and includes logic within its setter to call the 'Win()' function when the score reaches 10. This allows for controlled access and modification of properties from blueprints.

```csharp
private int _score;

[UProperty(PropertyFlags.BlueprintReadOnly)]
public int Score
{
    get { return _score; }
    set 
    {
        _score = value;
        
        if (_score == 10)
        {
            Win();
        }
    }
}
```
Tokens:
Raw