Merge pull request #341 from misternebula/anglerfish

Anglerfish

AssetBundles/conversation.manifest

@@ -1,22 +1,16 @@
 ManifestFileVersion: 0
-CRC: 3328595786
+CRC: 3924928763
 Hashes:
   AssetFileHash:
     serializedVersion: 2
-    Hash: b1b55f9f86f72ed72608b36f0729af6d
+    Hash: c99cab0df10436d2efe7dd1be82d453f
   TypeTreeHash:
     serializedVersion: 2
-    Hash: 50a27bfc3e679077929938a6fa57f4db
+    Hash: 02c9e7490734663480929abffb75366d
 HashAppended: 0
 ClassTypes:
 - Class: 1
   Script: {instanceID: 0}
-- Class: 21
-  Script: {instanceID: 0}
-- Class: 28
-  Script: {instanceID: 0}
-- Class: 48
-  Script: {instanceID: 0}
 - Class: 114
   Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
 - Class: 114
@@ -27,10 +21,6 @@ ClassTypes:
   Script: {fileID: 11500000, guid: 3245ec927659c4140ac4f8d17403cc18, type: 3}
 - Class: 115
   Script: {instanceID: 0}
-- Class: 128
-  Script: {instanceID: 0}
-- Class: 213
-  Script: {instanceID: 0}
 - Class: 222
   Script: {instanceID: 0}
 - Class: 223
@@ -40,5 +30,4 @@ ClassTypes:
 SerializeReferenceClassIdentifiers: []
 Assets:
 - Assets/DialogueBubble.prefab
-- Assets/GameAssets/Texture2D/UI_DialogueBox_d.png
 Dependencies: []

AssetBundles/debug.manifest

@@ -1,9 +1,9 @@
 ManifestFileVersion: 0
-CRC: 3095198160
+CRC: 1546595007
 Hashes:
   AssetFileHash:
     serializedVersion: 2
-    Hash: 44badca86c2222e5cc39a8497439be0c
+    Hash: ed5b355baab9b7042bfd721023c5f671
   TypeTreeHash:
     serializedVersion: 2
     Hash: b2ece8ae09df261ff59d764d08696641

AssetBundles/network.manifest

@@ -1,9 +1,9 @@
 ManifestFileVersion: 0
-CRC: 1991351671
+CRC: 460430998
 Hashes:
   AssetFileHash:
     serializedVersion: 2
-    Hash: e0f93ad04981fd266a4300b0be721792
+    Hash: 1b708df8b57f5442fbea4c45a9f17743
   TypeTreeHash:
     serializedVersion: 2
     Hash: 6968c5d2bbef57a79632abd61ea01bb3
@@ -26,5 +26,6 @@ Assets:
 - Assets/NetworkProbe.prefab
 - Assets/NETWORK_Player_Body.prefab
 - Assets/NetworkOrb.prefab
+- Assets/NetworkAngler.prefab
 - Assets/NetworkShip.prefab
 Dependencies: []

QSB/Anglerfish/AnglerManager.cs

@@ -0,0 +1,11 @@
+using QSB.Anglerfish.WorldObjects;
+using QSB.WorldSync;
+
+namespace QSB.Anglerfish
+{
+	public class AnglerManager : WorldObjectManager
+	{
+		protected override void RebuildWorldObjects(OWScene scene)
+			=> QSBWorldSync.Init<QSBAngler, AnglerfishController>();
+	}
+}

QSB/Anglerfish/Events/AnglerChangeStateEvent.cs

@@ -0,0 +1,78 @@
+using QSB.Anglerfish.WorldObjects;
+using QSB.Events;
+using QSB.Player;
+using QSB.WorldSync;
+using UnityEngine;
+using static AnglerfishController;
+using EventType = QSB.Events.EventType;
+
+namespace QSB.Anglerfish.Events
+{
+	public class AnglerChangeStateEvent : QSBEvent<AnglerChangeStateMessage>
+	{
+		public override EventType Type => EventType.AnglerChangeState;
+
+		public override void SetupListener()
+			=> GlobalMessenger<QSBAngler>.AddListener(EventNames.QSBAnglerChangeState, Handler);
+
+		public override void CloseListener()
+			=> GlobalMessenger<QSBAngler>.RemoveListener(EventNames.QSBAnglerChangeState, Handler);
+
+		private void Handler(QSBAngler qsbAngler) => SendEvent(CreateMessage(qsbAngler));
+
+		private AnglerChangeStateMessage CreateMessage(QSBAngler qsbAngler) => new AnglerChangeStateMessage
+		{
+			ObjectId = qsbAngler.ObjectId,
+			EnumValue = qsbAngler.AttachedObject._currentState,
+			TargetId = TargetToId(qsbAngler.TargetTransform),
+			LocalDisturbancePos = qsbAngler.AttachedObject._localDisturbancePos
+		};
+
+		public override void OnReceiveLocal(bool isHost, AnglerChangeStateMessage message) => OnReceive(isHost, message);
+		public override void OnReceiveRemote(bool isHost, AnglerChangeStateMessage message) => OnReceive(isHost, message);
+
+		private static void OnReceive(bool isHost, AnglerChangeStateMessage message)
+		{
+			var qsbAngler = QSBWorldSync.GetWorldFromId<QSBAngler>(message.ObjectId);
+
+			if (isHost)
+			{
+				qsbAngler.TransferAuthority(message.FromId);
+			}
+
+			qsbAngler.TargetTransform = IdToTarget(message.TargetId);
+			qsbAngler.AttachedObject._localDisturbancePos = message.LocalDisturbancePos;
+			qsbAngler.AttachedObject.ChangeState(message.EnumValue);
+		}
+
+		private static uint TargetToId(Transform transform)
+		{
+			if (transform == null)
+			{
+				return uint.MaxValue;
+			}
+
+			if (transform == Locator.GetShipTransform())
+			{
+				return uint.MaxValue - 1;
+			}
+
+			return QSBPlayerManager.LocalPlayerId;
+		}
+
+		private static Transform IdToTarget(uint id)
+		{
+			if (id == uint.MaxValue)
+			{
+				return null;
+			}
+
+			if (id == uint.MaxValue - 1)
+			{
+				return Locator.GetShipTransform();
+			}
+
+			return QSBPlayerManager.GetPlayer(id).Body.transform;
+		}
+	}
+}

QSB/Anglerfish/Events/AnglerChangeStateMessage.cs

@@ -0,0 +1,26 @@
+using QSB.WorldSync.Events;
+using QuantumUNET.Transport;
+using UnityEngine;
+
+namespace QSB.Anglerfish.Events
+{
+	public class AnglerChangeStateMessage : EnumWorldObjectMessage<AnglerfishController.AnglerState>
+	{
+		public uint TargetId;
+		public Vector3 LocalDisturbancePos;
+
+		public override void Deserialize(QNetworkReader reader)
+		{
+			base.Deserialize(reader);
+			TargetId = reader.ReadUInt32();
+			LocalDisturbancePos = reader.ReadVector3();
+		}
+
+		public override void Serialize(QNetworkWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(TargetId);
+			writer.Write(LocalDisturbancePos);
+		}
+	}
+}

QSB/Anglerfish/Patches/AnglerPatches.cs

@@ -0,0 +1,370 @@
+using HarmonyLib;
+using QSB.Anglerfish.WorldObjects;
+using QSB.Events;
+using QSB.Patches;
+using QSB.WorldSync;
+using System;
+using UnityEngine;
+
+namespace QSB.Anglerfish.Patches
+{
+	public class AnglerPatches : QSBPatch
+	{
+		public override QSBPatchTypes Type => QSBPatchTypes.OnClientConnect;
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(AnglerfishController), nameof(AnglerfishController.GetTargetPosition))]
+		public static bool GetTargetPosition(AnglerfishController __instance, ref Vector3 __result)
+		{
+			var qsbAngler = QSBWorldSync.GetWorldFromUnity<QSBAngler>(__instance);
+			if (qsbAngler == null || qsbAngler.TransformSync == null)
+			{
+				return false;
+			}
+
+			__result = qsbAngler.TargetTransform != null
+				? qsbAngler.TargetTransform.position
+				: __instance._brambleBody.transform.TransformPoint(__instance._localDisturbancePos);
+
+			return false;
+		}
+
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(AnglerfishController), nameof(AnglerfishController.OnSectorOccupantRemoved))]
+		public static bool OnSectorOccupantRemoved(AnglerfishController __instance,
+			SectorDetector sectorDetector)
+		{
+			var qsbAngler = QSBWorldSync.GetWorldFromUnity<QSBAngler>(__instance);
+			if (qsbAngler == null || qsbAngler.TransformSync == null)
+			{
+				return false;
+			}
+
+			if (!(qsbAngler.TargetTransform != null) || !(sectorDetector.GetAttachedOWRigidbody().transform == qsbAngler.TargetTransform))
+			{
+				return false;
+			}
+
+			qsbAngler.TargetTransform = null;
+
+			return false;
+		}
+
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(AnglerfishController), nameof(AnglerfishController.UpdateState))]
+		public static bool UpdateState(AnglerfishController __instance)
+		{
+			var qsbAngler = QSBWorldSync.GetWorldFromUnity<QSBAngler>(__instance);
+			if (qsbAngler == null || qsbAngler.TransformSync == null)
+			{
+				return false;
+			}
+
+			switch (__instance._currentState)
+			{
+				case AnglerfishController.AnglerState.Investigating:
+					if ((__instance._brambleBody.transform.TransformPoint(__instance._localDisturbancePos) - __instance._anglerBody.GetPosition()).sqrMagnitude >= __instance._arrivalDistance * (double)__instance._arrivalDistance)
+					{
+						break;
+					}
+
+					__instance.ChangeState(AnglerfishController.AnglerState.Lurking);
+					QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+					break;
+
+				case AnglerfishController.AnglerState.Chasing:
+					if (qsbAngler.TargetTransform == null)
+					{
+						__instance.ChangeState(AnglerfishController.AnglerState.Lurking);
+						QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+						break;
+					}
+
+					if ((qsbAngler.TargetTransform.position - __instance._anglerBody.GetPosition()).sqrMagnitude <= __instance._escapeDistance * (double)__instance._escapeDistance)
+					{
+						break;
+					}
+
+					qsbAngler.TargetTransform = null;
+					__instance.ChangeState(AnglerfishController.AnglerState.Lurking);
+					QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+					break;
+
+				case AnglerfishController.AnglerState.Consuming:
+					if (__instance._consumeComplete)
+					{
+						break;
+					}
+
+					if (qsbAngler.TargetTransform == null)
+					{
+						__instance.ChangeState(AnglerfishController.AnglerState.Lurking);
+						QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+						break;
+					}
+
+					var num = Time.time - __instance._consumeStartTime;
+					if (qsbAngler.TargetTransform.CompareTag("Player") && num > (double)__instance._consumeDeathDelay)
+					{
+						qsbAngler.TargetTransform = null;
+						__instance.ChangeState(AnglerfishController.AnglerState.Lurking);
+						QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+
+						Locator.GetDeathManager().KillPlayer(DeathType.Digestion);
+						__instance._consumeComplete = true;
+						break;
+					}
+
+					if (!qsbAngler.TargetTransform.CompareTag("Ship"))
+					{
+						break;
+					}
+
+					if (num > (double)__instance._consumeShipCrushDelay)
+					{
+						qsbAngler.TargetTransform.GetComponentInChildren<ShipDamageController>().TriggerSystemFailure();
+					}
+
+					if (num <= (double)__instance._consumeDeathDelay)
+					{
+						break;
+					}
+
+					if (PlayerState.IsInsideShip())
+					{
+						qsbAngler.TargetTransform = null;
+						__instance.ChangeState(AnglerfishController.AnglerState.Lurking);
+						QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+
+						Locator.GetDeathManager().KillPlayer(DeathType.Digestion);
+					}
+
+					__instance._consumeComplete = true;
+					break;
+
+				case AnglerfishController.AnglerState.Stunned:
+					__instance._stunTimer -= Time.deltaTime;
+					if (__instance._stunTimer > 0.0)
+					{
+						break;
+					}
+
+					if (qsbAngler.TargetTransform != null)
+					{
+						__instance.ChangeState(AnglerfishController.AnglerState.Chasing);
+						QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+						break;
+					}
+					__instance.ChangeState(AnglerfishController.AnglerState.Lurking);
+					QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+					break;
+			}
+
+			return false;
+		}
+
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(AnglerfishController), nameof(AnglerfishController.UpdateMovement))]
+		public static bool UpdateMovement(AnglerfishController __instance)
+		{
+			var qsbAngler = QSBWorldSync.GetWorldFromUnity<QSBAngler>(__instance);
+			if (qsbAngler == null || qsbAngler.TransformSync == null)
+			{
+				return false;
+			}
+
+			if (!qsbAngler.TransformSync.HasAuthority)
+			{
+				return false;
+			}
+
+			qsbAngler.FixedUpdate();
+
+			if (__instance._anglerBody.GetVelocity().sqrMagnitude > (double)Mathf.Pow(__instance._chaseSpeed * 1.5f, 2f))
+			{
+				__instance.ApplyDrag(10f);
+			}
+
+			switch (__instance._currentState)
+			{
+				case AnglerfishController.AnglerState.Lurking:
+					__instance.ApplyDrag(1f);
+					break;
+
+				case AnglerfishController.AnglerState.Investigating:
+					var targetPos = __instance._brambleBody.transform.TransformPoint(__instance._localDisturbancePos);
+					__instance.RotateTowardsTarget(targetPos, __instance._turnSpeed, __instance._turnSpeed);
+					if (__instance._turningInPlace)
+					{
+						break;
+					}
+
+					__instance.MoveTowardsTarget(targetPos, __instance._investigateSpeed, __instance._acceleration);
+					break;
+
+				case AnglerfishController.AnglerState.Chasing:
+					var velocity = qsbAngler.TargetVelocity;
+					var normalized = velocity.normalized;
+					var from = __instance._anglerBody.GetPosition() + __instance.transform.TransformDirection(__instance._mouthOffset) - qsbAngler.TargetTransform.position;
+					var magnitude1 = velocity.magnitude;
+					var num1 = Vector3.Angle(from, normalized);
+					var a = magnitude1 * 2f;
+					var num2 = a;
+					if (num1 < 90.0)
+					{
+						var magnitude2 = (double)from.magnitude;
+						var num3 = (float)magnitude2 * Mathf.Sin(num1 * ((float)Math.PI / 180f));
+						var num4 = (float)magnitude2 * Mathf.Cos(num1 * ((float)Math.PI / 180f));
+						var magnitude3 = __instance._anglerBody.GetVelocity().magnitude;
+						var num5 = num4 / Mathf.Max(magnitude1, 0.0001f) / (num3 / Mathf.Max(magnitude3, 0.0001f));
+						if (num5 <= 1.0)
+						{
+							var t = Mathf.Clamp01(num5);
+							num2 = Mathf.Lerp(a, num4, t);
+						}
+						else
+						{
+							var num6 = Mathf.InverseLerp(1f, 4f, num5);
+							num2 = Mathf.Lerp(num4, 0.0f, num6 * num6);
+						}
+					}
+
+					__instance._targetPos = qsbAngler.TargetTransform.position + normalized * num2;
+					__instance.RotateTowardsTarget(__instance._targetPos, __instance._turnSpeed, __instance._quickTurnSpeed);
+					if (__instance._turningInPlace)
+					{
+						break;
+					}
+
+					__instance.MoveTowardsTarget(__instance._targetPos, __instance._chaseSpeed, __instance._acceleration);
+					break;
+
+				case AnglerfishController.AnglerState.Consuming:
+					__instance.ApplyDrag(1f);
+					break;
+
+				case AnglerfishController.AnglerState.Stunned:
+					__instance.ApplyDrag(0.5f);
+					break;
+			}
+
+			return false;
+		}
+
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(AnglerfishController), nameof(AnglerfishController.OnImpact))]
+		public static bool OnImpact(AnglerfishController __instance,
+			ImpactData impact)
+		{
+			var qsbAngler = QSBWorldSync.GetWorldFromUnity<QSBAngler>(__instance);
+			if (qsbAngler == null || qsbAngler.TransformSync == null)
+			{
+				return false;
+			}
+
+			var attachedOwRigidbody = impact.otherCollider.GetAttachedOWRigidbody();
+			if ((attachedOwRigidbody.CompareTag("Player") || attachedOwRigidbody.CompareTag("Ship"))
+				&& __instance._currentState != AnglerfishController.AnglerState.Consuming
+				&& __instance._currentState != AnglerfishController.AnglerState.Stunned)
+			{
+				qsbAngler.TargetTransform = attachedOwRigidbody.transform;
+				__instance.ChangeState(AnglerfishController.AnglerState.Chasing);
+				QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+			}
+
+			return false;
+		}
+
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(AnglerfishController), nameof(AnglerfishController.OnClosestAudibleNoise))]
+		public static bool OnClosestAudibleNoise(AnglerfishController __instance,
+			NoiseMaker noiseMaker)
+		{
+			var qsbAngler = QSBWorldSync.GetWorldFromUnity<QSBAngler>(__instance);
+			if (qsbAngler == null || qsbAngler.TransformSync == null)
+			{
+				return false;
+			}
+
+			if (__instance._currentState == AnglerfishController.AnglerState.Consuming
+				|| __instance._currentState == AnglerfishController.AnglerState.Stunned)
+			{
+				return false;
+			}
+
+			if ((noiseMaker.GetNoiseOrigin() - __instance.transform.position).sqrMagnitude < __instance._pursueDistance * (double)__instance._pursueDistance)
+			{
+				if (!(qsbAngler.TargetTransform != noiseMaker.GetAttachedBody().transform))
+				{
+					return false;
+				}
+
+				qsbAngler.TargetTransform = noiseMaker.GetAttachedBody().transform;
+				if (__instance._currentState == AnglerfishController.AnglerState.Chasing)
+				{
+					return false;
+				}
+
+				__instance.ChangeState(AnglerfishController.AnglerState.Chasing);
+				QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+			}
+			else
+			{
+				if (__instance._currentState != AnglerfishController.AnglerState.Lurking
+					&& __instance._currentState != AnglerfishController.AnglerState.Investigating)
+				{
+					return false;
+				}
+
+				__instance._localDisturbancePos = __instance._brambleBody.transform.InverseTransformPoint(noiseMaker.GetNoiseOrigin());
+				if (__instance._currentState == AnglerfishController.AnglerState.Investigating)
+				{
+					return false;
+				}
+
+				__instance.ChangeState(AnglerfishController.AnglerState.Investigating);
+				QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+			}
+
+			return false;
+		}
+
+
+		[HarmonyPrefix]
+		[HarmonyPatch(typeof(AnglerfishController), nameof(AnglerfishController.OnCaughtObject))]
+		public static bool OnCaughtObject(AnglerfishController __instance,
+			OWRigidbody caughtBody)
+		{
+			var qsbAngler = QSBWorldSync.GetWorldFromUnity<QSBAngler>(__instance);
+
+			if (__instance._currentState == AnglerfishController.AnglerState.Consuming)
+			{
+				if (qsbAngler.TargetTransform.CompareTag("Player") || !caughtBody.CompareTag("Player"))
+				{
+					return false;
+				}
+
+				Locator.GetDeathManager().KillPlayer(DeathType.Digestion);
+			}
+			else
+			{
+				if (!caughtBody.CompareTag("Player") && !caughtBody.CompareTag("Ship"))
+				{
+					return false;
+				}
+
+				qsbAngler.TargetTransform = caughtBody.transform;
+				__instance._consumeStartTime = Time.time;
+				__instance.ChangeState(AnglerfishController.AnglerState.Consuming);
+				QSBEventManager.FireEvent(EventNames.QSBAnglerChangeState, qsbAngler);
+			}
+
+			return false;
+		}
+	}
+}

QSB/Anglerfish/TransformSync/AnglerTransformSync.cs

@@ -0,0 +1,61 @@
+using QSB.Anglerfish.WorldObjects;
+using QSB.Syncs.Unsectored.Rigidbodies;
+using QSB.WorldSync;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace QSB.Anglerfish.TransformSync
+{
+	public class AnglerTransformSync : UnsectoredRigidbodySync
+	{
+		public override bool IsReady => QSBCore.WorldObjectsReady;
+		public override bool UseInterpolation => true;
+
+		private QSBAngler _qsbAngler;
+		private static readonly List<AnglerTransformSync> _instances = new List<AnglerTransformSync>();
+
+		protected override OWRigidbody GetRigidbody()
+			=> _qsbAngler.AttachedObject._anglerBody;
+
+		public override void Start()
+		{
+			_instances.Add(this);
+			base.Start();
+		}
+
+		protected override void OnDestroy()
+		{
+			_instances.Remove(this);
+			base.OnDestroy();
+		}
+
+		public override float GetNetworkSendInterval()
+			=> 1 / 4f;
+
+		protected override void Init()
+		{
+			_qsbAngler = QSBWorldSync.GetWorldFromId<QSBAngler>(_instances.IndexOf(this));
+			_qsbAngler.TransformSync = this;
+
+			base.Init();
+			SetReferenceTransform(_qsbAngler.AttachedObject._brambleBody.transform);
+		}
+
+		protected override void OnRenderObject()
+		{
+			base.OnRenderObject();
+
+			if (!QSBCore.WorldObjectsReady
+				|| !QSBCore.DebugMode
+				|| !QSBCore.ShowLinesInDebug
+				|| !IsReady
+				|| ReferenceTransform == null
+				|| _intermediaryTransform.GetReferenceTransform() == null)
+			{
+				return;
+			}
+
+			Popcron.Gizmos.Line(AttachedObject.transform.position, _qsbAngler.AttachedObject.GetTargetPosition(), Color.white);
+		}
+	}
+}

QSB/Anglerfish/WorldObjects/QSBAngler.cs

@@ -0,0 +1,67 @@
+using QSB.Anglerfish.TransformSync;
+using QSB.Utility;
+using QSB.WorldSync;
+using QuantumUNET;
+using System.Linq;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace QSB.Anglerfish.WorldObjects
+{
+	public class QSBAngler : WorldObject<AnglerfishController>
+	{
+		public AnglerTransformSync TransformSync;
+		public Transform TargetTransform;
+		public Vector3 TargetVelocity { get; private set; }
+
+		private Vector3 _lastTargetPosition;
+
+		public override void Init(AnglerfishController attachedObject, int id)
+		{
+			ObjectId = id;
+			AttachedObject = attachedObject;
+
+			if (QSBCore.IsHost)
+			{
+				Object.Instantiate(QSBNetworkManager.Instance.AnglerPrefab).SpawnWithServerAuthority();
+			}
+		}
+
+		public override void OnRemoval()
+		{
+			if (QSBCore.IsHost)
+			{
+				QNetworkServer.Destroy(TransformSync.gameObject);
+			}
+		}
+
+		public void TransferAuthority(uint id)
+		{
+			var conn = QNetworkServer.connections.First(x => x.GetPlayerId() == id);
+			var identity = TransformSync.NetIdentity;
+
+			if (identity.ClientAuthorityOwner == conn)
+			{
+				return;
+			}
+
+			if (identity.ClientAuthorityOwner != null)
+			{
+				identity.RemoveClientAuthority(identity.ClientAuthorityOwner);
+			}
+			identity.AssignClientAuthority(conn);
+
+			DebugLog.DebugWrite($"angler {ObjectId} - transferred authority to {id}");
+		}
+
+		public void FixedUpdate()
+		{
+			if (TargetTransform == null)
+			{
+				return;
+			}
+			TargetVelocity = TargetTransform.position - _lastTargetPosition;
+			_lastTargetPosition = TargetTransform.position;
+		}
+	}
+}

QSB/Events/EventNames.cs

@@ -92,5 +92,6 @@
 		public static string QSBEnterSatelliteCamera = "QSBEnterSatelliteCamera";
 		public static string QSBExitSatelliteCamera = "QSBExitSatelliteCamera";
 		public static string QSBSatelliteSnapshot = "QSBSatelliteSnapshot";
+		public static string QSBAnglerChangeState = "QSBAnglerChangeState";
 	}
 }

QSB/Events/EventType.cs

@@ -133,6 +133,8 @@
 		RetrieveProbe,
 		PlayerRetrieveProbe,
 		LaunchProbe,
-		PlayerLaunchProbe
+		PlayerLaunchProbe,
+
+		AnglerChangeState
 	}
 }

QSB/Events/QSBEventManager.cs

@@ -24,6 +24,7 @@ using QSB.TimeSync.Events;
 using QSB.Tools.Events;
 using QSB.Tools.ProbeLauncherTool.Events;
 using QSB.TranslationSync.Events;
+using QSB.Anglerfish.Events;
 using QSB.Utility;
 using QSB.Utility.Events;
 using System.Collections.Generic;
@@ -89,6 +90,7 @@ namespace QSB.Events
 				new MoveToCarryEvent(),
 				new StartStatueEvent(),
 				new CampfireStateEvent(),
+				new AnglerChangeStateEvent(),
 				// Conversation/dialogue/exploration
 				new ConversationEvent(),
 				new ConversationStartEndEvent(),

QSB/Patches/QSBPatchManager.cs

@@ -27,6 +27,7 @@ using QSB.Utility;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using QSB.Anglerfish.Patches;
 
 namespace QSB.Patches
 {
@@ -71,7 +72,8 @@ namespace QSB.Patches
 				new LauncherPatches(),
 				new SolanumPatches(),
 				new SatelliteProjectorPatches(),
-				new LightSensorPatches()
+				new LightSensorPatches(),
+				new AnglerPatches()
 			};
 
 			TypeToInstance = new Dictionary<QSBPatchTypes, Harmony>

QSB/QSB.csproj

@@ -36,6 +36,12 @@
     <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="Anglerfish\AnglerManager.cs" />
+    <Compile Include="Anglerfish\Events\AnglerChangeStateEvent.cs" />
+    <Compile Include="Anglerfish\Events\AnglerChangeStateMessage.cs" />
+    <Compile Include="Anglerfish\Patches\AnglerPatches.cs" />
+    <Compile Include="Anglerfish\TransformSync\AnglerTransformSync.cs" />
+    <Compile Include="Anglerfish\WorldObjects\QSBAngler.cs" />
     <Compile Include="Animation\NPC\AnimationEvent.cs" />
     <Compile Include="Animation\NPC\CharacterAnimManager.cs" />
     <Compile Include="Animation\NPC\Events\NpcAnimationEvent.cs" />
@@ -440,7 +446,6 @@
       <Version>2.0.0</Version>
     </PackageReference>
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PostBuildEvent>md "$(OwmlDir)\Mods\$(ProjectName)"

QSB/QSBCore.cs

@@ -27,6 +27,7 @@ using QSB.Tools.ProbeLauncherTool;
 using QSB.TranslationSync;
 using QSB.Utility;
 using QSB.WorldSync;
+using QSB.Anglerfish;
 using QuantumUNET;
 using QuantumUNET.Components;
 using System.Linq;
@@ -123,6 +124,7 @@ namespace QSB
 			gameObject.AddComponent<ProbeLauncherManager>();
 			gameObject.AddComponent<LightSensorManager>();
 			gameObject.AddComponent<AirlockManager>();
+			gameObject.AddComponent<AnglerManager>();
 
 			DebugBoxManager.Init();
 

QSB/QSBNetworkManager.cs

@@ -13,6 +13,7 @@ using QSB.Player.TransformSync;
 using QSB.PoolSync;
 using QSB.ProbeSync.TransformSync;
 using QSB.ShipSync.TransformSync;
+using QSB.Anglerfish.TransformSync;
 using QSB.TimeSync;
 using QSB.Utility;
 using QSB.WorldSync;
@@ -37,6 +38,7 @@ namespace QSB
 		public bool IsReady { get; private set; }
 		public GameObject OrbPrefab { get; private set; }
 		public GameObject ShipPrefab { get; private set; }
+		public GameObject AnglerPrefab { get; private set; }
 		public string PlayerName { get; private set; }
 
 		private const int MaxConnections = 128;
@@ -82,6 +84,12 @@ namespace QSB
 			OrbPrefab.AddComponent<NomaiOrbTransformSync>();
 			spawnPrefabs.Add(OrbPrefab);
 
+			AnglerPrefab = _assetBundle.LoadAsset<GameObject>("assets/networkangler.prefab");
+			SetupNetworkId(AnglerPrefab, 5);
+			SetupNetworkTransform(AnglerPrefab);
+			AnglerPrefab.AddComponent<AnglerTransformSync>();
+			spawnPrefabs.Add(AnglerPrefab);
+
 			ConfigureNetworkManager();
 		}
 

QSB/Syncs/Sectored/Rigidbodies/SectoredRigidbodySync.cs

@@ -219,7 +219,6 @@ namespace QSB.Syncs.Sectored.Rigidbodies
 			return false;
 		}
 
-		// TODO : why? isn't owrigidbody.setvelocity the same...? :P
 		protected void SetVelocity(OWRigidbody rigidbody, Vector3 relativeVelocity)
 		{
 			var isRunningKinematic = rigidbody.RunningKinematicSimulation();

QSB/Syncs/Unsectored/Rigidbodies/UnsectoredRigidbodySync.cs

@@ -1,13 +1,261 @@
-using System;
+using OWML.Common;
+using OWML.Utils;
+using QSB.Utility;
+using QuantumUNET.Transport;
 using UnityEngine;
 
 namespace QSB.Syncs.Unsectored.Rigidbodies
 {
 	public abstract class UnsectoredRigidbodySync : BaseUnsectoredSync
 	{
+		public const float PositionMovedThreshold = 0.05f;
+		public const float AngleRotatedThreshold = 0.05f;
+		public const float VelocityChangeThreshold = 0.05f;
+		public const float AngVelocityChangeThreshold = 0.05f;
+
+		protected Vector3 _relativeVelocity;
+		protected Vector3 _relativeAngularVelocity;
+		protected Vector3 _prevVelocity;
+		protected Vector3 _prevAngularVelocity;
+
+		/// <summary>
+		/// The previous position of the VISIBLE object, as if parented to the reference.
+		/// </summary>
+		protected Vector3 _localPrevPosition;
+
+		/// <summary>
+		/// The previous rotation of the VISIBLE object, as if parented to the reference.
+		/// </summary>
+		protected Quaternion _localPrevRotation;
+
+		protected Vector3 _localPrevVelocity;
+		protected Vector3 _localPrevAngularVelocity;
 		protected abstract OWRigidbody GetRigidbody();
 
 		protected override Component SetAttachedObject()
-			=> throw new NotImplementedException();
+			=> GetRigidbody();
+
+		public override void SerializeTransform(QNetworkWriter writer, bool initialState)
+		{
+			base.SerializeTransform(writer, initialState);
+
+			var worldPos = _intermediaryTransform.GetPosition();
+			var worldRot = _intermediaryTransform.GetRotation();
+			var relativeVelocity = _relativeVelocity;
+			var relativeAngularVelocity = _relativeAngularVelocity;
+
+			writer.Write(worldPos);
+			SerializeRotation(writer, worldRot);
+			writer.Write(relativeVelocity);
+			writer.Write(relativeAngularVelocity);
+
+			_prevPosition = worldPos;
+			_prevRotation = worldRot;
+			_prevVelocity = relativeVelocity;
+			_prevAngularVelocity = relativeAngularVelocity;
+		}
+
+		public override void DeserializeTransform(QNetworkReader reader, bool initialState)
+		{
+			if (!QSBCore.WorldObjectsReady)
+			{
+				reader.ReadVector3();
+				DeserializeRotation(reader);
+				reader.ReadVector3();
+				reader.ReadVector3();
+				return;
+			}
+
+			var pos = reader.ReadVector3();
+			var rot = DeserializeRotation(reader);
+			var relativeVelocity = reader.ReadVector3();
+			var relativeAngularVelocity = reader.ReadVector3();
+
+			if (HasAuthority)
+			{
+				return;
+			}
+
+			if (_intermediaryTransform == null)
+			{
+				_intermediaryTransform = new IntermediaryTransform(transform);
+			}
+
+			_intermediaryTransform.SetPosition(pos);
+			_intermediaryTransform.SetRotation(rot);
+			_relativeVelocity = relativeVelocity;
+			_relativeAngularVelocity = relativeAngularVelocity;
+
+			if (_intermediaryTransform.GetPosition() == Vector3.zero)
+			{
+				// DebugLog.ToConsole($"Warning - {_logName} at (0,0,0)! - Given position was {pos}", MessageType.Warning);
+			}
+		}
+
+		protected void SetValuesToSync()
+		{
+			_intermediaryTransform.EncodePosition(AttachedObject.transform.position);
+			_intermediaryTransform.EncodeRotation(AttachedObject.transform.rotation);
+			_relativeVelocity = GetRelativeVelocity();
+			_relativeAngularVelocity = (AttachedObject as OWRigidbody).GetRelativeAngularVelocity(ReferenceTransform.GetAttachedOWRigidbody());
+		}
+
+
+		protected override bool UpdateTransform()
+		{
+			if (HasAuthority)
+			{
+				SetValuesToSync();
+				return true;
+			}
+
+			var targetPos = _intermediaryTransform.GetTargetPosition_Unparented();
+			var targetRot = _intermediaryTransform.GetTargetRotation_Unparented();
+
+			if (targetPos == Vector3.zero || _intermediaryTransform.GetTargetPosition_ParentedToReference() == Vector3.zero)
+			{
+				return false;
+			}
+
+			var positionToSet = targetPos;
+			var rotationToSet = targetRot;
+
+			if (UseInterpolation)
+			{
+				positionToSet = SmartSmoothDamp(AttachedObject.transform.position, targetPos);
+				rotationToSet = QuaternionHelper.SmoothDamp(AttachedObject.transform.rotation, targetRot, ref _rotationSmoothVelocity, SmoothTime);
+			}
+
+			var hasMoved = CustomHasMoved(
+				_intermediaryTransform.GetTargetPosition_ParentedToReference(),
+				_localPrevPosition,
+				_intermediaryTransform.GetTargetRotation_ParentedToReference(),
+				_localPrevRotation,
+				_relativeVelocity,
+				_localPrevVelocity,
+				_relativeAngularVelocity,
+				_localPrevAngularVelocity);
+
+			_localPrevPosition = _intermediaryTransform.GetTargetPosition_ParentedToReference();
+			_localPrevRotation = _intermediaryTransform.GetTargetRotation_ParentedToReference();
+			_localPrevVelocity = _relativeVelocity;
+			_localPrevAngularVelocity = _relativeAngularVelocity;
+
+			if (!hasMoved)
+			{
+				return true;
+			}
+
+			//(AttachedObject as OWRigidbody).SetPosition(positionToSet);
+			//(AttachedObject as OWRigidbody).SetRotation(rotationToSet);
+
+			(AttachedObject as OWRigidbody).MoveToPosition(positionToSet);
+			(AttachedObject as OWRigidbody).MoveToRotation(rotationToSet);
+
+			var targetVelocity = ReferenceTransform.GetAttachedOWRigidbody().GetPointVelocity(targetPos) + _relativeVelocity;
+			var targetAngularVelocity = ReferenceTransform.GetAttachedOWRigidbody().GetAngularVelocity() + _relativeAngularVelocity;
+
+			SetVelocity(AttachedObject as OWRigidbody, targetVelocity);
+			(AttachedObject as OWRigidbody).SetAngularVelocity(targetAngularVelocity);
+
+			return true;
+		}
+
+		public override bool HasMoved()
+			=> CustomHasMoved(
+				_intermediaryTransform.GetPosition(),
+				_prevPosition,
+				_intermediaryTransform.GetRotation(),
+				_prevRotation,
+				_relativeVelocity,
+				_prevVelocity,
+				_relativeAngularVelocity,
+				_prevAngularVelocity);
+
+		// OPTIMIZE : optimize by using sqrMagnitude
+		private bool CustomHasMoved(
+			Vector3 newPosition,
+			Vector3 prevPosition,
+			Quaternion newRotation,
+			Quaternion prevRotation,
+			Vector3 newVelocity,
+			Vector3 prevVelocity,
+			Vector3 newAngVelocity,
+			Vector3 prevAngVelocity)
+		{
+			var displacementMagnitude = (newPosition - prevPosition).magnitude;
+
+			if (displacementMagnitude > PositionMovedThreshold)
+			{
+				return true;
+			}
+
+			if (Quaternion.Angle(newRotation, prevRotation) > AngleRotatedThreshold)
+			{
+				return true;
+			}
+
+			var velocityChangeMagnitude = (newVelocity - prevVelocity).magnitude;
+			var angularVelocityChangeMagnitude = (newAngVelocity - prevAngVelocity).magnitude;
+			if (velocityChangeMagnitude > VelocityChangeThreshold)
+			{
+				return true;
+			}
+
+			if (angularVelocityChangeMagnitude > AngVelocityChangeThreshold)
+			{
+				return true;
+			}
+
+			return false;
+		}
+
+		protected void SetVelocity(OWRigidbody rigidbody, Vector3 relativeVelocity)
+		{
+			var isRunningKinematic = rigidbody.RunningKinematicSimulation();
+			var currentVelocity = rigidbody.GetValue<Vector3>("_currentVelocity");
+
+			if (isRunningKinematic)
+			{
+				var kinematicRigidbody = rigidbody.GetValue<KinematicRigidbody>("_kinematicRigidbody");
+				kinematicRigidbody.velocity = relativeVelocity + Locator.GetCenterOfTheUniverse().GetStaticFrameVelocity_Internal();
+			}
+			else
+			{
+				var normalRigidbody = rigidbody.GetValue<Rigidbody>("_rigidbody");
+				normalRigidbody.velocity = relativeVelocity + Locator.GetCenterOfTheUniverse().GetStaticFrameVelocity_Internal();
+			}
+
+			rigidbody.SetValue("_lastVelocity", currentVelocity);
+			rigidbody.SetValue("_currentVelocity", relativeVelocity);
+		}
+
+		public float GetVelocityChangeMagnitude()
+			=> (_relativeVelocity - _prevVelocity).magnitude;
+
+		public Vector3 GetRelativeVelocity()
+		{
+			if (AttachedObject == null)
+			{
+				DebugLog.ToConsole($"Error - Trying to get relative velocity when AttachedObject is null.", MessageType.Error);
+				return Vector3.zero;
+			}
+
+			if (ReferenceTransform == null)
+			{
+				DebugLog.ToConsole($"Error - Trying to get relative velocity when ReferenceTransform is null. ({AttachedObject.name})", MessageType.Error);
+				return Vector3.zero;
+			}
+
+			var attachedRigid = ReferenceTransform.GetAttachedOWRigidbody();
+			if (attachedRigid == null)
+			{
+				DebugLog.ToConsole($"Error - ReferenceTransform ({ReferenceTransform.name}) on {AttachedObject.name} has no attached OWRigidBody.", MessageType.Error);
+				return Vector3.zero;
+			}
+
+			var pointVelocity = attachedRigid.GetPointVelocity(AttachedObject.transform.position);
+			return (AttachedObject as OWRigidbody).GetVelocity() - pointVelocity;
+		}
 	}
 }

UnityProject/Assets/GameAssets.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: e2241e4bc9f9e994c9d743879f2f5fb2
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityProject/Assets/NetworkAngler.prefab

@@ -0,0 +1,89 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &4235888882139944903
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2283569403569444943}
+  - component: {fileID: 3221094810666780705}
+  - component: {fileID: 6460324066427500463}
+  m_Layer: 0
+  m_Name: NetworkAngler
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2283569403569444943
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4235888882139944903}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &3221094810666780705
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4235888882139944903}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 372142912, guid: 93b08009869340045a8e7321508b6355, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_SceneId:
+    m_Value: 0
+  m_AssetId:
+    i0: 0
+    i1: 0
+    i2: 0
+    i3: 0
+    i4: 0
+    i5: 0
+    i6: 0
+    i7: 0
+    i8: 0
+    i9: 0
+    i10: 0
+    i11: 0
+    i12: 0
+    i13: 0
+    i14: 0
+    i15: 0
+  m_ServerOnly: 0
+  m_LocalPlayerAuthority: 0
+--- !u!114 &6460324066427500463
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4235888882139944903}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: -1768714887, guid: 93b08009869340045a8e7321508b6355, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_TransformSyncMode: 0
+  m_SendInterval: 0.1
+  m_SyncRotationAxis: 7
+  m_RotationSyncCompression: 0
+  m_SyncSpin: 0
+  m_MovementTheshold: 0.001
+  m_VelocityThreshold: 0.0001
+  m_SnapThreshold: 5
+  m_InterpolateRotation: 1
+  m_InterpolateMovement: 1

UnityProject/Assets/NetworkAngler.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 840ab14be584dfc4584379a776e10ed8
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: network
+  assetBundleVariant: 

UnityProject/ProjectSettings/EditorSettings.asset

@@ -3,19 +3,33 @@
 --- !u!159 &1
 EditorSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 7
+  serializedVersion: 9
   m_ExternalVersionControlSupport: Hidden Meta Files
   m_SerializationMode: 2
   m_LineEndingsForNewScripts: 2
   m_DefaultBehaviorMode: 0
+  m_PrefabRegularEnvironment: {fileID: 0}
+  m_PrefabUIEnvironment: {fileID: 0}
   m_SpritePackerMode: 0
   m_SpritePackerPaddingPower: 1
   m_EtcTextureCompressorBehavior: 1
   m_EtcTextureFastCompressor: 1
   m_EtcTextureNormalCompressor: 2
   m_EtcTextureBestCompressor: 4
-  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmdef;rsp
+  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmdef;rsp;asmref
   m_ProjectGenerationRootNamespace: 
-  m_UserGeneratedProjectSuffix: 
   m_CollabEditorSettings:
     inProgressEnabled: 1
+  m_EnableTextureStreamingInEditMode: 1
+  m_EnableTextureStreamingInPlayMode: 1
+  m_AsyncShaderCompilation: 1
+  m_EnterPlayModeOptionsEnabled: 0
+  m_EnterPlayModeOptions: 3
+  m_ShowLightmapResolutionOverlay: 1
+  m_UseLegacyProbeSampleCount: 1
+  m_AssetPipelineMode: 0
+  m_CacheServerMode: 0
+  m_CacheServerEndpoint: 
+  m_CacheServerNamespacePrefix: default
+  m_CacheServerEnableDownload: 1
+  m_CacheServerEnableUpload: 1