Example Implementations

This page gives practical examples of how to use the Respawn Manager in common gameplay scenarios:

Resource nodes (trees, rocks, ore)
Loot chests
Foliage-based harvestables
Enemy spawners
Traps / destructibles

Use these as templates and adapt to your own systems.

1. Resource Node — Tree (Blueprint)

A classic “harvest → wait → regrow” pattern.

Setup

Blueprint: BP_TreeNode

Components:
- StaticMesh (TreeMesh)
- LootComponent (optional, for logs, sticks, sap)
Variables:
- RespawnTime (float, e.g. 300.0)
- bHasBeenHarvested (bool)

Implements BPI_Respawnable.

On Harvest (Blueprint)

Event OnHarvested
   ↓
Branch: bHasBeenHarvested?
   True  → Return
   False →
       Set bHasBeenHarvested = true
       ↓
       LootComponent → Generate Loot
           → For each item → Add to player inventory / Spawn world items
       ↓
       TreeMesh → Set Visibility(false)
       TreeMesh → Set Collision Enabled(NoCollision)
       Disable interaction (if you use an interaction component)
       ↓
       Get World Subsystem (RespawnManagerSubsystem)
           → Register Respawn Request
               Target Actor = Self
               Delay        = RespawnTime

On Respawn (Blueprint)

Event OnRespawnRequested  (from BPI_Respawnable)
   ↓
Set bHasBeenHarvested = false
LootComponent → Reset Loot
TreeMesh → Set Visibility(true)
TreeMesh → Set Collision Enabled(QueryAndPhysics)
Enable interaction

That’s a full, renewable tree node.

2. Resource Node — Ore Vein (C++)

UCLASS()
class YOURGAME_API AOreNode : public AActor, public IRespawnable
{
    GENERATED_BODY()

public:
    AOreNode();

    void OnHarvested(APlayerController* Harvester);

    // IRespawnable
    virtual void OnRespawnRequested() override;

protected:
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* Mesh;

    UPROPERTY(VisibleAnywhere)
    ULootComponent* LootComponent;

    UPROPERTY(EditAnywhere, Category="Respawn")
    float RespawnTime = 240.0f;

    bool bHarvested = false;
};

Source

AOreNode::AOreNode()
{
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>("Mesh");
    RootComponent = Mesh;

    LootComponent = CreateDefaultSubobject<ULootComponent>("LootComponent");
}

void AOreNode::OnHarvested(APlayerController* Harvester)
{
    if (bHarvested) return;
    bHarvested = true;

    // Generate loot
    if (LootComponent && Harvester)
    {
        FLootResult Loot = LootComponent->GenerateLoot();

        if (AMyCharacter* Character = Cast<AMyCharacter>(Harvester->GetPawn()))
        {
            for (const FLootedItem& Item : Loot.SpawnedItems)
            {
                Character->InventoryComponent->AddItem(Item.ItemData, Item.Quantity);
            }
        }
    }

    // Disable visuals and collision
    Mesh->SetVisibility(false);
    Mesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);

    // Register respawn
    if (URespawnManagerSubsystem* RM = GetWorld()->GetSubsystem<URespawnManagerSubsystem>())
    {
        RM->RegisterRespawnRequest(this, RespawnTime);
    }
}

void AOreNode::OnRespawnRequested()
{
    bHarvested = false;

    if (LootComponent)
    {
        LootComponent->ResetLoot();
    }

    Mesh->SetVisibility(true);
    Mesh->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
}

3. Respawnable Loot Chest (Blueprint)

Chest that refills over time.

Setup

Blueprint: BP_RespawnChest

Components:
- StaticMesh (ChestMesh)
- LootComponent
Variables:
- RespawnTime
- bIsOpen (bool)

Implements BPI_Respawnable.

On Chest Opened (Blueprint)

Event OnChestOpened
   ↓
Branch: bIsOpen?
   True  → Return (already open / on cooldown)
   False →
       Set bIsOpen = true
       ↓
       LootComponent → Generate Loot
           → Give items to player
       ↓
       Play "open" animation or swap mesh
       Disable interaction
       ↓
       Get World Subsystem (RespawnManagerSubsystem)
           → Register Respawn Request
               Target Actor = Self
               Delay        = RespawnTime

On Respawn (Blueprint)

Event OnRespawnRequested
   ↓
Set bIsOpen = false
LootComponent → Reset Loot
Play "close" animation or swap back to closed mesh
Enable interaction

This gives you a camp/world chest that periodically refills.

4. Foliage Harvest (Instance-Based) + Respawn (C++ Pseudocode)

For truly instanced foliage via UHierarchicalInstancedStaticMeshComponent:

On Harvest (C++ Pseudocode in FoliageInteractionManager)

void UFoliageInteractionManager::HandleHarvest(
    UHierarchicalInstancedStaticMeshComponent* HISM,
    int32 InstanceIndex,
    APlayerController* Harvester
)
{
    if (!HISM) return;

    FTransform InstanceTransform;
    HISM->GetInstanceTransform(InstanceIndex, InstanceTransform, true);

    // Remove the instance
    HISM->RemoveInstance(InstanceIndex);

    // (Optional) Generate loot here or via a LootTable reference

    // Build respawn data
    FFoliageRespawnEntry Entry;
    Entry.Component = HISM;
    Entry.Transform = InstanceTransform;
    Entry.FoliageTypeID = TEXT("Bush"); // optional category

    if (URespawnManagerSubsystem* RM = GetWorld()->GetSubsystem<URespawnManagerSubsystem>())
    {
        RM->RegisterFoliageRespawn(Entry, FoliageRespawnTime);
    }
}

On Foliage Respawn (called by Respawn Manager)

void UFoliageInteractionManager::OnFoliageRespawn(const FFoliageRespawnEntry& Entry)
{
    if (!Entry.Component.IsValid())
        return;

    UHierarchicalInstancedStaticMeshComponent* HISM = Entry.Component.Get();
    HISM->AddInstance(Entry.Transform);
}

This keeps foliage purely instanced, with Respawn Manager only scheduling when instances come back.

5. Enemy Spawner with Respawn Manager (C++)

Spawner uses Respawn Manager, enemy uses LootComponent.

Spawner Header

UCLASS()
class YOURGAME_API AEnemySpawner : public AActor, public IRespawnable
{
    GENERATED_BODY()

public:
    AEnemySpawner();

    void OnEnemyDied(AActor* DeadEnemy);

    virtual void OnRespawnRequested() override;

protected:
    UPROPERTY(EditAnywhere, Category="Spawning")
    TSubclassOf<AEnemyBase> EnemyClass;

    UPROPERTY(EditAnywhere, Category="Spawning")
    float RespawnDelay = 60.0f;

    UPROPERTY()
    AEnemyBase* ActiveEnemy;
};

Spawner Source

void AEnemySpawner::OnEnemyDied(AActor* DeadEnemy)
{
    ActiveEnemy = nullptr;

    if (URespawnManagerSubsystem* RM = GetWorld()->GetSubsystem<URespawnManagerSubsystem>())
    {
        RM->RegisterRespawnRequest(this, RespawnDelay);
    }
}

void AEnemySpawner::OnRespawnRequested()
{
    if (!EnemyClass) return;

    FActorSpawnParameters Params;
    Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;

    ActiveEnemy = GetWorld()->SpawnActor<AEnemyBase>(
        EnemyClass,
        GetActorLocation(),
        GetActorRotation(),
        Params
    );

    if (ActiveEnemy)
    {
        ActiveEnemy->SetSpawner(this); // so enemy can call OnEnemyDied
    }
}

Enemy Death (simplified)

void AEnemyBase::Die()
{
    // Handle loot via LootComponent
    FLootResult Loot = LootComponent->GenerateLoot();
    // Spawn WorldItemActors or auto-loot…

    if (Spawner)
    {
        Spawner->OnEnemyDied(this);
    }

    Destroy();
}

This cleanly separates:

LootComponent → what drops
Respawn Manager + Spawner → when a new enemy appears

6. Trap / Destructible with Cooldown (Blueprint)

Example: a spike trap that fires, disables, then resets after a delay.

Setup

Blueprint: BP_SpikeTrap

Components:
- Mesh, Collision, maybe a skeletal mesh for animation
Variables:
- RespawnTime
- bIsActive

Implements BPI_Respawnable.

When Triggered

Event OnTrapTriggered
   ↓
Branch: bIsActive?
   False → Return
   True  →
       Set bIsActive = false
       Play fire animation
       Apply damage to overlapping actors
       Disable collision for a bit (or immediately)
       ↓
       Get RespawnManagerSubsystem
          → Register Respawn Request
             Target Actor = Self
             Delay        = RespawnTime

On Respawn (Reset)

Event OnRespawnRequested
   ↓
Set bIsActive = true
Reset trap animation state (go back to idle)
Enable collision (if needed)

Now the trap behaves like any other timed game element.

7. Quick Checklist for Implementations

When you create a new respawnable:

Decide: Actor-based or foliage-instance based?
Implement “inactive” state (hidden, no collision, no interaction)
On “used/harvested/depleted”:
- Do your game logic (loot / damage / destruction)
- Call RegisterRespawnRequest on the manager
Implement OnRespawnRequested (via interface or Blueprint event):
- Reset flags
- Reset loot / state
- Re-enable visuals, collision, interaction

If you follow that pattern everywhere, everything that “comes back later” in your game will feel consistent and be easy to tune.

Installation & Setup

Core Concepts

Crafting System

Equipment System

Hotbar & Quick Actions

Interaction System

Inventory Component

Loot System

Merchant System

Respawn Manager

Saving & Loading

1. Resource Node — Tree (Blueprint)

Setup

On Harvest (Blueprint)

On Respawn (Blueprint)

2. Resource Node — Ore Vein (C++)

Header

Source

3. Respawnable Loot Chest (Blueprint)

Setup

On Chest Opened (Blueprint)

On Respawn (Blueprint)

4. Foliage Harvest (Instance-Based) + Respawn (C++ Pseudocode)

On Harvest (C++ Pseudocode in FoliageInteractionManager)

On Foliage Respawn (called by Respawn Manager)

5. Enemy Spawner with Respawn Manager (C++)

Spawner Header

Spawner Source

Enemy Death (simplified)

6. Trap / Destructible with Cooldown (Blueprint)

Setup

When Triggered

On Respawn (Reset)

7. Quick Checklist for Implementations

​1. Resource Node — Tree (Blueprint)

​Setup

​On Harvest (Blueprint)

​On Respawn (Blueprint)

​2. Resource Node — Ore Vein (C++)

​Header

​Source

​3. Respawnable Loot Chest (Blueprint)

​Setup

​On Chest Opened (Blueprint)

​On Respawn (Blueprint)

​4. Foliage Harvest (Instance-Based) + Respawn (C++ Pseudocode)

​On Harvest (C++ Pseudocode in FoliageInteractionManager)

​On Foliage Respawn (called by Respawn Manager)

​5. Enemy Spawner with Respawn Manager (C++)

​Spawner Header

​Spawner Source

​Enemy Death (simplified)

​6. Trap / Destructible with Cooldown (Blueprint)

​Setup

​When Triggered

​On Respawn (Reset)

​7. Quick Checklist for Implementations

1. Resource Node — Tree (Blueprint)

Setup

On Harvest (Blueprint)

On Respawn (Blueprint)

2. Resource Node — Ore Vein (C++)

Header

Source

3. Respawnable Loot Chest (Blueprint)

Setup

On Chest Opened (Blueprint)

On Respawn (Blueprint)

4. Foliage Harvest (Instance-Based) + Respawn (C++ Pseudocode)

On Harvest (C++ Pseudocode in FoliageInteractionManager)

On Foliage Respawn (called by Respawn Manager)

5. Enemy Spawner with Respawn Manager (C++)

Spawner Header

Spawner Source

Enemy Death (simplified)

6. Trap / Destructible with Cooldown (Blueprint)

Setup

When Triggered

On Respawn (Reset)

7. Quick Checklist for Implementations