Practice Code Typing – SkillsTyping

Choose your language:

ℹ️ Select 'Choose Exercise', or randomize 'Next Random Exercise' in selected language.

Choose Exercise:

Ready

Exercise Algorithm Area

Correct typos to continue.

1class UObjectPoolManager : public UObject
2{
3GENERATED_BODY()
4
5public:
6// The class of actor to be pooled.
7UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Object Pool")
8TSubclassOf<AActor> PooledActorClass;
9
10// The maximum number of actors allowed in the pool.
11UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Object Pool")
12int32 MaxPoolSize = 50;
13
14// The initial number of actors to pre-spawn.
15UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Object Pool")
16int32 InitialPoolSize = 10;
17
18// Delegate to be called when an actor is activated from the pool.
19DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnActorActivated, AActor*, ActivatedActor);
20UPROPERTY(BlueprintAssignable, Category = "Object Pool")
21FOnActorActivated OnActorActivated;
22
23// Delegate to be called when an actor is deactivated and returned to the pool.
24DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnActorDeactivated, AActor*, DeactivatedActor);
25UPROPERTY(BlueprintAssignable, Category = "Object Pool")
26FOnActorDeactivated OnActorDeactivated;
27
28UObjectPoolManager()
29{
30// Ensure PooledActorClass is set by the user.
31}
32
33// Initializes the object pool by pre-spawning actors.
34UFUNCTION(BlueprintCallable, Category = "Object Pool")
35void InitializePool(UWorld* World);
36
37// Retrieves an actor from the pool.
38// If no actors are available, it may spawn a new one if MaxPoolSize is not reached.
39// Returns a valid AActor pointer or nullptr if the pool is exhausted.
40UFUNCTION(BlueprintCallable, Category = "Object Pool")
41AActor* GetPooledActor(FVector Location, FRotator Rotation);
42
43// Returns an actor to the pool.
44// The actor will be deactivated and hidden.
45UFUNCTION(BlueprintCallable, Category = "Object Pool")
46void ReturnPooledActor(AActor* ActorToReturn);
47
48// Clears the pool and destroys all pooled actors.
49UFUNCTION(BlueprintCallable, Category = "Object Pool")
50void ClearPool();
51
52private:
53// Stores available actors that can be reused.
54TArray<AActor*> AvailableActors;
55
56// Stores actors that are currently in use.
57TArray<AActor*> ActiveActors;
58
59// The world context for spawning actors.
60UWorld* OwningWorld = nullptr;
61
62// Helper function to spawn a single actor.
63AActor* SpawnActor(FVector Location, FRotator Rotation);
64
65// Helper function to reset an actor's state before returning it to the pool.
66void ResetActorState(AActor* Actor);
67
68// Helper function to clean up an actor when it's permanently removed from the pool.
69void DestroyActor(AActor* Actor);
70};
71
72void UObjectPoolManager::InitializePool(UWorld* World)
73{
74if (!World || !PooledActorClass)
75{
76UE_LOG(LogTemp, Error, TEXT("ObjectPoolManager: Cannot initialize pool. World or PooledActorClass is invalid."));
77return;
78}
79OwningWorld = World;
80
81// Pre-spawn initial actors.
82for (int32 i = 0; i < InitialPoolSize; ++i)
83{
84if (AvailableActors.Num() < MaxPoolSize)
85{
86AActor* NewActor = SpawnActor(FVector::ZeroVector, FRotator::ZeroRotator);
87if (NewActor)
88{
89AvailableActors.Add(NewActor);
90// Initially hide and deactivate them.
91NewActor->SetActorHiddenInGame(true);
92NewActor->SetActorEnableCollision(false);
93NewActor->SetActorTickEnabled(false);
94}
95}
96else
97{
98break; // Reached max pool size during initialization.
99}
100}
101UE_LOG(LogTemp, Log, TEXT("ObjectPoolManager: Initialized with %d actors. Max size: %d."), AvailableActors.Num(), MaxPoolSize);
102}
103
104AActor* UObjectPoolManager::SpawnActor(FVector Location, FRotator Rotation)
105{
106if (!OwningWorld || !PooledActorClass)
107{
108return nullptr;
109}
110FActorSpawnParameters SpawnParams;
111SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
112AActor* NewActor = OwningWorld->SpawnActor<AActor>(PooledActorClass, Location, Rotation, SpawnParams);
113if (NewActor)
114{
115// Perform initial setup for the spawned actor if needed.
116// For example, getting a specific component.
117}
118return NewActor;
119}
120
121AActor* UObjectPoolManager::GetPooledActor(FVector Location, FRotator Rotation)
122{
123AActor* ActorToActivate = nullptr;
124
125// Try to get an actor from the available pool.
126if (AvailableActors.Num() > 0)
127{
128ActorToActivate = AvailableActors.Pop();
129ActiveActors.Add(ActorToActivate);
130}
131else if (ActiveActors.Num() < MaxPoolSize)
132{
133// If pool is empty but not at max size, spawn a new one.
134ActorToActivate = SpawnActor(Location, Rotation);
135if (ActorToActivate)
136{
137ActiveActors.Add(ActorToActivate);
138}
139}
140else
141{
142// Pool is full and no actors are available.
143UE_LOG(LogTemp, Warning, TEXT("ObjectPoolManager: Pool exhausted. Cannot retrieve actor."));
144return nullptr;
145}
146
147if (ActorToActivate)
148{
149// Reset actor state for reuse.
150ActorToActivate->SetActorLocation(Location);
151ActorToActivate->SetActorRotation(Rotation);
152ActorToActivate->SetActorHiddenInGame(false);
153ActorToActivate->SetActorEnableCollision(true);
154ActorToActivate->SetActorTickEnabled(true);
155// Call a specific reset function on the actor if it exists.
156// e.g., if (ActorToActivate->Implements<IResettableActor>()) { IResettableActor::Execute_Reset(ActorToActivate); }
157OnActorActivated.Broadcast(ActorToActivate);
158}
159
160return ActorToActivate;
161}
162
163void UObjectPoolManager::ReturnPooledActor(AActor* ActorToReturn)
164{
165if (!ActorToReturn || !ActiveActors.Contains(ActorToReturn))
166{
167// Actor is not managed by this pool or is already returned.
168return;
169}
170
171// Remove from active list and add to available list.
172ActiveActors.Remove(ActorToReturn);
173AvailableActors.Add(ActorToReturn);
174
175// Reset actor state and hide it.
176ResetActorState(ActorToReturn);
177ActorToReturn->SetActorHiddenInGame(true);
178ActorToReturn->SetActorEnableCollision(false);
179ActorToReturn->SetActorTickEnabled(false);
180
181OnActorDeactivated.Broadcast(ActorToReturn);
182}
183
184void UObjectPoolManager::ResetActorState(AActor* Actor)
185{
186if (!Actor)
187{
188return;
189}
190// Reset basic transform.
191Actor->SetActorLocation(FVector::ZeroVector);
192Actor->SetActorRotation(FRotator::ZeroRotator);
193
194// Reset components or specific actor properties.
195// This is highly dependent on the type of actor being pooled.
196// For example, resetting health, velocity, timers, etc.
197// A common pattern is to have a virtual Reset() function on the pooled actor class.
198
199// Example: If the pooled actor has a UHealthComponent, reset its health.
200// UHealthComponent* HealthComp = Actor->FindComponentByClass<UHealthComponent>();
201// if (HealthComp)
202// {
203//     HealthComp->ResetHealthToMax(); // Assuming such a function exists
204// }
205}
206
207void UObjectPoolManager::ClearPool()
208{
209for (AActor* Actor : AvailableActors)
210{
211DestroyActor(Actor);
212}
213AvailableActors.Empty();
214
215for (AActor* Actor : ActiveActors)
216{
217DestroyActor(Actor);
218}
219ActiveActors.Empty();
220
221OwningWorld = nullptr;
222UE_LOG(LogTemp, Log, TEXT("ObjectPoolManager: Pool cleared."));
223}
224
225void UObjectPoolManager::DestroyActor(AActor* Actor)
226{
227if (Actor && Actor->IsValidLowLevel())
228{
229Actor->Destroy();
230}
231}

Algorithm description viewbox

Actor Pooling: Object Pool Manager

Algorithm description:

This C++ code implements an `UObjectPoolManager` for Unreal Engine, designed to efficiently manage a pool of reusable actors. Instead of constantly spawning and destroying actors (which can be performance-intensive), this system pre-allocates a set of actors and reuses them. When an actor is needed, it's retrieved from the pool, its state is reset, and it's activated. When no longer needed, it's returned to the pool, deactivated, and hidden. This is commonly used for projectiles, enemies, or other frequently created/destroyed game entities.

Algorithm explanation:

The `UObjectPoolManager` utilizes two `TArray`s: `AvailableActors` for actors ready to be reused, and `ActiveActors` for actors currently in use. `InitializePool` pre-spawns a number of actors up to `InitialPoolSize` and adds them to `AvailableActors`, hiding and deactivating them. `GetPooledActor` first checks `AvailableActors`. If empty, it checks if `MaxPoolSize` is reached; if not, it spawns a new actor. The retrieved actor is then moved to `ActiveActors`, its transform is set, and it's made visible and enabled. `ReturnPooledActor` removes the actor from `ActiveActors`, adds it to `AvailableActors`, resets its state via `ResetActorState`, and hides/disables it. `ResetActorState` is a crucial helper that must be customized based on the pooled actor's type to ensure it's in a clean state for reuse. `ClearPool` destroys all actors managed by the pool. The time complexity for `GetPooledActor` is O(1) on average if actors are available in the pool or if spawning is not limited by `MaxPoolSize`. If the pool is exhausted and `MaxPoolSize` is reached, it returns `nullptr` in O(1). `ReturnPooledActor` is O(1) on average due to `TArray::Remove` and `TArray::Add`. `InitializePool` is O(I) where I is `InitialPoolSize`, and `ClearPool` is O(N) where N is the total number of actors in the pool. Space complexity is O(M) where M is `MaxPoolSize`.

Pseudocode:

Class ObjectPoolManager:
  PooledActorClass (Class)
  MaxPoolSize (int)
  InitialPoolSize (int)
  AvailableActors (Array of Actors)
  ActiveActors (Array of Actors)
  OwningWorld (World)

  Function InitializePool(World):
    Set OwningWorld = World
    For i from 0 to InitialPoolSize-1:
      If AvailableActors.Count < MaxPoolSize:
        Actor = SpawnActor(ZeroLocation, ZeroRotation)
        If Actor is valid:
          Add Actor to AvailableActors
          Hide and Deactivate Actor

  Function SpawnActor(Location, Rotation):
    Spawn actor of PooledActorClass at Location, Rotation
    Return spawned actor

  Function GetPooledActor(Location, Rotation):
    If AvailableActors is not empty:
      Actor = Remove last from AvailableActors
      Add Actor to ActiveActors
    Else if ActiveActors.Count < MaxPoolSize:
      Actor = SpawnActor(Location, Rotation)
      If Actor is valid:
        Add Actor to ActiveActors
      Else:
        Return null
    Else:
      Return null // Pool exhausted

    If Actor is valid:
      Set Actor Location, Rotation
      Make Actor Visible and Enabled
      Broadcast OnActorActivated
    Return Actor

  Function ReturnPooledActor(ActorToReturn):
    If ActorToReturn is not in ActiveActors:
      Return
    Remove ActorToReturn from ActiveActors
    Add ActorToReturn to AvailableActors
    ResetActorState(ActorToReturn)
    Hide and Deactivate ActorToReturn
    Broadcast OnActorDeactivated

  Function ResetActorState(Actor):
    // Reset actor's properties (health, position, etc.)

  Function ClearPool():
    For each Actor in AvailableActors:
      Destroy Actor
    Empty AvailableActors
    For each Actor in ActiveActors:
      Destroy Actor
    Empty ActiveActors
    Set OwningWorld = null

Library

Playable exercises

Choose Exercise

Filter, sort, and preview algorithm before you choose one to play.

Total 8 published items

Pages 1 pages available

Language

Sort by Direction

Browse published coding scenarios with filters, sorting, and pagination.

Published

C++ (Unreal) GameDev (cpp-unreal)

Find Peak Element in Sorted Array

Difficulty: writing: 1; length: 3
Popularity: 0
Created: 2026-01-26 13:59 UTC
Published: 2026-01-26 16:41 UTC
Author: Damian

#binary search #peak finding #array #algorithms #logarithmic time

goal: Find any peak element in an array. input: A TArray<int> named `nums`. output: The index of a peak element.

Canonical Algorithm Text

int FindPeakElement(const TArray<int>& nums) { int left = 0; int right = nums.Num() - 1; while (left < right) { int mid = left + (right - left) / 2; // Check if mid is a peak if (nums[mid] > nums[mid + 1] && nums[mid] > nums[mid - 1]) { return mid; // Found a peak } // If the rig...

Description Algorithm

This function finds a peak element in an array where elements are not necessarily sorted but have the property that nums[i] != nums[i+1]. A peak element is defined as an element that is strictly greater than its neighbor...

Explanation

The algorithm uses binary search to efficiently find a peak element. The key insight is that if an element `nums[mid]` is not a peak, then either its left neighbor or its right neighbor must be greater. If `nums[mid+1]` is greater, a peak must exist in the right half (including `mid+1`). If `nums[mid-1]` is greater (or `nums[mid+1]` is not greater), a peak must exist in the left half (including `mid`). This process halves the search space in each step, leading to a time complexity of O(log n). The space complexity is O(1) as it only uses a few variables. Edge cases like single-element arrays or peaks at the array boundaries are implicitly handled by the loop condition and the way `left` and `right` are updated. The invariant maintained is that a peak element is guaranteed to exist within the `[left, right]` range.

Pseudocode

function FindPeakElement(nums): left = 0 right = length(nums) - 1 while left < right: mid = left + (right - left) / 2 if nums[mid] < nums[mid + 1]: left = mid + 1 else: right = mid return left

Published

C++ (Unreal) GameDev (cpp-unreal)

Implement a Doubly Linked List with Basic Operations

Difficulty: writing: 10; length: 10
Popularity: 0
Created: 2026-01-26 13:59 UTC
Published: 2026-01-26 16:41 UTC
Author: Damian

#linked list #data structures #C++ #pointers #memory management

goal: Implement a Doubly Linked List with core operations. input: Various integer values for operations. output: Modified list state or boolean indicating success/failure.

Canonical Algorithm Text

class Node { public: int data; Node* next; Node* prev; Node(int val) : data(val), next(nullptr), prev(nullptr) {} }; class DoublyLinkedList { private: Node* head; Node* tail; int count; public: DoublyLinkedList() : head(nullptr), tail(nullptr), count(0) {} ~DoublyLinkedList() { N...

Description Algorithm

This C++ code defines a Doubly Linked List data structure with essential operations. A doubly linked list allows traversal in both forward and backward directions. It's commonly used in scenarios requiring efficient inse...

Explanation

The Doubly Linked List implementation involves a `Node` struct with `data`, `next`, and `prev` pointers, and a `DoublyLinkedList` class managing `head`, `tail`, and `count`. Insertion at the beginning and end involves creating a new node and carefully updating pointers of the new node and the existing head/tail. Deletion by value requires traversing the list, finding the node, and then reconnecting the `prev` and `next` pointers of its neighbors, with special handling for deleting the head or tail. Searching is a simple linear traversal. The destructor iterates through the list, deleting each node to prevent memory leaks. Time complexity for insertion, deletion, and search is O(n) in the worst case (traversing the list), but O(1) for insertion at head/tail if the pointers are maintained. Space complexity is O(n) to store n elements. Edge cases like an empty list, deleting the only node, or deleting the head/tail are handled explicitly to ensure pointer integrity.

Pseudocode

class Node: data next_pointer prev_pointer class DoublyLinkedList: head_pointer tail_pointer size_count function InsertAtBeginning(value): create newNode with value if list is empty: set head = newNode set tail = newNode...

Published

C++ (Unreal) GameDev (cpp-unreal)

Network Replication: Reliable RPC Parameter Serialization

Difficulty: writing: 8; length: 10
Popularity: 0
Created: 2026-01-26 12:29 UTC
Published: 2026-01-26 13:43 UTC
Author: Admin

#network replication #rpc #serialization #unreal engine #data structures

goal: Serialize and deserialize complex data for network transmission. input: A struct containing various data types, and a byte array buffer. output: A populated byte array (serialization) or a populated struct (deserialization).

Canonical Algorithm Text

struct FReplicatedData { int32 IntValue; float FloatValue; FString StringValue; TArray<int32> IntArray; TArray<FString> StringArray; FVector NestedVector; // Default constructor FReplicatedData() : IntValue(0), FloatValue(0.0f), NestedVector(FVector::ZeroVector) {} }; // Helper f...

Description Algorithm

This C++ code provides functions for serializing and deserializing a custom struct (`FReplicatedData`) into and from a byte array. This is a fundamental technique for network communication, particularly for sending compl...

Explanation

The `SerializeReplicatedData` function takes an `FReplicatedData` struct and appends its members, in a specific order, to a `TArray<uint8>` buffer. For primitive types like `int32` and `float`, it directly appends their byte representations. For strings, it first serializes their length and then their character data. Arrays are serialized by first writing the number of elements, followed by each element's serialized form. The `DeserializeReplicatedData` function reverses this process. It reads data from the buffer sequentially, using an `Offset` to track the current position. It first reads the size of each element (like string length or array size) and then reads the actual data. Crucially, both functions must use the exact same order and data types for serialization and deserialization to maintain data integrity. Error checking is performed at each step to ensure the buffer is not read past its bounds and that lengths are valid. The time complexity for both serialization and deserialization is O(S), where S is the total size of the data being serialized/deserialized, as each byte is processed. Space complexity is O(S) for storing the serialized buffer.

Pseudocode

Struct ReplicatedData: IntValue (int) FloatValue (float) StringValue (string) IntArray (array of int) StringArray (array of string) NestedVector (Vector) Function SerializeReplicatedData(Buffer, Data): Append Data.IntVal...

Published

C++ (Unreal) GameDev (cpp-unreal)

GAS: Ability Activation Cooldown Manager

Difficulty: writing: 2; length: 9
Popularity: 0
Created: 2026-01-26 12:29 UTC
Published: 2026-01-26 13:43 UTC
Author: Admin

#gameplay ability system #cooldown management #unreal engine #data structures #time tracking

goal: Manage ability cooldowns for a game. input: Ability tags, cooldown durations, current game time. output: Boolean indicating if ability is on cooldown, remaining cooldown time.

Canonical Algorithm Text

class UAbilityCooldownManager { public: // Stores the time when each ability's cooldown will end. // Key: Ability Tag, Value: End Cooldown Time (Game Time) TMap<FGameplayTag, float> CooldownEndTimes; // Constructor UAbilityCooldownManager() { // Initialize any default settings if...

Description Algorithm

This C++ code implements a cooldown manager for Unreal Engine's Gameplay Ability System. It allows developers to track and manage cooldowns for various player abilities. The system uses a map to store when each ability's...

Explanation

The `UAbilityCooldownManager` class uses a `TMap` to store the expiration time for each ability's cooldown. The keys are `FGameplayTag`s representing abilities, and the values are `float`s representing the game time at which the cooldown ends. The `ApplyCooldown` function adds or updates an entry in the map, calculating the end time based on the current game time and cooldown duration. `IsAbilityOnCooldown` checks if the current game time is before the stored end time for a given ability. `GetRemainingCooldownTime` calculates the difference between the end time and current time, ensuring it's not negative. `TickCooldowns` iterates through the map and removes entries where the cooldown has expired. Edge cases like zero or negative cooldown durations are handled by immediately removing the cooldown. Floating-point precision is managed by comparing current time against the end time. The time complexity for `ApplyCooldown`, `IsAbilityOnCooldown`, `RemoveCooldown`, and `GetRemainingCooldownTime` is typically O(1) on average due to the hash-based nature of `TMap`. `TickCooldowns` has a time complexity of O(N), where N is the number of active cooldowns, as it may iterate through all entries. Space complexity is O(M), where M is the number of abilities that can have a cooldown simultaneously.

Pseudocode

Class AbilityCooldownManager: Map CooldownEndTimes (Tag -> EndTime) Function ApplyCooldown(AbilityTag, Duration, CurrentTime): If Duration <= 0: RemoveCooldown(AbilityTag) Return EndTime = CurrentTime + Duration Add/Upda...

Published

C++ (Unreal) GameDev (cpp-unreal)

Gameplay Ability System: Ability Activation Conditions

Difficulty: writing: 2; length: 4
Popularity: 0
Created: 2026-01-26 12:29 UTC
Published: 2026-01-26 13:43 UTC
Author: Admin

#gameplay ability system #unreal engine #ability activation #resource management #basic logic

goal: Check if a character has sufficient resources for an ability. input: Ability System Component, required health percentage, required mana percentage. output: Boolean: true if conditions are met, false otherwise.

Canonical Algorithm Text

class UAbilitySystemComponent; // Checks if a character has enough health and mana to activate an ability. // ASC: The Ability System Component of the character. // RequiredHealth: The minimum health percentage required (0.0 to 1.0). // RequiredMana: The minimum mana percentage r...

Description Algorithm

This C++ code provides a basic function `CanActivateAbilityBasic` to determine if a character can activate a gameplay ability. It checks if the character's current health and mana (represented as percentages) meet the mi...

Explanation

The `CanActivateAbilityBasic` function takes an `UAbilitySystemComponent` pointer and the required health and mana percentages as input. It first validates that the `ASC` pointer is valid. Then, it calculates the current health percentage by dividing `ASC->GetHealth()` by `ASC->GetMaxHealth()`. If this current percentage is less than the `RequiredHealthPercent`, the function immediately returns `false`. If the health condition is met, it proceeds to calculate the current mana percentage using `ASC->GetMana()` and `ASC->GetMaxMana()`. If this is less than `RequiredManaPercent`, it returns `false`. If both health and mana conditions are satisfied, the function returns `true`, indicating that the ability can be activated. The time complexity is O(1) because it performs a fixed number of arithmetic operations and comparisons, regardless of the character's state. The space complexity is also O(1) as it only uses a few local variables.

Pseudocode

Function CanActivateAbilityBasic(ASC, RequiredHealthPercent, RequiredManaPercent): If ASC is null: Return false CurrentHealthPercent = ASC.GetHealth() / ASC.GetMaxHealth() If CurrentHealthPercent < RequiredHealthPercent:...

Published

C++ (Unreal) GameDev (cpp-unreal)

Actor Pooling: Object Pool Manager

Difficulty: writing: 4; length: 10
Popularity: 0
Created: 2026-01-26 12:29 UTC
Published: 2026-01-26 13:43 UTC
Author: Admin

#actor pooling #unreal engine #performance #object management #game development

goal: Manage a pool of reusable actors for performance optimization. input: Actor class to pool, desired location/rotation for retrieval. output: A retrieved and activated actor, or null if pool is exhausted.

Canonical Algorithm Text

class UObjectPoolManager : public UObject { GENERATED_BODY() public: // The class of actor to be pooled. UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Object Pool") TSubclassOf<AActor> PooledActorClass; // The maximum number of actors allowed in the pool. UPROPERTY(Edit...

Description Algorithm

This C++ code implements an `UObjectPoolManager` for Unreal Engine, designed to efficiently manage a pool of reusable actors. Instead of constantly spawning and destroying actors (which can be performance-intensive), thi...

Explanation

The `UObjectPoolManager` utilizes two `TArray`s: `AvailableActors` for actors ready to be reused, and `ActiveActors` for actors currently in use. `InitializePool` pre-spawns a number of actors up to `InitialPoolSize` and adds them to `AvailableActors`, hiding and deactivating them. `GetPooledActor` first checks `AvailableActors`. If empty, it checks if `MaxPoolSize` is reached; if not, it spawns a new actor. The retrieved actor is then moved to `ActiveActors`, its transform is set, and it's made visible and enabled. `ReturnPooledActor` removes the actor from `ActiveActors`, adds it to `AvailableActors`, resets its state via `ResetActorState`, and hides/disables it. `ResetActorState` is a crucial helper that must be customized based on the pooled actor's type to ensure it's in a clean state for reuse. `ClearPool` destroys all actors managed by the pool. The time complexity for `GetPooledActor` is O(1) on average if actors are available in the pool or if spawning is not limited by `MaxPoolSize`. If the pool is exhausted and `MaxPoolSize` is reached, it returns `nullptr` in O(1). `ReturnPooledActor` is O(1) on average due to `TArray::Remove` and `TArray::Add`. `InitializePool` is O(I) where I is `InitialPoolSize`, and `ClearPool` is O(N) where N is the total number of actors in the pool. Space complexity is O(M) where M is `MaxPoolSize`.

Pseudocode

Class ObjectPoolManager: PooledActorClass (Class) MaxPoolSize (int) InitialPoolSize (int) AvailableActors (Array of Actors) ActiveActors (Array of Actors) OwningWorld (World) Function InitializePool(World): Set OwningWor...

Published

C++ (Unreal) GameDev (cpp-unreal)

AI: Behavior Tree Node Prioritization

Difficulty: writing: 1; length: 8
Popularity: 0
Created: 2026-01-26 12:29 UTC
Published: 2026-01-26 13:43 UTC
Author: Admin

#ai #behavior trees #game development #algorithms #recursion

goal: Find the most relevant AI action node in a Behavior Tree. input: The root node of a Behavior Tree. output: The highest priority executable Behavior Tree node, or null if none found.

Canonical Algorithm Text

struct FBehaviorTreeNode { FString NodeName; TArray<TSharedPtr<FBehaviorTreeNode>> Children; TFunction<bool(void)> Condition; bool bIsComposite = false; // For composite nodes, specify type: 0=Selector, 1=Sequence int CompositeType = 0; FBehaviorTreeNode(FString Name, TFunction<b...

Description Algorithm

This C++ code defines a simplified AI Behavior Tree structure and a function to find the highest priority executable branch. It simulates how an AI might decide which action to take next by traversing a tree of condition...

Explanation

The `FindHighestPriorityBranch` function recursively traverses a simplified Behavior Tree. It starts at the `RootNode`. If the node has a condition and it fails, it returns `nullptr`. For leaf nodes (Tasks), it returns the node if its condition is met or if it has no condition. For composite nodes, it behaves as follows: a Selector node iterates through its children and returns the first one for which `FindHighestPriorityBranch` returns a non-null result. A Sequence node iterates through its children, and if all children can potentially execute (i.e., `FindHighestPriorityBranch` returns a non-null result for each), it returns the last successfully evaluated child. The time complexity is proportional to the number of nodes visited in the worst case, which can be O(N) where N is the total number of nodes in the tree. In a balanced tree, it might be closer to O(log N) if conditions frequently prune branches. Space complexity is O(H) due to the recursion depth, where H is the height of the Behavior Tree. Edge cases include an empty tree (`RootNode` is null), nodes with no conditions, and composite nodes with no children.

Pseudocode

Function FindHighestPriorityBranch(Node): If Node is null: Return null If Node has a Condition and Condition is false: Return null If Node is a Task: If Node has a Condition and Condition is true: Return Node Else if Nod...

Published

C++ (Unreal) GameDev (cpp-unreal)

Actor Components: Health Component Damage Calculation

Difficulty: writing: 3; length: 7
Popularity: 0
Created: 2026-01-26 12:29 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#actor components #unreal engine #damage calculation #health system #gameplay logic

goal: Calculate and apply damage to an actor, considering defenses. input: Base damage amount, damage type string. output: The final calculated damage after mitigation.

Canonical Algorithm Text

class UHealthComponent : public UActorComponent { GENERATED_BODY() public: // Current health of the actor. UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Health") float CurrentHealth; // Maximum health of the actor. UPROPERTY(EditAnywhere, BlueprintReadWrite, Category =...

Description Algorithm

This C++ code defines a `UHealthComponent` for Unreal Engine actors, managing their health and defense. The core functionality is the `TakeDamage` function, which calculates the final damage dealt to an actor after apply...

Explanation

The `UHealthComponent` class manages an actor's health and defense. The `TakeDamage` function is the primary logic for calculating damage. It first checks if the `BaseDamage` is valid (greater than 0). It then determines the `DamageMitigation` based on the `DamageType` (case-insensitively compared to "physical" or "magical"), applying `Armor` or `MagicResistance` respectively. The `FinalDamage` is calculated by subtracting mitigation from base damage, with a minimum of 1 damage to prevent trivial negation. This `FinalDamage` is then subtracted from `CurrentHealth`, ensuring health does not drop below 0. The `Heal` function increases `CurrentHealth` up to `MaxHealth`. `IsDead` simply checks if `CurrentHealth` is 0 or less. The time complexity for `TakeDamage`, `Heal`, and `IsDead` is O(1) as they involve a fixed number of arithmetic operations and comparisons. Space complexity is O(1) as it only uses a few member variables.

Pseudocode

Class HealthComponent: CurrentHealth, MaxHealth, Armor, MagicResistance Function TakeDamage(BaseDamage, DamageType): If BaseDamage <= 0: Return 0 Mitigation = 0 LowercaseDamageType = ToLowercase(DamageType) If LowercaseD...

Language (required)

Paste your code (required)

Max 20,000 characters. (Dangerous HTML/script fragments will be blocked)

Normalized preview:

I agree to Publish this, after admin approval (queued for review). (Not required) I confirm this submission is anonymous and does not contain personal data. I grant SkillsTyping a free, non-exclusive, worldwide, and irrevocable license to store, modify, adapt, and publish this content after review. I understand that publication is not guaranteed, that I retain no ownership or usage claims over published versions, and that no compensation will be provided. See Privacy Policy

Publish details

Shown only if you opt to submit for review. Required when consent is checked.

Title (required with consent)

Short description / summary (required with consent)

Algorithm explanation (required with consent)

Pseudocode (required with consent)