diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.cpp index e3b8497..d09132d 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.cpp @@ -2,6 +2,13 @@ namespace HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal { + const TCHAR* SharedHigherDimensionalTrainingMapPath = + TEXT("/Game/HyperTwistTraining/Maps/L_HyperTwist_ClassicTraining"); + const TCHAR* Magic120CellDedicatedTrainingMapPath = + TEXT("/Game/HyperTwistTraining/Maps/L_HyperTwist_Magic120CellTraining"); + const TCHAR* MagicCube5DDedicatedTrainingMapPath = + TEXT("/Game/HyperTwistTraining/Maps/L_HyperTwist_MagicCube5DTraining"); + template void AppendUniqueStrings(TArray& OutValues, const TStringArrayType& InValues) { @@ -27,6 +34,73 @@ namespace HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal return Attribution; } + FHyperTwistTrainingSourceAttribution MakeLaunchAttribution( + const FString& LaunchSurfaceId, + const FString& Notes + ) + { + FHyperTwistTrainingSourceAttribution Attribution; + Attribution.SourceMode = EHyperTwistTrainingSourceMode::FirstParty; + Attribution.SourceTrackId = TEXT("phase6c/higher-dimensional-runtime-launch"); + Attribution.SourceCaseId = LaunchSurfaceId; + Attribution.SourceNotes = Notes; + return Attribution; + } + + FHyperTwistTrainingSourceAttribution MakeHostAttribution( + const FString& HostSurfaceId, + const FString& Notes + ) + { + FHyperTwistTrainingSourceAttribution Attribution; + Attribution.SourceMode = EHyperTwistTrainingSourceMode::FirstParty; + Attribution.SourceTrackId = TEXT("phase6c/higher-dimensional-runtime-host"); + Attribution.SourceCaseId = HostSurfaceId; + Attribution.SourceNotes = Notes; + return Attribution; + } + + FHyperTwistTrainingSourceAttribution MakeViewContextAttribution( + const FString& ViewContextSurfaceId, + const FString& Notes + ) + { + FHyperTwistTrainingSourceAttribution Attribution; + Attribution.SourceMode = EHyperTwistTrainingSourceMode::FirstParty; + Attribution.SourceTrackId = TEXT("phase6c/higher-dimensional-runtime-view-context"); + Attribution.SourceCaseId = ViewContextSurfaceId; + Attribution.SourceNotes = Notes; + return Attribution; + } + + FHyperTwistTrainingImportedRuntimeSelector MakeSelector( + const FString& SelectorId, + const FString& Label, + const FString& SelectorBinding + ) + { + FHyperTwistTrainingImportedRuntimeSelector Selector; + Selector.SelectorId = SelectorId; + Selector.Label = Label; + Selector.SelectorBinding = SelectorBinding; + return Selector; + } + + FHyperTwistTrainingImportedRuntimeSelectorChoice MakeChoice( + const FString& SelectorId, + const FString& SelectorBinding, + const FString& SelectedValue, + const FString& DisplayValue + ) + { + FHyperTwistTrainingImportedRuntimeSelectorChoice Choice; + Choice.SelectorId = SelectorId; + Choice.SelectorBinding = SelectorBinding; + Choice.SelectedValue = SelectedValue; + Choice.DisplayValue = DisplayValue; + return Choice; + } + void AppendMagic120CellCapabilityTags( const FHyperTwistTrainingMagic120CellRuntimeProfileContract& RuntimeProfile, const FHyperTwistTrainingMagic120CellPersistenceBoundary& PersistenceBoundary, @@ -149,6 +223,156 @@ namespace HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal return Profile; } + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface BuildMagic120CellHostSurface() + { + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog ActivationCatalog = + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog(); + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeActivationProfileById( + ActivationCatalog, + TEXT("magic120cell-cleanroom-runtime-activation"), + Profile)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeHostSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface HostSurface; + HostSurface.HostSurfaceId = TEXT("phase6c/magic120cell/runtime-host-surface"); + HostSurface.ActivationProfileId = Profile.ActivationProfileId; + HostSurface.Title = TEXT("Magic120Cell dedicated-family host surface"); + HostSurface.Summary = TEXT("Explicit dedicated-family host seam for Magic120Cell that records the preferred owned training-map target while the effective runtime still resolves to the current shared HyperTwist training shell."); + HostSurface.PreferredHostMapPath = Magic120CellDedicatedTrainingMapPath; + HostSurface.PreferredHostMapRouteId = TEXT("phase6c/magic120cell/dedicated-training-map-host"); + HostSurface.PreferredHostMapLabel = TEXT("Magic120Cell dedicated training shell"); + HostSurface.EffectiveHostMapPath = SharedHigherDimensionalTrainingMapPath; + HostSurface.EffectiveHostMapRouteId = TEXT("phase6c/shared-training-map-host"); + HostSurface.EffectiveHostMapLabel = TEXT("Shared HyperTwist training shell"); + HostSurface.bDedicatedFamilyHostMapAuthored = false; + HostSurface.bUsesSharedTrainingMapFallback = true; + HostSurface.HostTags = + { + TEXT("phase6c"), + TEXT("higher-dimensional"), + TEXT("host-surface"), + TEXT("family:magic120cell"), + TEXT("preferred-host:dedicated-family-map"), + TEXT("effective-host:shared-training-map") + }; + HostSurface.SourceAttribution = MakeHostAttribution( + HostSurface.HostSurfaceId, + TEXT("Phase 6C explicit host-surface seam for Magic120Cell that preserves the preferred dedicated-family map target while keeping the current shared training-map fallback authoritative.") + ); + return HostSurface; + } + + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface BuildMagic120CellLaunchSurface() + { + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog ActivationCatalog = + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog(); + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeActivationProfileById( + ActivationCatalog, + TEXT("magic120cell-cleanroom-runtime-activation"), + Profile)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface HostSurface; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeHostCatalog(), + Profile.ActivationProfileId, + HostSurface)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + } + + const FHyperTwistTrainingMagic120CellReferenceBundle Bundle = + UHyperTwistTrainingMagic120CellLibrary::BuildBundledMagic120CellReferenceBundle(); + FHyperTwistTrainingMagic120CellRuntimeProfileContract RuntimeProfile; + FHyperTwistTrainingMagic120CellPersistenceBoundary PersistenceBoundary; + FHyperTwistTrainingMagic120CellViewProfileContract ViewProfile; + if (!UHyperTwistTrainingMagic120CellLibrary::TryGetRuntimeProfileContractById( + Bundle, + Bundle.PrimaryRuntimeProfileContractId, + RuntimeProfile) + || !UHyperTwistTrainingMagic120CellLibrary::TryGetPersistenceBoundaryById( + Bundle, + Bundle.PrimaryPersistenceBoundaryId, + PersistenceBoundary) + || !UHyperTwistTrainingMagic120CellLibrary::TryGetViewProfileContractById( + Bundle, + Bundle.PrimaryViewProfileContractId, + ViewProfile)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface LaunchSurface; + LaunchSurface.LaunchSurfaceId = TEXT("phase6c/magic120cell/shared-training-launch-surface"); + LaunchSurface.ActivationProfileId = Profile.ActivationProfileId; + LaunchSurface.HostSurfaceId = HostSurface.HostSurfaceId; + LaunchSurface.Title = TEXT("Magic120Cell shared-map launch surface"); + LaunchSurface.Summary = TEXT("Dedicated-family launch surface that binds the Magic120Cell clean-room activation profile to the current shared HyperTwist training map host, selector defaults, and generated-mode persistence execution path."); + LaunchSurface.HostMapPath = HostSurface.EffectiveHostMapPath; + LaunchSurface.HostMapRouteId = HostSurface.EffectiveHostMapRouteId; + LaunchSurface.HostMapLabel = HostSurface.EffectiveHostMapLabel; + LaunchSurface.bUsesSharedTrainingMapFallback = HostSurface.bUsesSharedTrainingMapFallback; + LaunchSurface.DeckId = TEXT("phase6c/magic120cell/launch"); + LaunchSurface.SeedCaseId = TEXT("phase6c/magic120cell/launch/seed"); + LaunchSurface.SeedPromptLabel = TEXT("Magic120Cell launch seed"); + LaunchSurface.SurfaceId = TEXT("phase6c/magic120cell/generated-runtime-surface"); + LaunchSurface.SurfaceLabel = TEXT("Magic120Cell Runtime Surface"); + LaunchSurface.RuntimeModeId = Profile.RuntimeModeId; + LaunchSurface.GeneratorType = TEXT("phase6c-higher-dimensional-dedicated-family"); + LaunchSurface.PrimaryPersistenceBoundaryId = PersistenceBoundary.BoundaryId; + AppendUniqueStrings( + LaunchSurface.PersistenceSurfaceTags, + PersistenceBoundary.PersistenceSurfaceTags); + AppendUniqueStrings( + LaunchSurface.PersistenceSurfaceTags, + PersistenceBoundary.TwistHistorySurfaceTags); + AppendUniqueStrings( + LaunchSurface.InteractionSurfaceTags, + RuntimeProfile.PuzzleTypeSurfaceTags); + AppendUniqueStrings( + LaunchSurface.InteractionSurfaceTags, + RuntimeProfile.SymmetrySurfaceTags); + AppendUniqueStrings( + LaunchSurface.InteractionSurfaceTags, + RuntimeProfile.VisibilitySurfaceTags); + AppendUniqueStrings( + LaunchSurface.ViewSurfaceTags, + ViewProfile.ProjectionSurfaceTags); + AppendUniqueStrings( + LaunchSurface.ViewSurfaceTags, + ViewProfile.VisibilityPresetTags); + AppendUniqueStrings( + LaunchSurface.ViewSurfaceTags, + ViewProfile.FocusSurfaceTags); + AppendUniqueStrings(LaunchSurface.LaunchTags, Profile.DefaultSelectionTags); + AppendUniqueStrings(LaunchSurface.LaunchTags, Profile.CapabilityTags); + AppendUniqueStrings(LaunchSurface.LaunchTags, HostSurface.HostTags); + LaunchSurface.RequiredNoticeActions = Profile.RequiredNoticeActions; + LaunchSurface.Selectors = + { + MakeSelector(TEXT("puzzle-type"), TEXT("Puzzle Type"), TEXT("puzzle-type")), + MakeSelector(TEXT("visibility-depth"), TEXT("Visibility Depth"), TEXT("visibility-depth")), + MakeSelector(TEXT("focus-mode"), TEXT("Focus Mode"), TEXT("focus-mode")) + }; + LaunchSurface.DefaultSelectorChoices = + { + MakeChoice(TEXT("puzzle-type"), TEXT("puzzle-type"), TEXT("full-color"), TEXT("Full Color")), + MakeChoice(TEXT("visibility-depth"), TEXT("visibility-depth"), TEXT("full-puzzle"), TEXT("Full Puzzle")), + MakeChoice(TEXT("focus-mode"), TEXT("focus-mode"), TEXT("center-cell"), TEXT("Center Cell")) + }; + LaunchSurface.SourceAttribution = MakeLaunchAttribution( + LaunchSurface.LaunchSurfaceId, + TEXT("Phase 6C dedicated-family launch surface for Magic120Cell on the explicit host-surface seam, with the preferred dedicated-family map target deferred and the current shared training-map host remaining authoritative for owned generated-mode execution.") + ); + return LaunchSurface; + } + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile BuildMagicCube5DActivationProfile() { const FHyperTwistTrainingMagicCube5DReferenceBundle Bundle = @@ -226,6 +450,370 @@ namespace HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal ); return Profile; } + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface BuildMagicCube5DHostSurface() + { + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog ActivationCatalog = + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog(); + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeActivationProfileById( + ActivationCatalog, + TEXT("magiccube5d-cleanroom-runtime-activation"), + Profile)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeHostSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface HostSurface; + HostSurface.HostSurfaceId = TEXT("phase6c/magiccube5d/runtime-host-surface"); + HostSurface.ActivationProfileId = Profile.ActivationProfileId; + HostSurface.Title = TEXT("MagicCube5D dedicated-family host surface"); + HostSurface.Summary = TEXT("Explicit dedicated-family host seam for MagicCube5D that records the preferred owned training-map target while the effective runtime still resolves to the current shared HyperTwist training shell."); + HostSurface.PreferredHostMapPath = MagicCube5DDedicatedTrainingMapPath; + HostSurface.PreferredHostMapRouteId = TEXT("phase6c/magiccube5d/dedicated-training-map-host"); + HostSurface.PreferredHostMapLabel = TEXT("MagicCube5D dedicated training shell"); + HostSurface.EffectiveHostMapPath = SharedHigherDimensionalTrainingMapPath; + HostSurface.EffectiveHostMapRouteId = TEXT("phase6c/shared-training-map-host"); + HostSurface.EffectiveHostMapLabel = TEXT("Shared HyperTwist training shell"); + HostSurface.bDedicatedFamilyHostMapAuthored = false; + HostSurface.bUsesSharedTrainingMapFallback = true; + HostSurface.HostTags = + { + TEXT("phase6c"), + TEXT("higher-dimensional"), + TEXT("host-surface"), + TEXT("family:magiccube5d"), + TEXT("preferred-host:dedicated-family-map"), + TEXT("effective-host:shared-training-map") + }; + HostSurface.SourceAttribution = MakeHostAttribution( + HostSurface.HostSurfaceId, + TEXT("Phase 6C explicit host-surface seam for MagicCube5D that preserves the preferred dedicated-family map target while keeping the current shared training-map fallback authoritative.") + ); + return HostSurface; + } + + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface BuildMagicCube5DLaunchSurface() + { + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog ActivationCatalog = + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog(); + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeActivationProfileById( + ActivationCatalog, + TEXT("magiccube5d-cleanroom-runtime-activation"), + Profile)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface HostSurface; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeHostCatalog(), + Profile.ActivationProfileId, + HostSurface)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + } + + const FHyperTwistTrainingMagicCube5DReferenceBundle Bundle = + UHyperTwistTrainingMagicCube5DLibrary::BuildBundledMagicCube5DReferenceBundle(); + FHyperTwistTrainingMagicCube5DRuntimeProfileContract RuntimeProfile; + FHyperTwistTrainingMagicCube5DPersistenceBoundary PersistenceBoundary; + FHyperTwistTrainingMagicCube5DViewProfileContract ViewProfile; + if (!UHyperTwistTrainingMagicCube5DLibrary::TryGetRuntimeProfileContractById( + Bundle, + Bundle.PrimaryRuntimeProfileContractId, + RuntimeProfile) + || !UHyperTwistTrainingMagicCube5DLibrary::TryGetPersistenceBoundaryById( + Bundle, + Bundle.PrimaryPersistenceBoundaryId, + PersistenceBoundary) + || !UHyperTwistTrainingMagicCube5DLibrary::TryGetViewProfileContractById( + Bundle, + Bundle.PrimaryViewProfileContractId, + ViewProfile)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface LaunchSurface; + LaunchSurface.LaunchSurfaceId = TEXT("phase6c/magiccube5d/shared-training-launch-surface"); + LaunchSurface.ActivationProfileId = Profile.ActivationProfileId; + LaunchSurface.HostSurfaceId = HostSurface.HostSurfaceId; + LaunchSurface.Title = TEXT("MagicCube5D shared-map launch surface"); + LaunchSurface.Summary = TEXT("Dedicated-family launch surface that binds the MagicCube5D clean-room activation profile to the current shared HyperTwist training map host, selector defaults, and generated-mode persistence execution path."); + LaunchSurface.HostMapPath = HostSurface.EffectiveHostMapPath; + LaunchSurface.HostMapRouteId = HostSurface.EffectiveHostMapRouteId; + LaunchSurface.HostMapLabel = HostSurface.EffectiveHostMapLabel; + LaunchSurface.bUsesSharedTrainingMapFallback = HostSurface.bUsesSharedTrainingMapFallback; + LaunchSurface.DeckId = TEXT("phase6c/magiccube5d/launch"); + LaunchSurface.SeedCaseId = TEXT("phase6c/magiccube5d/launch/seed"); + LaunchSurface.SeedPromptLabel = TEXT("MagicCube5D launch seed"); + LaunchSurface.SurfaceId = TEXT("phase6c/magiccube5d/generated-runtime-surface"); + LaunchSurface.SurfaceLabel = TEXT("MagicCube5D Runtime Surface"); + LaunchSurface.RuntimeModeId = Profile.RuntimeModeId; + LaunchSurface.GeneratorType = TEXT("phase6c-higher-dimensional-dedicated-family"); + LaunchSurface.PrimaryPersistenceBoundaryId = PersistenceBoundary.BoundaryId; + AppendUniqueStrings( + LaunchSurface.PersistenceSurfaceTags, + PersistenceBoundary.PersistenceSurfaceTags); + AppendUniqueStrings( + LaunchSurface.PersistenceSurfaceTags, + PersistenceBoundary.TwistHistorySurfaceTags); + AppendUniqueStrings( + LaunchSurface.PersistenceSurfaceTags, + PersistenceBoundary.MacroSurfaceTags); + AppendUniqueStrings( + LaunchSurface.InteractionSurfaceTags, + RuntimeProfile.OrderSurfaceTags); + AppendUniqueStrings( + LaunchSurface.InteractionSurfaceTags, + RuntimeProfile.InteractionSurfaceTags); + AppendUniqueStrings( + LaunchSurface.InteractionSurfaceTags, + RuntimeProfile.ProgressSurfaceTags); + AppendUniqueStrings( + LaunchSurface.ViewSurfaceTags, + ViewProfile.ProjectionSurfaceTags); + AppendUniqueStrings( + LaunchSurface.ViewSurfaceTags, + ViewProfile.StereoSurfaceTags); + AppendUniqueStrings( + LaunchSurface.ViewSurfaceTags, + ViewProfile.VisibilitySurfaceTags); + AppendUniqueStrings( + LaunchSurface.ViewSurfaceTags, + ViewProfile.FocusSurfaceTags); + AppendUniqueStrings(LaunchSurface.LaunchTags, Profile.DefaultSelectionTags); + AppendUniqueStrings(LaunchSurface.LaunchTags, Profile.CapabilityTags); + AppendUniqueStrings(LaunchSurface.LaunchTags, HostSurface.HostTags); + LaunchSurface.RequiredNoticeActions = Profile.RequiredNoticeActions; + LaunchSurface.Selectors = + { + MakeSelector(TEXT("family-mode"), TEXT("Family Mode"), TEXT("family-mode")), + MakeSelector(TEXT("stereo"), TEXT("Stereo"), TEXT("stereo")), + MakeSelector(TEXT("visibility"), TEXT("Visibility"), TEXT("visibility")) + }; + LaunchSurface.DefaultSelectorChoices = + { + MakeChoice(TEXT("family-mode"), TEXT("family-mode"), TEXT("order3"), TEXT("Order 3")), + MakeChoice(TEXT("stereo"), TEXT("stereo"), TEXT("off"), TEXT("Stereo Off")), + MakeChoice(TEXT("visibility"), TEXT("visibility"), TEXT("all-faces"), TEXT("All Faces")) + }; + LaunchSurface.SourceAttribution = MakeLaunchAttribution( + LaunchSurface.LaunchSurfaceId, + TEXT("Phase 6C dedicated-family launch surface for MagicCube5D on the explicit host-surface seam, with the preferred dedicated-family map target deferred and the current shared training-map host remaining authoritative for owned generated-mode execution.") + ); + return LaunchSurface; + } + + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface BuildMagic120CellViewContextSurface() + { + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface LaunchSurface; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeLaunchSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeLaunchCatalog(), + TEXT("magic120cell-cleanroom-runtime-activation"), + LaunchSurface)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface HostSurface; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeHostCatalog(), + LaunchSurface.ActivationProfileId, + HostSurface)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + } + + const FHyperTwistTrainingMagic120CellReferenceBundle Bundle = + UHyperTwistTrainingMagic120CellLibrary::BuildBundledMagic120CellReferenceBundle(); + FHyperTwistTrainingMagic120CellViewProfileContract ViewProfile; + if (!UHyperTwistTrainingMagic120CellLibrary::TryGetViewProfileContractById( + Bundle, + Bundle.PrimaryViewProfileContractId, + ViewProfile)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface ViewContextSurface; + ViewContextSurface.ViewContextSurfaceId = + TEXT("phase6c/magic120cell/shared-training-view-context-surface"); + ViewContextSurface.ActivationProfileId = LaunchSurface.ActivationProfileId; + ViewContextSurface.LaunchSurfaceId = LaunchSurface.LaunchSurfaceId; + ViewContextSurface.HostSurfaceId = HostSurface.HostSurfaceId; + ViewContextSurface.Title = TEXT("Magic120Cell shared-map view context surface"); + ViewContextSurface.Summary = + TEXT("Dedicated-family view-context surface that keeps the Magic120Cell projection, symmetry, visibility, and focus posture explicit above the shared HyperTwist training-map host."); + ViewContextSurface.HostMapPath = HostSurface.EffectiveHostMapPath; + ViewContextSurface.HostMapRouteId = HostSurface.EffectiveHostMapRouteId; + ViewContextSurface.HostMapLabel = HostSurface.EffectiveHostMapLabel; + ViewContextSurface.bUsesSharedTrainingMapFallback = + HostSurface.bUsesSharedTrainingMapFallback; + ViewContextSurface.PrimaryViewProfileContractId = ViewProfile.ContractId; + AppendUniqueStrings( + ViewContextSurface.ProjectionSurfaceTags, + ViewProfile.ProjectionSurfaceTags); + AppendUniqueStrings( + ViewContextSurface.ContextSurfaceTags, + ViewProfile.SymmetryPresetTags); + AppendUniqueStrings( + ViewContextSurface.ContextSurfaceTags, + ViewProfile.VisibilityPresetTags); + AppendUniqueStrings( + ViewContextSurface.FocusSurfaceTags, + ViewProfile.FocusSurfaceTags); + ViewContextSurface.ViewTags = + { + TEXT("phase6c"), + TEXT("higher-dimensional"), + TEXT("view-context"), + TEXT("family:magic120cell"), + TEXT("host:shared-training-map"), + FString::Printf(TEXT("activation-profile:%s"), + *LaunchSurface.ActivationProfileId.ToLower()), + FString::Printf(TEXT("host-surface:%s"), + *HostSurface.HostSurfaceId.ToLower()), + FString::Printf(TEXT("launch-surface:%s"), + *LaunchSurface.LaunchSurfaceId.ToLower()) + }; + AppendUniqueStrings(ViewContextSurface.ViewTags, LaunchSurface.ViewSurfaceTags); + AppendUniqueStrings(ViewContextSurface.ViewTags, HostSurface.HostTags); + AppendUniqueStrings( + ViewContextSurface.ViewTags, + ViewContextSurface.ProjectionSurfaceTags); + AppendUniqueStrings( + ViewContextSurface.ViewTags, + ViewContextSurface.ContextSurfaceTags); + AppendUniqueStrings( + ViewContextSurface.ViewTags, + ViewContextSurface.FocusSurfaceTags); + ViewContextSurface.Selectors = + { + MakeSelector(TEXT("projection"), TEXT("Projection"), TEXT("projection")), + MakeSelector(TEXT("symmetry"), TEXT("Symmetry"), TEXT("symmetry")), + MakeSelector(TEXT("visibility"), TEXT("Visibility"), TEXT("visibility")), + MakeSelector(TEXT("focus"), TEXT("Focus"), TEXT("focus")) + }; + ViewContextSurface.DefaultSelectorChoices = + { + MakeChoice(TEXT("projection"), TEXT("projection"), TEXT("4d-projection-distance"), TEXT("4D Projection Distance")), + MakeChoice(TEXT("symmetry"), TEXT("symmetry"), TEXT("full-puzzle-default-mode"), TEXT("Full Puzzle Default")), + MakeChoice(TEXT("visibility"), TEXT("visibility"), TEXT("logical-visibility-depth-ladder"), TEXT("Logical Visibility Ladder")), + MakeChoice(TEXT("focus"), TEXT("focus"), TEXT("center-cell-recentering"), TEXT("Center Cell Recentering")) + }; + ViewContextSurface.SourceAttribution = MakeViewContextAttribution( + ViewContextSurface.ViewContextSurfaceId, + TEXT("Phase 6C dedicated-family view-context surface for Magic120Cell on the explicit host-surface seam, preserving owned projection, symmetry, visibility, and focus defaults while the shared training-map fallback remains effective.") + ); + return ViewContextSurface; + } + + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface BuildMagicCube5DViewContextSurface() + { + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface LaunchSurface; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeLaunchSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeLaunchCatalog(), + TEXT("magiccube5d-cleanroom-runtime-activation"), + LaunchSurface)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface HostSurface; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeHostCatalog(), + LaunchSurface.ActivationProfileId, + HostSurface)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + } + + const FHyperTwistTrainingMagicCube5DReferenceBundle Bundle = + UHyperTwistTrainingMagicCube5DLibrary::BuildBundledMagicCube5DReferenceBundle(); + FHyperTwistTrainingMagicCube5DViewProfileContract ViewProfile; + if (!UHyperTwistTrainingMagicCube5DLibrary::TryGetViewProfileContractById( + Bundle, + Bundle.PrimaryViewProfileContractId, + ViewProfile)) + { + return FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + } + + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface ViewContextSurface; + ViewContextSurface.ViewContextSurfaceId = + TEXT("phase6c/magiccube5d/shared-training-view-context-surface"); + ViewContextSurface.ActivationProfileId = LaunchSurface.ActivationProfileId; + ViewContextSurface.LaunchSurfaceId = LaunchSurface.LaunchSurfaceId; + ViewContextSurface.HostSurfaceId = HostSurface.HostSurfaceId; + ViewContextSurface.Title = TEXT("MagicCube5D shared-map view context surface"); + ViewContextSurface.Summary = + TEXT("Dedicated-family view-context surface that keeps the MagicCube5D projection, stereo, visibility, and focus posture explicit above the shared HyperTwist training-map host."); + ViewContextSurface.HostMapPath = HostSurface.EffectiveHostMapPath; + ViewContextSurface.HostMapRouteId = HostSurface.EffectiveHostMapRouteId; + ViewContextSurface.HostMapLabel = HostSurface.EffectiveHostMapLabel; + ViewContextSurface.bUsesSharedTrainingMapFallback = + HostSurface.bUsesSharedTrainingMapFallback; + ViewContextSurface.PrimaryViewProfileContractId = ViewProfile.ContractId; + AppendUniqueStrings( + ViewContextSurface.ProjectionSurfaceTags, + ViewProfile.ProjectionSurfaceTags); + AppendUniqueStrings( + ViewContextSurface.ContextSurfaceTags, + ViewProfile.StereoSurfaceTags); + AppendUniqueStrings( + ViewContextSurface.ContextSurfaceTags, + ViewProfile.VisibilitySurfaceTags); + AppendUniqueStrings( + ViewContextSurface.FocusSurfaceTags, + ViewProfile.FocusSurfaceTags); + ViewContextSurface.ViewTags = + { + TEXT("phase6c"), + TEXT("higher-dimensional"), + TEXT("view-context"), + TEXT("family:magiccube5d"), + TEXT("host:shared-training-map"), + FString::Printf(TEXT("activation-profile:%s"), + *LaunchSurface.ActivationProfileId.ToLower()), + FString::Printf(TEXT("host-surface:%s"), + *HostSurface.HostSurfaceId.ToLower()), + FString::Printf(TEXT("launch-surface:%s"), + *LaunchSurface.LaunchSurfaceId.ToLower()) + }; + AppendUniqueStrings(ViewContextSurface.ViewTags, LaunchSurface.ViewSurfaceTags); + AppendUniqueStrings(ViewContextSurface.ViewTags, HostSurface.HostTags); + AppendUniqueStrings( + ViewContextSurface.ViewTags, + ViewContextSurface.ProjectionSurfaceTags); + AppendUniqueStrings( + ViewContextSurface.ViewTags, + ViewContextSurface.ContextSurfaceTags); + AppendUniqueStrings( + ViewContextSurface.ViewTags, + ViewContextSurface.FocusSurfaceTags); + ViewContextSurface.Selectors = + { + MakeSelector(TEXT("projection"), TEXT("Projection"), TEXT("projection")), + MakeSelector(TEXT("stereo"), TEXT("Stereo"), TEXT("stereo")), + MakeSelector(TEXT("visibility"), TEXT("Visibility"), TEXT("visibility")), + MakeSelector(TEXT("focus"), TEXT("Focus"), TEXT("focus")) + }; + ViewContextSurface.DefaultSelectorChoices = + { + MakeChoice(TEXT("projection"), TEXT("projection"), TEXT("5d-projection-distance"), TEXT("5D Projection Distance")), + MakeChoice(TEXT("stereo"), TEXT("stereo"), TEXT("stereo-disabled-default"), TEXT("Stereo Disabled Default")), + MakeChoice(TEXT("visibility"), TEXT("visibility"), TEXT("all-faces-visible-default"), TEXT("All Faces Visible")), + MakeChoice(TEXT("focus"), TEXT("focus"), TEXT("view-centered-solved-progress"), TEXT("View-centered Solved Progress")) + }; + ViewContextSurface.SourceAttribution = MakeViewContextAttribution( + ViewContextSurface.ViewContextSurfaceId, + TEXT("Phase 6C dedicated-family view-context surface for MagicCube5D on the explicit host-surface seam, preserving owned projection, stereo, visibility, and focus defaults while the shared training-map fallback remains effective.") + ); + return ViewContextSurface; + } } FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog @@ -339,3 +927,284 @@ bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryResolvePuzzleDefinit OutDefinition = Profile.ToDefinitionRef(); return OutDefinition.IsStructurallyValid(); } + +FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog +UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeHostCatalog() +{ + FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog Catalog; + Catalog.HostSurfaces = + { + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::BuildMagic120CellHostSurface(), + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::BuildMagicCube5DHostSurface() + }; + return Catalog; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByActivationProfileId( + const FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog& Catalog, + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface +) +{ + if (ActivationProfileId.IsEmpty()) + { + OutHostSurface = FHyperTwistTrainingHigherDimensionalRuntimeHostSurface(); + return false; + } + + for (const FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& HostSurface : + Catalog.HostSurfaces) + { + if (HostSurface.ActivationProfileId.Equals(ActivationProfileId, ESearchCase::IgnoreCase)) + { + OutHostSurface = HostSurface; + return true; + } + } + + OutHostSurface = FHyperTwistTrainingHigherDimensionalRuntimeHostSurface(); + return false; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByPuzzleId( + const FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog& Catalog, + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface +) +{ + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (PuzzleId.IsEmpty() + || !TryGetRuntimeActivationProfileByPuzzleId( + BuildBundledHigherDimensionalRuntimeActivationCatalog(), + PuzzleId, + Profile)) + { + OutHostSurface = FHyperTwistTrainingHigherDimensionalRuntimeHostSurface(); + return false; + } + + return TryGetRuntimeHostSurfaceByActivationProfileId( + Catalog, + Profile.ActivationProfileId, + OutHostSurface + ); +} + +FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog +UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeLaunchCatalog() +{ + FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog Catalog; + Catalog.LaunchSurfaces = + { + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::BuildMagic120CellLaunchSurface(), + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::BuildMagicCube5DLaunchSurface() + }; + return Catalog; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeLaunchSurfaceByActivationProfileId( + const FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog& Catalog, + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface +) +{ + if (ActivationProfileId.IsEmpty()) + { + OutLaunchSurface = FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + return false; + } + + for (const FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& LaunchSurface : + Catalog.LaunchSurfaces) + { + if (LaunchSurface.ActivationProfileId.Equals(ActivationProfileId, ESearchCase::IgnoreCase)) + { + OutLaunchSurface = LaunchSurface; + return true; + } + } + + OutLaunchSurface = FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + return false; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeLaunchSurfaceByPuzzleId( + const FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog& Catalog, + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface +) +{ + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (PuzzleId.IsEmpty() + || !TryGetRuntimeActivationProfileByPuzzleId( + BuildBundledHigherDimensionalRuntimeActivationCatalog(), + PuzzleId, + Profile)) + { + OutLaunchSurface = FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + return false; + } + + return TryGetRuntimeLaunchSurfaceByActivationProfileId( + Catalog, + Profile.ActivationProfileId, + OutLaunchSurface + ); +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryBuildTrainingDeckFromRuntimeLaunchSurface( + const FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& LaunchSurface, + FHyperTwistTrainingDeck& OutDeck +) +{ + OutDeck = FHyperTwistTrainingDeck(); + if (!LaunchSurface.IsStructurallyValid()) + { + return false; + } + + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog ActivationCatalog = + BuildBundledHigherDimensionalRuntimeActivationCatalog(); + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (!TryGetRuntimeActivationProfileById( + ActivationCatalog, + LaunchSurface.ActivationProfileId, + Profile)) + { + return false; + } + + FHyperTwistTrainingImportedRuntimeSurface RuntimeSurface; + RuntimeSurface.SurfaceKind = LaunchSurface.SurfaceKind; + RuntimeSurface.SurfaceId = LaunchSurface.SurfaceId; + RuntimeSurface.SurfaceLabel = LaunchSurface.SurfaceLabel; + RuntimeSurface.RuntimeModeId = LaunchSurface.RuntimeModeId; + RuntimeSurface.GeneratorType = LaunchSurface.GeneratorType; + RuntimeSurface.Selectors = LaunchSurface.Selectors; + RuntimeSurface.OriginPaths = + { + LaunchSurface.LaunchSurfaceId, + LaunchSurface.HostSurfaceId, + LaunchSurface.HostMapPath, + LaunchSurface.HostMapRouteId + }; + RuntimeSurface.Notes = LaunchSurface.Summary; + + FHyperTwistTrainingCase SeedCase; + SeedCase.CaseId = LaunchSurface.SeedCaseId; + SeedCase.PuzzleId = Profile.PuzzleId; + SeedCase.PromptKind = EHyperTwistTrainingPromptKind::State; + SeedCase.PromptLabel = LaunchSurface.SeedPromptLabel; + SeedCase.Tags = + { + TEXT("phase6c"), + TEXT("higher-dimensional"), + TEXT("runtime-surface:generated-mode"), + TEXT("generated-mode:launch-seed"), + FString::Printf(TEXT("activation-profile:%s"), *Profile.ActivationProfileId.ToLower()), + FString::Printf(TEXT("launch-surface:%s"), *LaunchSurface.LaunchSurfaceId.ToLower()), + FString::Printf(TEXT("host-surface:%s"), *LaunchSurface.HostSurfaceId.ToLower()), + FString::Printf(TEXT("host-map-route:%s"), *LaunchSurface.HostMapRouteId.ToLower()) + }; + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::AppendUniqueStrings( + SeedCase.Tags, + LaunchSurface.LaunchTags + ); + SeedCase.AllowedDeliveryModes = {EHyperTwistTrainingDeliveryMode::VirtualCube}; + SeedCase.SourceAttribution = LaunchSurface.SourceAttribution; + SeedCase.SourceAttribution.SourceDeckId = LaunchSurface.DeckId; + SeedCase.SourceAttribution.SourceCaseId = SeedCase.CaseId; + + OutDeck.DeckId = LaunchSurface.DeckId; + OutDeck.Title = LaunchSurface.Title; + OutDeck.DeliveryModes = {EHyperTwistTrainingDeliveryMode::VirtualCube}; + OutDeck.SelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted; + OutDeck.bSupportsAlgorithmReveal = false; + OutDeck.bSupportsVirtualCube = true; + OutDeck.Cases = {SeedCase}; + OutDeck.Tags = + { + TEXT("phase6c"), + TEXT("higher-dimensional"), + TEXT("runtime-surface:generated-mode"), + TEXT("generated-mode:dedicated-family-launch"), + FString::Printf(TEXT("activation-profile:%s"), *Profile.ActivationProfileId.ToLower()), + FString::Printf(TEXT("launch-surface:%s"), *LaunchSurface.LaunchSurfaceId.ToLower()), + FString::Printf(TEXT("host-surface:%s"), *LaunchSurface.HostSurfaceId.ToLower()), + FString::Printf(TEXT("host-map-route:%s"), *LaunchSurface.HostMapRouteId.ToLower()) + }; + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::AppendUniqueStrings( + OutDeck.Tags, + LaunchSurface.LaunchTags + ); + OutDeck.SourceAttribution = LaunchSurface.SourceAttribution; + OutDeck.SourceAttribution.SourceDeckId = LaunchSurface.DeckId; + OutDeck.ImportedRuntimeSurface = RuntimeSurface; + return OutDeck.IsStructurallyValid() + && OutDeck.ImportedRuntimeSurface.IsStructurallyValid() + && SeedCase.IsStructurallyValid(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog +UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeViewContextCatalog() +{ + FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog Catalog; + Catalog.ViewContextSurfaces = + { + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::BuildMagic120CellViewContextSurface(), + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::BuildMagicCube5DViewContextSurface() + }; + return Catalog; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeViewContextSurfaceByActivationProfileId( + const FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog& Catalog, + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface +) +{ + if (ActivationProfileId.IsEmpty()) + { + OutViewContextSurface = FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + return false; + } + + for (const FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& ViewContextSurface : + Catalog.ViewContextSurfaces) + { + if (ViewContextSurface.ActivationProfileId.Equals( + ActivationProfileId, + ESearchCase::IgnoreCase)) + { + OutViewContextSurface = ViewContextSurface; + return true; + } + } + + OutViewContextSurface = FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + return false; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeViewContextSurfaceByPuzzleId( + const FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog& Catalog, + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface +) +{ + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (PuzzleId.IsEmpty() + || !TryGetRuntimeActivationProfileByPuzzleId( + BuildBundledHigherDimensionalRuntimeActivationCatalog(), + PuzzleId, + Profile)) + { + OutViewContextSurface = FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + return false; + } + + return TryGetRuntimeViewContextSurfaceByActivationProfileId( + Catalog, + Profile.ActivationProfileId, + OutViewContextSurface + ); +} diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingPanelWidget.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingPanelWidget.cpp index 4b30e84..7c15030 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingPanelWidget.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingPanelWidget.cpp @@ -135,6 +135,27 @@ void UHyperTwistTrainingPanelWidget::RefreshTrainingState() CachedHigherDimensionalRuntimeActivationProfile = FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); } + if (!UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeHostSurface( + this, + CachedHigherDimensionalRuntimeHostSurface)) + { + CachedHigherDimensionalRuntimeHostSurface = + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface(); + } + if (!UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeLaunchSurface( + this, + CachedHigherDimensionalRuntimeLaunchSurface)) + { + CachedHigherDimensionalRuntimeLaunchSurface = + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + } + if (!UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeViewContextSurface( + this, + CachedHigherDimensionalRuntimeViewContextSurface)) + { + CachedHigherDimensionalRuntimeViewContextSurface = + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + } CachedMethodDrillRunState = UHyperTwistTrainingRuntimeLibrary::GetActiveMethodDrillRunState(this); CachedMethodDrillSummary = UHyperTwistTrainingRuntimeLibrary::GetActiveMethodDrillSummary(this); CachedMethodDrillDiagnosticPacket = @@ -417,6 +438,39 @@ UHyperTwistTrainingPanelWidget::GetDisplayedHigherDimensionalRuntimeActivationPr return CachedHigherDimensionalRuntimeActivationProfile; } +bool UHyperTwistTrainingPanelWidget::HasDisplayedHigherDimensionalRuntimeHostSurface() const +{ + return CachedHigherDimensionalRuntimeHostSurface.IsStructurallyValid(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeHostSurface +UHyperTwistTrainingPanelWidget::GetDisplayedHigherDimensionalRuntimeHostSurface() const +{ + return CachedHigherDimensionalRuntimeHostSurface; +} + +bool UHyperTwistTrainingPanelWidget::HasDisplayedHigherDimensionalRuntimeLaunchSurface() const +{ + return CachedHigherDimensionalRuntimeLaunchSurface.IsStructurallyValid(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface +UHyperTwistTrainingPanelWidget::GetDisplayedHigherDimensionalRuntimeLaunchSurface() const +{ + return CachedHigherDimensionalRuntimeLaunchSurface; +} + +bool UHyperTwistTrainingPanelWidget::HasDisplayedHigherDimensionalRuntimeViewContextSurface() const +{ + return CachedHigherDimensionalRuntimeViewContextSurface.IsStructurallyValid(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface +UHyperTwistTrainingPanelWidget::GetDisplayedHigherDimensionalRuntimeViewContextSurface() const +{ + return CachedHigherDimensionalRuntimeViewContextSurface; +} + FHyperTwistTrainingDeck UHyperTwistTrainingPanelWidget::BuildActiveCoachRecommendedDeck(const int32 MaxCases) { CachedCoachRecommendedDeck = UHyperTwistTrainingRuntimeLibrary::BuildActiveCoachRecommendedDeck( diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp index 5d4dad9..0f6385a 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp @@ -219,6 +219,63 @@ namespace HyperTwistTrainingRuntimeLibraryInternal OutProfile = FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); return false; } + + bool TryResolveHigherDimensionalRuntimeLaunchSurface( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface + ) + { + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile ActivationProfile; + if (!TryResolveHigherDimensionalRuntimeActivationProfile(RunState, ActivationProfile)) + { + OutLaunchSurface = FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + return false; + } + + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeLaunchSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeLaunchCatalog(), + ActivationProfile.ActivationProfileId, + OutLaunchSurface + ); + } + + bool TryResolveHigherDimensionalRuntimeHostSurface( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface + ) + { + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile ActivationProfile; + if (!TryResolveHigherDimensionalRuntimeActivationProfile(RunState, ActivationProfile)) + { + OutHostSurface = FHyperTwistTrainingHigherDimensionalRuntimeHostSurface(); + return false; + } + + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeHostCatalog(), + ActivationProfile.ActivationProfileId, + OutHostSurface + ); + } + + bool TryResolveHigherDimensionalRuntimeViewContextSurface( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface + ) + { + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile ActivationProfile; + if (!TryResolveHigherDimensionalRuntimeActivationProfile(RunState, ActivationProfile)) + { + OutViewContextSurface = FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + return false; + } + + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeViewContextSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeViewContextCatalog(), + ActivationProfile.ActivationProfileId, + OutViewContextSurface + ); + } } UHyperTwistTrainingSubsystem* UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(UObject* WorldContextObject) @@ -628,6 +685,24 @@ UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeActivationC return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog(); } +FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog +UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeHostCatalog() +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeHostCatalog(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog +UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeLaunchCatalog() +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeLaunchCatalog(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog +UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeViewContextCatalog() +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeViewContextCatalog(); +} + FHyperTwistTrainingLearnedSearchReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledLearnedSearchReferenceBundle() { @@ -7167,6 +7242,173 @@ bool UHyperTwistTrainingRuntimeLibrary::TryResolveBundledHigherDimensionalPuzzle ); } +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeHostSurfaceByActivationProfileId( + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByActivationProfileId( + GetBundledHigherDimensionalRuntimeHostCatalog(), + ActivationProfileId, + OutHostSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeHostSurfaceByPuzzleId( + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeHostSurfaceByPuzzleId( + GetBundledHigherDimensionalRuntimeHostCatalog(), + PuzzleId, + OutHostSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetHigherDimensionalRuntimeHostSurfaceForRunState( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface +) +{ + return HyperTwistTrainingRuntimeLibraryInternal::TryResolveHigherDimensionalRuntimeHostSurface( + RunState, + OutHostSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeLaunchSurfaceByActivationProfileId( + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeLaunchSurfaceByActivationProfileId( + GetBundledHigherDimensionalRuntimeLaunchCatalog(), + ActivationProfileId, + OutLaunchSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeLaunchSurfaceByPuzzleId( + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeLaunchSurfaceByPuzzleId( + GetBundledHigherDimensionalRuntimeLaunchCatalog(), + PuzzleId, + OutLaunchSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetHigherDimensionalRuntimeLaunchSurfaceForRunState( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface +) +{ + return HyperTwistTrainingRuntimeLibraryInternal::TryResolveHigherDimensionalRuntimeLaunchSurface( + RunState, + OutLaunchSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeViewContextSurfaceByActivationProfileId( + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeViewContextSurfaceByActivationProfileId( + GetBundledHigherDimensionalRuntimeViewContextCatalog(), + ActivationProfileId, + OutViewContextSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeViewContextSurfaceByPuzzleId( + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeViewContextSurfaceByPuzzleId( + GetBundledHigherDimensionalRuntimeViewContextCatalog(), + PuzzleId, + OutViewContextSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetHigherDimensionalRuntimeViewContextSurfaceForRunState( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface +) +{ + return HyperTwistTrainingRuntimeLibraryInternal::TryResolveHigherDimensionalRuntimeViewContextSurface( + RunState, + OutViewContextSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeHostSurface( + UObject* WorldContextObject, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface +) +{ + return TryGetHigherDimensionalRuntimeHostSurfaceForRunState( + GetActiveTrainingRunState(WorldContextObject), + OutHostSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeLaunchSurface( + UObject* WorldContextObject, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface +) +{ + return TryGetHigherDimensionalRuntimeLaunchSurfaceForRunState( + GetActiveTrainingRunState(WorldContextObject), + OutLaunchSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeViewContextSurface( + UObject* WorldContextObject, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface +) +{ + return TryGetHigherDimensionalRuntimeViewContextSurfaceForRunState( + GetActiveTrainingRunState(WorldContextObject), + OutViewContextSurface + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryStartHigherDimensionalLaunchSurface( + UObject* WorldContextObject, + const FString& ActivationProfileId, + const FString& UserId, + const FString& SessionId, + EHyperTwistTrainingDeliveryMode Mode, + const bool bExecuteGeneratedModeLaunchRequest, + FHyperTwistTrainingRunState& OutRunState, + FString& OutBlockedReason +) +{ + if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject)) + { + return TrainingSubsystem->TryStartHigherDimensionalLaunchSurface( + ActivationProfileId, + UserId, + SessionId, + Mode, + bExecuteGeneratedModeLaunchRequest, + OutRunState, + OutBlockedReason + ); + } + + OutRunState = FHyperTwistTrainingRunState(); + OutBlockedReason = TEXT("Higher-dimensional launch-surface execution requires a training subsystem."); + return false; +} + bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledLearnedSearchExperimentProfileContract( const FString& ContractId, FHyperTwistTrainingLearnedSearchExperimentProfileContract& OutContract diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSessionActor.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSessionActor.cpp index 4529cbc..8ab97a7 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSessionActor.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSessionActor.cpp @@ -235,6 +235,27 @@ void AHyperTwistTrainingSessionActor::RefreshCachedTrainingState() CachedHigherDimensionalRuntimeActivationProfile = FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); } + if (!UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeHostSurface( + this, + CachedHigherDimensionalRuntimeHostSurface)) + { + CachedHigherDimensionalRuntimeHostSurface = + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface(); + } + if (!UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeLaunchSurface( + this, + CachedHigherDimensionalRuntimeLaunchSurface)) + { + CachedHigherDimensionalRuntimeLaunchSurface = + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface(); + } + if (!UHyperTwistTrainingRuntimeLibrary::TryGetActiveHigherDimensionalRuntimeViewContextSurface( + this, + CachedHigherDimensionalRuntimeViewContextSurface)) + { + CachedHigherDimensionalRuntimeViewContextSurface = + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface(); + } CachedActiveTrainingSessionTemplates = UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingSessionTemplates(this); if (AutoStartUserId.IsEmpty()) @@ -390,6 +411,39 @@ AHyperTwistTrainingSessionActor::GetDisplayedHigherDimensionalRuntimeActivationP return CachedHigherDimensionalRuntimeActivationProfile; } +bool AHyperTwistTrainingSessionActor::HasDisplayedHigherDimensionalRuntimeHostSurface() const +{ + return CachedHigherDimensionalRuntimeHostSurface.IsStructurallyValid(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeHostSurface +AHyperTwistTrainingSessionActor::GetDisplayedHigherDimensionalRuntimeHostSurface() const +{ + return CachedHigherDimensionalRuntimeHostSurface; +} + +bool AHyperTwistTrainingSessionActor::HasDisplayedHigherDimensionalRuntimeLaunchSurface() const +{ + return CachedHigherDimensionalRuntimeLaunchSurface.IsStructurallyValid(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface +AHyperTwistTrainingSessionActor::GetDisplayedHigherDimensionalRuntimeLaunchSurface() const +{ + return CachedHigherDimensionalRuntimeLaunchSurface; +} + +bool AHyperTwistTrainingSessionActor::HasDisplayedHigherDimensionalRuntimeViewContextSurface() const +{ + return CachedHigherDimensionalRuntimeViewContextSurface.IsStructurallyValid(); +} + +FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface +AHyperTwistTrainingSessionActor::GetDisplayedHigherDimensionalRuntimeViewContextSurface() const +{ + return CachedHigherDimensionalRuntimeViewContextSurface; +} + FHyperTwistTrainingDeck AHyperTwistTrainingSessionActor::BuildCoachRecommendedDeck(const int32 MaxCases) { CachedCoachRecommendedDeck = UHyperTwistTrainingRuntimeLibrary::BuildActiveCoachRecommendedDeck( diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp index 4e968f7..0f89fae 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp @@ -9676,6 +9676,112 @@ bool UHyperTwistTrainingSubsystem::TryExecuteActiveImportedGeneratedModeLaunchRe return OutRunState.IsStructurallyValid(); } +bool UHyperTwistTrainingSubsystem::TryStartHigherDimensionalLaunchSurface( + const FString& ActivationProfileId, + const FString& UserId, + const FString& SessionId, + const EHyperTwistTrainingDeliveryMode Mode, + const bool bExecuteGeneratedModeLaunchRequest, + FHyperTwistTrainingRunState& OutRunState, + FString& OutBlockedReason +) +{ + OutRunState = FHyperTwistTrainingRunState(); + OutBlockedReason.Reset(); + + if (Mode != EHyperTwistTrainingDeliveryMode::VirtualCube) + { + OutBlockedReason = + TEXT("Higher-dimensional launch surfaces currently require VirtualCube delivery mode."); + return false; + } + + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface LaunchSurface; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeLaunchSurfaceByActivationProfileId( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeLaunchCatalog(), + ActivationProfileId, + LaunchSurface)) + { + OutBlockedReason = + TEXT("Higher-dimensional launch surface could not be resolved from the activation profile id."); + return false; + } + + FHyperTwistTrainingDeck LaunchDeck; + if (!UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryBuildTrainingDeckFromRuntimeLaunchSurface( + LaunchSurface, + LaunchDeck)) + { + OutBlockedReason = + TEXT("Higher-dimensional launch surface could not be translated into a structurally valid training deck."); + return false; + } + + const FString EffectiveUserId = UserId.IsEmpty() ? TEXT("local-user") : UserId; + const FString EffectiveSessionId = !SessionId.IsEmpty() + ? SessionId + : FString::Printf( + TEXT("phase6c_launch_%s"), + *FGuid::NewGuid().ToString(EGuidFormats::Digits)); + OutRunState = StartTrainingRunFromDeck( + LaunchDeck, + EffectiveUserId, + EffectiveSessionId, + Mode + ); + if (!OutRunState.IsStructurallyValid()) + { + OutBlockedReason = + TEXT("Higher-dimensional launch surface could not start a structurally valid seed run."); + return false; + } + + for (const FHyperTwistTrainingImportedRuntimeSelectorChoice& Choice : + LaunchSurface.DefaultSelectorChoices) + { + OutRunState = ApplyActiveImportedGeneratedModeSelectorChoice( + Choice.SelectorId, + Choice.SelectedValue, + Choice.DisplayValue + ); + if (!OutRunState.IsStructurallyValid()) + { + OutBlockedReason = FString::Printf( + TEXT("Higher-dimensional launch surface could not apply default selector %s."), + *Choice.SelectorId + ); + return false; + } + } + + if (!bExecuteGeneratedModeLaunchRequest) + { + return true; + } + + const FHyperTwistTrainingImportedGeneratedModeLaunchRequest LaunchRequest = + CreateActiveImportedGeneratedModeLaunchRequest( + TEXT("phase6c-higher-dimensional-launch-surface") + ); + if (!LaunchRequest.IsStructurallyValid()) + { + OutBlockedReason = + TEXT("Higher-dimensional launch surface could not persist a generated-mode launch request."); + return false; + } + + if (!TryExecuteActiveImportedGeneratedModeLaunchRequest(OutRunState, OutBlockedReason)) + { + if (OutBlockedReason.IsEmpty()) + { + OutBlockedReason = TEXT("Higher-dimensional launch surface generated-mode execution failed."); + } + return false; + } + + return OutRunState.IsStructurallyValid(); +} + FHyperTwistTrainingRunState UHyperTwistTrainingSubsystem::ApplyActiveImportedRuntimeSelectorOption( const FString& SelectorId, const FString& OptionId diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h index d2420e4..4ce8802 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h @@ -192,6 +192,500 @@ struct FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog } }; +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHigherDimensionalRuntimeHostSurface +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostSurfaceId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ActivationProfileId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Title; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Summary; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PreferredHostMapPath; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PreferredHostMapRouteId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PreferredHostMapLabel; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString EffectiveHostMapPath; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString EffectiveHostMapRouteId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString EffectiveHostMapLabel; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bDedicatedFamilyHostMapAuthored = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bUsesSharedTrainingMapFallback = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray HostTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FHyperTwistTrainingSourceAttribution SourceAttribution; + + bool IsStructurallyValid() const + { + return !HostSurfaceId.IsEmpty() + && !ActivationProfileId.IsEmpty() + && !Title.IsEmpty() + && !Summary.IsEmpty() + && !PreferredHostMapPath.IsEmpty() + && !PreferredHostMapRouteId.IsEmpty() + && !PreferredHostMapLabel.IsEmpty() + && !EffectiveHostMapPath.IsEmpty() + && !EffectiveHostMapRouteId.IsEmpty() + && !EffectiveHostMapLabel.IsEmpty() + && SourceAttribution.IsStructurallyValid(); + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CatalogId = TEXT("phase6c/higher-dimensional-runtime-host"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CatalogVersion = TEXT("2026.06.17"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray HostSurfaces; + + bool IsStructurallyValid() const + { + if (CatalogId.IsEmpty() || CatalogVersion.IsEmpty() || HostSurfaces.Num() == 0) + { + return false; + } + + TSet SeenHostSurfaceIds; + TSet SeenActivationProfileIds; + for (const FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& HostSurface : HostSurfaces) + { + if (!HostSurface.IsStructurallyValid()) + { + return false; + } + + const FString NormalizedHostSurfaceId = HostSurface.HostSurfaceId.ToLower(); + if (SeenHostSurfaceIds.Contains(NormalizedHostSurfaceId)) + { + return false; + } + + const FString NormalizedActivationProfileId = HostSurface.ActivationProfileId.ToLower(); + if (SeenActivationProfileIds.Contains(NormalizedActivationProfileId)) + { + return false; + } + + SeenHostSurfaceIds.Add(NormalizedHostSurfaceId); + SeenActivationProfileIds.Add(NormalizedActivationProfileId); + } + + return true; + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString LaunchSurfaceId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ActivationProfileId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostSurfaceId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Title; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Summary; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostMapPath; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostMapRouteId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostMapLabel; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bUsesSharedTrainingMapFallback = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString DeckId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString SeedCaseId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString SeedPromptLabel; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString SurfaceKind = TEXT("generated-mode"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString SurfaceId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString SurfaceLabel; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString RuntimeModeId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString GeneratorType; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryPersistenceBoundaryId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray PersistenceSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray InteractionSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ViewSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray LaunchTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RequiredNoticeActions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray Selectors; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray DefaultSelectorChoices; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FHyperTwistTrainingSourceAttribution SourceAttribution; + + bool IsStructurallyValid() const + { + if (LaunchSurfaceId.IsEmpty() + || ActivationProfileId.IsEmpty() + || HostSurfaceId.IsEmpty() + || Title.IsEmpty() + || HostMapPath.IsEmpty() + || HostMapRouteId.IsEmpty() + || DeckId.IsEmpty() + || SeedCaseId.IsEmpty() + || SeedPromptLabel.IsEmpty() + || SurfaceKind.IsEmpty() + || SurfaceId.IsEmpty() + || SurfaceLabel.IsEmpty() + || RuntimeModeId.IsEmpty() + || GeneratorType.IsEmpty() + || PrimaryPersistenceBoundaryId.IsEmpty() + || !SourceAttribution.IsStructurallyValid() + || Selectors.Num() == 0 + || DefaultSelectorChoices.Num() == 0) + { + return false; + } + + TSet SeenSelectorIds; + for (const FHyperTwistTrainingImportedRuntimeSelector& Selector : Selectors) + { + if (!Selector.IsStructurallyValid()) + { + return false; + } + + const FString NormalizedSelectorId = Selector.SelectorId.ToLower(); + if (SeenSelectorIds.Contains(NormalizedSelectorId)) + { + return false; + } + + SeenSelectorIds.Add(NormalizedSelectorId); + } + + TSet SeenChoiceSelectorIds; + for (const FHyperTwistTrainingImportedRuntimeSelectorChoice& Choice : DefaultSelectorChoices) + { + if (!Choice.IsStructurallyValid()) + { + return false; + } + + const FString NormalizedSelectorId = Choice.SelectorId.ToLower(); + if (!SeenSelectorIds.Contains(NormalizedSelectorId) + || SeenChoiceSelectorIds.Contains(NormalizedSelectorId)) + { + return false; + } + + SeenChoiceSelectorIds.Add(NormalizedSelectorId); + } + + return SeenChoiceSelectorIds.Num() == SeenSelectorIds.Num(); + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CatalogId = TEXT("phase6c/higher-dimensional-runtime-launch"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CatalogVersion = TEXT("2026.06.17"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray LaunchSurfaces; + + bool IsStructurallyValid() const + { + if (CatalogId.IsEmpty() || CatalogVersion.IsEmpty() || LaunchSurfaces.Num() == 0) + { + return false; + } + + TSet SeenLaunchSurfaceIds; + TSet SeenActivationProfileIds; + TSet SeenSurfaceIds; + for (const FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& LaunchSurface : LaunchSurfaces) + { + if (!LaunchSurface.IsStructurallyValid()) + { + return false; + } + + const FString NormalizedLaunchSurfaceId = LaunchSurface.LaunchSurfaceId.ToLower(); + if (SeenLaunchSurfaceIds.Contains(NormalizedLaunchSurfaceId)) + { + return false; + } + + const FString NormalizedActivationProfileId = LaunchSurface.ActivationProfileId.ToLower(); + if (SeenActivationProfileIds.Contains(NormalizedActivationProfileId)) + { + return false; + } + + const FString NormalizedSurfaceId = LaunchSurface.SurfaceId.ToLower(); + if (SeenSurfaceIds.Contains(NormalizedSurfaceId)) + { + return false; + } + + SeenLaunchSurfaceIds.Add(NormalizedLaunchSurfaceId); + SeenActivationProfileIds.Add(NormalizedActivationProfileId); + SeenSurfaceIds.Add(NormalizedSurfaceId); + } + + return true; + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ViewContextSurfaceId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ActivationProfileId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString LaunchSurfaceId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostSurfaceId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Title; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Summary; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostMapPath; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostMapRouteId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString HostMapLabel; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bUsesSharedTrainingMapFallback = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryViewProfileContractId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ProjectionSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ContextSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray FocusSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ViewTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray Selectors; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray DefaultSelectorChoices; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FHyperTwistTrainingSourceAttribution SourceAttribution; + + bool IsStructurallyValid() const + { + if (ViewContextSurfaceId.IsEmpty() + || ActivationProfileId.IsEmpty() + || LaunchSurfaceId.IsEmpty() + || HostSurfaceId.IsEmpty() + || Title.IsEmpty() + || HostMapPath.IsEmpty() + || HostMapRouteId.IsEmpty() + || HostMapLabel.IsEmpty() + || PrimaryViewProfileContractId.IsEmpty() + || !SourceAttribution.IsStructurallyValid() + || Selectors.Num() == 0 + || DefaultSelectorChoices.Num() == 0) + { + return false; + } + + TSet SeenSelectorIds; + for (const FHyperTwistTrainingImportedRuntimeSelector& Selector : Selectors) + { + if (!Selector.IsStructurallyValid()) + { + return false; + } + + const FString NormalizedSelectorId = Selector.SelectorId.ToLower(); + if (SeenSelectorIds.Contains(NormalizedSelectorId)) + { + return false; + } + + SeenSelectorIds.Add(NormalizedSelectorId); + } + + TSet SeenChoiceSelectorIds; + for (const FHyperTwistTrainingImportedRuntimeSelectorChoice& Choice : DefaultSelectorChoices) + { + if (!Choice.IsStructurallyValid()) + { + return false; + } + + const FString NormalizedSelectorId = Choice.SelectorId.ToLower(); + if (!SeenSelectorIds.Contains(NormalizedSelectorId) + || SeenChoiceSelectorIds.Contains(NormalizedSelectorId)) + { + return false; + } + + SeenChoiceSelectorIds.Add(NormalizedSelectorId); + } + + return SeenChoiceSelectorIds.Num() == SeenSelectorIds.Num(); + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CatalogId = TEXT("phase6c/higher-dimensional-runtime-view-context"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CatalogVersion = TEXT("2026.06.18"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ViewContextSurfaces; + + bool IsStructurallyValid() const + { + if (CatalogId.IsEmpty() || CatalogVersion.IsEmpty() || ViewContextSurfaces.Num() == 0) + { + return false; + } + + TSet SeenViewContextSurfaceIds; + TSet SeenActivationProfileIds; + TSet SeenLaunchSurfaceIds; + for (const FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& ViewContextSurface : + ViewContextSurfaces) + { + if (!ViewContextSurface.IsStructurallyValid()) + { + return false; + } + + const FString NormalizedViewContextSurfaceId = + ViewContextSurface.ViewContextSurfaceId.ToLower(); + if (SeenViewContextSurfaceIds.Contains(NormalizedViewContextSurfaceId)) + { + return false; + } + + const FString NormalizedActivationProfileId = + ViewContextSurface.ActivationProfileId.ToLower(); + if (SeenActivationProfileIds.Contains(NormalizedActivationProfileId)) + { + return false; + } + + const FString NormalizedLaunchSurfaceId = ViewContextSurface.LaunchSurfaceId.ToLower(); + if (SeenLaunchSurfaceIds.Contains(NormalizedLaunchSurfaceId)) + { + return false; + } + + SeenViewContextSurfaceIds.Add(NormalizedViewContextSurfaceId); + SeenActivationProfileIds.Add(NormalizedActivationProfileId); + SeenLaunchSurfaceIds.Add(NormalizedLaunchSurfaceId); + } + + return true; + } +}; + UCLASS() class UNREALHYPERTWIST_API UHyperTwistTrainingHigherDimensionalRuntimeLibrary : public UBlueprintFunctionLibrary { @@ -229,4 +723,64 @@ public: const FString& ActivationProfileIdOrPuzzleId, FHyperTwistPuzzleDefinitionRef& OutDefinition ); + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + static FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog + BuildBundledHigherDimensionalRuntimeHostCatalog(); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetRuntimeHostSurfaceByActivationProfileId( + const FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog& Catalog, + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetRuntimeHostSurfaceByPuzzleId( + const FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog& Catalog, + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface + ); + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + static FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog + BuildBundledHigherDimensionalRuntimeLaunchCatalog(); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetRuntimeLaunchSurfaceByActivationProfileId( + const FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog& Catalog, + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetRuntimeLaunchSurfaceByPuzzleId( + const FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog& Catalog, + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryBuildTrainingDeckFromRuntimeLaunchSurface( + const FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& LaunchSurface, + FHyperTwistTrainingDeck& OutDeck + ); + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + static FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog + BuildBundledHigherDimensionalRuntimeViewContextCatalog(); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetRuntimeViewContextSurfaceByActivationProfileId( + const FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog& Catalog, + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetRuntimeViewContextSurfaceByPuzzleId( + const FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog& Catalog, + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface + ); }; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingPanelWidget.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingPanelWidget.h index e1f9506..b764ff5 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingPanelWidget.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingPanelWidget.h @@ -114,6 +114,15 @@ public: UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training|HigherDimensional") FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile CachedHigherDimensionalRuntimeActivationProfile; + UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface CachedHigherDimensionalRuntimeHostSurface; + + UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface CachedHigherDimensionalRuntimeLaunchSurface; + + UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface CachedHigherDimensionalRuntimeViewContextSurface; + UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training") FHyperTwistTrainingRepositoryRoundTripVerification CachedRepositoryRoundTripVerification; @@ -226,6 +235,27 @@ public: FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile GetDisplayedHigherDimensionalRuntimeActivationProfile() const; + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + bool HasDisplayedHigherDimensionalRuntimeHostSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface + GetDisplayedHigherDimensionalRuntimeHostSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + bool HasDisplayedHigherDimensionalRuntimeLaunchSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface + GetDisplayedHigherDimensionalRuntimeLaunchSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + bool HasDisplayedHigherDimensionalRuntimeViewContextSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface + GetDisplayedHigherDimensionalRuntimeViewContextSurface() const; + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Coach") FHyperTwistTrainingDeck BuildActiveCoachRecommendedDeck(int32 MaxCases); diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h index 6df1d7f..ac1f52f 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h @@ -201,6 +201,18 @@ public: static FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog GetBundledHigherDimensionalRuntimeActivationCatalog(); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + static FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog + GetBundledHigherDimensionalRuntimeHostCatalog(); + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + static FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog + GetBundledHigherDimensionalRuntimeLaunchCatalog(); + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + static FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog + GetBundledHigherDimensionalRuntimeViewContextCatalog(); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|LearnedSearch") static FHyperTwistTrainingLearnedSearchReferenceBundle GetBundledLearnedSearchReferenceBundle(); @@ -3412,6 +3424,90 @@ public: FHyperTwistPuzzleDefinitionRef& OutDefinition ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetBundledHigherDimensionalRuntimeHostSurfaceByActivationProfileId( + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetBundledHigherDimensionalRuntimeHostSurfaceByPuzzleId( + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetHigherDimensionalRuntimeHostSurfaceForRunState( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetBundledHigherDimensionalRuntimeLaunchSurfaceByActivationProfileId( + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetBundledHigherDimensionalRuntimeLaunchSurfaceByPuzzleId( + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetHigherDimensionalRuntimeLaunchSurfaceForRunState( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetBundledHigherDimensionalRuntimeViewContextSurfaceByActivationProfileId( + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetBundledHigherDimensionalRuntimeViewContextSurfaceByPuzzleId( + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetHigherDimensionalRuntimeViewContextSurfaceForRunState( + const FHyperTwistTrainingRunState& RunState, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional", meta = (WorldContext = "WorldContextObject")) + static bool TryGetActiveHigherDimensionalRuntimeHostSurface( + UObject* WorldContextObject, + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface& OutHostSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional", meta = (WorldContext = "WorldContextObject")) + static bool TryGetActiveHigherDimensionalRuntimeLaunchSurface( + UObject* WorldContextObject, + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface& OutLaunchSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional", meta = (WorldContext = "WorldContextObject")) + static bool TryGetActiveHigherDimensionalRuntimeViewContextSurface( + UObject* WorldContextObject, + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface& OutViewContextSurface + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional", meta = (WorldContext = "WorldContextObject")) + static bool TryStartHigherDimensionalLaunchSurface( + UObject* WorldContextObject, + const FString& ActivationProfileId, + const FString& UserId, + const FString& SessionId, + EHyperTwistTrainingDeliveryMode Mode, + bool bExecuteGeneratedModeLaunchRequest, + FHyperTwistTrainingRunState& OutRunState, + FString& OutBlockedReason + ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|LearnedSearch") static bool TryGetBundledLearnedSearchExperimentProfileContract( const FString& ContractId, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSessionActor.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSessionActor.h index 3340c27..41a531b 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSessionActor.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSessionActor.h @@ -101,6 +101,15 @@ public: UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training|HigherDimensional") FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile CachedHigherDimensionalRuntimeActivationProfile; + UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface CachedHigherDimensionalRuntimeHostSurface; + + UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface CachedHigherDimensionalRuntimeLaunchSurface; + + UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface CachedHigherDimensionalRuntimeViewContextSurface; + UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HyperTwist|Training") FHyperTwistTrainingRepositoryRoundTripVerification CachedRepositoryRoundTripVerification; @@ -203,6 +212,27 @@ public: FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile GetDisplayedHigherDimensionalRuntimeActivationProfile() const; + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + bool HasDisplayedHigherDimensionalRuntimeHostSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface + GetDisplayedHigherDimensionalRuntimeHostSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + bool HasDisplayedHigherDimensionalRuntimeLaunchSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface + GetDisplayedHigherDimensionalRuntimeLaunchSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + bool HasDisplayedHigherDimensionalRuntimeViewContextSurface() const; + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface + GetDisplayedHigherDimensionalRuntimeViewContextSurface() const; + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Coach") FHyperTwistTrainingDeck BuildCoachRecommendedDeck(int32 MaxCases); diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h index e7d6593..c39e516 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h @@ -74,6 +74,17 @@ public: FString& OutBlockedReason ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + bool TryStartHigherDimensionalLaunchSurface( + const FString& ActivationProfileId, + const FString& UserId, + const FString& SessionId, + EHyperTwistTrainingDeliveryMode Mode, + bool bExecuteGeneratedModeLaunchRequest, + FHyperTwistTrainingRunState& OutRunState, + FString& OutBlockedReason + ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training") FHyperTwistTrainingRunState ApplyActiveImportedRuntimeSelectorOption( const FString& SelectorId, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHigherDimensionalPhase6CActivationContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHigherDimensionalPhase6CActivationContractTest.cpp index b1d7401..72e5859 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHigherDimensionalPhase6CActivationContractTest.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHigherDimensionalPhase6CActivationContractTest.cpp @@ -1,9 +1,11 @@ // Copyright HyperTwist, Inc. All Rights Reserved. +#include "Engine/GameInstance.h" #include "Misc/AutomationTest.h" #include "HyperTwistTraining/HyperTwistTrainingLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h" +#include "HyperTwistTraining/HyperTwistTrainingSubsystem.h" #if WITH_AUTOMATION_TESTS @@ -59,6 +61,29 @@ namespace HyperTwistHigherDimensionalPhase6CTestInternal Request.LaunchConfig = LaunchConfig; return Request; } + + UHyperTwistTrainingSubsystem* MakeTrainingSubsystem() + { + UGameInstance* GameInstance = NewObject(); + if (GameInstance == nullptr) + { + return nullptr; + } + + UHyperTwistTrainingSubsystem* TrainingSubsystem = + NewObject(GameInstance); + if (TrainingSubsystem == nullptr) + { + return nullptr; + } + + // Keep Phase 6C automation on the owned clean-room lane instead of + // inheriting host-local speech or vision sidecar config. + TrainingSubsystem->SetRecognitionClientKindForAutomation(TEXT("mock")); + TrainingSubsystem->SetCompanionSpeechClientKindForAutomation(TEXT("mock")); + TrainingSubsystem->RefreshCompanionSpeechServiceHealthForAutomation(); + return TrainingSubsystem; + } } IMPLEMENT_SIMPLE_AUTOMATION_TEST( @@ -77,6 +102,243 @@ bool FHyperTwistHigherDimensionalPhase6CActivationCatalogTest::RunTest(const FSt return true; } +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHigherDimensionalPhase6CHostCatalogTest, + "HyperTwist.FirstParty.HigherDimensional.Phase6C.HostCatalog", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHigherDimensionalPhase6CHostCatalogTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingHigherDimensionalRuntimeHostCatalog Catalog = + UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeHostCatalog(); + + TestTrue( + TEXT("The Phase 6C higher-dimensional host catalog must be structurally valid."), + Catalog.IsStructurallyValid() + ); + TestEqual( + TEXT("The Phase 6C higher-dimensional host catalog must expose both retained family host surfaces."), + Catalog.HostSurfaces.Num(), + 2 + ); + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface Magic120CellHostSurface; + TestTrue( + TEXT("The Magic120Cell host surface must resolve from the bundled catalog."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeHostSurfaceByActivationProfileId( + TEXT("magic120cell-cleanroom-runtime-activation"), + Magic120CellHostSurface + ) + ); + TestEqual( + TEXT("The Magic120Cell host surface must preserve the preferred dedicated family map target."), + Magic120CellHostSurface.PreferredHostMapPath, + TEXT("/Game/HyperTwistTraining/Maps/L_HyperTwist_Magic120CellTraining") + ); + TestEqual( + TEXT("The Magic120Cell host surface must still resolve to the shared effective host."), + Magic120CellHostSurface.EffectiveHostMapPath, + TEXT("/Game/HyperTwistTraining/Maps/L_HyperTwist_ClassicTraining") + ); + TestFalse( + TEXT("The Magic120Cell host surface must not claim the dedicated host map is authored yet."), + Magic120CellHostSurface.bDedicatedFamilyHostMapAuthored + ); + TestTrue( + TEXT("The Magic120Cell host surface must keep the shared-map fallback posture explicit."), + Magic120CellHostSurface.bUsesSharedTrainingMapFallback + ); + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface MagicCube5DHostSurface; + TestTrue( + TEXT("The MagicCube5D host surface must resolve from the bundled catalog."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeHostSurfaceByPuzzleId( + TEXT("hypercube/magiccube5d/order3"), + MagicCube5DHostSurface + ) + ); + TestEqual( + TEXT("The MagicCube5D host surface must preserve the preferred dedicated family route id."), + MagicCube5DHostSurface.PreferredHostMapRouteId, + TEXT("phase6c/magiccube5d/dedicated-training-map-host") + ); + TestTrue( + TEXT("The MagicCube5D host surface must carry shared-host fallback tags."), + MagicCube5DHostSurface.HostTags.Contains(TEXT("effective-host:shared-training-map")) + ); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHigherDimensionalPhase6CLaunchCatalogTest, + "HyperTwist.FirstParty.HigherDimensional.Phase6C.LaunchCatalog", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHigherDimensionalPhase6CLaunchCatalogTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingHigherDimensionalRuntimeLaunchCatalog Catalog = + UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeLaunchCatalog(); + + TestTrue( + TEXT("The Phase 6C higher-dimensional launch catalog must be structurally valid."), + Catalog.IsStructurallyValid() + ); + TestEqual( + TEXT("The Phase 6C higher-dimensional launch catalog must expose both retained family launch surfaces."), + Catalog.LaunchSurfaces.Num(), + 2 + ); + + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface Magic120CellLaunchSurface; + TestTrue( + TEXT("The Magic120Cell launch surface must resolve from the bundled catalog."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeLaunchSurfaceByActivationProfileId( + TEXT("magic120cell-cleanroom-runtime-activation"), + Magic120CellLaunchSurface + ) + ); + TestEqual( + TEXT("The Magic120Cell launch surface must stay on the current shared training map host."), + Magic120CellLaunchSurface.HostMapPath, + TEXT("/Game/HyperTwistTraining/Maps/L_HyperTwist_ClassicTraining") + ); + TestEqual( + TEXT("The Magic120Cell launch surface must resolve through the explicit host surface seam."), + Magic120CellLaunchSurface.HostSurfaceId, + TEXT("phase6c/magic120cell/runtime-host-surface") + ); + TestTrue( + TEXT("The Magic120Cell launch surface must remain flagged as a shared-map fallback until dedicated assets land."), + Magic120CellLaunchSurface.bUsesSharedTrainingMapFallback + ); + TestEqual( + TEXT("The Magic120Cell launch surface must preserve the generated runtime mode."), + Magic120CellLaunchSurface.RuntimeModeId, + TEXT("magic120cell-full-color-runtime-v1") + ); + TestEqual( + TEXT("The Magic120Cell launch surface must preserve the dedicated persistence boundary."), + Magic120CellLaunchSurface.PrimaryPersistenceBoundaryId, + TEXT("magic120cell-persistence-boundary") + ); + TestEqual( + TEXT("The Magic120Cell launch surface must preserve three default selector choices."), + Magic120CellLaunchSurface.DefaultSelectorChoices.Num(), + 3 + ); + + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface MagicCube5DLaunchSurface; + TestTrue( + TEXT("The MagicCube5D launch surface must resolve from the bundled catalog."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeLaunchSurfaceByPuzzleId( + TEXT("hypercube/magiccube5d/order3"), + MagicCube5DLaunchSurface + ) + ); + TestEqual( + TEXT("The MagicCube5D launch surface must preserve the generated runtime mode."), + MagicCube5DLaunchSurface.RuntimeModeId, + TEXT("magiccube5d-order3-runtime-v1") + ); + TestEqual( + TEXT("The MagicCube5D launch surface must preserve the dedicated persistence boundary."), + MagicCube5DLaunchSurface.PrimaryPersistenceBoundaryId, + TEXT("magiccube5d-persistence-boundary") + ); + TestEqual( + TEXT("The MagicCube5D launch surface must resolve through the explicit host surface seam."), + MagicCube5DLaunchSurface.HostSurfaceId, + TEXT("phase6c/magiccube5d/runtime-host-surface") + ); + TestEqual( + TEXT("The MagicCube5D launch surface must preserve three default selector choices."), + MagicCube5DLaunchSurface.DefaultSelectorChoices.Num(), + 3 + ); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHigherDimensionalPhase6CViewContextCatalogTest, + "HyperTwist.FirstParty.HigherDimensional.Phase6C.ViewContextCatalog", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHigherDimensionalPhase6CViewContextCatalogTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingHigherDimensionalRuntimeViewContextCatalog Catalog = + UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeViewContextCatalog(); + + TestTrue( + TEXT("The Phase 6C higher-dimensional view-context catalog must be structurally valid."), + Catalog.IsStructurallyValid() + ); + TestEqual( + TEXT("The Phase 6C higher-dimensional view-context catalog must expose both retained family view surfaces."), + Catalog.ViewContextSurfaces.Num(), + 2 + ); + + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface Magic120CellViewContextSurface; + TestTrue( + TEXT("The Magic120Cell view-context surface must resolve from the bundled catalog."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeViewContextSurfaceByActivationProfileId( + TEXT("magic120cell-cleanroom-runtime-activation"), + Magic120CellViewContextSurface + ) + ); + TestEqual( + TEXT("The Magic120Cell view-context surface must preserve the dedicated view-profile contract."), + Magic120CellViewContextSurface.PrimaryViewProfileContractId, + TEXT("magic120cell-focus-view-profile") + ); + TestEqual( + TEXT("The Magic120Cell view-context surface must preserve four default selector choices."), + Magic120CellViewContextSurface.DefaultSelectorChoices.Num(), + 4 + ); + TestEqual( + TEXT("The Magic120Cell view-context surface must preserve the explicit host surface seam."), + Magic120CellViewContextSurface.HostSurfaceId, + TEXT("phase6c/magic120cell/runtime-host-surface") + ); + TestTrue( + TEXT("The Magic120Cell view-context surface must stay on the shared training-map fallback."), + Magic120CellViewContextSurface.bUsesSharedTrainingMapFallback + ); + + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface MagicCube5DViewContextSurface; + TestTrue( + TEXT("The MagicCube5D view-context surface must resolve from the bundled catalog."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeViewContextSurfaceByPuzzleId( + TEXT("hypercube/magiccube5d/order3"), + MagicCube5DViewContextSurface + ) + ); + TestEqual( + TEXT("The MagicCube5D view-context surface must preserve the dedicated view-profile contract."), + MagicCube5DViewContextSurface.PrimaryViewProfileContractId, + TEXT("magiccube5d-projection-view-profile") + ); + TestEqual( + TEXT("The MagicCube5D view-context surface must preserve four default selector choices."), + MagicCube5DViewContextSurface.DefaultSelectorChoices.Num(), + 4 + ); + TestEqual( + TEXT("The MagicCube5D view-context surface must preserve the explicit host surface seam."), + MagicCube5DViewContextSurface.HostSurfaceId, + TEXT("phase6c/magiccube5d/runtime-host-surface") + ); + TestTrue( + TEXT("The MagicCube5D view-context surface must expose stereo context tags."), + MagicCube5DViewContextSurface.ContextSurfaceTags.Contains(TEXT("stereo disabled default")) + ); + return true; +} + IMPLEMENT_SIMPLE_AUTOMATION_TEST( FHyperTwistHigherDimensionalPhase6CMagic120CellActivationProfileTest, "HyperTwist.FirstParty.HigherDimensional.Phase6C.Magic120CellActivationProfile", @@ -269,4 +531,160 @@ bool FHyperTwistHigherDimensionalPhase6CRunStateActivationResolutionTest::RunTes return true; } +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHigherDimensionalPhase6CLaunchExecutionTest, + "HyperTwist.FirstParty.HigherDimensional.Phase6C.LaunchExecution", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHigherDimensionalPhase6CLaunchExecutionTest::RunTest(const FString& Parameters) +{ + UHyperTwistTrainingSubsystem* TrainingSubsystem = + HyperTwistHigherDimensionalPhase6CTestInternal::MakeTrainingSubsystem(); + TestNotNull( + TEXT("The Phase 6C launch-execution proof must allocate the training subsystem."), + TrainingSubsystem + ); + if (TrainingSubsystem == nullptr) + { + return false; + } + + FHyperTwistTrainingRunState StartedRunState; + FString BlockedReason; + TestTrue( + TEXT("The MagicCube5D launch surface must start and execute a generated-mode run."), + TrainingSubsystem->TryStartHigherDimensionalLaunchSurface( + TEXT("magiccube5d-cleanroom-runtime-activation"), + TEXT("phase6c-user"), + TEXT("phase6c-launch-execution-session"), + EHyperTwistTrainingDeliveryMode::VirtualCube, + true, + StartedRunState, + BlockedReason + ) + ); + TestTrue( + TEXT("The launch-execution proof must not report a blocked reason."), + BlockedReason.IsEmpty() + ); + TestTrue( + TEXT("The launch-execution proof must return a structurally valid owned run."), + StartedRunState.IsStructurallyValid() + ); + TestTrue( + TEXT("The launch-execution proof must persist a generated-mode launch request."), + StartedRunState.ImportedGeneratedModeLaunchRequest.IsStructurallyValid() + ); + TestEqual( + TEXT("The launch-execution proof must preserve the generated runtime mode."), + StartedRunState.ImportedGeneratedModeLaunchRequest.LaunchConfig.RuntimeModeId, + TEXT("magiccube5d-order3-runtime-v1") + ); + TestEqual( + TEXT("The launch-execution proof must preserve the generated runtime surface id."), + StartedRunState.ImportedGeneratedModeLaunchRequest.LaunchConfig.SurfaceId, + TEXT("phase6c/magiccube5d/generated-runtime-surface") + ); + TestTrue( + TEXT("The launch-execution proof must preserve the generated-mode execution tag."), + StartedRunState.ActiveDeck.Tags.Contains(TEXT("generated-mode:owned-execution")) + ); + + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile ActivationProfile; + TestTrue( + TEXT("The launch-execution proof must resolve the active higher-dimensional activation profile."), + UHyperTwistTrainingRuntimeLibrary::TryGetHigherDimensionalRuntimeActivationProfileForRunState( + StartedRunState, + ActivationProfile + ) + ); + TestEqual( + TEXT("The launch-execution proof must stay bound to the MagicCube5D activation profile."), + ActivationProfile.ActivationProfileId, + TEXT("magiccube5d-cleanroom-runtime-activation") + ); + + FHyperTwistTrainingHigherDimensionalRuntimeLaunchSurface LaunchSurface; + TestTrue( + TEXT("The launch-execution proof must resolve the active higher-dimensional launch surface."), + UHyperTwistTrainingRuntimeLibrary::TryGetHigherDimensionalRuntimeLaunchSurfaceForRunState( + StartedRunState, + LaunchSurface + ) + ); + TestEqual( + TEXT("The launch-execution proof must preserve the shared host map route."), + LaunchSurface.HostMapPath, + TEXT("/Game/HyperTwistTraining/Maps/L_HyperTwist_ClassicTraining") + ); + TestTrue( + TEXT("The launch-execution proof must keep the shared-map fallback posture explicit."), + LaunchSurface.bUsesSharedTrainingMapFallback + ); + TestEqual( + TEXT("The launch-execution proof must preserve the launch surface persistence boundary."), + LaunchSurface.PrimaryPersistenceBoundaryId, + TEXT("magiccube5d-persistence-boundary") + ); + TestEqual( + TEXT("The launch-execution proof must preserve the resolved launch surface id."), + LaunchSurface.LaunchSurfaceId, + TEXT("phase6c/magiccube5d/shared-training-launch-surface") + ); + TestEqual( + TEXT("The launch-execution proof must preserve the resolved host surface id."), + LaunchSurface.HostSurfaceId, + TEXT("phase6c/magiccube5d/runtime-host-surface") + ); + + FHyperTwistTrainingHigherDimensionalRuntimeHostSurface HostSurface; + TestTrue( + TEXT("The launch-execution proof must resolve the active higher-dimensional host surface."), + UHyperTwistTrainingRuntimeLibrary::TryGetHigherDimensionalRuntimeHostSurfaceForRunState( + StartedRunState, + HostSurface + ) + ); + TestEqual( + TEXT("The launch-execution proof must preserve the preferred dedicated host target."), + HostSurface.PreferredHostMapPath, + TEXT("/Game/HyperTwistTraining/Maps/L_HyperTwist_MagicCube5DTraining") + ); + TestEqual( + TEXT("The launch-execution proof must preserve the effective shared host route."), + HostSurface.EffectiveHostMapRouteId, + TEXT("phase6c/shared-training-map-host") + ); + TestTrue( + TEXT("The launch-execution proof must keep the shared-host fallback posture explicit."), + HostSurface.bUsesSharedTrainingMapFallback + ); + + FHyperTwistTrainingHigherDimensionalRuntimeViewContextSurface ViewContextSurface; + TestTrue( + TEXT("The launch-execution proof must resolve the active higher-dimensional view-context surface."), + UHyperTwistTrainingRuntimeLibrary::TryGetHigherDimensionalRuntimeViewContextSurfaceForRunState( + StartedRunState, + ViewContextSurface + ) + ); + TestEqual( + TEXT("The launch-execution proof must preserve the resolved view-context surface id."), + ViewContextSurface.ViewContextSurfaceId, + TEXT("phase6c/magiccube5d/shared-training-view-context-surface") + ); + TestEqual( + TEXT("The launch-execution proof must preserve the dedicated view-profile contract."), + ViewContextSurface.PrimaryViewProfileContractId, + TEXT("magiccube5d-projection-view-profile") + ); + TestEqual( + TEXT("The launch-execution proof must preserve four default view selector choices."), + ViewContextSurface.DefaultSelectorChoices.Num(), + 4 + ); + return true; +} + #endif diff --git a/docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md b/docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md index cd4e7c6..b545373 100644 --- a/docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md +++ b/docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md @@ -354,8 +354,13 @@ Closure read: - [x] Land a first-party higher-dimensional runtime-activation catalog with canonical `Magic120Cell` and `MagicCube5D` launch definitions, primary contract ids, default selection posture, and no external-process requirement - `2026-06-13` continuation proof: current code now resolves the active higher-dimensional activation profile from training run state through both canonical puzzle ids and imported generated-mode `RuntimeModeId` fallback, then mirrors that resolved profile through the training runtime library plus the live training panel and session-actor caches - `2026-06-13` Windows checkpoint: the primary reverse-SSH lane rebuilt the slice in isolated worktree `C:\HyperTwist_worktrees\phase10validate` with `Result: Succeeded` / UnrealBuildTool `Total execution time: 1061.50 seconds`, and targeted `UnrealEditor-Cmd` automation found `5` tests under `HyperTwist.FirstParty.HigherDimensional.Phase6C` and passed all `5`, including `RunStateActivationResolution` +- [x] Widen the owned activation lane into shared-map higher-dimensional launch, view-context, and generated-mode execution surfaces above the landed runtime-profile seams +- `2026-06-18` continuation proof: current code now bundles higher-dimensional launch and view-context catalogs for `Magic120Cell` and `MagicCube5D`, resolves those surfaces through the training runtime library plus the live training panel/session-actor caches, and executes the shared-map seed-run plus generated-mode owned-run bridge through the training subsystem while keeping automation on the owned mock speech/vision lane +- `2026-06-18` Windows checkpoint: after recovering an interrupted follow-up and re-proving the primary reverse-SSH lane, the same isolated worktree `C:\HyperTwist_worktrees\phase10validate` rebuilt the cleaned slice with `Result: Succeeded` / UnrealBuildTool `Total execution time: 124.81 seconds`, and targeted `UnrealEditor-Cmd` automation found `8` tests under `HyperTwist.FirstParty.HigherDimensional.Phase6C` and passed all `8`, including `LaunchCatalog`, `ViewContextCatalog`, `LaunchExecution`, and `RunStateActivationResolution`; the commandlet emitted `Ignoring very large delta of 499.13 seconds` during `LaunchExecution`, so that quiet interval is now known-good rather than a corruption signal +- `2026-06-18` continuation proof: current code now adds an explicit higher-dimensional host-surface catalog that records the preferred dedicated-family `Magic120Cell` / `MagicCube5D` host-map targets while keeping the current shared training-map host as the effective fallback, then mirrors that resolved host surface through the training runtime library plus the live training panel/session-actor caches and the launch/view-context surfaces themselves +- `2026-06-18` Windows checkpoint: the same isolated worktree `C:\HyperTwist_worktrees\phase10validate` rebuilt the widened host-surface slice with `Result: Succeeded` / UnrealBuildTool `Total execution time: 2858.02 seconds`, and targeted `UnrealEditor-Cmd` automation found `9` tests under `HyperTwist.FirstParty.HigherDimensional.Phase6C` and passed all `9`, including the new `HostCatalog`; `LaunchExecution` again emitted `Ignoring very large delta of 425.99 seconds`, confirming that long quiet interval remains a known-good characteristic rather than a corruption signal - [ ] Implement the full owned interactive `120-cell` and `5D` projection/runtime surfaces in Unreal above the new activation catalog -- [ ] Widen the new activation catalog into actual map-level launch, interaction, and persistence execution for the dedicated families +- [ ] Replace the current shared-map execution bridge with full owned dedicated-family interactive launch, map, and persistence surfaces for `120-cell` and `5D` **Estimated actions:** 100–200 **Estimated time:** 1–2 weeks @@ -524,4 +529,18 @@ Recommended next widening order: `RuntimeModeId` paths, mirroring the result into the training panel/session caches, and validating the slice on `localhost:22022` with `5` passing `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests +- `2026-06-18`: the next `Phase 6C` continuation widened that same lane again + into bundled launch and view-context catalogs plus owned shared-map launch + and generated-mode execution surfaces, then revalidated the cleaned code on + `localhost:22022` with `8` passing + `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests; the long quiet + `LaunchExecution` interval is now known to be healthy rather than a stall +- `2026-06-18`: the next `Phase 6C` continuation added an explicit + higher-dimensional host-surface catalog that preserves preferred dedicated + `Magic120Cell` / `MagicCube5D` host-map targets above the current shared-map + fallback, mirrors that host seam into the launch/view-context surfaces plus + the training panel/session caches, and revalidated the widened slice on + `localhost:22022` with `9` passing + `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests, including the new + `HostCatalog` - later classic-cube polish only when a concrete presentation gap remains, not as the default next move diff --git a/docs/ops/HYPERTWIST_REVERSE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md b/docs/ops/HYPERTWIST_REVERSE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md index 0c88d61..5c70b34 100644 --- a/docs/ops/HYPERTWIST_REVERSE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md +++ b/docs/ops/HYPERTWIST_REVERSE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md @@ -237,6 +237,28 @@ Current interpretation after this follow-up: lookup tests; also prove that real training-run puzzle-definition resolution follows the same lane +## Addendum - 2026-06-18 (primary-lane Phase 6C continuation recovery pass) + +Live follow-up on `2026-06-18` established these additional current facts: + +- the same primary `22022` lane remained healthy after an interrupted + continuation run and was directly re-proved through a fresh Windows login +- the lane again carried the isolated Windows validation tree + `C:\HyperTwist_worktrees\phase10validate` +- the changed `Phase 6C` subsystem/test files were hash-matched back into that + isolated worktree before the final proof pass +- the cleaned `Build.bat` run still succeeded with UnrealBuildTool `Total + execution time: 124.81 seconds` +- targeted `UnrealEditor-Cmd` automation then found `8` tests under + `HyperTwist.FirstParty.HigherDimensional.Phase6C` +- all `8` tests succeeded, including `LaunchCatalog`, `ViewContextCatalog`, + `LaunchExecution`, and `RunStateActivationResolution`, and the run closed + with `**** TEST COMPLETE. EXIT CODE: 0 ****` +- the long quiet `LaunchExecution` interval can legitimately produce controller + output such as `Ignoring very large delta of 499.13 seconds` even when the + lane is healthy, so that interval is now treated as expected behavior for + this slice rather than a default stall/corruption signal + ## Maintenance rule If the live listener set, accepted login shape, or command family changes, diff --git a/docs/ops/HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md b/docs/ops/HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md index 4cc7663..8ed6430 100644 --- a/docs/ops/HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md +++ b/docs/ops/HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md @@ -366,6 +366,31 @@ Operational rules reinforced by this proof: first, validate both direct profile resolution and real training-run definition propagation on the same Windows Unreal lane +## Addendum - 2026-06-18 (Phase 6C continuation recovery and final proof) + +Live follow-up on `2026-06-18` established these additional facts: + +- the same primary `localhost:22022` lane remained healthy after an interrupted + follow-up that initially made `LaunchExecution` appear stalled +- the validated route again used the isolated Windows tree + `C:\HyperTwist_worktrees\phase10validate` +- the recovery path re-proved Windows login on the active reverse tunnel and + then hash-matched the changed subsystem/test files back into that isolated + worktree before rebuilding +- the cleaned `Build.bat` pass for `UnrealHyperTwistEditor` still succeeded + there with `Result: Succeeded` and UnrealBuildTool `Total execution time: + 124.81 seconds` +- targeted headless automation then found `8` tests under + `HyperTwist.FirstParty.HigherDimensional.Phase6C` +- all `8` of those tests succeeded, including `LaunchCatalog`, + `ViewContextCatalog`, `LaunchExecution`, and + `RunStateActivationResolution` +- the command-line run closed with + `**** TEST COMPLETE. EXIT CODE: 0 ****` +- `LaunchExecution` remained long-running enough for the controller to emit + `Ignoring very large delta of 499.13 seconds`, so the quiet interval is now + known-good on this lane rather than a default corruption indicator + ## Addendum - 2026-06-13 (replay, leaderboard, and structured package-report proof) Live follow-up on `2026-06-13` established these additional facts: diff --git a/docs/ops/HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md b/docs/ops/HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md index 8b360f7..e4f2671 100644 --- a/docs/ops/HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md +++ b/docs/ops/HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md @@ -177,6 +177,22 @@ including `RunStateActivationResolution`, with earlier activation-catalog checkpoint into current active-run and `RuntimeModeId` fallback proof on the same primary reverse-SSH lane. +Further `2026-06-18` continuation proof on that same primary lane recovered an +interrupted follow-up without source corruption: after re-proving the +`localhost:22022` login path and hash-matching the changed subsystem/test files +back into isolated worktree `C:\HyperTwist_worktrees\phase10validate`, the +cleaned-code `Build.bat` pass completed with `Result: Succeeded` and +UnrealBuildTool `Total execution time: 124.81 seconds`, and targeted +`UnrealEditor-Cmd` automation then found `8` tests under +`HyperTwist.FirstParty.HigherDimensional.Phase6C` and passed all `8`, +including `LaunchCatalog`, `ViewContextCatalog`, `LaunchExecution`, and +`RunStateActivationResolution`, with `**** TEST COMPLETE. EXIT CODE: 0 ****`. +The same proof also established that the long quiet `LaunchExecution` interval +can legitimately trigger controller output such as +`Ignoring very large delta of 499.13 seconds` even when the commandlet is +healthy, so that quiet interval is now an expected operational characteristic +of this slice rather than a default corruption signal. + Further `2026-06-13` continuation proof on that same primary lane recovered the classic-cube replay/leaderboard/package slice after a corrupted reverse sync incident: a prior aborted broad tar sync left remote diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md index 9a515c6..f3a522e 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md @@ -268,6 +268,8 @@ repo. | Dedicated `5D` family runtime profile and persistence boundary | Implemented now | landed `MagicCube5D` packet | Current bounded family-specific widening is live beneath the retained `Hyperspeedcube` runtime anchor. | | Dedicated `5D` projection and focus view profiles | Implemented now | landed `MagicCube5D` `Phase 6R-AM` | Current bounded settings-derived projection-distance, stereo posture, per-face visibility, accent emphasis, and fifth-axis focus posture are live above the landed dedicated `5D` runtime-profile seam without widening into renderer, host-shell, or generic hyper-runtime ownership. | | Higher-dimensional clean-room runtime activation catalog | Implemented now | landed `Phase 6C` activation packet | First-party current code now resolves canonical `polychoron/magic120cell` and `hypercube/magiccube5d/order3` puzzle definitions, default launch posture, primary donor-boundary contract ids, and the no-external-process clean-room stance above the retained `Magic120Cell` / `MagicCube5D` contracts and the retained `Hyperspeedcube` runtime anchor. The current continuation also resolves the active higher-dimensional activation profile from live training run state through both puzzle-id and imported generated-mode `RuntimeModeId` paths, then mirrors that resolved profile through the training runtime library plus the training panel/session caches; the primary `localhost:22022` Windows lane passed all `5` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests on `2026-06-13`. | +| Higher-dimensional shared-map launch and view-context execution bridge | Implemented now | landed `Phase 6C` continuation packet | First-party current code now bundles higher-dimensional launch surfaces and view-context surfaces for `Magic120Cell` and `MagicCube5D`, resolves those surfaces through the training runtime library plus the live training panel/session-actor caches, and lets the training subsystem start the shared-map seed run, apply default selector posture, persist the generated-mode launch request, and start the owned generated run without widening into external-process ownership. After recovering an interrupted follow-up, the primary reverse-SSH `localhost:22022` Windows lane rebuilt the cleaned slice on `2026-06-18` with `Result: Succeeded`, UnrealBuildTool `Total execution time: 124.81 seconds`, and passed all `8` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests, including `LaunchCatalog`, `ViewContextCatalog`, `LaunchExecution`, and `RunStateActivationResolution`; the quiet `LaunchExecution` interval is now known to be healthy rather than a stalled commandlet. | +| Higher-dimensional explicit dedicated-host seam | Implemented now | landed `Phase 6C` host-surface continuation packet | First-party current code now records the preferred dedicated-family `Magic120Cell` / `MagicCube5D` host-map targets in an explicit higher-dimensional host-surface catalog while keeping the current shared training map as the effective runtime fallback, mirrors that resolved host seam through the training runtime library plus the panel/session caches, and threads the host-surface id into the launch/view-context surfaces and generated-mode lineage. The primary reverse-SSH `localhost:22022` Windows lane rebuilt this widened slice on `2026-06-18` with `Result: Succeeded`, UnrealBuildTool `Total execution time: 2858.02 seconds`, and passed all `9` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests, including the new `HostCatalog`; the long `LaunchExecution` quiet interval remained known-good. | | Broad non-Euclidean interaction shell and host ownership | Deep-source grounded retained | `MagicTile` retained remainder | Broad interaction-shell, WinForms/OpenTK host ownership, and generic runtime replacement remain deferred after the landed `Phase 6R-T` slice. | ### 7. Speech input and voice sidecars diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md index 79afe1e..7faa84e 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md @@ -121,6 +121,27 @@ Current consolidated milestone snapshot: Succeeded` and passed all `5` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests, including `RunStateActivationResolution` +- `2026-06-18`: the next `Phase 6C` continuation widened that lane again into + bundled higher-dimensional launch and view-context catalogs plus owned + shared-map launch and generated-mode execution through the training + subsystem; after recovering an interrupted follow-up, the primary + `localhost:22022` lane rebuilt the cleaned slice with `Result: Succeeded`, + UnrealBuildTool `Total execution time: 124.81 seconds`, and passed all `8` + `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests, including + `LaunchCatalog`, `ViewContextCatalog`, `LaunchExecution`, and + `RunStateActivationResolution` +- `2026-06-18`: the next `Phase 6C` continuation added an explicit + higher-dimensional host-surface catalog that preserves preferred dedicated + `Magic120Cell` / `MagicCube5D` host-map targets while keeping the current + shared training-map host as the effective runtime fallback, then mirrored + that host seam through the runtime library plus the panel/session caches; + the same `localhost:22022` lane rebuilt the widened slice with `Result: + Succeeded`, UnrealBuildTool `Total execution time: 2858.02 seconds`, and + passed all `9` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests, + including the new `HostCatalog` +- the remaining `Phase 6C` gap is now the full dedicated interactive + `120-cell` / `5D` runtime and map replacement, not the shared-map execution + bridge or the current active-run proof - the canonical HyperTwist repo-row portfolio is now treated as `75` rows, not `71` - currently implemented rows are now `35`, not `20`