Custom DreamWorld Support (#953)

## Major features
- Added `Dream.inDreamWorld` to planet configs to treat a planet as if
it were part of the dream world dimension. The planet's contents will be
deactivated unless you enter via a dream arrival point or another dream
world dimension. Closes #916
- Added `dreamCampfires` and `dreamArrivalPoints` as new linked prop
types, which allow you to create new entry points into Echoes of the
Eye's dream world or create similar experiences using custom planets.

## Improvements
- General support for dream world simulations even if the vanilla dream
world is disabled in custom solar systems.

NewHorizons/Builder/Body/DreamDimensionBuilder.cs

@@ -0,0 +1,107 @@
+using NewHorizons.Components.EOTE;
+using NewHorizons.Components.Props;
+using NewHorizons.External;
+using NewHorizons.External.Configs;
+using NewHorizons.Utility;
+using NewHorizons.Utility.OuterWilds;
+using NewHorizons.Utility.OWML;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Builder.Body
+{
+    public static class DreamDimensionBuilder
+    {
+        private static Material gridMaterial;
+        private static Material waterMaterial;
+
+        private readonly static string[] EXCLUDED_OBJECT_NAMES =
+        {
+            "Prefab_IP_SIM_",
+            "Props_IP_SIM_",
+            "Effects_IP_SIM_",
+        };
+
+        private readonly static string[] EXCLUDED_SHADER_NAMES =
+        {
+            "Fog",
+            "Simulation Bubble",
+            "Foliage",
+            "Flame",
+        };
+
+        public static void Make(GameObject planetGO, Sector sector, NewHorizonsBody body)
+        {
+            var bodyWantsSimMeshes = body.Config.Dream?.generateSimulationMeshes ?? false;
+            var propsWantSimMeshes = body.Config.Props?.dreamArrivalPoints?.Any(p => p.generateSimulationMeshes) ?? false;
+            if (bodyWantsSimMeshes || propsWantSimMeshes)
+            {
+                MakeDreamSimulationMeshes(sector ? sector.gameObject : planetGO);
+            }
+
+            if (body.Config?.Dream?.inDreamWorld ?? false)
+            {
+                var dreamDimension = planetGO.AddComponent<DreamDimension>();
+                Delay.FireInNUpdates(() =>
+                {
+                    dreamDimension.Initialize();
+                }, 4);
+            }
+            
+        }
+
+        public static void MakeDreamSimulationMeshes(GameObject go)
+        {
+            if (gridMaterial == null) gridMaterial = SearchUtilities.FindResourceOfTypeAndName<Material>("Terrain_IP_DreamGrid_mat");
+            if (waterMaterial == null) waterMaterial = SearchUtilities.FindResourceOfTypeAndName<Material>("Terrain_IP_DreamGrid_mat");
+
+            foreach (var mr in go.GetComponentsInChildren<MeshRenderer>(true))
+            {
+                if (mr.GetType() != typeof(MeshRenderer)) continue;
+                var mf = mr.GetComponent<MeshFilter>();
+                if (mf == null) continue;
+                if (!CheckMeshCreationHeuristic(mr.gameObject, mr.sharedMaterials)) continue;
+                var simMesh = new GameObject("SimulationMesh").AddComponent<DreamSimulationMesh>();
+                simMesh.Init(mr.transform, GetMeshMaterial(go, mr.sharedMaterials));
+            }
+        }
+
+        private static Material GetMeshMaterial(GameObject go, Material[] materials)
+        {
+            if (materials.Any(m => m.name.Contains("Ocean_Stencil_mat"))) return waterMaterial;
+            return gridMaterial;
+        }
+
+        private static bool CheckMeshCreationHeuristic(GameObject go, Material[] materials)
+        {
+            if (go.layer == Layer.DreamSimulation) return false;
+            var mr = go.GetComponent<MeshRenderer>();
+            if (EXCLUDED_SHADER_NAMES.Any(name => materials.Any(mat => mat.shader.name.Contains(name)))) return false;
+            if (go.transform.parent)
+            {
+                foreach (Transform c in go.transform.parent)
+                {
+                    if (c && c.gameObject.layer == Layer.DreamSimulation) return false;
+                }
+                if (go.transform.parent.parent)
+                {
+                    foreach (Transform c in go.transform.parent.parent)
+                    {
+                        if (c && c.gameObject.layer == Layer.DreamSimulation) return false;
+                    }
+                }
+            }
+            var t = go.transform;
+            while (t != null)
+            {
+                if (EXCLUDED_OBJECT_NAMES.Any(t.name.Contains)) return false;
+                t = t.parent;
+            }
+            return true;
+        }
+    }
+}

NewHorizons/Builder/General/AmbientLightBuilder.cs

@@ -2,6 +2,7 @@ using UnityEngine;
 using NewHorizons.Utility;
 using NewHorizons.External.Modules;
 using NewHorizons.Utility.Files;
+using NewHorizons.Components;
 
 namespace NewHorizons.Builder.General
 {

NewHorizons/Builder/Props/EchoesOfTheEye/DreamArrivalPointBuilder.cs

@@ -0,0 +1,63 @@
+using NewHorizons.Components.Props;
+using NewHorizons.External.Modules.Props;
+using NewHorizons.External.Modules.Props.EchoesOfTheEye;
+using NewHorizons.Handlers;
+using NewHorizons.Utility;
+using NewHorizons.Utility.OWML;
+using OWML.Common;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Builder.Props.EchoesOfTheEye
+{
+    public static class DreamArrivalPointBuilder
+    {
+        private static GameObject _prefab;
+
+        internal static void InitPrefab()
+        {
+            if (_prefab == null)
+            {
+                _prefab = SearchUtilities.Find("DreamWorld_Body/Sector_DreamWorld/Sector_DreamZone_1/DreamFireHouse_1/Interactibles_DreamFireHouse_1/Prefab_IP_DreamArrivalPoint_Zone1").InstantiateInactive().Rename("Prefab_DreamArrivalPoint").DontDestroyOnLoad();
+                if (_prefab == null)
+                {
+                    NHLogger.LogWarning($"Tried to make a dream arrival point but couldn't. Do you have the DLC installed?");
+                    return;
+                }
+                else
+                {
+                    _prefab.AddComponent<DestroyOnDLC>()._destroyOnDLCNotOwned = true;
+                    var dreamArrivalPoint = _prefab.GetComponent<DreamArrivalPoint>();
+                    dreamArrivalPoint._location = DreamArrivalPoint.Location.Undefined;
+                    dreamArrivalPoint._sector = null;
+                    dreamArrivalPoint._entrywayVolumes = new OWTriggerVolume[0];
+                    dreamArrivalPoint._raftSpawn = null;
+                    dreamArrivalPoint._connectedDreamCampfire = null;
+                    dreamArrivalPoint._campfire._sector = null;
+                }
+            }
+        }
+
+        public static GameObject Make(GameObject planetGO, Sector sector, DreamArrivalPointInfo info, IModBehaviour mod)
+        {
+            InitPrefab();
+
+            if (_prefab == null || sector == null) return null;
+
+            var arrivalPointObj = DetailBuilder.Make(planetGO, sector, mod, _prefab, new DetailInfo(info));
+
+            StreamingHandler.SetUpStreaming(arrivalPointObj, sector);
+
+            DreamArrivalPoint arrivalPoint = arrivalPointObj.GetComponent<DreamArrivalPoint>();
+            arrivalPoint._sector = arrivalPoint.GetComponentInParent<Sector>();
+            arrivalPoint._location = DreamHandler.GetDreamArrivalLocation(info.id);
+            Locator.RegisterDreamArrivalPoint(arrivalPoint, arrivalPoint._location);
+
+            return arrivalPointObj;
+        }
+    }
+}

NewHorizons/Builder/Props/EchoesOfTheEye/DreamCampfireBuilder.cs

@@ -0,0 +1,74 @@
+using NewHorizons.External.Modules.Props;
+using NewHorizons.External.Modules.Props.EchoesOfTheEye;
+using NewHorizons.Handlers;
+using NewHorizons.Utility;
+using NewHorizons.Utility.OWML;
+using OWML.Common;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Builder.Props.EchoesOfTheEye
+{
+    public static class DreamCampfireBuilder
+    {
+        private static GameObject _prefab;
+
+        internal static void InitPrefab()
+        {
+            if (_prefab == null)
+            {
+                _prefab = SearchUtilities.Find("RingWorld_Body/Sector_RingInterior/Sector_Zone4/Sector_PrisonDocks/Sector_PrisonInterior/Interactibles_PrisonInterior/Prefab_IP_DreamCampfire").InstantiateInactive().Rename("Prefab_DreamCampfire").DontDestroyOnLoad();
+                if (_prefab == null)
+                {
+                    NHLogger.LogWarning($"Tried to make a dream campfire but couldn't. Do you have the DLC installed?");
+                    return;
+                }
+                else
+                {
+                    _prefab.AddComponent<DestroyOnDLC>()._destroyOnDLCNotOwned = true;
+                    var campfire = _prefab.GetComponentInChildren<DreamCampfire>();
+                    campfire._dreamArrivalLocation = DreamArrivalPoint.Location.Undefined;
+                    campfire._sector = null;
+                    campfire._entrywayVolumes = new OWTriggerVolume[0];
+                }
+            }
+        }
+
+        public static GameObject Make(GameObject planetGO, Sector sector, DreamCampfireInfo info, IModBehaviour mod)
+        {
+            InitPrefab();
+
+            if (_prefab == null || sector == null) return null;
+
+            var campfireObj = DetailBuilder.Make(planetGO, sector, mod, _prefab, new DetailInfo(info));
+
+            var campfire = campfireObj.GetComponentInChildren<DreamCampfire>();
+            campfire._dreamArrivalLocation = DreamHandler.GetDreamArrivalLocation(info.id);
+
+            // The streaming groups on DreamCampfires get set on Start() so we wait until after to change it again
+            Delay.FireInNUpdates(() => {
+                var streaming = campfireObj.GetComponentInChildren<DreamCampfireStreaming>();
+                if (streaming != null)
+                {
+                    var targetArrivalPoint = Locator.GetDreamArrivalPoint(campfire._dreamArrivalLocation);
+                    if (targetArrivalPoint != null)
+                    {
+                        var streamingGroup = targetArrivalPoint.transform.root.GetComponentInChildren<StreamingGroup>();
+                        if (streamingGroup)
+                        {
+                            streaming._streamingGroup = streamingGroup;
+                        }
+                    }
+                }
+            }, 2);
+
+            Locator.RegisterDreamCampfire(campfire, campfire._dreamArrivalLocation);
+
+            return campfireObj;
+        }
+    }
+}

NewHorizons/Builder/Props/PropBuildManager.cs

@@ -1,5 +1,6 @@
 using NewHorizons.Builder.Body;
 using NewHorizons.Builder.Props.Audio;
+using NewHorizons.Builder.Props.EchoesOfTheEye;
 using NewHorizons.Builder.Props.TranslatorText;
 using NewHorizons.Builder.ShipLog;
 using NewHorizons.External;
@@ -101,6 +102,8 @@ namespace NewHorizons.Builder.Props
             // If a prop has set its parentPath and the parent cannot be found, add it to the next pass and try again later
             nextPass = new List<Action>();
 
+            if (Main.HasDLC) MakeGeneralProps(go, config.Props.dreamCampfires, (campfire) => DreamCampfireBuilder.Make(go, sector, campfire, mod), (campfire) => campfire.id);
+            if (Main.HasDLC) MakeGeneralProps(go, config.Props.dreamArrivalPoints, (point) => DreamArrivalPointBuilder.Make(go, sector, point, mod), (point) => point.id);
             MakeGeneralProps(go, config.Props.gravityCannons, (cannon) => GravityCannonBuilder.Make(go, sector, cannon, mod), (cannon) => cannon.shuttleID);
             MakeGeneralProps(go, config.Props.shuttles, (shuttle) => ShuttleBuilder.Make(go, sector, mod, shuttle), (shuttle) => shuttle.id);
             MakeGeneralProps(go, config.Props.details, (detail) => DetailBuilder.Make(go, sector, mod, detail), (detail) => detail.path);

NewHorizons/Components/EOTE/DreamDimension.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Components.EOTE
+{
+    public class DreamDimension : MonoBehaviour
+    {
+        private bool initialized;
+        private bool active;
+        private List<GameObject> toggledObjects = new();
+
+        public void Initialize()
+        {
+            if (initialized) return;
+
+            foreach (Transform child in transform)
+            {
+                if (child.gameObject.name == "FieldDetector") continue;
+                toggledObjects.Add(child.gameObject);
+            }
+
+            initialized = true;
+            UpdateState();
+        }
+
+        public void SetActive(bool active)
+        {
+            if (this.active != active)
+            {
+                this.active = active;
+                UpdateState();
+            }
+        }
+
+        void Awake()
+        {
+            GlobalMessenger.AddListener("EnterDreamWorld", OnEnterDreamWorld);
+            GlobalMessenger.AddListener("ExitDreamWorld", OnExitDreamWorld);
+        }
+
+        void OnDestroy()
+        {
+            GlobalMessenger.RemoveListener("EnterDreamWorld", OnEnterDreamWorld);
+            GlobalMessenger.RemoveListener("ExitDreamWorld", OnExitDreamWorld);
+        }
+
+        void UpdateState()
+        {
+            foreach (var obj in toggledObjects) obj.SetActive(active);
+        }
+
+        void OnEnterDreamWorld()
+        {
+            SetActive(true);
+        }
+
+        void OnExitDreamWorld()
+        {
+            SetActive(false);
+        }
+    }
+}

NewHorizons/Components/EOTE/LanternExtinguisher.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Components.EOTE;
+
+public class LanternExtinguisher : MonoBehaviour
+{
+    public void Update()
+    {
+        if (PlayerState.InDreamWorld() && PlayerState.IsCameraUnderwater())
+        {
+            var heldItem = Locator.GetToolModeSwapper().GetItemCarryTool().GetHeldItem();
+            if (heldItem is DreamLanternItem lantern && lantern._lanternController._lit)
+            {
+                Locator.GetDreamWorldController().ExitDreamWorld(DreamWakeType.LanternSubmerged);
+            }
+        }
+    }
+}

NewHorizons/Components/Props/DreamSimulationMesh.cs

@@ -0,0 +1,76 @@
+using NewHorizons.Utility.OuterWilds;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Remoting;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Components.Props
+{
+    public class DreamSimulationMesh : MonoBehaviour
+    {
+        Transform target;
+        Material mat;
+        MeshFilter sourceMeshFilter;
+        MeshRenderer sourceMeshRenderer;
+        MeshFilter targetMeshFilter;
+        MeshRenderer targetMeshRenderer;
+        StreamingRenderMeshHandle streamingHandle;
+
+        bool initialized;
+
+        public void Init(Transform target, Material mat)
+        {
+            this.target = target;
+            this.mat = mat;
+
+            gameObject.layer = Layer.DreamSimulation;
+            
+            sourceMeshFilter = target.GetComponent<MeshFilter>();
+            sourceMeshRenderer = target.GetComponent<MeshRenderer>();
+            targetMeshFilter = gameObject.AddComponent<MeshFilter>();
+            targetMeshRenderer = gameObject.AddComponent<MeshRenderer>();
+
+            transform.SetParent(target.transform, false);
+
+            streamingHandle = target.GetComponent<StreamingRenderMeshHandle>();
+            if (streamingHandle != null)
+            {
+                streamingHandle.OnMeshLoaded += OnMeshLoaded;
+                streamingHandle.OnMeshUnloaded += OnMeshUnloaded;
+            }
+
+            initialized = true;
+            Sync();
+        }
+
+        public void Sync()
+        {
+            if (!initialized) return;
+            targetMeshFilter.sharedMesh = sourceMeshFilter.sharedMesh;
+            targetMeshRenderer.sharedMaterials = sourceMeshRenderer.sharedMaterials.Select(_ => mat).ToArray();
+            targetMeshRenderer.enabled = sourceMeshRenderer.enabled;
+        }
+
+        void OnDestroy()
+        {
+            if (streamingHandle != null)
+            {
+                streamingHandle.OnMeshLoaded -= OnMeshLoaded;
+                streamingHandle.OnMeshUnloaded -= OnMeshUnloaded;
+            }
+        }
+
+        void OnMeshLoaded()
+        {
+            Sync();
+        }
+
+        void OnMeshUnloaded()
+        {
+            Sync();
+        }
+    }
+}

NewHorizons/External/Configs/PlanetConfig.cs

@@ -90,6 +90,11 @@ namespace NewHorizons.External.Configs
         /// </summary>
         public CloakModule Cloak;
 
+        /// <summary>
+        /// Make this planet part of the dream world
+        /// </summary>
+        public DreamModule Dream;
+
         /// <summary>
         /// Make this body into a focal point (barycenter)
         /// </summary>
@@ -279,6 +284,9 @@ namespace NewHorizons.External.Configs
 
             // Stars and focal points shouldnt be destroyed by stars
             if (Star != null || FocalPoint != null) Base.hasFluidDetector = false;
+
+            // Disable map marker for dream dimensions
+            if (Dream != null && Dream.inDreamWorld) MapMarker.enabled = false;
         }
 
         public void Migrate()

NewHorizons/External/Modules/DreamModule.cs

@@ -0,0 +1,17 @@
+using Newtonsoft.Json;
+
+namespace NewHorizons.External.Modules
+{
+    [JsonObject]
+    public class DreamModule
+    {
+        /// <summary>
+        /// Setting this value will make this body a dream world style dimension where its contents are only activated while entering it from a dream campfire. Disables the body's map marker.
+        /// </summary>
+        public bool inDreamWorld;
+        /// <summary>
+        /// Whether to generate simulation meshes (the models used in the "tronworld" or "matrix" view) for most objects on this planet by cloning the existing meshes and applying the simulation materials. Leave this off if you are building your own simulation meshes or using existing objects which have them.
+        /// </summary>
+        public bool generateSimulationMeshes;
+    }
+}

NewHorizons/External/Modules/PropModule.cs

@@ -123,6 +123,16 @@ namespace NewHorizons.External.Modules
         /// </summary>
         public ShuttleInfo[] shuttles;
 
+        /// <summary>
+        /// Add campfires that allow you to enter the dream world/simulation. Must be paired with a dream arrival point, which can be placed on this planet or elsewhere.
+        /// </summary>
+        public DreamCampfireInfo[] dreamCampfires;
+        
+        /// <summary>
+        /// Add the points you will arrive at when entering the dream world/simulation from a paired dream campfire, which can be placed on this planet or elsewhere. The planet with the arrival point should be statically positioned to avoid issues with the simulation view materials.
+        /// </summary>
+        public DreamArrivalPointInfo[] dreamArrivalPoints;
+
         [Obsolete("reveal is deprecated. Use Volumes->revealVolumes instead.")] public RevealVolumeInfo[] reveal;
 
         [Obsolete("audioVolumes is deprecated. Use Volumes->audioVolumes instead.")] public AudioVolumeInfo[] audioVolumes;

NewHorizons/External/Modules/Props/EchoesOfTheEye/DreamArrivalPointInfo.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NewHorizons.External.Modules.Props.EchoesOfTheEye
+{
+    [JsonObject]
+    public class DreamArrivalPointInfo : GeneralPropInfo
+    {
+        /// <summary>
+        /// Unique ID for this dream-world arrival point
+        /// </summary>
+        public string id;
+        /// <summary>
+        /// Whether to generate simulation meshes (the models used in the "tronworld" or "matrix" view) for most objects on the current planet by cloning the existing meshes and applying the simulation materials. Leave this off if you are building your own simulation meshes or using existing objects which have them.
+        /// </summary>
+        public bool generateSimulationMeshes;
+    }
+}

NewHorizons/External/Modules/Props/EchoesOfTheEye/DreamCampfireInfo.cs

@@ -0,0 +1,18 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NewHorizons.External.Modules.Props.EchoesOfTheEye
+{
+    [JsonObject]
+    public class DreamCampfireInfo : GeneralPropInfo
+    {
+        /// <summary>
+        /// Unique ID for this dream-world campfire
+        /// </summary>
+        public string id;
+    }
+}

NewHorizons/External/NewHorizonBody.cs

@@ -39,8 +39,11 @@ namespace NewHorizons.External
             {
                 var detailPaths = Config?.Props?.details?.Select(x => x.path) ?? Array.Empty<string>();
                 return Config?.Cloak != null
+                    || Config?.Dream != null
                     || Config?.Props?.rafts != null
                     || Config?.Props?.slideShows != null
+                    || Config?.Props?.dreamArrivalPoints != null
+                    || Config?.Props?.dreamCampfires != null
                     || detailPaths.Any(x => x.StartsWith("RingWorld_Body") || x.StartsWith("DreamWorld_Body"));
             }
             catch

NewHorizons/Handlers/DreamHandler.cs

@@ -0,0 +1,88 @@
+using NewHorizons.Utility;
+using NewHorizons.Utility.OWML;
+using OWML.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Handlers
+{
+    public static class DreamHandler
+    {
+        public static DreamArrivalPoint.Location GetDreamArrivalLocation(string id)
+        {
+            try
+            {
+                if (EnumUtils.TryParse(id, out DreamArrivalPoint.Location location))
+                {
+                    return location;
+                }
+                else
+                {
+                    NHLogger.LogVerbose($"Registering new dream arrival location [{id}]");
+                    return EnumUtilities.Create<DreamArrivalPoint.Location>(id);
+                }
+            }
+            catch (Exception e)
+            {
+                NHLogger.LogError($"Couldn't load dream arrival location [{id}]:\n{e}");
+                return DreamArrivalPoint.Location.Undefined;
+            }
+        }
+
+        public static void MigrateDreamWorldController()
+        {
+            // Create new DreamWorldController instance since the existing one is disabled
+            var managerObj = new GameObject("DreamWorldManager");
+            managerObj.SetActive(false);
+            var oldDWC = Locator.GetDreamWorldController();
+            var dwc = managerObj.AddComponent<DreamWorldController>();
+
+            var simRootObj = MigrateCopy(oldDWC._primarySimulationRoot.gameObject, managerObj);
+
+            dwc._primarySimulationRoot = simRootObj.transform;
+            dwc._simulationRoots = new Transform[] { simRootObj.transform };
+            dwc._simulationCamera = simRootObj.FindChild("Camera_Simulation").GetComponent<SimulationCamera>();
+            dwc._simulationSphere = simRootObj.FindChild("SimulationSphere").GetComponent<OWRenderer>();
+
+            dwc._tempSkyboxColor = oldDWC._tempSkyboxColor;
+            dwc._sarcophagusController = oldDWC._sarcophagusController;
+            dwc._prisonerDirector = oldDWC._prisonerDirector;
+
+            // These should correspond to the arrival point's attached body
+            dwc._dreamBody = null;
+            dwc._dreamWorldSector = null;
+            dwc._dreamWorldVolume = null;
+
+            // These should correspond to the campfire's attached body
+            dwc._planetBody = null;
+            dwc._ringWorldController = null;
+
+            managerObj.SetActive(true);
+
+            // Run after Start() completes
+            Delay.FireOnNextUpdate(() =>
+            {
+                dwc._dreamBody = null;
+                dwc._dreamWorldSector = null;
+                dwc._dreamWorldVolume = null;
+                dwc._planetBody = null;
+                dwc._ringWorldController = null;
+
+                // Dreamworld has a giant plane for simulation water, we don't want that in our custom world
+                dwc._primarySimulationRoot.Find("water_simulation").gameObject.SetActive(false);
+            });
+
+        }
+
+        private static GameObject MigrateCopy(GameObject go, GameObject newParent)
+        {
+            var clone = GameObject.Instantiate(go);
+            clone.transform.SetParent(newParent.transform, false);
+            return clone;
+        }
+    }
+}

NewHorizons/Handlers/PlanetCreationHandler.cs

@@ -1,3 +1,4 @@
+using Epic.OnlineServices;
 using NewHorizons.Builder.Atmosphere;
 using NewHorizons.Builder.Body;
 using NewHorizons.Builder.General;
@@ -729,6 +730,11 @@ namespace NewHorizons.Handlers
                 }
             }
 
+            if (Main.HasDLC)
+            {
+                DreamDimensionBuilder.Make(go, sector, body);
+            }
+
             // Has to go last probably
             if (willHaveCloak)
             {

NewHorizons/Handlers/PlanetDestructionHandler.cs

@@ -70,6 +70,7 @@ namespace NewHorizons.Handlers
                     if (Main.HasDLC)
                     {
                         StrangerRemoved();
+                        DreamWorldRemoved();
                     }
 
                     // Put it back at the center of the universe after banishing it else there are weird graphical bugs
@@ -90,6 +91,11 @@ namespace NewHorizons.Handlers
             }
         }
 
+        private static void DreamWorldRemoved()
+        {
+            DreamHandler.MigrateDreamWorldController();
+        }
+
         private static void SunRemoved()
         {
             var sun = SearchUtilities.Find("Sun_Body").GetComponent<AstroObject>();
@@ -207,6 +213,9 @@ namespace NewHorizons.Handlers
                     case AstroObject.Name.RingWorld:
                         StrangerRemoved();
                         break;
+                    case AstroObject.Name.DreamWorld:
+                        DreamWorldRemoved();
+                        break;
                 }
 
                 // Always delete the children

NewHorizons/Main.cs

@@ -4,7 +4,9 @@ using NewHorizons.Builder.Body;
 using NewHorizons.Builder.General;
 using NewHorizons.Builder.Props;
 using NewHorizons.Builder.Props.Audio;
+using NewHorizons.Builder.Props.EchoesOfTheEye;
 using NewHorizons.Builder.Props.TranslatorText;
+using NewHorizons.Components.EOTE;
 using NewHorizons.Components.Fixers;
 using NewHorizons.Components.Ship;
 using NewHorizons.Components.SizeControllers;
@@ -381,6 +383,8 @@ namespace NewHorizons
                         ProjectionBuilder.InitPrefabs();
                         CloakBuilder.InitPrefab();
                         RaftBuilder.InitPrefab();
+                        DreamCampfireBuilder.InitPrefab();
+                        DreamArrivalPointBuilder.InitPrefab();
                     }
 
                     WarpPadBuilder.InitPrefabs();
@@ -619,6 +623,7 @@ namespace NewHorizons
                 Locator.GetPlayerBody().gameObject.AddComponent<DebugPropPlacer>();
                 Locator.GetPlayerBody().gameObject.AddComponent<DebugMenu>();
                 Locator.GetPlayerBody().gameObject.AddComponent<PlayerShipAtmosphereDetectorFix>();
+                if (HasDLC) Locator.GetPlayerBody().gameObject.AddComponent<LanternExtinguisher>();
 
                 PlayerSpawnHandler.OnSystemReady(shouldWarpInFromShip, shouldWarpInFromVessel);
 

NewHorizons/Patches/EchoesOfTheEyePatches/DreamworldControllerPatches.cs

@@ -1,4 +1,5 @@
 using HarmonyLib;
+using NewHorizons.Components.EOTE;
 using System.Collections.Generic;
 using System.Reflection.Emit;
 using UnityEngine;
@@ -26,5 +27,97 @@ namespace NewHorizons.Patches.EchoesOfTheEyePatches
                 .Repeat(matcher => matcher.RemoveInstructions(5))
                 .InstructionEnumeration();
         }
+
+        [HarmonyPrefix]
+        [HarmonyPatch(nameof(DreamWorldController.EnterDreamWorld))]
+        public static bool DreamWorldController_EnterDreamWorld(DreamWorldController __instance, DreamCampfire dreamCampfire, DreamArrivalPoint arrivalPoint)
+        {
+            // If we are arriving in a custom dream dimension, activate it immediately
+            var dimension = arrivalPoint.GetAttachedOWRigidbody().GetComponent<DreamDimension>();
+            if (dimension != null)
+            {
+                dimension.SetActive(true);
+            }
+
+            // Make the body/sector/volume where the player 'wakes up' in the dream match the body where the arrival point is located if it isn't the vanilla DreamWorld, or reset it if it is
+            var dreamWorldAO = Locator.GetAstroObject(AstroObject.Name.DreamWorld);
+            if (arrivalPoint.GetAttachedOWRigidbody() == dreamWorldAO.GetOWRigidbody())
+            {
+                __instance._dreamBody = dreamWorldAO.GetAttachedOWRigidbody();
+                __instance._dreamWorldSector = dreamWorldAO.GetRootSector();
+                __instance._dreamWorldVolume = __instance._dreamWorldSector.transform.Find("Volumes_DreamWorld").Find("DreamWorldVolume").GetComponent<OWTriggerVolume>();
+            }
+            else
+            {
+                var arrivalAO = arrivalPoint.GetComponentInParent<AstroObject>();
+                __instance._dreamBody = arrivalAO.GetAttachedOWRigidbody();
+                __instance._dreamWorldSector = arrivalAO.GetRootSector();
+                __instance._dreamWorldVolume = arrivalAO._gravityVolume.GetOWTriggerVolume();
+            }
+
+            // Make the 'bubble' around the artifact load correctly when the destination body isn't the vanilla DreamWorld
+            __instance._primarySimulationRoot.GetComponent<SectorCullGroup>().SetSector(__instance._dreamWorldSector);
+
+            // if the player's already in the dream world, we want to wake up at the first campfire we slept at, so don't override those values
+            if (PlayerState.InDreamWorld())
+            {
+                __instance._dreamArrivalPoint = arrivalPoint;
+                __instance._enteringDream = true;
+                return false;
+            }
+
+            // Make the body where the player 'wakes up' out of the dream match the body where the campfire is located if it isn't the Stranger ("RingWorld"), or reset it if it is
+            var ringWorldAO = Locator.GetAstroObject(AstroObject.Name.RingWorld);
+            if (dreamCampfire.GetAttachedOWRigidbody() == ringWorldAO.GetOWRigidbody())
+            {
+                __instance._planetBody = ringWorldAO.GetAttachedOWRigidbody();
+                __instance._ringWorldController = ringWorldAO.GetComponent<RingWorldController>();
+            }
+            else
+            {
+                var departureAO = dreamCampfire.GetComponentInParent<AstroObject>();
+                __instance._planetBody = departureAO.GetAttachedOWRigidbody();
+                __instance._ringWorldController = null;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Load assets when dying in dreamworld and returning to a custom dream campfire
+        /// Only really relevant for campfires on stock planets
+        /// 
+        /// This only gets us like a 1 second headstart on loading so honestly it's barely worth it,
+        /// could be replaced with keeping the assets loaded the entire time you're in the dreamworld
+        /// but we should only do that if it becomes relevant I think
+        /// </summary>
+        /// <param name="__instance"></param>
+        /// <param name="dreamCampfire"></param>
+        [HarmonyPrefix, HarmonyPatch(nameof(DreamWorldController.EnterDreamWorld))]
+        private static void OnEnterDreamWorld(DreamWorldController __instance, DreamCampfire dreamCampfire)
+        {
+            var planet = dreamCampfire.GetComponentInParent<AstroObject>();
+            if (planet.GetAstroObjectName() != AstroObject.Name.RingWorld)
+            {
+                _dreamEntryLocationStreamingGroup = planet.GetComponentInChildren<StreamingGroup>();
+                GlobalMessenger<DeathType>.AddListener("PlayerDeath", OnPlayerDeath);
+            }
+        }
+
+        private static StreamingGroup _dreamEntryLocationStreamingGroup;
+
+        private static void OnPlayerDeath(DeathType type)
+        {
+            if (PlayerState.InDreamWorld())
+            {
+                if (_dreamEntryLocationStreamingGroup != null)
+                {
+                    _dreamEntryLocationStreamingGroup.RequestRequiredAssets(0);
+                    _dreamEntryLocationStreamingGroup.RequestGeneralAssets(0);
+                }
+                _dreamEntryLocationStreamingGroup = null;
+            }
+            GlobalMessenger<DeathType>.RemoveListener("PlayerDeath", OnPlayerDeath);
+        }
     }
 }

NewHorizons/Schemas/body_schema.json

@@ -65,6 +65,10 @@
       "description": "Add a cloaking field to this planet",
       "$ref": "#/definitions/CloakModule"
     },
+    "Dream": {
+      "description": "Make this planet part of the dream world",
+      "$ref": "#/definitions/DreamModule"
+    },
     "FocalPoint": {
       "description": "Make this body into a focal point (barycenter)",
       "$ref": "#/definitions/FocalPointModule"
@@ -799,6 +803,20 @@
         }
       }
     },
+    "DreamModule": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "inDreamWorld": {
+          "type": "boolean",
+          "description": "Setting this value will make this body a dream world style dimension where its contents are only activated while entering it from a dream campfire. Disables the body's map marker."
+        },
+        "generateSimulationMeshes": {
+          "type": "boolean",
+          "description": "Whether to generate simulation meshes (the models used in the \"tronworld\" or \"matrix\" view) for most objects on this planet by cloning the existing meshes and applying the simulation materials. Leave this off if you are building your own simulation meshes or using existing objects which have them."
+        }
+      }
+    },
     "FocalPointModule": {
       "type": "object",
       "additionalProperties": false,
@@ -1294,6 +1312,20 @@
           "items": {
             "$ref": "#/definitions/ShuttleInfo"
           }
+        },
+        "dreamCampfires": {
+          "type": "array",
+          "description": "Add campfires that allow you to enter the dream world/simulation. Must be paired with a dream arrival point, which can be placed on this planet or elsewhere.",
+          "items": {
+            "$ref": "#/definitions/DreamCampfireInfo"
+          }
+        },
+        "dreamArrivalPoints": {
+          "type": "array",
+          "description": "Add the points you will arrive at when entering the dream world/simulation from a paired dream campfire, which can be placed on this planet or elsewhere. The planet with the arrival point should be statically positioned to avoid issues with the simulation view materials.",
+          "items": {
+            "$ref": "#/definitions/DreamArrivalPointInfo"
+          }
         }
       }
     },
@@ -3371,6 +3403,84 @@
         }
       }
     },
+    "DreamCampfireInfo": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "rotation": {
+          "description": "Rotation of the object",
+          "$ref": "#/definitions/MVector3"
+        },
+        "alignRadial": {
+          "type": [
+            "boolean",
+            "null"
+          ],
+          "description": "Do we try to automatically align this object to stand upright relative to the body's center? Stacks with rotation.\nDefaults to true for geysers, tornados, and volcanoes, and false for everything else."
+        },
+        "position": {
+          "description": "Position of the object",
+          "$ref": "#/definitions/MVector3"
+        },
+        "isRelativeToParent": {
+          "type": "boolean",
+          "description": "Whether the positional and rotational coordinates are relative to parent instead of the root planet object."
+        },
+        "parentPath": {
+          "type": "string",
+          "description": "The relative path from the planet to the parent of this object. Optional (will default to the root sector)."
+        },
+        "rename": {
+          "type": "string",
+          "description": "An optional rename of this object"
+        },
+        "id": {
+          "type": "string",
+          "description": "Unique ID for this dream-world campfire"
+        }
+      }
+    },
+    "DreamArrivalPointInfo": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "rotation": {
+          "description": "Rotation of the object",
+          "$ref": "#/definitions/MVector3"
+        },
+        "alignRadial": {
+          "type": [
+            "boolean",
+            "null"
+          ],
+          "description": "Do we try to automatically align this object to stand upright relative to the body's center? Stacks with rotation.\nDefaults to true for geysers, tornados, and volcanoes, and false for everything else."
+        },
+        "position": {
+          "description": "Position of the object",
+          "$ref": "#/definitions/MVector3"
+        },
+        "isRelativeToParent": {
+          "type": "boolean",
+          "description": "Whether the positional and rotational coordinates are relative to parent instead of the root planet object."
+        },
+        "parentPath": {
+          "type": "string",
+          "description": "The relative path from the planet to the parent of this object. Optional (will default to the root sector)."
+        },
+        "rename": {
+          "type": "string",
+          "description": "An optional rename of this object"
+        },
+        "id": {
+          "type": "string",
+          "description": "Unique ID for this dream-world arrival point"
+        },
+        "generateSimulationMeshes": {
+          "type": "boolean",
+          "description": "Whether to generate simulation meshes (the models used in the \"tronworld\" or \"matrix\" view) for most objects on the current planet by cloning the existing meshes and applying the simulation materials. Leave this off if you are building your own simulation meshes or using existing objects which have them."
+        }
+      }
+    },
     "ReferenceFrameModule": {
       "type": "object",
       "additionalProperties": false,