A first-person puzzle game built around seamless world-switching — the player shifts instantly between an ancient Arab city and a futuristic counterpart shaped by the same cultural roots. Set in a high-fidelity, realistic environment, the prototype pushes UE5's lighting, rendering, and world-streaming systems to their limits. Developed in 6 weeks part-time by a cross-discipline team, the game took 1st place at the Arab Youth Gaming Hackathon, supported by Futuregames and the Arab Youth Center.

What I Built

• World-switching runtime — engineered the core mechanic allowing instant, seamless transitions between the ancient and futuristic world layers using UE5 World Partition and Data Layers, with no loading screens or hitches during the swap.
• State preservation system — built a per-actor state snapshot system so puzzle objects, doors, and interactive props maintain correct state across both world layers independently, preventing desync on repeated switches.
• High-fidelity environment pipeline — set up UE5 Lumen global illumination, Nanite geometry, and multi-layered post-process stacks for both historical and futuristic settings, ensuring visual coherence between the two worlds.
• Puzzle framework — designed and implemented a data-driven first-person puzzle framework where switch-dependent logic is author-friendly for designers, with each puzzle supporting arbitrary world-layer configurations.
• Team architecture lead — led technical direction for a cross-discipline team of artists and designers over 6 weeks part-time; structured the project to ship a polished playable build within hackathon constraints.

void UWorldSwitchComponent::ExecuteSwitch()
{
    if (bTransitionInProgress) return;
    bTransitionInProgress = true;

    // Capture current world state before swap
    SnapshotActorStates(ActiveLayer);

    EWorldLayer TargetLayer = (ActiveLayer == EWorldLayer::Ancient)
        ? EWorldLayer::Futuristic
        : EWorldLayer::Ancient;

    // Stream in target, stream out current via Data Layers
    SetDataLayerState(LayerAssets[ActiveLayer], EDataLayerState::Unloaded);
    SetDataLayerState(LayerAssets[TargetLayer],  EDataLayerState::Activated);

    ActiveLayer = TargetLayer;
    RestoreActorStates(ActiveLayer);

    PlaySwitchFX(GetOwner()->GetActorLocation());
    bTransitionInProgress = false;
}

void UWorldSwitchComponent::SnapshotActorStates(EWorldLayer Layer)
{
    TArray<AActor*> LayerActors;
    GetActorsInLayer(Layer, LayerActors);

    for (AActor* Actor : LayerActors)
    {
        if (IWorldStateful* Stateful = Cast<IWorldStateful>(Actor))
        {
            FLayerState& State = LayerStateCache[Layer][Actor];
            State.bIsActive  = Actor->IsActorTickEnabled();
            State.Transform  = Actor->GetActorTransform();
            State.CustomData = Stateful->SerializeState();
        }
    }
}

void ALayerPuzzleGate::OnLayerActivated(EWorldLayer NewLayer)
{
    // Each gate tracks requirements per-layer independently
    const FPuzzleRequirement& Req = Requirements[NewLayer];

    if (Req.IsMet())
    {
        SetGateState(EGateState::Open);
        BroadcastGateCleared(NewLayer);
    }
    else
    {
        SetGateState(EGateState::Locked);
        UpdateHUD_RequirementsLeft(Req.CountRemaining());
    }
}