Better vessel warp (#887)

## Improvements

- Relative spawning when warping with vessel just like vanilla
- No more wake up effects for vessel warping

## Bug fixes

- Fixed nomai lamps on custom vessel looking like they are off
- Fixed broken black and white holes on custom vessel
- Fixed vessel coordinate orb not unlocking on start

NewHorizons/Assets/newhorizons_private.manifest

@@ -1,12 +1,12 @@
 ManifestFileVersion: 0
-CRC: 423323461
+CRC: 2245901288
 Hashes:
   AssetFileHash:
     serializedVersion: 2
-    Hash: 4199cf66477e2054e4ac61871d811161
+    Hash: e765e5fc418c1ed69586a3826e0cdea3
   TypeTreeHash:
     serializedVersion: 2
-    Hash: 83784250589f972ee0b86ea39a5a5305
+    Hash: 65942a71d50cdc9f2387a8fa9383a3f8
 HashAppended: 0
 ClassTypes:
 - Class: 1
@@ -41,6 +41,8 @@ ClassTypes:
   Script: {instanceID: 0}
 - Class: 114
   Script: {fileID: 11500000, guid: 70edf1000ebf31e4eb3ab4e289a345c0, type: 3}
+- Class: 114
+  Script: {fileID: 11500000, guid: 86d5ae109bbc920409997135e88f1755, type: 3}
 - Class: 114
   Script: {fileID: 11500000, guid: 77b727c07614b4041a5fe1fba0cfacff, type: 3}
 - Class: 114
@@ -105,8 +107,6 @@ ClassTypes:
   Script: {fileID: 11500000, guid: f645b92850d716a4488617b651223700, type: 3}
 - Class: 114
   Script: {fileID: 11500000, guid: 8ef66a28deb09ab4aaba30bb60b9f19a, type: 3}
-- Class: 114
-  Script: {fileID: 11500000, guid: 0863077874402f14dba0ca4ae81752dd, type: 3}
 - Class: 114
   Script: {fileID: 11500000, guid: bf998978a8a701b4eb09fcd94048f916, type: 3}
 - Class: 114

NewHorizons/Components/EyeOfTheUniverse/EyeAstroObject.cs

@@ -1,7 +1,15 @@
+using NewHorizons.Components.Orbital;
+
 namespace NewHorizons.Components.EyeOfTheUniverse
 {
-    public class EyeAstroObject : AstroObject
+    public class EyeAstroObject : NHAstroObject
     {
+        public EyeAstroObject()
+        {
+            isVanilla = true;
+            modUniqueName = Main.Instance.ModHelper.Manifest.UniqueName;
+        }
+
         public new void Awake()
         {
             _owRigidbody = GetComponent<OWRigidbody>();

NewHorizons/Components/FixPhysics.cs

@@ -0,0 +1,29 @@
+using NewHorizons.Utility.OuterWilds;
+using NewHorizons.Utility.OWML;
+using System.Collections;
+using UnityEngine;
+
+namespace NewHorizons.Components;
+
+[DisallowMultipleComponent]
+public class FixPhysics : MonoBehaviour
+{
+    private OWRigidbody _body;
+
+    private void Awake()
+    {
+        _body = GetComponent<OWRigidbody>();
+        _body._lastPosition = transform.position;
+    }
+
+    private void Start()
+    {
+        var parentBody = _body.GetOrigParentBody();
+        if (parentBody == null) return;
+        _body.SetVelocity(parentBody.GetPointVelocity(_body.GetWorldCenterOfMass()));
+        _body.SetAngularVelocity(parentBody.GetAngularVelocity());
+        if (_body._simulateInSector) _body.OnSectorOccupantsUpdated();
+        var gravity = parentBody.GetComponentInChildren<GravityVolume>();
+        if (gravity != null) gravity.GetComponent<OWTriggerVolume>().AddObjectToVolume(_body.GetComponentInChildren<ForceDetector>().gameObject);
+    }
+}

NewHorizons/Components/MaterialReplacer.cs

@@ -30,6 +30,13 @@ namespace NewHorizons.Components
                 nnc._inactiveMaterial = materials[0];
                 nnc._activeMaterial = materials[1];
             }
+
+            NomaiLamp nl = GetComponentInParent<NomaiLamp>();
+            if (nl != null)
+            {
+                nl.enabled = true;
+                nl.Awake();
+            }
         }
     }
 }

NewHorizons/Components/Vessel/VesselOrbLocker.cs

@@ -45,11 +45,55 @@ namespace NewHorizons.Components
             _powerOrb.AddLock();
         }
 
-        public void RemoveLocks()
+        public void RemoveLockFromCoordinateOrb()
+        {
+            _coordinateInterfaceOrb.RemoveLock();
+        }
+
+        public void RemoveLockFromWarpOrb()
+        {
+            _coordinateInterfaceUpperOrb.RemoveLock();
+        }
+
+        public void RemoveLockFromPowerOrb()
+        {
+            _powerOrb.RemoveLock();
+        }
+
+        public void RemoveAllLocksFromCoordinateOrb()
         {
             _coordinateInterfaceOrb.RemoveAllLocks();
+        }
+
+        public void RemoveAllLocksFromWarpOrb()
+        {
             _coordinateInterfaceUpperOrb.RemoveAllLocks();
+        }
+
+        public void RemoveAllLocksFromPowerOrb()
+        {
             _powerOrb.RemoveAllLocks();
         }
+
+        public void AddLock()
+        {
+            AddLockToCoordinateOrb();
+            AddLockToWarpOrb();
+            AddLockToPowerOrb();
+        }
+
+        public void RemoveLock()
+        {
+            RemoveLockFromCoordinateOrb();
+            RemoveLockFromWarpOrb();
+            RemoveLockFromPowerOrb();
+        }
+
+        public void RemoveAllLocks()
+        {
+            RemoveAllLocksFromCoordinateOrb();
+            RemoveAllLocksFromWarpOrb();
+            RemoveAllLocksFromPowerOrb();
+        }
     }
 }

NewHorizons/Components/Vessel/VesselSpawnPoint.cs

@@ -0,0 +1,78 @@
+using NewHorizons.Handlers;
+using NewHorizons.Utility;
+using NewHorizons.Utility.OWML;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Components
+{
+    [UsedInUnityProject]
+    public class VesselSpawnPoint : EyeSpawnPoint
+    {
+        public GameObject warpControllerObject;
+        private VesselWarpController _warpController;
+
+        public VesselWarpController WarpController
+        {
+            get
+            {
+                if (_warpController == null && warpControllerObject != null) WarpController = warpControllerObject.GetComponent<VesselWarpController>();
+                return _warpController;
+            }
+            set
+            {
+                _warpController = value;
+                if (_warpController != null) _triggerVolumes = new OWTriggerVolume[1] { _warpController._bridgeVolume };
+            }
+        }
+
+        public VesselSpawnPoint()
+        {
+            _eyeState = EyeState.AboardVessel;
+        }
+
+        public int index = 0;
+
+        public void WarpPlayer(bool spawn = false)
+        {
+            var warpController = WarpController;
+            var player = Locator.GetPlayerBody();
+            var relativeTransform = warpController.transform;
+            var relativeBody = relativeTransform.GetAttachedOWRigidbody();
+            if (!spawn) Locator.GetPlayerCamera().GetComponent<PlayerCameraEffectController>().OpenEyesImmediate();
+            if (VesselWarpController.s_relativeLocationSaved)
+            {
+                Locator.GetPlayerBody().MoveToRelativeLocation(VesselWarpController.s_playerWarpLocation, relativeBody, relativeTransform);
+            }
+            else
+            {
+                player.SetPosition(warpController._defaultPlayerWarpPoint.position);
+                player.SetRotation(warpController._defaultPlayerWarpPoint.rotation);
+                player.SetVelocity(relativeBody.GetPointVelocity(warpController._defaultPlayerWarpPoint.position));
+            }
+            AddPlayerToVolume(warpController._bridgeVolume);
+            AddPlayerToTriggerVolumes();
+        }
+
+        public override void OnSpawnPlayer()
+        {
+            Delay.FireOnNextUpdate(() => WarpPlayer(true));
+        }
+
+        public void AddPlayerToVolume(OWTriggerVolume volume)
+        {
+            volume.AddObjectToVolume(Locator.GetPlayerDetector());
+            volume.AddObjectToVolume(Locator.GetPlayerCameraDetector());
+        }
+
+        public void AddPlayerToTriggerVolumes()
+        {
+            AddObjectToTriggerVolumes(Locator.GetPlayerDetector());
+            AddObjectToTriggerVolumes(Locator.GetPlayerCameraDetector());
+        }
+    }
+}

NewHorizons/Handlers/VesselWarpHandler.cs

@@ -41,7 +41,7 @@ namespace NewHorizons.Handlers
         {
             var vesselConfig = SystemDict[Instance.CurrentStarSystem].Config?.Vessel;
             var shouldSpawnOnVessel = IsVesselPresent() && (vesselConfig?.spawnOnVessel ?? false);
-            return !Instance.IsWarpingFromShip && (Instance.IsWarpingFromVessel || shouldSpawnOnVessel);
+            return !Instance.IsWarpingFromShip && (Instance.IsWarpingFromVessel || Instance.DidWarpFromVessel || shouldSpawnOnVessel);
         }
 
         public static void LoadVessel()
@@ -56,16 +56,46 @@ namespace NewHorizons.Handlers
             if (IsVesselPresentAndActive())
                 _vesselSpawnPoint = Instance.CurrentStarSystem == "SolarSystem" ? UpdateVessel() : CreateVessel();
             else
-                _vesselSpawnPoint = SearchUtilities.Find("DB_VesselDimension_Body/Sector_VesselDimension").GetComponentInChildren<SpawnPoint>();
+            {
+                var vesselDimension = SearchUtilities.Find("DB_VesselDimension_Body/Sector_VesselDimension");
+                var vesselDimensionSpawn = vesselDimension.GetComponentInChildren<SpawnPoint>(true);
+                var vesselWarpController = vesselDimension.GetComponentInChildren<VesselWarpController>(true);
+
+                var defaultPlayerWarpPoint = new GameObject("DefaultPlayerWarpPos");
+                defaultPlayerWarpPoint.transform.SetParent(vesselWarpController.transform, false);
+                defaultPlayerWarpPoint.transform.localPosition = new Vector3(0, -5.82f, -6.56f);
+                vesselWarpController._defaultPlayerWarpPoint = defaultPlayerWarpPoint.transform;
+
+                var vesselSpawnObj = new GameObject("SPAWN_Vessel");
+                vesselSpawnObj.transform.SetParent(vesselWarpController.transform.parent.parent, false);
+                vesselSpawnObj.transform.localPosition = new Vector3(-0.3f, -5.18f, -6.35f);
+                var vesselSpawnPoint = vesselSpawnObj.AddComponent<VesselSpawnPoint>();
+                vesselSpawnPoint.WarpController = vesselWarpController;
+                vesselSpawnPoint._triggerVolumes = vesselDimensionSpawn._triggerVolumes;
+                _vesselSpawnPoint = vesselSpawnPoint;
+            }
         }
 
         public static void TeleportToVessel()
         {
             var playerSpawner = Object.FindObjectOfType<PlayerSpawner>();
-            NHLogger.LogVerbose("Debug warping into vessel");
-            playerSpawner.DebugWarp(_vesselSpawnPoint);
+            if (_vesselSpawnPoint is VesselSpawnPoint vesselSpawnPoint)
+            {
+                NHLogger.LogVerbose("Relative warping into vessel");
+                vesselSpawnPoint.WarpPlayer();//Delay.FireOnNextUpdate(vesselSpawnPoint.WarpPlayer);
+            }
+            else
+            {
+                NHLogger.LogVerbose("Debug warping into vessel");
+                playerSpawner.DebugWarp(_vesselSpawnPoint);
+            }
             Builder.General.SpawnPointBuilder.SuitUp();
 
+            LoadDB();
+        }
+
+        public static void LoadDB()
+        {
             if (Instance.CurrentStarSystem == "SolarSystem")
             {
                 // Deactivate village music because for some reason it still plays.
@@ -81,7 +111,7 @@ namespace NewHorizons.Handlers
             }
         }
 
-        public static EyeSpawnPoint CreateVessel()
+        public static VesselSpawnPoint CreateVessel()
         {
             var system = SystemDict[Instance.CurrentStarSystem];
 
@@ -131,16 +161,23 @@ namespace NewHorizons.Handlers
             vesselWarpController._targetWarpPlatform._whiteHole.OnCollapse += vesselWarpController._targetWarpPlatform.OnWhiteHoleCollapse;
 
             GameObject blackHole = SearchUtilities.Find("DB_VesselDimension_Body/Sector_VesselDimension/Sector_VesselBridge/Interactibles_VesselBridge/BlackHole");
-            GameObject newBlackHole = Object.Instantiate(blackHole, Vector3.zero, Quaternion.identity, singularityRoot.transform);
+            GameObject newBlackHole = Object.Instantiate(blackHole, singularityRoot.transform);
+            newBlackHole.transform.localPosition = Vector3.zero;
+            newBlackHole.transform.localRotation = Quaternion.identity;
+            newBlackHole.transform.localScale = Vector3.one;
             newBlackHole.name = "BlackHole";
             vesselWarpController._blackHole = newBlackHole.GetComponentInChildren<SingularityController>();
             vesselWarpController._blackHoleOneShot = vesselWarpController._blackHole.transform.parent.Find("BlackHoleAudio_OneShot").GetComponent<OWAudioSource>();
 
             GameObject whiteHole = SearchUtilities.Find("DB_VesselDimension_Body/Sector_VesselDimension/Sector_VesselBridge/Interactibles_VesselBridge/WhiteHole");
-            GameObject newWhiteHole = Object.Instantiate(whiteHole, Vector3.zero, Quaternion.identity, singularityRoot.transform);
+            GameObject newWhiteHole = Object.Instantiate(whiteHole, singularityRoot.transform);
+            newWhiteHole.transform.localPosition = Vector3.zero;
+            newWhiteHole.transform.localRotation = Quaternion.identity;
+            newWhiteHole.transform.localScale = Vector3.one;
             newWhiteHole.name = "WhiteHole";
             vesselWarpController._whiteHole = newWhiteHole.GetComponentInChildren<SingularityController>();
             vesselWarpController._whiteHoleOneShot = vesselWarpController._whiteHole.transform.parent.Find("WhiteHoleAudio_OneShot").GetComponent<OWAudioSource>();
+            vesselWarpController._whiteHole._startActive = true;
 
             vesselObject.GetComponent<MapMarker>()._labelID = (UITextType)TranslationHandler.AddUI("Vessel");
 
@@ -165,6 +202,17 @@ namespace NewHorizons.Handlers
                     Object.Destroy(rfVolume.gameObject);
                 }
             }
+            
+            if (hasParentBody)
+            {
+                foreach (OWRigidbody dynamicProp in vesselObject.GetComponentsInChildren<OWRigidbody>(true))
+                {
+                    if (dynamicProp.GetComponent<NomaiInterfaceOrb>() == null)
+                    {
+                        dynamicProp.gameObject.AddComponent<FixPhysics>();
+                    }
+                }
+            }
 
             var attachWarpExitToVessel = system.Config.Vessel?.warpExit?.attachToVessel ?? false;
             var warpExitParent = vesselWarpController._targetWarpPlatform.transform.parent;
@@ -186,20 +234,22 @@ namespace NewHorizons.Handlers
                 }
             }
 
-            EyeSpawnPoint eyeSpawnPoint = vesselObject.GetComponentInChildren<EyeSpawnPoint>(true);
+            VesselSpawnPoint spawnPoint = vesselObject.GetComponentInChildren<VesselSpawnPoint>(true);
             if (ShouldSpawnAtVessel())
             {
-                system.SpawnPoint = eyeSpawnPoint;
+                system.SpawnPoint = spawnPoint;
             }
 
             vesselObject.SetActive(true);
 
-            Delay.FireOnNextUpdate(() => SetupWarpController(vesselWarpController));
+            var power = vesselWarpController.transform.Find("PowerSwitchInterface");
+            var orb = power.GetComponentInChildren<NomaiInterfaceOrb>(true);
+            Delay.FireOnNextUpdate(() => SetupWarpController(vesselWarpController, orb));
 
-            return eyeSpawnPoint;
+            return spawnPoint;
         }
 
-        public static SpawnPoint UpdateVessel()
+        public static VesselSpawnPoint UpdateVessel()
         {
             var system = SystemDict[Instance.CurrentStarSystem];
 
@@ -207,7 +257,7 @@ namespace NewHorizons.Handlers
             var vectorSector = SearchUtilities.Find("DB_VesselDimension_Body/Sector_VesselDimension");
             VesselObject = vectorSector;
 
-            var spawnPoint = vectorSector.GetComponentInChildren<SpawnPoint>();
+            var spawnPoint = vectorSector.GetComponentInChildren<SpawnPoint>(true);
 
             VesselWarpController vesselWarpController = vectorSector.GetComponentInChildren<VesselWarpController>(true);
             WarpController = vesselWarpController;
@@ -219,12 +269,29 @@ namespace NewHorizons.Handlers
                 vesselWarpController._whiteHoleOneShot = vesselWarpController._whiteHole.transform.parent.Find("WhiteHoleAudio_OneShot").GetComponent<OWAudioSource>();
             }
 
-            Delay.FireOnNextUpdate(() => SetupWarpController(vesselWarpController, true));
+            vesselWarpController._whiteHole._startActive = true;
+            vesselWarpController._whiteHole.Stabilize();
 
-            return spawnPoint;
+            var defaultPlayerWarpPoint = new GameObject("DefaultPlayerWarpPos");
+            defaultPlayerWarpPoint.transform.SetParent(vesselWarpController.transform, false);
+            defaultPlayerWarpPoint.transform.localPosition = new Vector3(0, -5.82f, -6.56f);
+            vesselWarpController._defaultPlayerWarpPoint = defaultPlayerWarpPoint.transform;
+
+            var vesselSpawnObj = new GameObject("SPAWN_Vessel");
+            vesselSpawnObj.transform.SetParent(vesselWarpController.transform.parent.parent, false);
+            vesselSpawnObj.transform.localPosition = new Vector3(-0.3f, -5.18f, -6.35f);
+            var vesselSpawnPoint = vesselSpawnObj.AddComponent<VesselSpawnPoint>();
+            vesselSpawnPoint.WarpController = vesselWarpController;
+            vesselSpawnPoint._triggerVolumes = spawnPoint._triggerVolumes;
+
+            var power = vesselWarpController.transform.Find("PowerSwitchInterface");
+            var orb = power.GetComponentInChildren<NomaiInterfaceOrb>(true);
+            Delay.FireOnNextUpdate(() => SetupWarpController(vesselWarpController, orb, true));
+
+            return vesselSpawnPoint;
         }
 
-        public static void SetupWarpController(VesselWarpController vesselWarpController, bool db = false)
+        public static void SetupWarpController(VesselWarpController vesselWarpController, NomaiInterfaceOrb orb, bool db = false)
         {
             if (db)
             {
@@ -259,17 +326,33 @@ namespace NewHorizons.Handlers
                                 if (light.GetLight()) light.GetLight().enabled = true;
                             }
                         }
-                        vesselWarpController._coreSocket.PlaceIntoSocket(newCore);
+                        vesselWarpController._coreSocket._socketedItem = newCore;
+                        newCore.SocketItem(vesselWarpController._coreSocket._socketTransform, vesselWarpController._coreSocket._sector);
+                        newCore.PlaySocketAnimation();
+                        vesselWarpController._coreSocket.enabled = true;
+                        vesselWarpController.SetPowered(true);
                         break;
                     }
                 }
             }
+            else
+            {
+                foreach (NomaiLamp lamp in vesselWarpController.transform.root.GetComponentsInChildren<NomaiLamp>(true))
+                {
+                    lamp._startOn = true;
+                    lamp.Awake();
+                }
+            }
+
             vesselWarpController.OnSlotDeactivated(vesselWarpController._coordinatePowerSlot);
-            if (!db) vesselWarpController.OnSlotActivated(vesselWarpController._coordinatePowerSlot);
             vesselWarpController._gravityVolume.SetFieldMagnitude(vesselWarpController._origGravityMagnitude);
             vesselWarpController._coreCable.SetPowered(true);
-            vesselWarpController._coordinateCable.SetPowered(!db);
             vesselWarpController._warpPlatformCable.SetPowered(false);
+            orb.SetOrbPosition(vesselWarpController._coordinatePowerSlot.transform.position);
+            orb._occupiedSlot = vesselWarpController._coordinatePowerSlot;
+            orb._enterSlotTime = Time.time;
+            Delay.RunWhen(() => !vesselWarpController._coordinateInterface._pillarRaised, () => vesselWarpController.OnSlotActivated(vesselWarpController._coordinatePowerSlot));
+            vesselWarpController._coordinateCable.SetPowered(true);
             vesselWarpController._cageClosed = true;
             if (vesselWarpController._cageAnimator != null)
             {

NewHorizons/Main.cs

@@ -526,6 +526,8 @@ namespace NewHorizons
                         PlayerData.SaveLoopCount(2);
                         PlayerData.SetPersistentCondition("LAUNCH_CODES_GIVEN", true);
                     }
+
+                    if (shouldWarpInFromVessel) VesselWarpHandler.LoadDB();
                 }
                 else if (isEyeOfTheUniverse)
                 {
@@ -942,6 +944,7 @@ namespace NewHorizons
                 IsWarpingFromVessel = vessel;
                 DidWarpFromVessel = false;
                 OnChangeStarSystem?.Invoke(newStarSystem);
+                VesselWarpController.s_relativeLocationSaved = false;
 
                 NHLogger.Log($"Warping to {newStarSystem}");
                 if (warp && ShipWarpController) ShipWarpController.WarpOut();
@@ -981,8 +984,38 @@ namespace NewHorizons
             }
         }
 
+        /// <summary>
+        /// Exclusively for <see cref="Patches.WarpPatches.VesselWarpControllerPatches.VesselWarpController_OnSlotActivated(VesselWarpController, NomaiInterfaceSlot)"/>
+        /// </summary>
+        internal void ChangeCurrentStarSystemVesselAsync(string newStarSystem)
+        {
+            if (IsChangingStarSystem) return;
+
+            if (LoadManager.GetCurrentScene() == OWScene.SolarSystem || LoadManager.GetCurrentScene() == OWScene.EyeOfTheUniverse)
+            {
+                IsWarpingFromShip = false;
+                IsWarpingFromVessel = true;
+                DidWarpFromVessel = false;
+                OnChangeStarSystem?.Invoke(newStarSystem);
+
+                NHLogger.Log($"Vessel warping to {newStarSystem}");
+                IsChangingStarSystem = true;
+                WearingSuit = PlayerState.IsWearingSuit();
+
+                PlayerData.SaveEyeCompletion(); // So that the title screen doesn't keep warping you back to eye
+
+                if (SystemDict[CurrentStarSystem].Config.enableTimeLoop) SecondsElapsedInLoop = TimeLoop.GetSecondsElapsed();
+                else SecondsElapsedInLoop = -1;
+
+                CurrentStarSystem = newStarSystem;
+
+                LoadManager.LoadSceneAsync(OWScene.SolarSystem, false, LoadManager.FadeType.ToBlack);
+            }
+        }
+
         void OnDeath(DeathType _)
         {
+            VesselWarpController.s_relativeLocationSaved = false;
             // We reset the solar system on death
             if (!IsChangingStarSystem)
             {
@@ -998,9 +1031,13 @@ namespace NewHorizons
             {
                 CurrentStarSystem = _defaultSystemOverride;
 
-                if (BodyDict.TryGetValue(_defaultSystemOverride, out var bodies) && bodies.Any(x => x.Config?.Spawn?.shipSpawn != null))
+                // #738 - Sometimes the override will not support spawning regularly, so always warp in if possible
+                if (SystemDict[_defaultSystemOverride].Config.Vessel?.spawnOnVessel == true)
+                {
+                    IsWarpingFromVessel = true;
+                }
+                else if (BodyDict.TryGetValue(_defaultSystemOverride, out var bodies) && bodies.Any(x => x.Config?.Spawn?.shipSpawn != null))
                 {
-                    // #738 - Sometimes the override will not support spawning regularly, so always warp in if possible
                     IsWarpingFromShip = true;
                 }
                 else

NewHorizons/Patches/PlayerPatches/PlayerBreathingAudioPatches.cs

@@ -0,0 +1,17 @@
+using HarmonyLib;
+
+namespace NewHorizons.Patches.PlayerPatches
+{
+    [HarmonyPatch(typeof(PlayerBreathingAudio))]
+    public static class PlayerBreathingAudioPatches
+    {
+        [HarmonyPrefix]
+        [HarmonyPatch(nameof(PlayerBreathingAudio.OnWakeUp))]
+        public static bool PlayerBreathingAudio_OnWakeUp(PlayerBreathingAudio __instance)
+        {
+            if (Main.Instance.IsWarpingFromShip || Main.Instance.IsWarpingFromVessel || Main.Instance.DidWarpFromShip || Main.Instance.DidWarpFromVessel)
+                return false;
+            return true;
+        }
+    }
+}

NewHorizons/Patches/PlayerPatches/PlayerCameraEffectControllerPatches.cs

@@ -0,0 +1,24 @@
+using HarmonyLib;
+using NewHorizons.Utility;
+using NewHorizons.Utility.OWML;
+using UnityEngine;
+
+namespace NewHorizons.Patches.PlayerPatches
+{
+    [HarmonyPatch(typeof(PlayerCameraEffectController))]
+    public static class PlayerCameraEffectControllerPatches
+    {
+        [HarmonyPrefix]
+        [HarmonyPatch(nameof(PlayerCameraEffectController.OnStartOfTimeLoop))]
+        public static bool PlayerCameraEffectController_OnStartOfTimeLoop(PlayerCameraEffectController __instance, int loopCount)
+        {
+            if (__instance.gameObject.CompareTag("MainCamera") && (Main.Instance.IsWarpingFromShip || Main.Instance.IsWarpingFromVessel || Main.Instance.DidWarpFromShip || Main.Instance.DidWarpFromVessel))
+            {
+                __instance.CloseEyesImmediate();
+                GlobalMessenger.FireEvent("WakeUp");
+                return false;
+            }
+            return true;
+        }
+    }
+}

NewHorizons/Patches/WarpPatches/VesselWarpControllerPatches.cs

@@ -1,6 +1,9 @@
 using HarmonyLib;
+using NewHorizons.Components.Ship;
+using NewHorizons.Handlers;
 using NewHorizons.Utility;
 using NewHorizons.Utility.OuterWilds;
+using NewHorizons.Utility.OWML;
 
 namespace NewHorizons.Patches.WarpPatches
 {
@@ -20,6 +23,7 @@ namespace NewHorizons.Patches.WarpPatches
             if (!Main.Instance.IsWarpingFromVessel)
                 PlayerData.SaveWarpedToTheEye(TimeLoopUtilities.GetVanillaSecondsRemaining());
 
+            Locator.GetPlayerSectorDetector().RemoveFromAllSectors();
             LoadManager.EnableAsyncLoadTransition();
 
             return false;
@@ -64,10 +68,10 @@ namespace NewHorizons.Patches.WarpPatches
                 if (canWarpToEye || canWarpToStarSystem && targetSystem == "EyeOfTheUniverse")
                 {
                     Main.Instance.CurrentStarSystem = "EyeOfTheUniverse";
-                    LoadManager.LoadSceneAsync(OWScene.EyeOfTheUniverse, false, LoadManager.FadeType.ToWhite);
+                    LoadManager.LoadSceneAsync(OWScene.EyeOfTheUniverse, false, LoadManager.FadeType.ToBlack);// Mobius had the fade set to white. Doesn't look that good because of the loadng screen being black.
                 }
-                else if (canWarpToStarSystem)
-                    Main.Instance.ChangeCurrentStarSystem(targetSystem, false, true);
+                else if (canWarpToStarSystem && targetSystem != "EyeOfTheUniverse")
+                    Main.Instance.ChangeCurrentStarSystemVesselAsync(targetSystem);
                 __instance._blackHoleOneShot.PlayOneShot(AudioType.VesselSingularityCreate);
                 GlobalMessenger.FireEvent("StartVesselWarp");
             }

NewHorizons/Utility/CollectionUtilities.cs

@@ -1,11 +1,11 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 namespace NewHorizons.Utility
 {
     public static class CollectionUtilities
     {
-        public static T KeyByValue<T, W>(Dictionary<T, W> dict, W val)
+        public static T KeyByValue<T, W>(Dictionary<T, W> dict, W val, T defaultValue = default)
         {
-            T key = default;
+            T key = defaultValue;
             foreach (KeyValuePair<T, W> pair in dict)
             {
                 if (EqualityComparer<W>.Default.Equals(pair.Value, val))

NewHorizons/Utility/DebugTools/DebugReload.cs

@@ -46,7 +46,7 @@ namespace NewHorizons.Utility.DebugTools
             SearchUtilities.Find("/PauseMenu/PauseMenuManagers").GetComponent<PauseMenuManager>().OnSkipToNextTimeLoop();
 
             Main.Instance.ForceClearCaches = true;
-            Main.Instance.ChangeCurrentStarSystem(Main.Instance.CurrentStarSystem);
+            Main.Instance.ChangeCurrentStarSystem(Main.Instance.CurrentStarSystem, Main.Instance.DidWarpFromShip, Main.Instance.DidWarpFromVessel);
 
             Main.SecondsElapsedInLoop = -1f;
         }

NewHorizons/Utility/NewHorizonExtensions.cs

@@ -387,5 +387,43 @@ namespace NewHorizons.Utility
             // return Regex.Replace(text.Trim(), @"[^\S\r\n]+", "GUH");
             return Regex.Replace(text.Trim(), @"\s+", " ").ToLowerInvariant();
         }
+
+        public static void Stabilize(this SingularityController singularity)
+        {
+            singularity._state = SingularityController.State.Stable;
+            singularity._timer = 0f;
+            singularity._baseRadius = singularity._targetRadius;
+            singularity._currentRadius = singularity._targetRadius;
+            singularity._renderer.SetActivation(active: true);
+            singularity._renderer.SetMaterialProperty(singularity._propID_Radius, singularity._targetRadius);
+            if (singularity._owAmbientSource != null) singularity._owAmbientSource.FadeIn(0.5f);
+            singularity.enabled = true;
+        }
+
+        public static void OpenEyesImmediate(this PlayerCameraEffectController playerCameraEffectController)
+        {
+            playerCameraEffectController._lastOpenness = 1;
+            playerCameraEffectController._wakeCurve = playerCameraEffectController._fastWakeCurve;
+            playerCameraEffectController._isOpeningEyes = false;
+            playerCameraEffectController._isClosingEyes = false;
+            playerCameraEffectController._eyeAnimDuration = 0;
+            playerCameraEffectController._eyeAnimStartTime = Time.time;
+            playerCameraEffectController._owCamera.postProcessingSettings.eyeMask.openness = 1;
+            playerCameraEffectController._owCamera.postProcessingSettings.bloom.threshold = playerCameraEffectController._owCamera.postProcessingSettings.bloomDefault.threshold;
+            playerCameraEffectController._owCamera.postProcessingSettings.eyeMaskEnabled = false;
+        }
+
+        public static void CloseEyesImmediate(this PlayerCameraEffectController playerCameraEffectController)
+        {
+            playerCameraEffectController._lastOpenness = 0f;
+            playerCameraEffectController._wakeCurve = playerCameraEffectController._fastWakeCurve;
+            playerCameraEffectController._isOpeningEyes = false;
+            playerCameraEffectController._isClosingEyes = false;
+            playerCameraEffectController._eyeAnimDuration = 0;
+            playerCameraEffectController._eyeAnimStartTime = Time.time;
+            playerCameraEffectController._owCamera.postProcessingSettings.eyeMask.openness = 0f;
+            playerCameraEffectController._owCamera.postProcessingSettings.bloom.threshold = 0f;
+            playerCameraEffectController._owCamera.postProcessingSettings.eyeMaskEnabled = true;
+        }
     }
 }