fix regex, change worldobjects

QSB/ConversationSync/Events/ConversationEvent.cs

@@ -32,7 +32,7 @@ namespace QSB.ConversationSync.Events
 			{
 				case ConversationType.Character:
 					var translated = TextTranslation.Translate(message.Message).Trim();
-					translated = Regex.Replace(translated, @"<Pause=?\d*\.?\d*\s\/>", "");
+					translated = Regex.Replace(translated, @"<[Pp]ause=?\d*\.?\d*\s?\/?>", "");
 					ConversationManager.Instance.DisplayCharacterConversationBox(message.ObjectId, translated);
 					break;
 

QSB/ElevatorSync/ElevatorManager.cs

@@ -1,22 +1,11 @@
 using QSB.ElevatorSync.WorldObjects;
 using QSB.WorldSync;
-using UnityEngine;
 
 namespace QSB.ElevatorSync
 {
-	public class ElevatorManager : MonoBehaviour
+	public class ElevatorManager : WorldObjectManager
 	{
-		public static ElevatorManager Instance { get; private set; }
+		protected override void RebuildWorldObjects(OWScene scene)
-
-		public void Awake()
-		{
-			Instance = this;
-			QSBSceneManager.OnSceneLoaded += OnSceneLoaded;
-		}
-
-		public void OnDestroy() => QSBSceneManager.OnSceneLoaded -= OnSceneLoaded;
-
-		private void OnSceneLoaded(OWScene scene, bool isInUniverse)
 			=> QSBWorldSync.Init<QSBElevator, Elevator>();
 	}
 }

QSB/GeyserSync/GeyserManager.cs

@@ -5,21 +5,21 @@ using UnityEngine;
 
 namespace QSB.GeyserSync
 {
-	public class GeyserManager : MonoBehaviour
+	public class GeyserManager : WorldObjectManager
 	{
-		public void Awake()
+		public override void Awake()
 		{
-			QSBSceneManager.OnSceneLoaded += OnSceneLoaded;
+			base.Awake();
 			QSBPatchManager.OnPatchType += OnPatchType;
 		}
 
-		public void OnDestroy()
+		public override void OnDestroy()
 		{
-			QSBSceneManager.OnSceneLoaded -= OnSceneLoaded;
+			base.OnDestroy();
 			QSBPatchManager.OnPatchType -= OnPatchType;
 		}
 
-		private void OnSceneLoaded(OWScene scene, bool isInUniverse)
+		protected override void RebuildWorldObjects(OWScene scene)
 			=> QSBWorldSync.Init<QSBGeyser, GeyserController>();
 
 		public void OnPatchType(QSBPatchTypes type)

QSB/ItemSync/CustomNomaiRemoteCameraPlatform.cs

@@ -216,7 +216,9 @@ namespace QSB.ItemSync
 			if (_platformActive)
 			{
 				var localInBounds = _connectionBounds.PointInside(_playerCamera.transform.position);
-				_anyoneStillOnPlatform = QSBPlayerManager.PlayerList.Any(x => _connectionBounds.PointInside(x.Camera.transform.position));
+				_anyoneStillOnPlatform = QSBCore.IsInMultiplayer
+					? QSBPlayerManager.PlayerList.Any(x => _connectionBounds.PointInside(x.Camera.transform.position))
+					: localInBounds;
 				if (!localInBounds && _wasLocalInBounds)
 				{
 					OnLeaveBounds();

QSB/ItemSync/Events/MoveToCarryEvent.cs

@@ -50,7 +50,7 @@ namespace QSB.ItemSync.Events
 					break;
 
 			}
-			itemObject.PickUpItem(itemSocket);
+			itemObject.PickUpItem(itemSocket, message.AboutId);
 		}
 	}
 }

QSB/ItemSync/ItemManager.cs

@@ -6,29 +6,19 @@ using UnityEngine;
 
 namespace QSB.ItemSync
 {
-	internal class ItemManager : MonoBehaviour
+	internal class ItemManager : WorldObjectManager
 	{
-		public static ItemManager Instance { get; private set; }
+		protected override void RebuildWorldObjects(OWScene scene)
-
-		public void Awake()
-		{
-			Instance = this;
-			QSBSceneManager.OnUniverseSceneLoaded += RebuildItems;
-		}
-
-		public void OnDestroy() => QSBSceneManager.OnUniverseSceneLoaded -= RebuildItems;
-
-		public void RebuildItems(OWScene scene)
 		{
 			DebugLog.DebugWrite("Rebuilding OWItems...", MessageType.Warning);
-			QSBWorldSync.Init<QSBScrollItem, ScrollItem>();
 			QSBWorldSync.Init<QSBScrollSocket, ScrollSocket>();
-			QSBWorldSync.Init<QSBSharedStone, SharedStone>();
+			QSBWorldSync.Init<QSBScrollItem, ScrollItem>();
 			QSBWorldSync.Init<QSBSharedStoneSocket, SharedStoneSocket>();
-			QSBWorldSync.Init<QSBWarpCoreItem, WarpCoreItem>();
+			QSBWorldSync.Init<QSBSharedStone, SharedStone>();
 			QSBWorldSync.Init<QSBWarpCoreSocket, WarpCoreSocket>();
-			QSBWorldSync.Init<QSBNomaiConversationStone, NomaiConversationStone>();
+			QSBWorldSync.Init<QSBWarpCoreItem, WarpCoreItem>();
 			QSBWorldSync.Init<QSBNomaiConversationStoneSocket, NomaiConversationStoneSocket>();
+			QSBWorldSync.Init<QSBNomaiConversationStone, NomaiConversationStone>();
 			foreach (var streaming in Resources.FindObjectsOfTypeAll<NomaiRemoteCameraStreaming>())
 			{
 				streaming.gameObject.AddComponent<CustomNomaiRemoteCameraStreaming>();

QSB/ItemSync/WorldObjects/IQSBOWItem.cs

@@ -8,7 +8,7 @@ namespace QSB.ItemSync.WorldObjects
 		ItemType GetItemType();
 		void SetColliderActivation(bool active);
 		void SocketItem(Transform socketTransform, Sector sector);
-		void PickUpItem(Transform holdTransform);
+		void PickUpItem(Transform holdTransform, uint playerId);
 		void DropItem(Vector3 position, Vector3 normal, Sector sector);
 		void PlaySocketAnimation();
 		void PlayUnsocketAnimation();

QSB/ItemSync/WorldObjects/QSBOWItem.cs

@@ -1,4 +1,7 @@
 using OWML.Utils;
+using QSB.Player;
+using QSB.SectorSync.WorldObjects;
+using QSB.Utility;
 using QSB.WorldSync;
 using UnityEngine;
 
@@ -7,7 +10,51 @@ namespace QSB.ItemSync.WorldObjects
 	internal class QSBOWItem<T> : WorldObject<T>, IQSBOWItem
 		where T : OWItem
 	{
-		public override void Init(T attachedObject, int id) { }
+		public IQSBOWItemSocket InitialSocket { get; private set; }
+		public Transform InitialParent { get; private set; }
+		public Vector3 InitialPosition { get; private set; }
+		public Quaternion InitialRotation { get; private set; }
+		public QSBSector InitialSector { get; private set; }
+		public uint HoldingPlayer { get; private set; }
+
+		public override void Init(T attachedObject, int id)
+		{
+			InitialParent = attachedObject.transform.parent;
+			InitialPosition = attachedObject.transform.localPosition;
+			InitialRotation = attachedObject.transform.localRotation;
+			InitialSector = QSBWorldSync.GetWorldFromUnity<QSBSector, Sector>(attachedObject.GetSector());
+			if (InitialParent.GetComponent<OWItemSocket>() != null)
+			{
+				var qsbObj = ItemManager.GetObject(InitialParent.GetComponent<OWItemSocket>());
+				InitialSocket = qsbObj;
+			}
+			QSBPlayerManager.OnRemovePlayer += OnPlayerLeave;
+		}
+
+		public override void OnRemoval()
+		{
+			QSBPlayerManager.OnRemovePlayer -= OnPlayerLeave;
+		}
+
+		private void OnPlayerLeave(uint player)
+		{
+			if (HoldingPlayer != player)
+			{
+				return;
+			}
+			if (InitialSocket != null)
+			{
+				InitialSocket.PlaceIntoSocket(this);
+				return;
+			}
+			DebugLog.DebugWrite($"OnPlayerLeave {player} for item {AttachedObject.name}");
+			AttachedObject.transform.parent = InitialParent;
+			AttachedObject.transform.localPosition = InitialPosition;
+			AttachedObject.transform.localRotation = InitialRotation;
+			AttachedObject.transform.localScale = Vector3.one;
+			AttachedObject.SetSector(InitialSector.AttachedObject);
+			AttachedObject.SetColliderActivation(true);
+		}
 
 		public ItemType GetItemType()
 			=> AttachedObject.GetItemType();
@@ -16,10 +63,19 @@ namespace QSB.ItemSync.WorldObjects
 			=> AttachedObject.SetColliderActivation(active);
 
 		public virtual void SocketItem(Transform socketTransform, Sector sector)
-			=> AttachedObject.SocketItem(socketTransform, sector);
+		{
+			AttachedObject.SocketItem(socketTransform, sector);
+			DebugLog.DebugWrite($"{AttachedObject.name} set holding to 0");
+			HoldingPlayer = 0;
+		}
 
-		public virtual void PickUpItem(Transform holdTransform)
+
-			=> AttachedObject.PickUpItem(holdTransform);
+		public virtual void PickUpItem(Transform holdTransform, uint playerId)
+		{
+			AttachedObject.PickUpItem(holdTransform);
+			DebugLog.DebugWrite($"{AttachedObject.name} set holding to {playerId}");
+			HoldingPlayer = playerId;
+		}
 
 		public virtual void DropItem(Vector3 position, Vector3 normal, Sector sector)
 		{
@@ -32,6 +88,8 @@ namespace QSB.ItemSync.WorldObjects
 			AttachedObject.transform.position = sector.transform.TransformPoint(position) + AttachedObject.transform.TransformDirection(localDropOffset);
 			AttachedObject.SetSector(sector);
 			AttachedObject.SetColliderActivation(true);
+			DebugLog.DebugWrite($"{AttachedObject.name} set holding to 0");
+			HoldingPlayer = 0;
 		}
 
 		public virtual void PlaySocketAnimation() { }

QSB/OrbSync/Events/OrbUserEvent.cs

@@ -51,9 +51,14 @@ namespace QSB.OrbSync.Events
 		private static void HandleServer(WorldObjectMessage message)
 		{
 			var fromPlayer = QNetworkServer.connections.First(x => x.GetPlayerId() == message.FromId);
-			if (QSBWorldSync.OrbSyncList.Count == 0)
+			if (QSBWorldSync.OrbSyncList == null || QSBWorldSync.OrbSyncList.Count == 0)
 			{
-				DebugLog.ToConsole($"Error - OrbSyncList is empty. (ID {message.ObjectId})", MessageType.Error);
+				DebugLog.ToConsole($"Error - OrbSyncList is empty or null. (ID {message.ObjectId})", MessageType.Error);
+				return;
+			}
+			if (QSBWorldSync.OldOrbList == null || QSBWorldSync.OldOrbList.Count == 0)
+			{
+				DebugLog.ToConsole($"Error - OldOrbList is empty or null. (ID {message.ObjectId})", MessageType.Error);
 				return;
 			}
 			if (fromPlayer == null)
@@ -83,11 +88,14 @@ namespace QSB.OrbSync.Events
 
 		private static void HandleClient(WorldObjectMessage message)
 		{
-			if (QSBWorldSync.OrbSyncList.Count < message.ObjectId)
+			if (QSBWorldSync.OrbSyncList == null || QSBWorldSync.OrbSyncList.Count == 0)
 			{
-				DebugLog.ToConsole(
+				DebugLog.ToConsole($"Error - OrbSyncList is empty or null. (ID {message.ObjectId})", MessageType.Error);
-					$"Error - Orb id {message.ObjectId} out of range of orb sync list {QSBWorldSync.OrbSyncList.Count}.",
+				return;
-					MessageType.Error);
+			}
+			if (QSBWorldSync.OldOrbList == null || QSBWorldSync.OldOrbList.Count == 0)
+			{
+				DebugLog.ToConsole($"Error - OldOrbList is empty or null. (ID {message.ObjectId})", MessageType.Error);
 				return;
 			}
 			if (!QSBWorldSync.OrbSyncList.Any(x => x.AttachedOrb == QSBWorldSync.OldOrbList[message.ObjectId]))

QSB/OrbSync/OrbManager.cs

@@ -9,23 +9,20 @@ using UnityEngine;
 
 namespace QSB.OrbSync
 {
-	public class OrbManager : MonoBehaviour
+	public class OrbManager : WorldObjectManager
 	{
-		public static OrbManager Instance { get; private set; }
+		protected override void RebuildWorldObjects(OWScene scene)
-
-		private void Awake() => Instance = this;
-
-		private void BuildOrbSlots()
 		{
 			QSBWorldSync.Init<QSBOrbSlot, NomaiInterfaceSlot>();
 			DebugLog.DebugWrite($"Finished slot build with {QSBWorldSync.GetWorldObjects<QSBOrbSlot>().Count()} slots.", MessageType.Success);
+			BuildOrbs();
 		}
 
-		public void BuildOrbs()
+		private void BuildOrbs()
 		{
 			QSBWorldSync.OldOrbList.Clear();
 			QSBWorldSync.OldOrbList = Resources.FindObjectsOfTypeAll<NomaiInterfaceOrb>().ToList();
-			if (QNetworkServer.active)
+			if (QSBCore.IsServer)
 			{
 				QSBWorldSync.OrbSyncList.ForEach(x => QNetworkServer.Destroy(x.gameObject));
 				QSBWorldSync.OrbSyncList.Clear();
@@ -33,35 +30,5 @@ namespace QSB.OrbSync
 			}
 			DebugLog.DebugWrite($"Finished orb build with {QSBWorldSync.OldOrbList.Count} orbs.", MessageType.Success);
 		}
-
-		public void OnRenderObject()
-		{
-			if (!QSBCore.HasWokenUp || !QSBCore.DebugMode || !QSBCore.ShowLinesInDebug)
-			{
-				return;
-			}
-
-			foreach (var orb in QSBWorldSync.OldOrbList)
-			{
-				var rails = orb.GetValue<OWRail[]>("_safetyRails");
-				if (rails.Length > 0)
-				{
-					foreach (var rail in rails)
-					{
-						var points = rail.GetValue<Vector3[]>("_railPoints");
-						for (var i = 0; i < points.Length; i++)
-						{
-							if (i > 0)
-							{
-								Popcron.Gizmos.Line(rail.transform.TransformPoint(points[i - 1]), rail.transform.TransformPoint(points[i]), Color.white);
-							}
-						}
-					}
-				}
-			}
-		}
-
-		public void QueueBuildSlots() => QSBCore.UnityEvents.RunWhen(() => QSBCore.HasWokenUp, BuildOrbSlots);
-		public void QueueBuildOrbs() => QSBCore.UnityEvents.RunWhen(() => QNetworkServer.active, BuildOrbs);
 	}
 }

QSB/Player/QSBPlayerManager.cs

@@ -32,6 +32,8 @@ namespace QSB.Player
 			}
 		}
 
+		public static Action<uint> OnRemovePlayer;
+
 		public static PlayerInfo LocalPlayer => GetPlayer(LocalPlayerId);
 		public static List<PlayerInfo> PlayerList { get; } = new List<PlayerInfo>();
 

QSB/QSB.csproj

@@ -303,6 +303,7 @@
     <Compile Include="WorldSync\IWorldObjectTypeSubset.cs" />
     <Compile Include="WorldSync\QSBWorldSync.cs" />
     <Compile Include="WorldSync\WorldObject.cs" />
+    <Compile Include="WorldSync\WorldObjectManager.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="default-config.json">

QSB/QSBNetworkManager.cs

@@ -6,6 +6,8 @@ using QSB.ElevatorSync.WorldObjects;
 using QSB.Events;
 using QSB.GeyserSync.WorldObjects;
 using QSB.Instruments;
+using QSB.ItemSync;
+using QSB.ItemSync.WorldObjects;
 using QSB.OrbSync;
 using QSB.OrbSync.WorldObjects;
 using QSB.Patches;
@@ -110,8 +112,6 @@ namespace QSB
 
 		private void OnSceneLoaded(OWScene scene)
 		{
-			OrbManager.Instance.BuildOrbs();
-			OrbManager.Instance.QueueBuildSlots();
 			QSBWorldSync.OldDialogueTrees.Clear();
 			QSBWorldSync.OldDialogueTrees = Resources.FindObjectsOfTypeAll<CharacterDialogueTree>().ToList();
 		}
@@ -134,10 +134,6 @@ namespace QSB
 		public override void OnStartServer()
 		{
 			DebugLog.DebugWrite("OnStartServer", MessageType.Info);
-			if (QSBWorldSync.OrbSyncList.Count == 0 && QSBSceneManager.IsInUniverse)
-			{
-				OrbManager.Instance.QueueBuildOrbs();
-			}
 			if (QSBWorldSync.OldDialogueTrees.Count == 0 && QSBSceneManager.IsInUniverse)
 			{
 				QSBWorldSync.OldDialogueTrees = Resources.FindObjectsOfTypeAll<CharacterDialogueTree>().ToList();
@@ -178,9 +174,7 @@ namespace QSB
 
 			if (QSBSceneManager.IsInUniverse)
 			{
-				QSBSectorManager.Instance?.RebuildSectors();
+				WorldObjectManager.Rebuild(QSBSceneManager.CurrentScene);
-				OrbManager.Instance?.QueueBuildSlots();
-				QuantumManager.Instance?.RebuildQuantumObjects(QSBSceneManager.CurrentScene);
 			}
 
 			var specificType = QNetworkServer.active ? QSBPatchTypes.OnServerClientConnect : QSBPatchTypes.OnNonServerClientConnect;
@@ -244,14 +238,8 @@ namespace QSB
 					identity.RemoveClientAuthority(connection);
 				}
 			}
-
-			// Server takes some time to process removal of player/deletion of networkidentity
-			Invoke(nameof(LateFinalizeDisconnect), 1f);
 		}
 
-		private void LateFinalizeDisconnect()
-			=> QuantumManager.Instance.CheckExistingPlayers();
-
 		public override void OnStopServer()
 		{
 			DebugLog.DebugWrite("OnStopServer", MessageType.Info);
@@ -269,11 +257,23 @@ namespace QSB
 
 		private void RemoveWorldObjects()
 		{
-			QSBWorldSync.RemoveWorldObjects<QSBOrbSlot>();
+			QSBWorldSync.RemoveWorldObjects<IWorldObjectTypeSubset>();
-			QSBWorldSync.RemoveWorldObjects<QSBElevator>();
+			QSBWorldSync.RemoveWorldObjects<IWorldObject>();
-			QSBWorldSync.RemoveWorldObjects<QSBGeyser>();
+			foreach (var streaming in Resources.FindObjectsOfTypeAll<CustomNomaiRemoteCameraStreaming>())
-			QSBWorldSync.RemoveWorldObjects<QSBSector>();
+			{
-			QSBWorldSync.RemoveWorldObjects<IQSBQuantumObject>();
+				streaming.GetComponent<NomaiRemoteCameraStreaming>().enabled = true;
+				Destroy(streaming);
+			}
+			foreach (var camera in Resources.FindObjectsOfTypeAll<CustomNomaiRemoteCamera>())
+			{
+				camera.GetComponent<NomaiRemoteCamera>().enabled = true;
+				Destroy(camera);
+			}
+			foreach (var platform in Resources.FindObjectsOfTypeAll<CustomNomaiRemoteCameraPlatform>())
+			{
+				platform.GetComponent<NomaiRemoteCameraPlatform>().enabled = true;
+				Destroy(platform);
+			}
 		}
 	}
 }

QSB/QSBSceneManager.cs

@@ -1,5 +1,6 @@
 using OWML.Common;
 using QSB.Utility;
+using QSB.WorldSync;
 using System;
 
 namespace QSB
@@ -22,6 +23,10 @@ namespace QSB
 		private static void OnCompleteSceneLoad(OWScene oldScene, OWScene newScene)
 		{
 			DebugLog.DebugWrite($"COMPLETE SCENE LOAD ({oldScene} -> {newScene})", MessageType.Info);
+			if (QSBCore.IsInMultiplayer)
+			{
+				WorldObjectManager.Rebuild(newScene);
+			}
 			var universe = InUniverse(newScene);
 			OnSceneLoaded?.SafeInvoke(newScene, universe);
 			if (universe)

QSB/QuantumSync/QuantumManager.cs

@@ -11,21 +11,26 @@ using UnityEngine;
 
 namespace QSB.QuantumSync
 {
-	internal class QuantumManager : MonoBehaviour
+	internal class QuantumManager : WorldObjectManager
 	{
 		public static QuantumManager Instance { get; private set; }
 		public QuantumShrine Shrine;
 		public bool IsReady;
 
-		public void Awake()
+		public override void Awake()
 		{
+			base.Awake();
 			Instance = this;
-			QSBSceneManager.OnUniverseSceneLoaded += RebuildQuantumObjects;
+			QSBPlayerManager.OnRemovePlayer += PlayerLeave;
 		}
 
-		public void OnDestroy() => QSBSceneManager.OnUniverseSceneLoaded -= RebuildQuantumObjects;
+		public override void OnDestroy()
+		{
+			base.OnDestroy();
+			QSBPlayerManager.OnRemovePlayer -= PlayerLeave;
+		}
 
-		public void RebuildQuantumObjects(OWScene scene)
+		protected override void RebuildWorldObjects(OWScene scene)
 		{
 			DebugLog.DebugWrite("Rebuilding quantum objects...", MessageType.Warning);
 			QSBWorldSync.Init<QSBQuantumState, QuantumState>();
@@ -42,14 +47,17 @@ namespace QSB.QuantumSync
 			IsReady = true;
 		}
 
-		public void CheckExistingPlayers()
+		public void PlayerLeave(uint playerId)
 		{
-			DebugLog.DebugWrite("Checking quantum objects for non-existent players...", MessageType.Info);
+			if (!QSBCore.IsServer)
+			{
+				return;
+			}
 			var quantumObjects = QSBWorldSync.GetWorldObjects<IQSBQuantumObject>().ToList();
 			for (var i = 0; i < quantumObjects.Count; i++)
 			{
 				var obj = quantumObjects[i];
-				if (!QSBPlayerManager.PlayerExists(obj.ControllingPlayer))
+				if (obj.ControllingPlayer == playerId)
 				{
 					var idToSend = obj.IsEnabled ? QSBPlayerManager.LocalPlayerId : 0u;
 					QSBEventManager.FireEvent(EventNames.QSBQuantumAuthority, i, idToSend);

QSB/SectorSync/QSBSectorManager.cs

@@ -10,7 +10,7 @@ using UnityEngine;
 
 namespace QSB.SectorSync
 {
-	public class QSBSectorManager : MonoBehaviour, IRepeating
+	public class QSBSectorManager : WorldObjectManager, IRepeating
 	{
 		public static QSBSectorManager Instance { get; private set; }
 		public bool IsReady { get; private set; }
@@ -25,24 +25,14 @@ namespace QSB.SectorSync
 				.Where(x => x.HasAuthority).ToList().ForEach(CheckTransformSyncSector);
 		}
 
-		public void Awake()
+		public override void Awake()
 		{
-			if (Instance != null)
+			base.Awake();
-			{
-				DebugLog.ToConsole("Error - Cannot have multiple QSBSectorManagers!", MessageType.Error);
-				Destroy(this);
-				return;
-			}
 			Instance = this;
-			QSBSceneManager.OnUniverseSceneLoaded += (OWScene scene) => RebuildSectors();
 			DebugLog.DebugWrite("Sector Manager ready.", MessageType.Success);
 		}
 
-		public void OnDestroy()
+		protected override void RebuildWorldObjects(OWScene scene)
-			=> QSBSceneManager.OnUniverseSceneLoaded -= (OWScene scene) => RebuildSectors();
-
-
-		public void RebuildSectors()
 		{
 			DebugLog.DebugWrite("Rebuilding sectors...", MessageType.Warning);
 			if (QSBSceneManager.CurrentScene == OWScene.SolarSystem)

QSB/TimeSync/WakeUpSync.cs

@@ -187,6 +187,7 @@ namespace QSB.TimeSync
 		{
 			if (OWInput.GetInputMode() != InputMode.None && _isInputEnabled)
 			{
+				DebugLog.DebugWrite($"Change input to none - was {OWInput.GetInputMode()}");
 				OWInput.ChangeInputMode(InputMode.None);
 				_isInputEnabled = false;
 			}
@@ -197,10 +198,12 @@ namespace QSB.TimeSync
 			_isInputEnabled = true;
 			if (OWInput.GetInputMode() != InputMode.None)
 			{
-				DebugLog.ToConsole($"Warning - InputMode was changed to {OWInput.GetInputMode()} while pausing/fastforwarding!", MessageType.Warning);
+				DebugLog.ToConsole($"Warning - InputMode was changed to {OWInput.GetInputMode()} while pausing/fastforwarding, and wasn't accounted for!", MessageType.Warning);
 				return;
 			}
+			DebugLog.DebugWrite($"Enable Input - Restore previous inputs!");
 			OWInput.RestorePreviousInputs();
+			DebugLog.DebugWrite($"input now {OWInput.GetInputMode()}");
 		}
 
 		public void Update()

QSB/Tools/PlayerToolsManager.cs

@@ -198,6 +198,7 @@ namespace QSB.Tools
 			tool.Type = ToolType.ProbeLauncher;
 			tool.ToolGameObject = model;
 
+			// TODO : investigate why probe is wack
 			GetRenderer(launcherRoot, "Props_HEA_Probe_Prelaunch").materials[0] = _playerToolsMaterial;
 			GetRenderer(launcherRoot, "Props_HEA_Probe_Prelaunch").materials[1] = _lightbulbMaterial;
 			GetRenderer(launcherRoot, "PressureGauge_Arrow").material = _playerToolsMaterial;

QSB/TransformSync/NomaiOrbTransformSync.cs

@@ -1,4 +1,5 @@
-using QSB.WorldSync;
+using QSB.Utility;
+using QSB.WorldSync;
 using QuantumUNET;
 using UnityEngine;
 
@@ -25,6 +26,11 @@ namespace QSB.TransformSync
 
 		private void OnReady()
 		{
+			if (QSBWorldSync.OldOrbList == null || QSBWorldSync.OldOrbList.Count < Index)
+			{
+				DebugLog.ToConsole($"Error - OldOrbList is null or does not contain index {Index}.", OWML.Common.MessageType.Error);
+				return;
+			}
 			AttachedOrb = QSBWorldSync.OldOrbList[Index];
 			_isReady = true;
 		}

QSB/TransformSync/PlayerTransformSync.cs

@@ -16,6 +16,7 @@ namespace QSB.TransformSync
 
 		protected override void OnDestroy()
 		{
+			QSBPlayerManager.OnRemovePlayer?.Invoke(PlayerId);
 			base.OnDestroy();
 			if (QSBPlayerManager.PlayerExists(PlayerId))
 			{

QSB/TranslationSync/SpiralManager.cs

@@ -1,22 +1,11 @@
 using QSB.TranslationSync.WorldObjects;
 using QSB.WorldSync;
-using UnityEngine;
 
 namespace QSB.TranslationSync
 {
-	internal class SpiralManager : MonoBehaviour
+	internal class SpiralManager : WorldObjectManager
 	{
-		public static SpiralManager Instance { get; private set; }
+		protected override void RebuildWorldObjects(OWScene scene)
-
-		public void Awake()
-		{
-			Instance = this;
-			QSBSceneManager.OnUniverseSceneLoaded += OnSceneLoaded;
-		}
-
-		public void OnDestroy() => QSBSceneManager.OnUniverseSceneLoaded -= OnSceneLoaded;
-
-		private void OnSceneLoaded(OWScene scene)
 		{
 			QSBWorldSync.Init<QSBWallText, NomaiWallText>();
 			QSBWorldSync.Init<QSBComputer, NomaiComputer>();

QSB/WorldSync/QSBWorldSync.cs

@@ -137,7 +137,12 @@ namespace QSB.WorldSync
 				DebugLog.ToConsole($"Error - No QSBOrbSlot found for {slot.name}!", MessageType.Error);
 				return;
 			}
-			var orbSync = OrbSyncList.First(x => x.AttachedOrb == affectingOrb);
+			var orbSync = OrbSyncList.FirstOrDefault(x => x.AttachedOrb == affectingOrb);
+			if (orbSync == null)
+			{
+				DebugLog.ToConsole($"Error - No NomaiOrbTransformSync found for {affectingOrb.name} (For slot {slot.name})!", MessageType.Error);
+				return;
+			}
 			if (orbSync.HasAuthority)
 			{
 				qsbSlot.HandleEvent(state, OldOrbList.IndexOf(affectingOrb));

QSB/WorldSync/WorldObjectManager.cs

@@ -0,0 +1,27 @@
+using QSB.Utility;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace QSB.WorldSync
+{
+	public abstract class WorldObjectManager : MonoBehaviour
+	{
+		private static List<WorldObjectManager> _managers = new List<WorldObjectManager>();
+
+		public virtual void Awake() 
+			=> _managers.Add(this);
+
+		public virtual void OnDestroy()
+			=> _managers.Remove(this);
+
+		public static void Rebuild(OWScene scene)
+		{
+			foreach (var manager in _managers)
+			{
+				manager.RebuildWorldObjects(scene);
+			}
+		}
+
+		protected abstract void RebuildWorldObjects(OWScene scene);
+	}
+}