The Drop-Off Pile: Home Location and Pyramid Stacking

The last beat of the loop is the satisfying one: the worker reaches home, drops its haul, and the pile grows by one, neatly. This card covers where “home” is and how items stack without turning into a heap. It closes Resource Gathering AI in Unreal Engine and follows The carried resource, which produces the items that land here.

Where home is

Every worker has a CharacterHomeLocation. It is set when the assignment begins: either the value you pass to TryBeginAssignment, or, if you pass FVector::ZeroVector, a line trace straight down from the character’s feet onto the ground (covered in the Gatherer component). The Behavior Tree reads it back through a small task that writes it to the HomeLocation Blackboard key, and the worker’s second move-to walks there:

Home does not have to be fixed. UpdateAssignmentHome lets a player relocate it under the cursor, and a Server RPC moves both the value and the marker:

void UGathererComponent::UpdateAssignmentHome()
{
    APlayerController* PC = GetWorld()->GetFirstPlayerController();
    FHitResult HitResult;
    if (PC && PC->GetHitResultUnderCursor(ECC_Visibility, false, HitResult))
    {
        CharacterHomeLocation = HitResult.Location;
        Server_UpdateAssignmentHome(HitResult.Location);   // moves the spawned home actor too
    }
}

The home marker

Each assignment can name an optional Home Actor, a banner or flag, spawned at the home location when the assignment starts so players can see where a worker drops. It is spawned replicated and follows the home location if you move it:

if (ActiveAssignment.HomeActor)
{
    SpawnedHomeActor = GetWorld()->SpawnActor<AActor>(
        ActiveAssignment.HomeActor, CharacterHomeLocation, FRotator::ZeroRotator, SpawnParams);
    SpawnedHomeActor->SetReplicates(true);
    SpawnedHomeActor->SetReplicateMovement(true);
}

Stacking into a pyramid

If every haul dropped at exactly CharacterHomeLocation, you would get one item flickering in place. Instead, a UResourceStackingUtility hands back the next free slot in a centered pyramid. On drop, the Gatherer detaches the item and places it at that slot:

void UGathererComponent::DetachExtractedResourceFromCharacter()
{
    SpawnedExtractedResource->DetachFromActor(DetachRules);
    OnDroppedActor.Broadcast();   // re-enables the item's collision

    FVector NextLocation = WoodPileMaker->GetLocationForLogIndex(CharacterHomeLocation);
    SpawnedExtractedResource->SetActorLocation(NextLocation, true);
    SpawnedExtractedResource->SetActorRotation(FRotator(0, 0, 70));
}

The utility keeps a running count and walks the pyramid rows to find which one the next item belongs in. The rows shrink as they rise, a 3x3 base, a 2x2 middle, then a single capstone:

for (int32 CurrentRow = 0; CurrentRow < MAX_ROWS; CurrentRow++)
{
    int32 LogsPerSide = 3 - CurrentRow;             // 3x3, then 2x2, then 1x1
    int32 LogsInThisRow = LogsPerSide * LogsPerSide;
    if (Position < LogsInThisRow) { Row = CurrentRow; break; }
    Position -= LogsInThisRow;
}

Within a row, the running position becomes a 2D grid coordinate, and each item is offset by the log dimensions and centered, with each row lifted by the log height:

int32 XIndex = Position % LogsPerSide;
int32 YIndex = Position / LogsPerSide;
float XOffset = (XIndex - (LogsPerSide - 1) / 2.0f) * LOG_LENGTH;   // 40
float YOffset = (YIndex - (LogsPerSide - 1) / 2.0f) * LOG_WIDTH;    // 30
float ZOffset = Row * LOG_HEIGHT;                                   // 18
return StartLocation + FVector(XOffset, YOffset, ZOffset);

With the defaults (log dimensions 40 by 30 by 18 Unreal units, three rows), the pile holds fourteen items (9 + 4 + 1) before it caps out. Those are constants in the utility, so a taller or wider pyramid is a code change, not a design accident.

What to take away

• Home is CharacterHomeLocation, set on assignment (passed in, or traced to the ground) and movable by cursor through a Server RPC that also relocates the marker.
• An optional, replicated Home Actor marks the drop point.
• UResourceStackingUtility turns drop order into a centered three-row pyramid, so hauls stack tidily; its dimensions and capacity are constants you can tune.

That closes the loop: order, find, walk, extract, carry, walk home, drop, repeat, replicated. Head back to the guide hub for the full map, or drop the finished system into your project with Resource Gathering Minions on FAB.