progress

QSB/Events/EventNames.cs

@@ -93,5 +93,8 @@
 		public static string QSBExitSatelliteCamera = "QSBExitSatelliteCamera";
 		public static string QSBSatelliteSnapshot = "QSBSatelliteSnapshot";
 		public static string QSBAnglerChangeState = "QSBAnglerChangeState";
+		public static string QSBMeteorLaunch = "QSBMeteorLaunch";
+		public static string QSBMeteorImpact = "QSBMeteorImpact";
+		public static string QSBMeteorResync = "QSBMeteorResync";
 	}
 }

QSB/Events/EventType.cs

@@ -135,6 +135,10 @@
 		LaunchProbe,
 		PlayerLaunchProbe,
 
-		AnglerChangeState
+		AnglerChangeState,
+
+		MeteorLaunch,
+		MeteorImpact,
+		MeteorResync
 	}
 }

QSB/Events/QSBEventManager.cs

@@ -28,6 +28,7 @@ using QSB.Anglerfish.Events;
 using QSB.Utility;
 using QSB.Utility.Events;
 using System.Collections.Generic;
+using QSB.MeteorSync.Events;
 
 namespace QSB.Events
 {
@@ -91,6 +92,9 @@ namespace QSB.Events
 				new StartStatueEvent(),
 				new CampfireStateEvent(),
 				new AnglerChangeStateEvent(),
+				new MeteorLaunchEvent(),
+				new MeteorImpactEvent(),
+				new MeteorResyncEvent(),
 				// Conversation/dialogue/exploration
 				new ConversationEvent(),
 				new ConversationStartEndEvent(),

QSB/MeteorSync/Events/MeteorImpactEvent.cs

@@ -0,0 +1,34 @@
+using QSB.Events;
+using QSB.MeteorSync.WorldObjects;
+using QSB.WorldSync;
+using QSB.WorldSync.Events;
+using EventType = QSB.Events.EventType;
+
+namespace QSB.MeteorSync.Events
+{
+	public class MeteorImpactEvent : QSBEvent<WorldObjectMessage>
+	{
+		public override EventType Type => EventType.MeteorImpact;
+
+		public override void SetupListener()
+			=> GlobalMessenger<QSBMeteor>.AddListener(EventNames.QSBMeteorImpact, Handler);
+
+		public override void CloseListener()
+			=> GlobalMessenger<QSBMeteor>.RemoveListener(EventNames.QSBMeteorImpact, Handler);
+
+		private void Handler(QSBMeteor qsbMeteor) => SendEvent(CreateMessage(qsbMeteor));
+
+		private WorldObjectMessage CreateMessage(QSBMeteor qsbMeteor) => new WorldObjectMessage
+		{
+			ObjectId = qsbMeteor.ObjectId
+			// todo where
+			// todo velocity
+		};
+
+		public override void OnReceiveRemote(bool isHost, WorldObjectMessage message)
+		{
+			var qsbMeteor = QSBWorldSync.GetWorldFromId<QSBMeteor>(message.ObjectId);
+			// todo
+		}
+	}
+}

QSB/MeteorSync/Events/MeteorLaunchEvent.cs

@@ -0,0 +1,33 @@
+using QSB.Events;
+using QSB.MeteorSync.WorldObjects;
+using QSB.WorldSync;
+using QSB.WorldSync.Events;
+using EventType = QSB.Events.EventType;
+
+namespace QSB.MeteorSync.Events
+{
+	public class MeteorLaunchEvent : QSBEvent<BoolWorldObjectMessage>
+	{
+		public override EventType Type => EventType.MeteorLaunch;
+
+		public override void SetupListener()
+			=> GlobalMessenger<int, bool>.AddListener(EventNames.QSBMeteorLaunch, Handler);
+
+		public override void CloseListener()
+			=> GlobalMessenger<int, bool>.RemoveListener(EventNames.QSBMeteorLaunch, Handler);
+
+		private void Handler(int id, bool preLaunch) => SendEvent(CreateMessage(id, preLaunch));
+
+		private BoolWorldObjectMessage CreateMessage(int id, bool preLaunch) => new BoolWorldObjectMessage
+		{
+			ObjectId = id,
+			State = preLaunch
+		};
+
+		public override void OnReceiveRemote(bool isHost, BoolWorldObjectMessage message)
+		{
+			var qsbMeteorLauncher = QSBWorldSync.GetWorldFromId<QSBMeteorLauncher>(message.ObjectId);
+			qsbMeteorLauncher.LaunchMeteor(message.State);
+		}
+	}
+}

QSB/MeteorSync/Events/MeteorResyncEvent.cs

@@ -0,0 +1,35 @@
+using QSB.Events;
+using QSB.MeteorSync.WorldObjects;
+using QSB.WorldSync;
+using QSB.WorldSync.Events;
+using EventType = QSB.Events.EventType;
+
+namespace QSB.MeteorSync.Events
+{
+	/// called when we request a resync on client join
+	public class MeteorResyncEvent : QSBEvent<WorldObjectMessage>
+	{
+		public override EventType Type => EventType.MeteorResync;
+
+		public override void SetupListener()
+			=> GlobalMessenger<QSBMeteor>.AddListener(EventNames.QSBMeteorResync, Handler);
+
+		public override void CloseListener()
+			=> GlobalMessenger<QSBMeteor>.RemoveListener(EventNames.QSBMeteorResync, Handler);
+
+		private void Handler(QSBMeteor qsbMeteor) => SendEvent(CreateMessage(qsbMeteor));
+
+		private WorldObjectMessage CreateMessage(QSBMeteor qsbMeteor) => new WorldObjectMessage
+		{
+			ObjectId = qsbMeteor.ObjectId
+			// todo is suspended
+			// todo fragment states
+		};
+
+		public override void OnReceiveRemote(bool isHost, WorldObjectMessage message)
+		{
+			var qsbMeteor = QSBWorldSync.GetWorldFromId<QSBMeteor>(message.ObjectId);
+			// todo
+		}
+	}
+}

QSB/MeteorSync/MeteorManager.cs

@@ -10,6 +10,7 @@ namespace QSB.MeteorSync
 
 		protected override void RebuildWorldObjects(OWScene scene)
 		{
+			QSBWorldSync.Init<QSBMeteorLauncher, MeteorLauncher>();
 			// wait a bit because meteors get created late
 			QSBCore.UnityEvents.FireInNUpdates(() =>
 			{

QSB/MeteorSync/Patches/MeteorClientPatches.cs

@@ -0,0 +1,60 @@
+using HarmonyLib;
+using QSB.Patches;
+
+namespace QSB.MeteorSync.Patches
+{
+	public class MeteorClientPatches : QSBPatch
+	{
+		public override QSBPatchTypes Type => QSBPatchTypes.OnNonServerClientConnect;
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(MeteorLauncher), nameof(MeteorLauncher.FixedUpdate))]
+		public static bool FixedUpdate(MeteorLauncher __instance)
+		{
+			if (__instance._launchedMeteors != null)
+			{
+				for (var i = __instance._launchedMeteors.Count - 1; i >= 0; i--)
+				{
+					if (__instance._launchedMeteors[i] == null)
+					{
+						__instance._launchedMeteors.QuickRemoveAt(i);
+					}
+					else if (__instance._launchedMeteors[i].isSuspended)
+					{
+						__instance._meteorPool.Add(__instance._launchedMeteors[i]);
+						__instance._launchedMeteors.QuickRemoveAt(i);
+					}
+				}
+			}
+			if (__instance._launchedDynamicMeteors != null)
+			{
+				for (var j = __instance._launchedDynamicMeteors.Count - 1; j >= 0; j--)
+				{
+					if (__instance._launchedDynamicMeteors[j] == null)
+					{
+						__instance._launchedDynamicMeteors.QuickRemoveAt(j);
+					}
+					else if (__instance._launchedDynamicMeteors[j].isSuspended)
+					{
+						__instance._dynamicMeteorPool.Add(__instance._launchedDynamicMeteors[j]);
+						__instance._launchedDynamicMeteors.QuickRemoveAt(j);
+					}
+				}
+			}
+
+			return false;
+		}
+
+
+		[HarmonyPostfix]
+		[HarmonyPatch(typeof(MeteorController), nameof(MeteorController.Launch))]
+		public static void Launch(MeteorController __instance)
+		{
+			foreach (var owCollider in __instance._owColliders)
+			{
+				owCollider.SetActivation(false);
+			}
+			__instance._owRigidbody.MakeKinematic();
+		}
+	}
+}

QSB/MeteorSync/Patches/MeteorPatches.cs

@@ -1,11 +0,0 @@
-using QSB.Patches;
-
-namespace QSB.MeteorSync.Patches
-{
-	public class MeteorPatches : QSBPatch
-	{
-		public override QSBPatchTypes Type => QSBPatchTypes.OnClientConnect;
-
-		// todo
-	}
-}

QSB/MeteorSync/Patches/MeteorServerPatches.cs

@@ -0,0 +1,89 @@
+using HarmonyLib;
+using QSB.Events;
+using QSB.MeteorSync.WorldObjects;
+using QSB.Patches;
+using QSB.WorldSync;
+using UnityEngine;
+
+namespace QSB.MeteorSync.Patches
+{
+	public class MeteorServerPatches : QSBPatch
+	{
+		public override QSBPatchTypes Type => QSBPatchTypes.OnServerClientConnect;
+
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(MeteorLauncher), nameof(MeteorLauncher.FixedUpdate))]
+		public static bool LaunchMeteor(MeteorLauncher __instance)
+		{
+			if (__instance._launchedMeteors != null)
+			{
+				for (var i = __instance._launchedMeteors.Count - 1; i >= 0; i--)
+				{
+					if (__instance._launchedMeteors[i] == null)
+					{
+						__instance._launchedMeteors.QuickRemoveAt(i);
+					}
+					else if (__instance._launchedMeteors[i].isSuspended)
+					{
+						__instance._meteorPool.Add(__instance._launchedMeteors[i]);
+						__instance._launchedMeteors.QuickRemoveAt(i);
+					}
+				}
+			}
+			if (__instance._launchedDynamicMeteors != null)
+			{
+				for (var j = __instance._launchedDynamicMeteors.Count - 1; j >= 0; j--)
+				{
+					if (__instance._launchedDynamicMeteors[j] == null)
+					{
+						__instance._launchedDynamicMeteors.QuickRemoveAt(j);
+					}
+					else if (__instance._launchedDynamicMeteors[j].isSuspended)
+					{
+						__instance._dynamicMeteorPool.Add(__instance._launchedDynamicMeteors[j]);
+						__instance._launchedDynamicMeteors.QuickRemoveAt(j);
+					}
+				}
+			}
+			if (__instance._initialized && Time.time > __instance._lastLaunchTime + __instance._launchDelay)
+			{
+				var qsbMeteorLauncher = QSBWorldSync.GetWorldFromUnity<QSBMeteorLauncher>(__instance);
+				if (!__instance._areParticlesPlaying)
+				{
+					__instance._areParticlesPlaying = true;
+					foreach (var particleSystem in __instance._launchParticles)
+					{
+						particleSystem.Play();
+					}
+
+					QSBEventManager.FireEvent(EventNames.QSBMeteorLaunch, qsbMeteorLauncher.ObjectId, true);
+				}
+				if (Time.time > __instance._lastLaunchTime + __instance._launchDelay + 2.3f)
+				{
+					__instance.LaunchMeteor();
+					__instance._lastLaunchTime = Time.time;
+					__instance._launchDelay = Random.Range(__instance._minInterval, __instance._maxInterval);
+					__instance._areParticlesPlaying = false;
+					foreach (var particleSystem in __instance._launchParticles)
+					{
+						particleSystem.Stop();
+					}
+
+					QSBEventManager.FireEvent(EventNames.QSBMeteorLaunch, qsbMeteorLauncher.ObjectId, false);
+				}
+			}
+
+			return false;
+		}
+
+
+		[HarmonyPostfix]
+		[HarmonyPatch(typeof(MeteorController), nameof(MeteorController.Impact))]
+		public static void Impact(MeteorController __instance)
+		{
+			var qsbMeteor = QSBWorldSync.GetWorldFromUnity<QSBMeteor>(__instance);
+			QSBEventManager.FireEvent(EventNames.QSBMeteorImpact, qsbMeteor);
+		}
+	}
+}

QSB/MeteorSync/WorldObjects/QSBMeteor.cs

@@ -45,5 +45,12 @@ namespace QSB.MeteorSync.WorldObjects
 
 			MeteorManager.AllReady = false;
 		}
+
+
+
+		public void Impact()
+		{
+			// todo
+		}
 	}
 }

QSB/MeteorSync/WorldObjects/QSBMeteorLauncher.cs

@@ -0,0 +1,33 @@
+using QSB.WorldSync;
+
+namespace QSB.MeteorSync.WorldObjects
+{
+	public class QSBMeteorLauncher : WorldObject<MeteorLauncher>
+	{
+		public override void Init(MeteorLauncher attachedObject, int id)
+		{
+			ObjectId = id;
+			AttachedObject = attachedObject;
+		}
+
+
+		public void LaunchMeteor(bool preLaunch)
+		{
+			if (preLaunch)
+			{
+				foreach (var particleSystem in AttachedObject._launchParticles)
+				{
+					particleSystem.Play();
+				}
+			}
+			else
+			{
+				AttachedObject.LaunchMeteor();
+				foreach (var particleSystem in AttachedObject._launchParticles)
+				{
+					particleSystem.Stop();
+				}
+			}
+		}
+	}
+}

QSB/Patches/QSBPatchManager.cs

@@ -75,7 +75,8 @@ namespace QSB.Patches
 				new SatelliteProjectorPatches(),
 				new LightSensorPatches(),
 				new AnglerPatches(),
-				new MeteorPatches()
+				new MeteorClientPatches(),
+				new MeteorServerPatches()
 			};
 
 			TypeToInstance = new Dictionary<QSBPatchTypes, Harmony>

QSB/Player/Events/RequestStateResyncEvent.cs

@@ -1,5 +1,6 @@
 using OWML.Utils;
 using QSB.CampfireSync.WorldObjects;
+using QSB.MeteorSync.WorldObjects;
 using QSB.ClientServerStateSync;
 using QSB.Events;
 using QSB.Messaging;
@@ -79,6 +80,9 @@ namespace QSB.Player.Events
 
 			QSBWorldSync.GetWorldObjects<QSBCampfire>().ForEach(campfire
 				=> QSBEventManager.FireEvent(EventNames.QSBCampfireState, campfire.ObjectId, campfire.GetState()));
+
+			QSBWorldSync.GetWorldObjects<QSBMeteor>().ForEach(meteor
+				=> QSBEventManager.FireEvent(EventNames.QSBMeteorResync, meteor));
 		}
 	}
 }

QSB/QSB.csproj

@@ -124,10 +124,15 @@
     <Compile Include="Menus\IMenuAPI.cs" />
     <Compile Include="Menus\MenuManager.cs" />
     <Compile Include="Messaging\BoolMessage.cs" />
+    <Compile Include="MeteorSync\Events\MeteorImpactEvent.cs" />
+    <Compile Include="MeteorSync\Events\MeteorLaunchEvent.cs" />
+    <Compile Include="MeteorSync\Events\MeteorResyncEvent.cs" />
     <Compile Include="MeteorSync\MeteorManager.cs" />
-    <Compile Include="MeteorSync\Patches\MeteorPatches.cs" />
+    <Compile Include="MeteorSync\Patches\MeteorClientPatches.cs" />
+    <Compile Include="MeteorSync\Patches\MeteorServerPatches.cs" />
     <Compile Include="MeteorSync\TransformSync\MeteorTransformSync.cs" />
     <Compile Include="MeteorSync\WorldObjects\QSBMeteor.cs" />
+    <Compile Include="MeteorSync\WorldObjects\QSBMeteorLauncher.cs" />
     <Compile Include="OrbSync\TransformSync\NomaiOrbTransformSync.cs" />
     <Compile Include="Player\Events\PlayerInformationEvent.cs" />
     <Compile Include="Player\Events\PlayerInformationMessage.cs" />
@@ -450,9 +455,6 @@
       <Version>2.0.0</Version>
     </PackageReference>
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="MeteorSync\Events" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PostBuildEvent>md "$(OwmlDir)\Mods\$(ProjectName)"