Merge pull request #519 from misternebula/tomb-sync

Tomb sync

QSB/EchoesOfTheEye/DreamCandles/DreamCandleManager.cs

@@ -7,7 +7,7 @@ namespace QSB.EchoesOfTheEye.DreamCandles;
 
 public class DreamCandleManager : WorldObjectManager
 {
-	public override WorldObjectScene WorldObjectScene => WorldObjectScene.SolarSystem;
+	public override WorldObjectScene WorldObjectScene => WorldObjectScene.Both;
 	public override bool DlcOnly => true;
 
 	public override async UniTask BuildWorldObjects(OWScene scene, CancellationToken ct) =>

QSB/EchoesOfTheEye/LightSensorSync/LightSensorManager.cs

@@ -9,7 +9,7 @@ namespace QSB.EchoesOfTheEye.LightSensorSync;
 
 internal class LightSensorManager : WorldObjectManager
 {
-	public override WorldObjectScene WorldObjectScene => WorldObjectScene.SolarSystem;
+	public override WorldObjectScene WorldObjectScene => WorldObjectScene.Both;
 	public override bool DlcOnly => true;
 
 	public static bool ShouldIgnore(LightSensor lightSensor) =>

QSB/EyeOfTheUniverse/Tomb/EyeTombWatcher.cs

@@ -0,0 +1,54 @@
+using QSB.EyeOfTheUniverse.Tomb.Messages;
+using QSB.Messaging;
+using QSB.Player;
+using UnityEngine;
+
+namespace QSB.EyeOfTheUniverse.Tomb;
+
+internal class EyeTombWatcher : MonoBehaviour
+{
+	private EyeTombController tomb;
+	private bool _observedGrave;
+
+	private void Start()
+	{
+		tomb = GetComponent<EyeTombController>();
+		tomb._graveObserveTrigger.OnGainFocus += OnObserveGrave;
+	}
+
+	private void OnDestroy()
+		=> tomb._graveObserveTrigger.OnGainFocus -= OnObserveGrave;
+
+	private void OnObserveGrave()
+	{
+		_observedGrave = true;
+		tomb._graveObserveTrigger.OnGainFocus -= OnObserveGrave;
+	}
+	
+	private void FixedUpdate()
+	{
+		if (!_observedGrave)
+		{
+			return;
+		}
+
+		var canShowStage = true;
+		foreach (var player in QSBPlayerManager.PlayerList)
+		{
+			var playerToStage = tomb._stageRoot.transform.position - player.Body.transform.position;
+			var playerLookDirection = player.Body.transform.forward;
+			var angle = Vector3.Angle(playerLookDirection, playerToStage);
+			if (angle < 70)
+			{
+				canShowStage = false;
+			}
+		}
+
+		if (canShowStage)
+		{
+			tomb._stageRoot.SetActive(true);
+			new ShowStageMessage().Send();
+			enabled = false;
+		}
+	}
+}

QSB/EyeOfTheUniverse/Tomb/Messages/CloseDoorMessage.cs

@@ -0,0 +1,14 @@
+using QSB.Messaging;
+using QSB.Utility;
+using QSB.WorldSync;
+
+namespace QSB.EyeOfTheUniverse.Tomb.Messages;
+
+internal class CloseDoorMessage : QSBMessage
+{
+	public override void OnReceiveRemote()
+	{
+		var mirror = QSBWorldSync.GetUnityObject<EyeMirrorController>();
+		mirror._door.Close();
+	}
+}

QSB/EyeOfTheUniverse/Tomb/Messages/EnterExitStageMessage.cs

@@ -0,0 +1,16 @@
+using QSB.Messaging;
+using QSB.WorldSync;
+using System.Linq;
+
+namespace QSB.EyeOfTheUniverse.Tomb.Messages;
+
+internal class EnterExitStageMessage : QSBMessage<bool>
+{
+	public EnterExitStageMessage(bool enter) : base(enter) { }
+
+	public override void OnReceiveRemote()
+	{
+		var tomb = QSBWorldSync.GetUnityObjects<EyeTombController>().First();
+		tomb._candleController.FadeTo(Data ? 1f : 0f, 1f);
+	}
+}

QSB/EyeOfTheUniverse/Tomb/Messages/ShowStageMessage.cs

@@ -0,0 +1,14 @@
+using QSB.Messaging;
+using QSB.Utility;
+using QSB.WorldSync;
+
+namespace QSB.EyeOfTheUniverse.Tomb.Messages;
+
+internal class ShowStageMessage : QSBMessage
+{
+	public override void OnReceiveRemote()
+	{
+		var tomb = QSBWorldSync.GetUnityObject<EyeTombController>();
+		tomb._stageRoot.SetActive(true);
+	}
+}

QSB/EyeOfTheUniverse/Tomb/Messages/ToggleLitStateMessage.cs

@@ -0,0 +1,43 @@
+using QSB.Messaging;
+using QSB.Utility;
+using QSB.WorldSync;
+
+namespace QSB.EyeOfTheUniverse.Tomb.Messages;
+
+internal class ToggleLitStateMessage : QSBMessage<(int stateIndex, int direction, bool wasLit)>
+{
+	public ToggleLitStateMessage(int currentStateIndex, int direction, bool wasLit) : base((currentStateIndex, direction, wasLit)) { }
+
+	public override void OnReceiveRemote()
+	{
+		var tomb = QSBWorldSync.GetUnityObject<EyeTombController>();
+
+		if (tomb._stateIndex != Data.stateIndex)
+		{
+			DebugLog.ToConsole($"Warning - Received ToggleLitStateMessage with stateIndex of {Data.stateIndex}, but is currently {tomb._stateIndex}. Correcting...");
+			tomb._states[tomb._stateIndex].SetActive(false);
+			tomb._stateIndex = Data.stateIndex;
+		}
+
+		if (tomb._lit != Data.wasLit)
+		{
+			DebugLog.ToConsole($"Warning - Received ToggleLitStateMessage, and the value of lit did not match. Correcting...");
+			tomb._lit = Data.wasLit;
+		}
+
+		tomb._lit = !tomb._lit;
+		tomb._planetLightController.SetIntensity(tomb._lit ? 1f : 0f);
+		tomb._planetObject.SetActive(tomb._lit);
+		tomb._lightBeamController.SetFade(tomb._lit ? 1f : 0f);
+
+		if (!tomb._lit)
+		{
+			tomb._states[tomb._stateIndex].SetActive(false);
+			tomb._stateIndex += Data.direction;
+			tomb._states[tomb._stateIndex].SetActive(true);
+		}
+
+		tomb._gearEffects.AddRotation(Data.direction * 45f, 0f);
+		tomb._oneShotSource.PlayOneShot((Data.direction > 0f) ? AudioType.Projector_Next : AudioType.Projector_Prev, 1f);
+	}
+}

QSB/EyeOfTheUniverse/Tomb/Messages/UseTombMessage.cs

@@ -0,0 +1,25 @@
+using QSB.Messaging;
+using QSB.WorldSync;
+
+namespace QSB.EyeOfTheUniverse.Tomb.Messages;
+
+internal class UseTombMessage : QSBMessage<bool>
+{
+	public UseTombMessage(bool use) : base(use) { }
+
+	public override void OnReceiveRemote()
+	{
+		var tomb = QSBWorldSync.GetUnityObject<EyeTombController>();
+
+		if (Data)
+		{
+			if (!tomb._hasMovedSignalDeeper)
+			{
+				tomb._hasMovedSignalDeeper = true;
+				tomb._buriedSignal.transform.position = tomb._signalDeepSocket.position;
+			}
+		}
+
+		tomb._interactReceiver.SetInteractionEnabled(!Data);
+	}
+}

QSB/EyeOfTheUniverse/Tomb/Patches/EyeMirrorControllerPatches.cs

@@ -0,0 +1,47 @@
+using HarmonyLib;
+using QSB.EyeOfTheUniverse.Tomb.Messages;
+using QSB.Messaging;
+using QSB.Patches;
+using QSB.Player;
+using QSB.Utility;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace QSB.EyeOfTheUniverse.Tomb.Patches;
+
+[HarmonyPatch(typeof(EyeMirrorController))]
+internal class EyeMirrorControllerPatches : QSBPatch
+{
+	public override QSBPatchTypes Type => QSBPatchTypes.OnClientConnect;
+
+	[HarmonyPostfix]
+	[HarmonyPatch(nameof(EyeMirrorController.OnSwapPortrait))]
+	public static void OnSwapPortrait(EyeMirrorController __instance)
+	{
+		DebugLog.DebugWrite($"_numSwappedPortraits is now {__instance._numSwappedPortraits}. _portrait.Length is {__instance._portraits.Length}");
+	}
+
+	[HarmonyPrefix]
+	[HarmonyPatch(nameof(EyeMirrorController.OnEnterCloseDoorTrigger))]
+	public static bool OnEnterCloseDoorTrigger(EyeMirrorController __instance, GameObject hitObj)
+	{
+		if (hitObj.CompareTag("PlayerDetector"))
+		{
+			__instance._door.Close();
+			new CloseDoorMessage().Send();
+		}
+
+		return false;
+	}
+
+	[HarmonyPostfix]
+	[HarmonyPatch(nameof(EyeMirrorController.OnLitStateChanged))]
+	public static void OnLitStateChanged()
+	{
+		QSBPlayerManager.HideAllPlayers(0.5f);
+	}
+}

QSB/EyeOfTheUniverse/Tomb/Patches/EyeTombControllerPatches.cs

@@ -0,0 +1,88 @@
+using HarmonyLib;
+using QSB.EyeOfTheUniverse.Tomb.Messages;
+using QSB.Messaging;
+using QSB.Patches;
+using QSB.Player;
+using UnityEngine;
+
+namespace QSB.EyeOfTheUniverse.Tomb.Patches;
+
+[HarmonyPatch(typeof(EyeTombController))]
+internal class EyeTombControllerPatches : QSBPatch
+{
+	public override QSBPatchTypes Type => QSBPatchTypes.OnClientConnect;
+
+	[HarmonyPostfix]
+	[HarmonyPatch(nameof(EyeTombController.OnPressInteract))]
+	public static void OnPressInteract() => new UseTombMessage(true).Send();
+
+	[HarmonyPostfix]
+	[HarmonyPatch(nameof(EyeTombController.CancelInteraction))]
+	public static void CancelInteract() => new UseTombMessage(false).Send();
+
+	[HarmonyPrefix]
+	[HarmonyPatch(nameof(EyeTombController.OnEnterStage))]
+	public static bool OnEnterStage(EyeTombController __instance, GameObject hitObj)
+	{
+		if (hitObj.CompareTag("PlayerDetector"))
+		{
+			__instance._candleController.FadeTo(1, 1);
+			new EnterExitStageMessage(true).Send();
+		}
+
+		return false;
+	}
+
+	[HarmonyPrefix]
+	[HarmonyPatch(nameof(EyeTombController.OnExitStage))]
+	public static bool OnExitStage(EyeTombController __instance, GameObject hitObj)
+	{
+		if (hitObj.CompareTag("PlayerDetector"))
+		{
+			__instance._candleController.FadeTo(0, 1);
+			new EnterExitStageMessage(false).Send();
+		}
+
+		return false;
+	}
+
+	[HarmonyPrefix]
+	[HarmonyPatch(nameof(EyeTombController.ToggleLitState))]
+	public static bool ToggleLitState(EyeTombController __instance, int direction)
+	{
+		var newStateIndex = __instance._stateIndex + direction;
+		if (__instance._lit && (newStateIndex < 0 || newStateIndex > __instance._states.Length - 1))
+		{
+			__instance._gearEffects.PlayFailure(direction > 0, 1f);
+			return false;
+		}
+
+		new ToggleLitStateMessage(__instance._stateIndex, direction, __instance._lit).Send();
+
+		__instance._lit = !__instance._lit;
+		__instance._planetLightController.SetIntensity(__instance._lit ? 1f : 0f);
+		__instance._planetObject.SetActive(__instance._lit);
+		__instance._lightBeamController.SetFade(__instance._lit ? 1f : 0f);
+		if (!__instance._lit)
+		{
+			__instance._states[__instance._stateIndex].SetActive(false);
+			__instance._stateIndex += direction;
+			__instance._states[__instance._stateIndex].SetActive(true);
+		}
+
+		__instance._gearEffects.AddRotation(direction * 45f, 0f);
+		__instance._oneShotSource.PlayOneShot((direction > 0f) ? AudioType.Projector_Next : AudioType.Projector_Prev, 1f);
+
+		return false;
+	}
+
+	[HarmonyPrefix]
+	[HarmonyPatch(nameof(EyeTombController.OnObserveGrave))]
+	public static bool OnObserveGrave()
+		=> false;
+
+	[HarmonyPostfix]
+	[HarmonyPatch(nameof(EyeTombController.OnFinishGather))]
+	public static void OnFinishGather()
+		=> QSBPlayerManager.ShowAllPlayers(0.5f);
+}

QSB/EyeOfTheUniverse/Tomb/TombManager.cs

@@ -0,0 +1,21 @@
+using Cysharp.Threading.Tasks;
+using QSB.WorldSync;
+using System.Threading;
+
+namespace QSB.EyeOfTheUniverse.Tomb;
+
+internal class TombManager : WorldObjectManager
+{
+	public override bool DlcOnly => true;
+	public override WorldObjectScene WorldObjectScene => WorldObjectScene.Eye;
+
+	public override async UniTask BuildWorldObjects(OWScene scene, CancellationToken ct)
+	{
+		if (QSBCore.IsHost)
+		{
+			// sike!! no worldobjects here
+			var tomb = QSBWorldSync.GetUnityObject<EyeTombController>();
+			tomb.gameObject.AddComponent<EyeTombWatcher>();
+		}
+	}
+}

QSB/Player/QSBPlayerManager.cs

@@ -94,11 +94,11 @@ public static class QSBPlayerManager
 	public static IEnumerable<ThrusterLightTracker> GetThrusterLightTrackers()
 		=> PlayerList.Select(x => x.ThrusterLightTracker).Where(x => x != null);
 
-	public static void ShowAllPlayers()
-		=> PlayerList.ForEach(x => x.SetVisible(true, 2));
+	public static void ShowAllPlayers(float time = 2f)
+		=> PlayerList.ForEach(x => x.SetVisible(true, time));
 
-	public static void HideAllPlayers()
-		=> PlayerList.ForEach(x => x.SetVisible(false, 2));
+	public static void HideAllPlayers(float time = 2f)
+		=> PlayerList.ForEach(x => x.SetVisible(false, time));
 
 	public static PlayerInfo GetClosestPlayerToWorldPoint(Vector3 worldPoint, bool includeLocalPlayer) => includeLocalPlayer
 		? GetClosestPlayerToWorldPoint(PlayerList, worldPoint)

QSB/Utility/DebugGUI.cs

@@ -173,6 +173,8 @@ internal class DebugGUI : MonoBehaviour, IAddComponentOnStart
 
 		#endregion
 
+		if (QSBSceneManager.CurrentScene == OWScene.SolarSystem)
+		{
 			#region Column3 - Ship data
 
 			WriteLine(3, $"Current Flyer : {ShipManager.Instance.CurrentFlyer}");
@@ -274,6 +276,7 @@ internal class DebugGUI : MonoBehaviour, IAddComponentOnStart
 					}
 				}
 			}
+		}
 
 		/*
 		#region Column4 - Quantum Object Possesion