How I think through the systems I build.

NOTE-03 · DEV SESSION 17 MAY 9 2026 · Alchemist TD · Memory & lifetime · Solo · UE5 · C++

Object pooling for enemies

Reusing enemies instead of creating and destroying them.

Alchemist TD gameplay. I spam potions into waves of enemies. This no longer causes an ERROR_ACCESS VIOLATION, as enemy spawning is handled by object pooling

01 · CRASH: EXCEPTION_ACCESS_VIOLATION

Under stress spamming potions into a dense crowd so enemies died rapidly the game crashed:

The cause was a dangling pointer. The spawn timer's lambda held raw pointers to the enemies (and to the spawner itself). When an enemy was destroyed before the timer next fired, that pointer was left pointing at memory that had already been freed so the timer reached for something that no longer existed. The tiny near-zero address is the fingerprint of exactly that.

My first fix was trying to switch the enemy references to TWeakObjectPtr (which invalidates automatically when the object is destroyed) and added IsValid guards. That stopped the crash but it was still guarding against a dangerous situation rather than removing it.

02 · REDESIGNING SPAWN ARCHITECTURE

// fresh actor created every spawn,
// destroyed on death.
void AWaveManager::SpawnSingleEnemy(...)
{
    AEnemyBase* Enemy =
      GetWorld()->SpawnActor<AEnemyBase>(
        EnemyClass, Loc, Rot, Params);
      // ^ heap alloc, every spawn
}
// On death:
Destroy();  // timer may still
            // reach for it

// existing actor checked out of a
// pre-filled pool. no alloc.
void AWaveManager::SpawnSingleEnemy(...)
{
    AEnemyBase* Enemy =
      EnemyPool->GetFromPool(EnemyType);
    if (!Enemy) { /* exhausted */ }
    Enemy->SetActorLocationAndRotation(...);
}
// On death:
EnemyPool->ReturnToPool(this);
       // reset, no destroy

commit bd20f4e · “implement object pooling — replace SpawnActor with pre-spawned enemy pool” · 9 May 2026

The pool itself is a map from each enemy type to an array of reusable enemy instances. The level's enemy types and quantity per enemy to pre-spawn are set in the editor by the designer via the UPROPERTY macro, so adding a new enemy type or level is a simple editor change, not a code change.

/*  UEnemyPoolComponent
 *   Owns all pre-spawned enemy actors for the level.
 *   One array per enemy type; all spawned once at load, then reused. */
private:
    // map:  enemy type  →  reusable instances
    TMap<EEnemyType, TArray<TObjectPtr<AEnemyBase>>> Pool;
public:
    void InitializePool();                  // pre-spawn everything at load
    AEnemyBase* GetFromPool(EEnemyType Type); // check out a free instance
    void ReturnToPool(AEnemyBase* Enemy);   // reset + hand back on death

AEnemyBase* UEnemyPoolComponent::GetFromPool(EEnemyType EnemyType)
{
    TArray<TObjectPtr<AEnemyBase>>* TypePool = Pool.Find(EnemyType);
    if (!TypePool)
    {
        // no pool for this type — was InitializePool called?
        return nullptr;
    }

    // walk this type's array by reference; return first free instance
    for (TObjectPtr<AEnemyBase>& EnemyPtr : *TypePool)
    {
        if (!IsValid(EnemyPtr)) continue;   // skip invalid
        if (EnemyPtr->bIsInUse)  continue;   // skip ones already alive
        Activate(EnemyPtr);
        return EnemyPtr;                     // hand back the real reference
    }

    // nothing free — pool sized too small for this wave
    return nullptr;
}

void UEnemyPoolComponent::ReturnToPool(AEnemyBase* Enemy)
{
    if (!IsValid(Enemy)) return;
    Enemy->GetWorldTimerManager().ClearTimer(Enemy->ChaseTimer);

    Enemy->OnReturnToPool();
    Enemy->CurrentWaypointIndex = 0;
    Enemy->bIsDead        = false;
    Enemy->bMovementHeld  = true;
    Enemy->bIsInUse       = false;
    Enemy->LateralOffset  = 0.f;

    if (IsValid(Enemy->PhaseManagerRef))
    {
        Enemy->PhaseManagerRef->OnPhaseChanged.RemoveDynamic(Enemy, &AEnemyBase::HandlePhaseChanged);
    }
    Enemy->PhaseManagerRef = nullptr;
    Enemy->WaveManagerRef  = nullptr;

    // Stop AI movement
    if (AAIController* AI = Cast<AAIController>(Enemy->GetController()))
    {
        AI->StopMovement();
    }

    // Clear status effects
    if (IsValid(Enemy->StatusEffectComponent))
    {
        Enemy->StatusEffectComponent->OnStatusApplied.RemoveDynamic(Enemy, &AEnemyBase::OnStatusApplied);
        Enemy->StatusEffectComponent->OnStatusExpired.RemoveDynamic(Enemy, &AEnemyBase::OnStatusExpired);
    }

    Deactivate(Enemy);
}

03 · REFLECTION

NOTE-02 · DEV SESSION 29 MAY 18 2026 · Alchemist TD · Search · Vectors · Solo · UE5 · C++

Finding the nearest enemy

Search efficiently.

Alchemist TD: When the objective (teddy in img) is dropped on the ground. The closest enemy rushes to capture it.

// Returns the closest living enemy within Radius of Location.
AEnemyBase* APhaseManager::FindClosestEnemy(FVector Location, float Radius,
                                          AActor* ActorToIgnore) const
{
    // 1 — ask the physics system for only the enemies inside the sphere.
    TArray<FOverlapResult> OverlapResults;
    FCollisionQueryParams QueryParams;
    if (ActorToIgnore) QueryParams.AddIgnoredActor(ActorToIgnore);

    GetWorld()->OverlapMultiByChannel(
        OverlapResults, Location, FQuat::Identity,
        ECC_GameTraceChannel2,                 // the "Enemy" channel only
        FCollisionShape::MakeSphere(Radius), QueryParams);

    // 2 — scan the survivors, keep the closest one.
    //     FLT_MAX = "nothing found yet", so the first real enemy always wins.
    AEnemyBase* ClosestEnemy = nullptr;
    float ClosestDistance = FLT_MAX;

    for (const FOverlapResult& Result : OverlapResults)
    {
        AEnemyBase* Enemy = Cast<AEnemyBase>(Result.GetActor());
        if (!IsValid(Enemy)) continue;   // skip non-enemies / invalid
        if (Enemy->bIsDead)   continue;

        float Distance = FVector::Dist(Enemy->GetActorLocation(), Location);
        if (Distance < ClosestDistance)
        {
            ClosestDistance = Distance;
            ClosestEnemy = Enemy;
        }
    }
    return ClosestEnemy;
}

NOTE-01 · RMIT PROJECT MAY 9 2026 · Thanks Carl · Structs · GROUP · UNITY · C#

ThanksCarl Development Highlights

Virtual Reality - Tower Defense Crafting Potions

01 · DROP TABLE (LOOT CHANCE) LOGIC ABSTRACTION FOR SPAWNING MONSTERS

M.W had built a random drop table for crafting ingredients. I realised the same idea worked for enemies: if it can randomly pick from a table of ingredients and produce one, I could swap the objects for monsters and get a randomised wave composition so every playthrough gives a different mix of enemies, and the player can't lean on one repeated strategy.

I repurposed it into RunMinionDropTable(), spawning monsters into a spawn area at the end of the combat zone, then pushing each one toward a target at the cauldron.

// NEW PICKER WITH WEIGHTING
// swap ingredient logic for a monster drop table, so each
// wave's composition is randomised per playthrough
var monsterPrefab = RunMinionDropTable(wave.minionPrefabsTable);

GameObject m = Instantiate(monsterPrefab, spawnPosition, Quaternion.identity);

// hand the spawned monster its movement target (the cauldron)
EnemyMovement em = m.GetComponent<EnemyMovement>();
em.endzoneTrigger = endZoneVolume;
em.endLookTarget  = endLookTarget;

02 · STRUCTS WITHIN STRUCTS

The waves-and-levels system was the part I'm proudest of from this project, because I was able to create an inspector tool so my teammates could easily edit waves and test the game. A struct lets you define the shape of a wave once, then fill in many of them from the Unity inspector without touching code. A level became an array of waves; each wave carried its own count, batch size, timing, and enemy table.

[Serializable] // Wave config — editable in the inspector
public struct WaveConfig
{
    public string name;
    public Minions[] minionPrefabsTable; // which monsters can appear
    public int totalMinions;              // how many in this wave
    public int batchSize;                 // how many spawn at once
    public float batchInterval;           // time between batches
    public float inBatchSpacing;          // spacing within a batch
}

[Serializable] // Level config — an array of waves + a boss
public struct LevelConfig
{
    public string level;
    public GameObject bossPrefab;
    public int wavesToBoss;
    public WaveConfig[] wave; // many waves per level
}

In the inspector, designers can simply edit waves and levels. As a level is an array of structures including waves, bosses and level environments. A wave is a structure made up of enemies, time and a table of monsters and spawn chances.