quantum-space-buddies/QSB/Animation/NPC/Patches/CharacterAnimationPatches.cs

using HarmonyLib;
using OWML.Common;
using QSB.Animation.NPC.Messages;
using QSB.Animation.NPC.WorldObjects;
using QSB.ConversationSync;
using QSB.Messaging;
using QSB.Patches;
using QSB.Player;
using QSB.TriggerSync.WorldObjects;
using QSB.Utility;
using QSB.WorldSync;
using System.Linq;
using UnityEngine;

namespace QSB.Animation.NPC.Patches
{
	[HarmonyPatch]
	public class CharacterAnimationPatches : QSBPatch
	{
		public override QSBPatchTypes Type => QSBPatchTypes.OnClientConnect;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CharacterAnimController), nameof(CharacterAnimController.OnAnimatorIK))]
		public static bool AnimatorIKReplacement(
			CharacterAnimController __instance)
		{
			if (!QSBWorldSync.AllObjectsReady || ConversationManager.Instance == null)
			{
				return true;
			}

			var playerId = ConversationManager.Instance.GetPlayerTalkingToTree(__instance._dialogueTree);
			var player = QSBPlayerManager.GetPlayer(playerId);

			if (__instance.playerTrackingZone == null)
			{
				return true;
			}

			var qsbObj = __instance.playerTrackingZone.GetWorldObject<QSBCharacterTrigger>(); // OPTIMIZE : maybe cache this somewhere... or assess how slow this is

			PlayerInfo playerToUse = null;
			if (__instance._inConversation)
			{
				if (playerId == uint.MaxValue)
				{
					DebugLog.ToConsole($"Error - {__instance.name} is in conversation with a null player! Defaulting to active camera.", MessageType.Error);
					playerToUse = QSBPlayerManager.LocalPlayer;
				}
				else
				{
					playerToUse = player.CameraBody == null
						? QSBPlayerManager.LocalPlayer
						: player;
				}
			}
			else if (!__instance.lookOnlyWhenTalking && qsbObj.Occupants.Count != 0) // IDEA : maybe this would be more fun if characters looked between players at random times? :P
			{
				playerToUse = QSBPlayerManager.GetClosestPlayerToWorldPoint(qsbObj.Occupants, __instance.transform.position);
			}
			else if (QSBPlayerManager.PlayerList.Count != 0)
			{
				playerToUse = QSBPlayerManager.GetClosestPlayerToWorldPoint(__instance.transform.position, true);
			}

			var localPosition = playerToUse != null
				? __instance._animator.transform.InverseTransformPoint(playerToUse.CameraBody.transform.position)
				: Vector3.zero;

			var targetWeight = __instance.headTrackingWeight;
			if (__instance.lookOnlyWhenTalking)
			{
				if (!__instance._inConversation
				    || qsbObj.Occupants.Count == 0
				    || !qsbObj.Occupants.Contains(playerToUse))
				{
					targetWeight *= 0;
				}
			}
			else
			{
				if (qsbObj.Occupants.Count == 0
				    || !qsbObj.Occupants.Contains(playerToUse))
				{
					targetWeight *= 0;
				}
			}

			__instance._currentLookWeight = Mathf.Lerp(__instance._currentLookWeight, targetWeight, Time.deltaTime * 2f);
			__instance._currentLookTarget = __instance.lookSpring.Update(__instance._currentLookTarget, localPosition, Time.deltaTime);
			__instance._animator.SetLookAtPosition(__instance._animator.transform.TransformPoint(__instance._currentLookTarget));
			__instance._animator.SetLookAtWeight(__instance._currentLookWeight);
			return false;

		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(FacePlayerWhenTalking), nameof(FacePlayerWhenTalking.OnStartConversation))]
		public static bool OnStartConversation(FacePlayerWhenTalking __instance)
		{
			var playerId = ConversationManager.Instance.GetPlayerTalkingToTree(__instance._dialogueTree);
			if (playerId == uint.MaxValue)
			{
				DebugLog.ToConsole($"Error - No player talking to {__instance._dialogueTree.name}!", MessageType.Error);
				return false;
			}

			var player = QSBPlayerManager.GetPlayer(playerId);

			var distance = player.Body.transform.position - __instance.transform.position;
			var vector2 = distance - Vector3.Project(distance, __instance.transform.up);
			var angle = Vector3.Angle(__instance.transform.forward, vector2) * Mathf.Sign(Vector3.Dot(vector2, __instance.transform.right));
			var axis = __instance.transform.parent.InverseTransformDirection(__instance.transform.up);
			var lhs = Quaternion.AngleAxis(angle, axis);
			__instance.FaceLocalRotation(lhs * __instance.transform.localRotation);

			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CharacterDialogueTree), nameof(CharacterDialogueTree.StartConversation))]
		public static bool StartConversation(CharacterDialogueTree __instance)
		{
			var allNpcAnimControllers = QSBWorldSync.GetWorldObjects<INpcAnimController>();
			var ownerOfThis = allNpcAnimControllers.FirstOrDefault(x => x.GetDialogueTree() == __instance);
			if (ownerOfThis == default)
			{
				return true;
			}

			ownerOfThis.SendMessage(new NpcAnimationMessage(true));
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CharacterDialogueTree), nameof(CharacterDialogueTree.EndConversation))]
		public static bool EndConversation(CharacterDialogueTree __instance)
		{
			var allNpcAnimControllers = QSBWorldSync.GetWorldObjects<INpcAnimController>();
			var ownerOfThis = allNpcAnimControllers.FirstOrDefault(x => x.GetDialogueTree() == __instance);
			if (ownerOfThis == default)
			{
				return true;
			}

			ownerOfThis.SendMessage(new NpcAnimationMessage(false));
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(KidRockController), nameof(KidRockController.Update))]
		public static bool UpdateReplacement(KidRockController __instance)
		{
			if (!QSBWorldSync.AllObjectsReady)
			{
				return true;
			}

			var qsbObj = QSBWorldSync.GetWorldObjects<QSBCharacterAnimController>().First(x => x.GetDialogueTree() == __instance._dialogueTree);

			if (!__instance._throwingRock && !qsbObj.InConversation() && Time.time > __instance._nextThrowTime)
			{
				__instance.StartRockThrow();
			}

			return false;
		}
	}
}