diff --git a/JotunnModStub/Trol/TrolConfig.cs b/JotunnModStub/Trol/TrolConfig.cs index 2a152ae..eaecaae 100644 --- a/JotunnModStub/Trol/TrolConfig.cs +++ b/JotunnModStub/Trol/TrolConfig.cs @@ -51,6 +51,9 @@ namespace RacesOfValheim public static ConfigEntry TrueFormCooldown; public static ConfigEntry TrueFormScaleNormal; public static ConfigEntry TrueFormScaleAdvanced; + public static ConfigEntry TrueFormUseTrollModel; + public static ConfigEntry TrueFormModelSize; + public static ConfigEntry TrueFormTrollDamageShare; // ─── Log Weapon (tier 7+) ────────────────────────────────────────────── public static ConfigEntry LogWeaponMaxDurability; @@ -133,6 +136,12 @@ namespace RacesOfValheim new ConfigDescription("Model scale while in True Form, tier 5-6.", new AcceptableValueRange(1f, 4f))); TrueFormScaleAdvanced = config.Bind(trueForm, "Scale (Tier 7+)", 2.5f, new ConfigDescription("Model scale while in True Form, tier 7+.", new AcceptableValueRange(1f, 4f))); + TrueFormUseTrollModel = config.Bind(trueForm, "Troll Model", true, + new ConfigDescription("Wear Valheim's own troll in True Form, with its own punch and ground slam instead of your weapons. Off: the old True Form, a bigger Trol with weapons in hand.")); + TrueFormModelSize = config.Bind(trueForm, "Troll Model Size", 1f, + new ConfigDescription("How tall the troll stands, as a share of the True Form size set by Scale above. 1 = exactly as tall as the old True Form.", new AcceptableValueRange(0.5f, 2f))); + TrueFormTrollDamageShare = config.Bind(trueForm, "Troll Attack Damage", 0.5f, + new ConfigDescription("Share of a real troll's damage each troll attack deals. Your Clubs skill then scales it the way it scales a club, and the True Form Melee Bonus and tier bonuses add on top.", new AcceptableValueRange(0.1f, 2f))); const string logWeapon = "Trol - Log Weapon"; LogWeaponMaxDurability = config.Bind(logWeapon, "Max Durability", 6f, diff --git a/JotunnModStub/Trol/TrolRace.cs b/JotunnModStub/Trol/TrolRace.cs index e2d26c4..dd5e546 100644 --- a/JotunnModStub/Trol/TrolRace.cs +++ b/JotunnModStub/Trol/TrolRace.cs @@ -153,6 +153,10 @@ namespace RacesOfValheim private void Update() { + // Before the race check, on purpose: a race change or a death has to take the troll + // costume off, and nothing below the check runs for them any more. + TrolTrueFormModel.Tick(Player.m_localPlayer); + if (!IsTrol()) return; if (RaceInput.Allowed) @@ -247,6 +251,8 @@ namespace RacesOfValheim if (nview != null && nview.IsValid()) nview.GetZDO().Set(Trol_PlayerUpdate_Patch.TrueFormKey, false); } + if (TrolTrueFormModel.RemoveLocal(player)) hadForm = true; + isTransforming = false; wasTrueFormActive = false; return hadForm; @@ -402,8 +408,20 @@ namespace RacesOfValheim Player.m_localPlayer.GetInventory().RemoveItem(rightItem); } - // Wait a moment for the animation to reach the throw point - yield return new WaitForSeconds(0.4f); + // Wait a moment for the animation to reach the throw point. Wearing the troll, that is + // the troll's own throw, and the rock leaves the hand on its OnAttackTrigger. + TrolTrueFormBehavior troll = isTrueForm ? FindObjectOfType() : null; + int baseline = troll != null ? troll.PlayThrow() : -1; + if (baseline >= 0) + { + float started = Time.time; + while (TrolTrueFormModel.AttackEvents == baseline && Time.time - started < 1.5f) yield return null; + } + else + { + yield return new WaitForSeconds(0.4f); + } + if (Player.m_localPlayer == null) yield break; Vector3 spawnPos = Player.m_localPlayer.GetEyePoint() + Player.m_localPlayer.GetLookDir() * 1.5f; diff --git a/JotunnModStub/Trol/TrolTrueFormBehavior.cs b/JotunnModStub/Trol/TrolTrueFormBehavior.cs new file mode 100644 index 0000000..1e52a57 --- /dev/null +++ b/JotunnModStub/Trol/TrolTrueFormBehavior.cs @@ -0,0 +1,399 @@ +using System.Collections; +using System.Collections.Generic; +using HarmonyLib; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// Drives the local player's troll: its legs from the hidden player's Animator, its fists from + /// the mouse. FenrirFormBehavior in shape - a trigger on the costume's Animator, then a sweep for + /// whatever is in reach - with two differences. The hit waits for the troll's own OnAttackTrigger + /// (see TrolTrueFormModel) instead of a fixed delay, and the damage is the troll's own, scaled. + /// + /// Left click punches, right click slams the ground. With a log in hand they become the troll's + /// two log swings, and each one that lands wears the log down the way a club swing used to. + /// + public class TrolTrueFormBehavior : MonoBehaviour + { + // Longest a swing waits for the troll's own hit event before landing anyway: a clip with + // no event must not leave the player swinging at nothing. + private const float HitEventTimeout = 1.5f; + + private Animator anim; + private Animator playerAnim; + private readonly FormLocomotion locomotion = new FormLocomotion(); + private readonly HashSet triggers = new HashSet(); + + private bool isAttacking; + private float busySince = -1f; + + private GameObject heldLog; + private string heldLogName; + + public bool IsAttacking => isAttacking; + + private void Start() + { + anim = GetComponentInChildren(); + Transform visual = Player.m_localPlayer != null ? Player.m_localPlayer.transform.Find("Visual") : null; + if (visual != null) playerAnim = visual.GetComponent(); + + if (anim != null) + { + foreach (AnimatorControllerParameter p in anim.parameters) + { + if (p.type == AnimatorControllerParameterType.Trigger) triggers.Add(p.name); + } + } + } + + /// Re-hides the body every frame; see RavagerFormBehavior.LateUpdate for why a + /// timer is not enough. + private void LateUpdate() + { + Player player = Player.m_localPlayer; + if (player == null) return; + PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-local"); + } + + private void Update() + { + Player player = Player.m_localPlayer; + if (player == null || anim == null || playerAnim == null) return; + + transform.localScale = Vector3.one * TrolTrueFormModel.ScaleFor(player); + + ItemDrop.ItemData right = Traverse.Create(player).Field("m_rightItem").Value; + TrolTrueFormModel.UpdateHeldLog(gameObject, right?.m_dropPrefab, ref heldLog, ref heldLogName); + + if (FormAnimGuard.Stuck(isAttacking, ref busySince)) + { + StopAllCoroutines(); + isAttacking = false; + } + + if (isAttacking || player.IsDead()) return; + + bool grounded = locomotion.Mirror(anim, playerAnim, player.IsCrouching()); + if (!grounded || !RaceInput.Allowed) return; + + bool log = heldLogName != null; + if (RaceInput.AttackDown(0)) + { + Play(log ? TrolTrueFormModel.AttackKind.LogSwingH : TrolTrueFormModel.AttackKind.Punch); + } + else if (RaceInput.AttackDown(1)) + { + Play(log ? TrolTrueFormModel.AttackKind.LogSwingV : TrolTrueFormModel.AttackKind.Slam); + } + } + + private void Play(TrolTrueFormModel.AttackKind kind) + { + TrolTrueFormModel.Profile profile = TrolTrueFormModel.Get(kind); + // A log swing the troll does not have falls back on the fist, rather than doing nothing. + if (profile == null && kind == TrolTrueFormModel.AttackKind.LogSwingH) profile = TrolTrueFormModel.Get(TrolTrueFormModel.AttackKind.Punch); + if (profile == null && kind == TrolTrueFormModel.AttackKind.LogSwingV) profile = TrolTrueFormModel.Get(TrolTrueFormModel.AttackKind.Slam); + if (profile == null) return; + + bool log = kind == TrolTrueFormModel.AttackKind.LogSwingH || kind == TrolTrueFormModel.AttackKind.LogSwingV; + StartCoroutine(AttackRoutine(profile, log)); + } + + /// + /// Plays the troll's throw for TrolRace's Throw Rock and holds the troll still through it. + /// Returns the event count to wait on, or -1 if the troll has no throw to play. + /// + public int PlayThrow() + { + TrolTrueFormModel.Profile profile = TrolTrueFormModel.Get(TrolTrueFormModel.AttackKind.Throw); + if (profile == null || isAttacking) return -1; + + int baseline = TrolTrueFormModel.AttackEvents; + StartCoroutine(ThrowRoutine(profile)); + return baseline; + } + + private IEnumerator ThrowRoutine(TrolTrueFormModel.Profile profile) + { + isAttacking = true; + Fire(profile.Trigger); + yield return WaitForClip(); + isAttacking = false; + } + + private IEnumerator AttackRoutine(TrolTrueFormModel.Profile profile, bool log) + { + isAttacking = true; + Player player = Player.m_localPlayer; + + int baseline = TrolTrueFormModel.AttackEvents; + Fire(profile.Trigger); + profile.Shared.m_startEffect.Create(player.transform.position, player.transform.rotation, player.transform); + float started = Time.time; + + while (TrolTrueFormModel.AttackEvents == baseline && Time.time - started < HitEventTimeout) + { + yield return null; + } + + if (player != null && !player.IsDead()) + { + profile.Shared.m_triggerEffect.Create(player.transform.position, player.transform.rotation, player.transform); + int landed = TrolTrueFormHit.Sweep(player, profile, transform.localScale.x); + if (landed > 0) + { + player.RaiseSkill(Skills.SkillType.Clubs, 1f); + if (log) WearLog(player); + } + } + + yield return WaitForClip(Time.time - started); + isAttacking = false; + } + + private void Fire(string trigger) + { + if (anim == null || string.IsNullOrEmpty(trigger) || !triggers.Contains(trigger)) return; + + try { anim.SetFloat("forward_speed", 0f); } catch {} + try { anim.SetFloat("sideway_speed", 0f); } catch {} + anim.SetTrigger(trigger); + TrolTrueFormModel.PublishAttackTrigger(Player.m_localPlayer, trigger); + } + + /// + /// Holds the lock until the attack clip has played out. The clip is read off the Animator a + /// frame after the trigger, when the transition into it has started; the length is clamped + /// so a wrong guess can neither cut a swing short nor freeze the troll. + /// + private IEnumerator WaitForClip(float alreadySpent = 0f) + { + yield return null; + + float length = 1.2f; + if (anim != null) + { + AnimatorClipInfo[] clips = anim.IsInTransition(0) ? anim.GetNextAnimatorClipInfo(0) : anim.GetCurrentAnimatorClipInfo(0); + if (clips != null && clips.Length > 0 && clips[0].clip != null) length = clips[0].clip.length; + } + + float remaining = Mathf.Clamp(length, 0.6f, 3f) - alreadySpent; + if (remaining > 0f) yield return new WaitForSeconds(remaining); + } + + /// The same wear a club swing put on the log, per swing that lands. TrolRace.Update + /// breaks it once it reaches zero. + private static void WearLog(Player player) + { + ItemDrop.ItemData right = Traverse.Create(player).Field("m_rightItem").Value; + if (right == null || right.m_dropPrefab == null || !right.m_dropPrefab.name.StartsWith("TrolWeapon_")) return; + right.m_durability = Mathf.Max(0f, right.m_durability - TrolConfig.LogWeaponDurabilityDrainPerHit.Value); + } + } + + /// + /// One troll blow against whatever is in reach. FenrirFormBehavior.ExecuteClawDamage's shape and + /// cover test, with the reach taken off the troll's own weapon and multiplied by how big the + /// costume is - a troll's arm is a troll's arm, at whatever size it is worn. + /// + internal static class TrolTrueFormHit + { + private const string FormLabel = "Troll"; + + private static readonly int Mask = LayerMask.GetMask("Default", "static_solid", "Default_small", "piece", + "piece_nonsolid", "terrain", "character", "character_net", "character_ghost", "hitbox", + "character_noenv", "vehicle"); + + /// How many things the blow landed on. + public static int Sweep(Player player, TrolTrueFormModel.Profile profile, float costumeScale) + { + Vector3 pos = player.transform.position; + Vector3 forward = player.transform.forward; + float range = Mathf.Max(1.5f, profile.Range * costumeScale); + bool area = profile.Type == Attack.AttackType.Area; + + Vector3 center = area + ? pos + forward * (range * 0.3f) + Vector3.up + : pos + forward * (range * 0.5f) + Vector3.up * Mathf.Max(1f, profile.Height * costumeScale); + float radius = area ? range * 0.7f : range * 0.5f + 0.5f; + float halfAngle = area ? 180f : Mathf.Max(60f, profile.Angle * 0.5f); + + Collider[] hits = Physics.OverlapSphere(center, radius, Mask); + FormMelee.LogSwing(FormLabel, hits.Length); + + HitData.DamageTypes damage = TrolTrueFormModel.DamageFor(player, profile); + var done = new HashSet(); + int landed = 0; + + foreach (Collider hit in hits) + { + if (hit.gameObject == player.gameObject) continue; + if (hit.attachedRigidbody != null && hit.attachedRigidbody.gameObject == player.gameObject) continue; + + IDestructible target = hit.GetComponentInParent(); + if (target == null || (target is Character c && c == player)) continue; + + GameObject targetObj = (target as MonoBehaviour)?.gameObject; + if (targetObj != null && done.Contains(targetObj)) continue; + + Vector3 targetCenter = hit.bounds.center; + Vector3 flat = targetCenter - pos; + flat.y = 0f; + float angle = flat.sqrMagnitude > 0.0001f ? Vector3.Angle(forward, flat) : 0f; + if (angle > halfAngle) + { + FormMelee.LogMiss(FormLabel, hit, $"outside the swing arc ({angle:0} deg)"); + continue; + } + + Vector3 eye = player.GetEyePoint(); + if (!FormMelee.CanReach(eye, center, hit, target, out string cover)) + { + FormMelee.LogMiss(FormLabel, hit, "no clear line, blocked by '" + cover + "'"); + continue; + } + + HitData hitData = new HitData(); + hitData.m_damage = damage; + hitData.m_point = targetCenter; + hitData.m_dir = (targetCenter - pos).normalized; + hitData.m_pushForce = profile.PushForce; + hitData.m_skill = Skills.SkillType.Clubs; + hitData.m_toolTier = (short)profile.ToolTier; + hitData.m_dodgeable = true; + hitData.m_blockable = true; + hitData.m_hitType = HitData.HitType.PlayerHit; + hitData.SetAttacker(player); + + if (targetObj != null) done.Add(targetObj); + FormMelee.LogHit(FormLabel, target, damage.GetTotalDamage()); + target.Damage(hitData); + profile.Shared.m_hitEffect.Create(targetCenter, Quaternion.identity); + landed++; + } + + return landed; + } + } + + /// + /// The troll every other client sees. RemoteFenrirAnimator in shape: legs from the remote + /// player's own Animator, which ZSyncAnimation keeps fed over the network, and attacks replayed + /// from the trigger the owner publishes. Sized and given its log the same way as the owner's. + /// + public class RemoteTrolTrueFormAnimator : MonoBehaviour + { + private Player player; + private Animator anim; + private Animator playerAnim; + private ZNetView nview; + private string lastAttack; + private readonly FormLocomotion locomotion = new FormLocomotion(); + + private GameObject heldLog; + private string heldLogName; + + private void LateUpdate() + { + if (player == null) return; + PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-remote"); + } + + private void Update() + { + if (player == null) player = GetComponentInParent(); + if (player == null) return; + if (nview == null) nview = player.GetComponent(); + if (anim == null) anim = GetComponentInChildren(); + if (playerAnim == null) + { + Transform visual = player.transform.Find("Visual"); + if (visual != null) playerAnim = visual.GetComponent(); + } + if (anim == null || playerAnim == null || nview == null || !nview.IsValid()) return; + + transform.localScale = Vector3.one * TrolTrueFormModel.ScaleFor(player); + + int rightHash = nview.GetZDO().GetInt(ZDOVars.s_rightItem, 0); + GameObject rightPrefab = rightHash != 0 && ObjectDB.instance != null ? ObjectDB.instance.GetItemPrefab(rightHash) : null; + TrolTrueFormModel.UpdateHeldLog(gameObject, rightPrefab, ref heldLog, ref heldLogName); + + ReplayAttack(); + locomotion.Mirror(anim, playerAnim, player.IsCrouching()); + } + + private void ReplayAttack() + { + string current = nview.GetZDO().GetString(TrolTrueFormModel.AttackTriggerKey, ""); + + // The first look only records what is there, so a punch from an earlier True Form does + // not replay the moment this troll is built. + if (lastAttack == null) { lastAttack = current; return; } + if (string.IsNullOrEmpty(current) || current == lastAttack) return; + lastAttack = current; + + int seqAt = current.LastIndexOf('#'); + string trigger = seqAt >= 0 ? current.Substring(0, seqAt) : current; + + foreach (AnimatorControllerParameter p in anim.parameters) + { + if (p.type == AnimatorControllerParameterType.Trigger && p.name == trigger) + { + try { anim.SetFloat("forward_speed", 0f); } catch {} + anim.SetTrigger(trigger); + break; + } + } + } + } + + /// + /// Puts the troll on every other client, from the True Form flag Trol_PlayerUpdate_Patch already + /// publishes for sizing. Sverm_RavagerRemoteVisuals_Patch's arrangement. + /// + [HarmonyPatch(typeof(VisEquipment), "UpdateVisuals")] + public static class Trol_TrueFormRemoteVisuals_Patch + { + public static void Postfix(VisEquipment __instance) + { + if (__instance == null || !__instance.m_isPlayer) return; + + Player player = __instance.GetComponent(); + if (player == null || player.IsOwner()) return; // The owner's own troll: TrolTrueFormModel.Tick. + + ZNetView nview = player.GetComponent(); + if (nview == null || !nview.IsValid()) return; + + ZDO zdo = nview.GetZDO(); + bool active = TrolConfig.TrueFormUseTrollModel.Value && + !player.IsDead() && + zdo.GetString("RacesOfValheim_Race", "Human") == "Trol" && + zdo.GetBool(Trol_PlayerUpdate_Patch.TrueFormKey, false); + + Transform existing = player.transform.Find(TrolTrueFormModel.RemoteModelName); + Transform playerVisual = player.transform.Find("Visual"); + + if (!active) + { + if (existing != null) + { + existing.gameObject.SetActive(false); + Object.Destroy(existing.gameObject); + PlayerVisualHider.Show(playerVisual, "trol-trueform-remote-revert"); + } + return; + } + + if (existing == null) + { + GameObject model = TrolTrueFormModel.Spawn(player, TrolTrueFormModel.RemoteModelName); + if (model == null) return; + model.AddComponent(); + } + + PlayerVisualHider.Hide(playerVisual, "trol-trueform-remote"); + } + } +} diff --git a/JotunnModStub/Trol/TrolTrueFormModel.cs b/JotunnModStub/Trol/TrolTrueFormModel.cs new file mode 100644 index 0000000..9748bf8 --- /dev/null +++ b/JotunnModStub/Trol/TrolTrueFormModel.cs @@ -0,0 +1,407 @@ +using System.Collections.Generic; +using HarmonyLib; +using Jotunn.Managers; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// True Form wears Valheim's own forest troll instead of a scaled-up player. + /// + /// Built the way the Fenrir forms are, not the way the Sverm's Ravager is: the troll's Visual is + /// instantiated live under the player, CharacterAnimEvent and AnimationEffect included. That + /// costs a FormFootsteps.Detach, and in return the troll's own clips play their own sounds and, + /// more to the point here, fire OnAttackTrigger at the exact frame a fist lands. That event + /// resolves to the PLAYER (the first Character up the hierarchy), and + /// Trol_TrueFormAttackTrigger_Patch catches it there - so every hit lands on the troll's own + /// timing rather than on a delay somebody guessed. + /// + /// SIZE. The costume does not have a size of its own. Every frame it is sized to stand as tall as + /// the player's hidden Visual would - the same Visual Trol_PlayerUpdate_Patch already grows from + /// 1.2-1.3 to the True Form scale, on the owner's client and every onlooker's. So the grow-in, the + /// shrink back and the size other players see all come from code that already worked, and + /// "Scale" / "Scale (Tier 7+)" keep meaning what they meant: how many player heights tall. + /// + /// ATTACKS. Read once off the troll's own weapons (Humanoid.m_defaultItems and friends): the + /// trigger each one plays, its damage, its reach. Nothing is cloned or equipped. The damage is a + /// share of the troll's (Troll Attack Damage), scaled by the player's Clubs skill exactly the way + /// a weapon is, and hit as Clubs - so Trol_Character_ApplyDamage_Patch adds the True Form and tier + /// bonuses on top just as it did for a club in hand. + /// + public static class TrolTrueFormModel + { + public const string Creature = "Troll"; + public const string LocalModelName = "TrolTrueFormModel"; + public const string RemoteModelName = "TrolTrueFormRemoteModel"; + + // Published by the owner after every trigger it fires, with a running count so the same + // punch twice in a row still reads as two - see FenrirAttackSync. + public const string AttackTriggerKey = "RacesOfValheim_TrolTrueFormAttack"; + private static int attackSeq; + + private static readonly int TrueFormHash = "SE_TrolTrueForm".GetStableHashCode(); + + public enum AttackKind { Punch, Slam, Throw, LogSwingH, LogSwingV } + + public class Profile + { + public string Source; + public string Trigger; + public HitData.DamageTypes Damage; + public Attack.AttackType Type; + public float Range; + public float Height; + public float Angle; + public float PushForce; + public int ToolTier; + public ItemDrop.ItemData.SharedData Shared; + } + + private static readonly Dictionary profiles = new Dictionary(); + private static bool profilesRead; + + // Measured once off the prefab: how tall the troll stands at scale 1. + private static float trollHeight = -1f; + private static string rightHandPath; + + private static GameObject localModel; + private static int attackEvents; + + public static bool LocalActive => localModel != null; + + /// How many OnAttackTrigger events the local troll has fired. Attack routines + /// remember the count and wait for it to move. + public static int AttackEvents => attackEvents; + + public static void NotifyAttackTrigger() => attackEvents++; + + // ─── Lifecycle ─────────────────────────────────────────────────────── + + /// + /// Called every frame from TrolRace.Update, before its race check, so a race change, a death + /// or the form running out all take the costume off even though nothing else in TrolRace + /// looks at the player any more by then. + /// + public static void Tick(Player player) + { + if (player == null || player != Player.m_localPlayer) return; + + bool wanted = TrolConfig.TrueFormUseTrollModel.Value && + !player.IsDead() && + TrolRace.IsTrol() && + player.GetSEMan().HaveStatusEffect(TrueFormHash); + + if (wanted && localModel == null) SpawnLocal(player); + else if (!wanted && localModel != null) RemoveLocal(player); + } + + private static void SpawnLocal(Player player) + { + localModel = Spawn(player, LocalModelName); + if (localModel == null) return; + + localModel.AddComponent(); + PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-local"); + + GameObject smoke = PrefabManager.Cache.GetPrefab("vfx_corpse_destruction_medium"); + if (smoke != null) Object.Instantiate(smoke, player.transform.position + Vector3.up, Quaternion.identity); + } + + /// Takes the costume off and gives the body back. Safe to call when there is none. + public static bool RemoveLocal(Player player) + { + if (localModel == null) return false; + + // SetActive first: Destroy waits for the end of the frame, and the behaviour's + // LateUpdate would hide the body again after the Show below. Same trap + // SvermRavagerForm.Exit documents. + localModel.SetActive(false); + Object.Destroy(localModel); + localModel = null; + + if (player != null) PlayerVisualHider.Show(player.transform.Find("Visual"), "trol-trueform-revert"); + return true; + } + + /// + /// The troll's Visual, under the given player. Shared by the owner's copy and every + /// onlooker's, so both look alike; only the driving component differs. + /// + public static GameObject Spawn(Player player, string name) + { + GameObject prefab = PrefabManager.Cache.GetPrefab(Creature); + Transform source = prefab != null ? prefab.transform.Find("Visual") : null; + if (source == null) + { + Jotunn.Logger.LogWarning($"[Trol] No '{Creature}' Visual to build True Form from; staying in the old shape."); + return null; + } + + MeasureTroll(prefab); + + GameObject model = Object.Instantiate(source.gameObject, player.transform); + model.name = name; + model.transform.localPosition = Vector3.zero; + model.transform.localRotation = Quaternion.identity; + model.transform.localScale = Vector3.one * ScaleFor(player); + + FormFootsteps.Detach(model, Creature); + + Animator anim = model.GetComponentInChildren(true); + if (anim != null) + { + anim.cullingMode = AnimatorCullingMode.AlwaysAnimate; + if (anim.GetComponent("AnimationEffect") == null) anim.gameObject.AddComponent(); + } + + Tint(model, SkinColorOf(player)); + return model; + } + + /// + /// The costume's scale for this player right now: as tall as their Visual stands, in + /// player heights, times the Troll Model Size setting. + /// + public static float ScaleFor(Player player) + { + if (player == null || trollHeight <= 0f) return 1f; + + GameObject visual = Traverse.Create(player).Field("m_visual").GetValue(); + float visualScale = visual != null ? visual.transform.localScale.y : 1f; + + CapsuleCollider capsule = player.GetComponent(); + float playerHeight = capsule != null ? capsule.height : 1.85f; + + return playerHeight * visualScale / trollHeight * TrolConfig.TrueFormModelSize.Value; + } + + private static void MeasureTroll(GameObject prefab) + { + if (trollHeight > 0f) return; + + CapsuleCollider capsule = prefab.GetComponent(); + trollHeight = capsule != null ? capsule.height * prefab.transform.localScale.y : 0f; + if (trollHeight <= 0.5f) trollHeight = 4.5f; + + // Where the troll holds its log: VisEquipment knows, so ask it rather than guess bones. + VisEquipment vis = prefab.GetComponent(); + Transform hand = vis != null ? vis.m_rightHand : null; + Transform visualRoot = prefab.transform.Find("Visual"); + if (hand != null && visualRoot != null && hand.IsChildOf(visualRoot)) + { + rightHandPath = PathFrom(visualRoot, hand); + } + + Jotunn.Logger.LogInfo($"[Trol] True Form model: '{Creature}' stands {trollHeight:0.00} m at scale 1, " + + $"right hand '{rightHandPath ?? "not found"}'."); + } + + private static string PathFrom(Transform root, Transform child) + { + var parts = new List(); + for (Transform t = child; t != null && t != root; t = t.parent) parts.Insert(0, t.name); + return string.Join("/", parts); + } + + // ─── Looks ─────────────────────────────────────────────────────────── + + /// The colour this Trol picked in Trol - Appearance, as published on their ZDO. + public static Color SkinColorOf(Player player) + { + ZNetView nview = player != null ? player.GetComponent() : null; + if (nview != null && nview.IsValid()) + { + Vector3 v = nview.GetZDO().GetVec3(TrolSkinColorPatch.SkinColorKey, new Vector3(-1f, -1f, -1f)); + if (v.x >= 0f) return new Color(v.x, v.y, v.z, 1f); + } + return player == Player.m_localPlayer ? TrolConfig.SkinColor.Value : TrolConfig.DefaultSkinColor; + } + + /// + /// Multiplies the troll's own colour by the player's skin colour, brought up to full + /// brightness first: the troll's texture is already dark, and multiplying it by the swatch + /// as-is turned it nearly black. The hue is the player's, the shading stays the troll's. + /// + private static void Tint(GameObject model, Color skin) + { + float max = Mathf.Max(skin.r, Mathf.Max(skin.g, skin.b)); + if (max <= 0.001f) return; + Color tint = new Color(skin.r / max, skin.g / max, skin.b / max, 1f); + + foreach (Renderer r in model.GetComponentsInChildren(true)) + { + if (r is ParticleSystemRenderer) continue; + foreach (Material m in r.materials) + { + if (m != null && m.HasProperty("_Color")) m.SetColor("_Color", m.GetColor("_Color") * tint); + } + } + } + + /// + /// Puts a copy of the held Trol log in the troll's right hand, or takes it away. Called every + /// frame by both drivers with whatever the player has in their right hand. + /// + public static void UpdateHeldLog(GameObject model, GameObject itemPrefab, ref GameObject current, ref string currentName) + { + string wanted = itemPrefab != null && itemPrefab.name.StartsWith("TrolWeapon_") ? itemPrefab.name : null; + if (wanted == currentName) return; + + if (current != null) Object.Destroy(current); + current = null; + currentName = wanted; + if (wanted == null || rightHandPath == null) return; + + Transform hand = model.transform.Find(rightHandPath); + Transform attach = itemPrefab.transform.Find("attach"); + if (hand == null || attach == null) return; + + current = Object.Instantiate(attach.gameObject, hand); + current.name = "TrolTrueFormLog"; + current.transform.localPosition = Vector3.zero; + current.transform.localRotation = Quaternion.identity; + // Left at the attach's own scale: the hand bone already carries the costume's, so the + // log grows and shrinks with the troll. Whether it looks right in the fist is a thing + // only an eye can settle - this is the line to change if it does not. + current.transform.localScale = Vector3.one; + } + + // ─── Attacks ───────────────────────────────────────────────────────── + + public static Profile Get(AttackKind kind) + { + EnsureProfiles(); + profiles.TryGetValue(kind, out Profile p); + return p; + } + + private static void EnsureProfiles() + { + if (profilesRead) return; + GameObject prefab = PrefabManager.Cache.GetPrefab(Creature); + Humanoid humanoid = prefab != null ? prefab.GetComponent() : null; + if (humanoid == null) return; + profilesRead = true; + + var weapons = new List(); + if (humanoid.m_defaultItems != null) weapons.AddRange(humanoid.m_defaultItems); + if (humanoid.m_randomWeapon != null) weapons.AddRange(humanoid.m_randomWeapon); + if (humanoid.m_randomSets != null) + { + foreach (Humanoid.ItemSet set in humanoid.m_randomSets) + { + if (set?.m_items != null) weapons.AddRange(set.m_items); + } + } + + foreach (GameObject weapon in weapons) + { + ItemDrop drop = weapon != null ? weapon.GetComponent() : null; + ItemDrop.ItemData.SharedData shared = drop?.m_itemData?.m_shared; + if (shared?.m_attack == null || string.IsNullOrEmpty(shared.m_attack.m_attackAnimation)) continue; + + AttackKind? kind = Classify(weapon.name.ToLower(), shared); + if (kind == null || profiles.ContainsKey(kind.Value)) continue; + + Attack a = shared.m_attack; + Profile p = new Profile + { + Source = weapon.name, + Trigger = a.m_attackAnimation, + Damage = shared.m_damages, + Type = a.m_attackType, + Range = a.m_attackRange, + Height = a.m_attackHeight, + Angle = a.m_attackAngle, + PushForce = shared.m_attackForce, + ToolTier = shared.m_toolTier, + Shared = shared, + }; + profiles[kind.Value] = p; + + Jotunn.Logger.LogInfo($"[Trol] True Form {kind.Value} <- '{p.Source}': trigger '{p.Trigger}', {p.Type}, " + + $"range {p.Range:0.0}, blunt {p.Damage.m_blunt:0} slash {p.Damage.m_slash:0} " + + $"chop {p.Damage.m_chop:0} pickaxe {p.Damage.m_pickaxe:0}."); + } + + if (!profiles.ContainsKey(AttackKind.Punch)) + { + Jotunn.Logger.LogWarning($"[Trol] '{Creature}' carries no punch; True Form left click will do nothing."); + } + } + + private static AttackKind? Classify(string name, ItemDrop.ItemData.SharedData shared) + { + if (name.Contains("throw") || shared.m_attack.m_attackProjectile != null) return AttackKind.Throw; + if (name.Contains("log")) + { + return name.EndsWith("_v") || name.Contains("vertical") ? AttackKind.LogSwingV : AttackKind.LogSwingH; + } + if (name.Contains("slam") || shared.m_attack.m_attackType == Attack.AttackType.Area) return AttackKind.Slam; + if (name.Contains("punch")) return AttackKind.Punch; + return null; + } + + /// + /// The owner's side of a remote replay: records the trigger just fired, so + /// RemoteTrolTrueFormAnimator plays it on every other client's copy. + /// + public static void PublishAttackTrigger(Player player, string trigger) + { + ZNetView nview = player != null ? player.GetComponent() : null; + if (nview == null || !nview.IsValid()) return; + + attackSeq++; + nview.GetZDO().Set(AttackTriggerKey, trigger + "#" + attackSeq); + } + + /// + /// The damage a troll attack deals for this player right now: the troll's own numbers, times + /// Troll Attack Damage, times the same random Clubs factor a club would get. + /// + public static HitData.DamageTypes DamageFor(Player player, Profile profile) + { + HitData.DamageTypes damage = profile.Damage.Clone(); + float factor = TrolConfig.TrueFormTrollDamageShare.Value * player.GetRandomSkillFactor(Skills.SkillType.Clubs); + damage.Modify(factor); + return damage; + } + + // ─── Native attack loop, shut while the costume is on ──────────────── + + [HarmonyPatch(typeof(Humanoid), "StartAttack")] + public static class Trol_TrueFormBlockNativeAttack_Patch + { + public static bool Prefix(Humanoid __instance) + { + return __instance != Player.m_localPlayer || !LocalActive; + } + } + + /// Crossbow reload and draw live here; see Fenrir's BlockPlayerAttackInputPatch. + [HarmonyPatch(typeof(Player), "PlayerAttackInput")] + public static class Trol_TrueFormBlockAttackInput_Patch + { + public static bool Prefix(Player __instance) + { + return __instance != Player.m_localPlayer || !LocalActive; + } + } + + /// + /// The troll's own clips call OnAttackTrigger at the moment a blow lands, and it arrives on + /// the player. It is the hit cue for TrolTrueFormBehavior, and it must go no further: let + /// through, it fires whatever attack the human still has in hand. + /// + [HarmonyPatch(typeof(Humanoid), nameof(Humanoid.OnAttackTrigger))] + public static class Trol_TrueFormAttackTrigger_Patch + { + public static bool Prefix(Humanoid __instance) + { + if (__instance != Player.m_localPlayer || !LocalActive) return true; + NotifyAttackTrigger(); + return false; + } + } + } +}