[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6FESJ2X9XNGSEPBVDX3Q4RB":3,"skill-same:01M6FESJ2X9XNGSEPBVDX3Q4RB":48},{"skillNo":4,"name":5,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":21,"linkOnly":22,"markdownContent":23,"markdownBody":23,"frontMatter":24,"refName":25,"commitSha":26,"skillDirectory":27,"forksCount":28,"repositoryHtmlUrl":29,"repositoryHomepageUrl":30,"ownerHtmlUrl":31,"ownerBlogUrl":6,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M6FESJ2X9XNGSEPBVDX3Q4RB","ue-world-level-streaming",null,"ComeOnOliver\u002Fskillshub","ComeOnOliver","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F43215937?v=4","01M6E5JNFECJAAVFE0W7SMWWD2","Haoran Shu","01M6E5JNNDQS7AJZDYFQ8TPZCK",67,"MIT","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fquodsoler\u002Funreal-engine-skills\u002Fue-world-level-streaming\u002FSKILL.md",[],[18,19,20],"streaming","world","ue world level streaming","2026-11-10 10:12:30",false,"# UE World & Level Streaming\n\nYou are an expert in Unreal Engine's world management and level streaming systems.\n\n---\n\n## Context\n\nRead `.agents\u002Fue-project-context.md` before advising. Pay attention to:\n- **Engine version** — World Partition is UE5 only; sub-level streaming works in both UE4 and UE5.\n- **Build targets** — Dedicated server has no rendering-driven streaming; streaming must be server-safe.\n- **World size** — Determines whether World Partition or manual sub-level streaming is appropriate.\n- **Multiplayer** — Seamless travel requirements and per-player streaming radius.\n\n---\n\n## Information to Gather\n\nBefore recommending a streaming approach, confirm:\n\n1. **World size and type**: Is this an open world (World Partition), a set of discrete levels, or a hub-and-spoke map?\n2. **Multiplayer**: Are you running a dedicated server? Are per-player streaming radii needed?\n3. **Streaming control**: Does gameplay code need to control load\u002Funload explicitly, or should proximity drive it?\n4. **Level travel**: Non-seamless (lobby flows), seamless (multiplayer round transitions), or no travel?\n5. **Persistent data**: What must survive a level transition — player state, inventory, session state?\n\n---\n\n## World Partition (UE5)\n\n### Enabling World Partition\n\nEnable via the Level menu: **World -> World Partition -> Convert Level**. Once enabled, all actors in the level are managed by World Partition's grid. The level can no longer have traditional sub-levels. Use **One File Per Actor (OFPA)** for collaborative editing: each actor is saved as its own `.uasset` under `__ExternalActors__`.\n\n### Runtime Data Layers\n\nData layers replace the old sub-level toggle pattern. A runtime data layer can be loaded\u002Funloaded at runtime without traveling to a new map.\n\n```cpp\n\u002F\u002F MyGameMode.cpp\n#include \"WorldPartition\u002FDataLayer\u002FDataLayerManager.h\"\n\nvoid AMyGameMode::ActivateDungeonDataLayer()\n{\n    UDataLayerManager* DLMgr = UDataLayerManager::GetDataLayerManager(GetWorld());\n    if (!DLMgr) return;\n\n    \u002F\u002F Get by asset reference (set up in editor as a UDataLayerAsset)\n    UDataLayerAsset* DungeonLayer = DungeonDataLayerAsset.LoadSynchronous();\n    DLMgr->SetDataLayerRuntimeState(DungeonLayer, EDataLayerRuntimeState::Activated);\n}\n\nvoid AMyGameMode::DeactivateDungeonDataLayer()\n{\n    UDataLayerManager* DLMgr = UDataLayerManager::GetDataLayerManager(GetWorld());\n    if (!DLMgr) return;\n\n    UDataLayerAsset* DungeonLayer = DungeonDataLayerAsset.LoadSynchronous();\n    DLMgr->SetDataLayerRuntimeState(DungeonLayer, EDataLayerRuntimeState::Unloaded);\n}\n```\n\n**Data layer states:**\n- `Unloaded` — not loaded, not visible.\n- `Loaded` — loaded into memory, not visible (pre-warming).\n- `Activated` — loaded and visible (fully active).\n\n### Streaming Sources\n\nEach player controller is a streaming source by default. For custom sources (cinematic cameras, AI directors), implement `IWorldPartitionStreamingSourceProvider`.\n\n### HLOD\n\nHLOD provides distant merged-mesh representations of World Partition cells. Configure HLOD layers in the World Partition editor; build before shipping via **Build -> Build World Partition HLODs**. Without HLOD, content beyond the streaming radius is simply absent.\n\n### Converting Sub-Levels to World Partition\n\nUse **Tools -> World Partition -> Convert Level**. Actors migrate into the persistent level under WP management. Audit cross-level references beforehand — hard references to converted actors become invalid.\n\n### World Partition and Multiplayer\n\nIn a multiplayer session, each player controller acts as a streaming source with a configurable radius. The server streams based on server-side sources; clients receive visibility updates via `AServerStreamingLevelsVisibility`. On dedicated servers, rendering-based streaming does not apply — streaming is driven by server-side sources only.\n\nStreaming radius is configured per-partition in the World Partition editor UI (`LoadingRange` on `URuntimePartition`), not via ini.\n\n---\n\n## Level Streaming (Manual Sub-Levels)\n\n### ULevelStreaming State Machine\n\nFrom `LevelStreaming.h`, the full state sequence is:\n\n```\nRemoved -> Unloaded -> Loading -> LoadedNotVisible -> MakingVisible -> LoadedVisible -> MakingInvisible -> LoadedNotVisible\n                                      |\n                                 FailedToLoad   (check logs; level asset missing or corrupt)\n```\n\nQuery state with:\n\n```cpp\nULevelStreaming* StreamingLevel = \u002F* ... *\u002F;\nELevelStreamingState State = StreamingLevel->GetLevelStreamingState();\n\nswitch (State)\n{\n    case ELevelStreamingState::Unloaded:         \u002F* not in memory *\u002F break;\n    case ELevelStreamingState::Loading:          \u002F* async load in progress *\u002F break;\n    case ELevelStreamingState::LoadedNotVisible: \u002F* in memory, not rendered *\u002F break;\n    case ELevelStreamingState::MakingVisible:    \u002F* adding to world *\u002F break;\n    case ELevelStreamingState::LoadedVisible:    \u002F* fully active *\u002F break;\n    case ELevelStreamingState::MakingInvisible:  \u002F* removing from rendering *\u002F break;\n    case ELevelStreamingState::FailedToLoad:     \u002F* check logs *\u002F break;\n}\n```\n\n### UGameplayStatics: LoadStreamLevel \u002F UnloadStreamLevel\n\nFor Blueprint-friendly async streaming with latent actions (from `GameplayStatics.h`):\n\n```cpp\n\u002F\u002F MyActor.cpp — async load using FLatentActionInfo\n#include \"Kismet\u002FGameplayStatics.h\"\n\nvoid AMyActor::StreamInRoom(FName LevelName)\n{\n    FLatentActionInfo LatentInfo;\n    LatentInfo.CallbackTarget = this;\n    LatentInfo.ExecutionFunction = FName(\"OnRoomLoaded\");\n    LatentInfo.Linkage = 0;\n    LatentInfo.UUID = GetUniqueID();\n\n    UGameplayStatics::LoadStreamLevel(\n        this,           \u002F\u002F WorldContextObject\n        LevelName,      \u002F\u002F e.g., FName(\"Room_01\")\n        true,           \u002F\u002F bMakeVisibleAfterLoad\n        false,          \u002F\u002F bShouldBlockOnLoad — keep false for async\n        LatentInfo\n    );\n}\n\nUFUNCTION()\nvoid AMyActor::OnRoomLoaded()\n{\n    \u002F\u002F Room is now loaded and visible\n}\n\nvoid AMyActor::StreamOutRoom(FName LevelName)\n{\n    FLatentActionInfo LatentInfo;\n    LatentInfo.CallbackTarget = this;\n    LatentInfo.ExecutionFunction = FName(\"OnRoomUnloaded\");\n    LatentInfo.Linkage = 0;\n    LatentInfo.UUID = GetUniqueID() + 1;\n\n    UGameplayStatics::UnloadStreamLevel(\n        this,\n        LevelName,\n        LatentInfo,\n        false \u002F\u002F bShouldBlockOnUnload\n    );\n}\n```\n\nFor soft object pointers (preferred for packaging safety), use `LoadStreamLevelBySoftObjectPtr` with the same arguments.\n\n### ULevelStreamingDynamic: Runtime Level Instances\n\nUse `ULevelStreamingDynamic::LoadLevelInstance` to load the same level package multiple times at different transforms — for procedural dungeons, modular buildings, or instanced rooms (from `LevelStreamingDynamic.h`):\n\n```cpp\n#include \"Engine\u002FLevelStreamingDynamic.h\"\n\nvoid AMyDungeonGenerator::SpawnRoom(FVector Location, FRotator Rotation)\n{\n    bool bSuccess = false;\n    ULevelStreamingDynamic* StreamingLevel = ULevelStreamingDynamic::LoadLevelInstance(\n        this,                              \u002F\u002F WorldContextObject\n        TEXT(\"\u002FGame\u002FLevels\u002FRoom_Corridor\"), \u002F\u002F LongPackageName — full path\n        Location,\n        Rotation,\n        bSuccess\n    );\n\n    if (bSuccess && StreamingLevel)\n    {\n        \u002F\u002F Bind to delegate to know when visible\n        StreamingLevel->OnLevelShown.AddDynamic(this, &AMyDungeonGenerator::OnRoomShown);\n        StreamingLevel->OnLevelHidden.AddDynamic(this, &AMyDungeonGenerator::OnRoomHidden);\n\n        LoadedRooms.Add(StreamingLevel);\n    }\n}\n\nvoid AMyDungeonGenerator::UnloadRoom(ULevelStreamingDynamic* StreamingLevel)\n{\n    if (StreamingLevel)\n    {\n        StreamingLevel->SetShouldBeLoaded(false);\n        StreamingLevel->SetShouldBeVisible(false);\n        StreamingLevel->SetIsRequestingUnloadAndRemoval(true);\n    }\n}\n```\n\nFor networking: use `OptionalLevelNameOverride` to give all clients and server the same package name for a given instance. Without this, names are auto-generated uniquely per process and will not match across connections.\n\n```cpp\nULevelStreamingDynamic::FLoadLevelInstanceParams Params(\n    GetWorld(),\n    TEXT(\"\u002FGame\u002FLevels\u002FRoom_Corridor\"),\n    FTransform(Rotation, Location)\n);\nParams.OptionalLevelNameOverride = &InstanceName; \u002F\u002F FString, same on server and clients\nParams.bInitiallyVisible = true;\n\nbool bSuccess = false;\nULevelStreamingDynamic* Level = ULevelStreamingDynamic::LoadLevelInstance(Params, bSuccess);\n```\n\n### OnLevelShown \u002F OnLevelHidden Delegates\n\nFrom `LevelStreaming.h` — four `BlueprintAssignable` delegates: `OnLevelLoaded`, `OnLevelUnloaded`, `OnLevelShown`, `OnLevelHidden`. Bind with `AddDynamic`:\n\n```cpp\nStreamingLevel->OnLevelShown.AddDynamic(this, &UMyManager::HandleLevelShown);\nStreamingLevel->OnLevelLoaded.AddDynamic(this, &UMyManager::HandleLevelLoaded);\n```\n\n### Streaming Volumes\n\n`ALevelStreamingVolume` automatically controls sub-level loading when the player camera is inside or outside the volume. From `LevelStreamingVolume.h`:\n\n```cpp\n\u002F\u002F EStreamingVolumeUsage — set on the volume in editor\nSVB_Loading                 \u002F\u002F load but do not make visible\nSVB_LoadingAndVisibility    \u002F\u002F load and make visible (most common)\nSVB_VisibilityBlockingOnLoad \u002F\u002F force blocking load when entering\nSVB_BlockingOnLoad          \u002F\u002F block load of associated levels\nSVB_LoadingNotVisible       \u002F\u002F load, keep invisible (pre-warm)\n```\n\nVolumes are assigned to a sub-level via its `EditorStreamingVolumes` array. Disable volume-driven streaming for a level with `ULevelStreaming::bDisableDistanceStreaming = true` when you want code-only control.\n\n### Manual Visibility Control\n\n```cpp\n\u002F\u002F Get streaming level reference from world\nconst TArray\u003CULevelStreaming*>& Levels = GetWorld()->GetStreamingLevels();\nfor (ULevelStreaming* Level : Levels)\n{\n    if (Level->GetWorldAssetPackageFName() == FName(\"\u002FGame\u002FLevels\u002FMySubLevel\"))\n    {\n        Level->SetShouldBeLoaded(true);\n        Level->SetShouldBeVisible(true);\n        break;\n    }\n}\n```\n\nForce flush all streaming (blocks until complete — use sparingly):\n```cpp\nUGameplayStatics::FlushLevelStreaming(this);\n```\n\n---\n\n## Level Instances\n\n`ALevelInstance` places a level as a reusable chunk in the editor. Actors inside are editable as a unit. For runtime instancing, see `ULevelStreamingDynamic` above.\n\n**Packed Level Actors** merge instance meshes into a single static mesh for performance. Enable via right-click on Level Instance → **Pack Level Actor**.\n\n**Per-instance property overrides (UE5.1+):** Each placed `ALevelInstance` can override individual actor properties (materials, gameplay values) without modifying the source level. Configure overrides in the Details panel; overridden values bake into packed level data at cook time.\n\n---\n\n## Level Travel\n\n### Non-Seamless: UGameplayStatics::OpenLevel\n\nDestroys the current world and loads a new one; all clients disconnect. From `GameplayStatics.h`:\n\n```cpp\nUGameplayStatics::OpenLevel(this, FName(\"\u002FGame\u002FMaps\u002FMainMenu\"), true);\nUGameplayStatics::OpenLevel(this, FName(\"\u002FGame\u002FMaps\u002FGameLevel\"), true, TEXT(\"?Difficulty=Hard\"));\nUGameplayStatics::OpenLevelBySoftObjectPtr(this, GameLevelAsset, true); \u002F\u002F packaging-safe\n```\n\n### Server Travel (Multiplayer, Non-Seamless)\n\nInitiated on the server; all connected clients follow (`World.h`):\n\n```cpp\nGetWorld()->ServerTravel(TEXT(\"\u002FGame\u002FMaps\u002FLevel02?listen\"), \u002F*bAbsolute=*\u002Ffalse);\n```\n\n### Seamless Travel\n\nSeamless travel loads the destination map in the background via a transition (midpoint) map. Clients stay connected. From `World.h`:\n\n```cpp\nvoid UWorld::SeamlessTravel(const FString& InURL, bool bAbsolute);\nbool UWorld::IsInSeamlessTravel() const;\nvoid UWorld::SetSeamlessTravelMidpointPause(bool bNowPaused);\n```\n\n**Setup requirements:**\n\n1. Set `bUseSeamlessTravel = true` on `AGameModeBase`:\n\n```cpp\n\u002F\u002F bUseSeamlessTravel is already declared in AGameModeBase — do NOT redeclare it.\n\u002F\u002F Just set it in the constructor:\n\n\u002F\u002F MyGameMode.cpp constructor\nbUseSeamlessTravel = true;\n```\n\n2. Set a transition map in `DefaultEngine.ini`:\n\n```ini\n[\u002FScript\u002FEngine.GameMapsSettings]\nTransitionMap=\u002FGame\u002FMaps\u002FTransition\n```\n\n3. Override `GetSeamlessTravelActorList` to control which actors persist:\n\n```cpp\n\u002F\u002F GameMode — called on server side during transition\nvoid AMyGameMode::GetSeamlessTravelActorList(bool bToTransition, TArray\u003CAActor*>& ActorList)\n{\n    Super::GetSeamlessTravelActorList(bToTransition, ActorList);\n\n    if (!bToTransition)\n    {\n        \u002F\u002F bToTransition=false means we're moving TO the destination\n        \u002F\u002F Add actors that should survive (e.g., GameState, custom managers)\n        ActorList.Add(MyPersistentManager);\n    }\n}\n\n\u002F\u002F GameMode — called after destination map is loaded\nvoid AMyGameMode::PostSeamlessTravel()\n{\n    Super::PostSeamlessTravel();\n    \u002F\u002F Re-initialize any post-travel systems\n}\n\n\u002F\u002F GameMode — handle re-possessing players after travel\nvoid AMyGameMode::HandleSeamlessTravelPlayer(AController*& C)\n{\n    Super::HandleSeamlessTravelPlayer(C);\n    \u002F\u002F Restore player-specific state here\n}\n```\n\n4. Trigger on server:\n\n```cpp\n\u002F\u002F From GameMode, server-only\nGetWorld()->ServerTravel(TEXT(\"\u002FGame\u002FMaps\u002FLevel02?listen\"));\n\u002F\u002F Seamless travel is automatic because bUseSeamlessTravel is true\n```\n\n**Travel sequence:** current world -> transition map -> destination world. Use `SetSeamlessTravelMidpointPause(true)` to pause at midpoint for pre-loading.\n\n### Client Travel\n\nFor client-initiated travel (join server, change options), call `APlayerController::ClientTravel(URL, ETravelType::TRAVEL_Absolute)` from the player controller.\n\n---\n\n## World Subsystems\n\n`UWorldSubsystem` (from `Subsystems\u002FWorldSubsystem.h`) is auto-instantiated once per `UWorld`. It is destroyed when the world is destroyed — including on level travel. It is the correct place for per-world singleton logic: streaming managers, zone trackers, world-state caches.\n\n```cpp\n\u002F\u002F MyStreamingManager.h\nUCLASS()\nclass MYGAME_API UMyStreamingManager : public UWorldSubsystem\n{\n    GENERATED_BODY()\npublic:\n    virtual void PostInitialize() override;                          \u002F\u002F after all subsystems init\n    virtual void OnWorldBeginPlay(UWorld& InWorld) override;         \u002F\u002F after all BeginPlay\n    virtual void PreDeinitialize() override;                         \u002F\u002F cleanup hook\n    virtual bool ShouldCreateSubsystem(UObject* Outer) const override; \u002F\u002F filter world type\n\n    void RequestLoadZone(FName ZoneName);\n    void RequestUnloadZone(FName ZoneName);\nprivate:\n    TMap\u003CFName, TWeakObjectPtr\u003CULevelStreaming>> ActiveZones;\n};\n```\n\nAccess from anywhere with a world context:\n\n```cpp\nUMyStreamingManager* Manager = GetWorld()->GetSubsystem\u003CUMyStreamingManager>();\nif (Manager)\n{\n    Manager->RequestLoadZone(FName(\"Zone_A\"));\n}\n```\n\n### UTickableWorldSubsystem\n\nFor per-frame updates (distance checks, zone detection). Inherit from `UTickableWorldSubsystem`. Must call `Super::Initialize` and `Super::Deinitialize` to enable\u002Fdisable ticking. Implement `GetStatId` returning a `RETURN_QUICK_DECLARE_CYCLE_STAT`.\n\n---\n\n## Persistent Data Across Level Transitions\n\n| Mechanism | Lifetime | Use Case |\n|---|---|---|\n| `UGameInstance` | Entire application session | Cross-level player state, session config |\n| `UGameInstanceSubsystem` | Entire application session | Services that outlive any world |\n| Seamless travel actor list | Transition only | Actors that physically cross (GameState, managers) |\n| `USaveGame` + `SaveGameToSlot` | Disk-persistent | Long-term saves, progression |\n| `UWorldSubsystem` | Per world | World-scoped cache; push data to `UGameInstance` in `Deinitialize()` before travel clears it |\n\n### GameInstance Pattern\n\nStore cross-level data in `UGameInstance` properties (survives all level travel). Access from anywhere with a world context:\n\n```cpp\nUMyGameInstance* GI = GetGameInstance\u003CUMyGameInstance>();\nif (GI) GI->PlayerScore += 100;\n```\n\n---\n\n## Common Mistakes and Anti-Patterns\n\n**Loading everything at once.** Setting `bShouldBlockOnLoad = true` on many sub-levels causes hitches. Use async loading and the latent action pattern. Only block on load when the game is behind a loading screen.\n\n**Streaming volume gaps.** Overlapping volumes cause spurious unload\u002Freload cycles. Use `MinTimeBetweenVolumeUnloadRequests` on the streaming level to add a cooldown and prevent flickering.\n\n**Broken seamless travel in multiplayer.** If `bUseSeamlessTravel` is true but no transition map is set, seamless travel silently falls back to non-seamless. Always set `TransitionMap` in `DefaultEngine.ini`.\n\n**Cross-level hard references.** Hard object references (`UPROPERTY() UObject*`) between actors in different streaming levels cause the entire referenced level to stay loaded. Always use `TSoftObjectPtr` or `TSoftClassPtr` across level boundaries.\n\n**Dynamic streaming level names not matching server and client.** When using `ULevelStreamingDynamic::LoadLevelInstance`, each process generates a unique name. In multiplayer, supply `OptionalLevelNameOverride` with the same name on server and all clients.\n\n**World Partition on dedicated server.** The server does not use rendering-driven streaming. Streaming sources must be explicitly added server-side (e.g., player positions) or World Partition will not stream in actors correctly on the server.\n\n**Modifying `StreamingLevels` directly.** Do not add to `UWorld::StreamingLevels` directly. Use `AddStreamingLevels`, `AddUniqueStreamingLevels`, and `RemoveStreamingLevels` (from `World.h`) which handle internal bookkeeping and `StreamingLevelsToConsider`.\n\n**Forgetting to call `Super::Initialize` \u002F `Super::Deinitialize` in `UTickableWorldSubsystem`.** These calls enable and disable ticking respectively. Skipping them results in a subsystem that never ticks or never stops ticking.\n\n---\n\n## Quick Reference: Key APIs\n\n| API | Header | Notes |\n|---|---|---|\n| `UGameplayStatics::LoadStreamLevel` | `Kismet\u002FGameplayStatics.h` | Async latent load of named sub-level |\n| `UGameplayStatics::UnloadStreamLevel` | `Kismet\u002FGameplayStatics.h` | Async latent unload |\n| `UGameplayStatics::FlushLevelStreaming` | `Kismet\u002FGameplayStatics.h` | Blocking flush — use behind loading screens |\n| `UGameplayStatics::OpenLevel` | `Kismet\u002FGameplayStatics.h` | Non-seamless level travel |\n| `ULevelStreamingDynamic::LoadLevelInstance` | `Engine\u002FLevelStreamingDynamic.h` | Runtime level instancing |\n| `ULevelStreaming::GetLevelStreamingState` | `Engine\u002FLevelStreaming.h` | Query current stream state |\n| `ULevelStreaming::SetShouldBeLoaded` | `Engine\u002FLevelStreaming.h` | Drive load state |\n| `ULevelStreaming::SetShouldBeVisible` | `Engine\u002FLevelStreaming.h` | Drive visibility |\n| `ULevelStreaming::SetIsRequestingUnloadAndRemoval` | `Engine\u002FLevelStreaming.h` | Remove level from world |\n| `UWorld::ServerTravel` | `Engine\u002FWorld.h` | Multiplayer level transition |\n| `UWorld::SeamlessTravel` | `Engine\u002FWorld.h` | Background seamless transition |\n| `UWorld::GetStreamingLevels` | `Engine\u002FWorld.h` | Iterate all streaming levels |\n| `UDataLayerManager::SetDataLayerRuntimeState` | `WorldPartition\u002FDataLayer\u002FDataLayerManager.h` | World Partition data layer control (use `UDataLayerManager::GetDataLayerManager(World)`) |\n| `UWorldSubsystem::OnWorldBeginPlay` | `Subsystems\u002FWorldSubsystem.h` | Post-BeginPlay init hook |\n| `AGameModeBase::GetSeamlessTravelActorList` | `GameFramework\u002FGameModeBase.h` | Control actor persistence |\n\n---\n\n## Related Skills\n\n- `ue-gameplay-framework` — GameMode travel callbacks, `PostSeamlessTravel`, actor persistence rules.\n- `ue-data-assets-tables` — async asset loading patterns that complement level streaming.\n- `ue-networking-replication` — net visibility transactions, server streaming authority.\n- `ue-cpp-foundations` — subsystem patterns, `UGameInstance` lifetime.\n",{},"main","def8531e65114c0fca8fb8551c1871ee0eed705c","skills\u002Fquodsoler\u002Funreal-engine-skills\u002Fue-world-level-streaming",24,"https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub","https:\u002F\u002Fskillshub.wtf","https:\u002F\u002Fgithub.com\u002FComeOnOliver","AI & Blockchain Engineer\r\n","2026-06-24 22:07:19",{"source":7,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add ComeOnOliver\u002Fskillshub --skill ue-world-level-streaming",{"tool":40,"command":41},"bunx","bunx skills add ComeOnOliver\u002Fskillshub --skill ue-world-level-streaming",{"tool":43,"command":44},"pnpm","pnpm dlx skills add ComeOnOliver\u002Fskillshub --skill ue-world-level-streaming","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fquodsoler\u002Funreal-engine-skills\u002Fue-world-level-streaming\u002FSKILL.md",true,[],[49,63,73,82,88,95],{"skillNo":50,"name":51,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":59,"publishedAt":21},"01M6FKJN13GMG4KY57J3QD8GY5","model-hierarchy-skill","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzscole\u002Fmodel-hierarchy-skill\u002Fmodel-hierarchy-skill\u002FSKILL.md",[54],{"categoryNo":55,"categoryName":56,"taxonomyType":57,"taxonomyTypeDesc":58},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[60,61,62],"model","model hierarchy","model hierarchy skill",{"skillNo":64,"name":65,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":69,"publishedAt":21},"01M6FKJJJ6GCAMR4PPPRD12M5X","zoom-mcp","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-mcp\u002FSKILL.md",[68],{"categoryNo":55,"categoryName":56,"taxonomyType":57,"taxonomyTypeDesc":58},[70,71,72],"MCP","zoom","zoom mcp",{"skillNo":74,"name":75,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":21},"01M6FKJE3KYT3KPEZMEEHYKA6K","zoom-apps-sdk","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-apps-sdk\u002FSKILL.md",[],[79,80,81,71],"sdk","zoom apps sdk","apps",{"skillNo":83,"name":84,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":21},"01M6FKJ9EDH9Q5VWDF8HAJRSP0","windows","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwindows\u002FSKILL.md",[],[84],{"skillNo":89,"name":90,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":91,"categories":92,"keywords":94,"publishedAt":21},"01M6FKJ666BEEFC3AE9GJ72Q93","whiteboard","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwhiteboard\u002FSKILL.md",[93],{"categoryNo":55,"categoryName":56,"taxonomyType":57,"taxonomyTypeDesc":58},[90],{"skillNo":96,"name":97,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":98,"categories":99,"keywords":100,"publishedAt":21},"01M6FKJ21WFCDGTJQ2Q91T9DVW","websockets","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwebsockets\u002FSKILL.md",[],[97]]