Better vessel warping

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

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/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

@@ -56,14 +56,39 @@ 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");
+            if (_vesselSpawnPoint is VesselSpawnPoint vesselSpawnPoint)
-            playerSpawner.DebugWarp(_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();
@@ -86,7 +111,7 @@ namespace NewHorizons.Handlers
             }
         }
 
-        public static EyeSpawnPoint CreateVessel()
+        public static VesselSpawnPoint CreateVessel()
         {
             var system = SystemDict[Instance.CurrentStarSystem];
 
@@ -209,10 +234,10 @@ 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);
@@ -221,10 +246,10 @@ namespace NewHorizons.Handlers
             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];
 
@@ -247,11 +272,23 @@ namespace NewHorizons.Handlers
             vesselWarpController._whiteHole._startActive = true;
             vesselWarpController._whiteHole.Stabilize();
 
+            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 spawnPoint;
+            return vesselSpawnPoint;
         }
 
         public static void SetupWarpController(VesselWarpController vesselWarpController, NomaiInterfaceOrb orb, bool db = false)

NewHorizons/Main.cs

@@ -944,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();
@@ -983,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)
             {

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)
+                else if (canWarpToStarSystem && targetSystem != "EyeOfTheUniverse")
-                    Main.Instance.ChangeCurrentStarSystem(targetSystem, false, true);
+                    Main.Instance.ChangeCurrentStarSystemVesselAsync(targetSystem);
                 __instance._blackHoleOneShot.PlayOneShot(AudioType.VesselSingularityCreate);
                 GlobalMessenger.FireEvent("StartVesselWarp");
             }