From c64cb393c7ddbb1bed9108f0509616cec0f2ac94 Mon Sep 17 00:00:00 2001 From: kanym Date: Wed, 14 Oct 2026 16:56:34 +0200 Subject: [PATCH 1/4] feat(trol): True Form wears Valheim's own troll True Form now hides the Trol's body and puts the vanilla forest troll's model in its place, on the owner's client and on every other player's. The costume stands as tall as the old True Form did: it follows the Visual scale Trol_PlayerUpdate_Patch already grows and publishes, so the grow-in, the shrink back and the size others see come for free. It takes the Trol skin colour from Trol - Appearance. Weapons are out while it is up. Left click is the troll's punch, right click its ground slam, and with a log in hand they become its two log swings, which wear the log down per hit as a club swing did. Throw Rock plays the troll's throw. The attacks, their triggers and reach are read off the troll's own weapons at runtime, and each hit lands on the troll's OnAttackTrigger event rather than a fixed delay. Damage is a share of the troll's own (Troll Attack Damage, 0.5), scaled by the Clubs skill like a club and hit as Clubs, so the True Form and tier melee bonuses still add on top. Other players see the troll from the existing True Form ZDO flag, with attacks replayed from a new trigger key. New options in Trol - True Form: Troll Model (on/off), Troll Model Size, Troll Attack Damage. --- JotunnModStub/Trol/TrolConfig.cs | 9 + JotunnModStub/Trol/TrolRace.cs | 22 +- JotunnModStub/Trol/TrolTrueFormBehavior.cs | 399 ++++++++++++++++++++ JotunnModStub/Trol/TrolTrueFormModel.cs | 407 +++++++++++++++++++++ 4 files changed, 835 insertions(+), 2 deletions(-) create mode 100644 JotunnModStub/Trol/TrolTrueFormBehavior.cs create mode 100644 JotunnModStub/Trol/TrolTrueFormModel.cs 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; + } + } + } +} From db29f868ea8f5dbb80c152310b5998afde9ac113 Mon Sep 17 00:00:00 2001 From: kanym Date: Wed, 14 Oct 2026 17:08:20 +0200 Subject: [PATCH 2/4] fix(trol): True Form troll size, log, reach, root during attacks, slam The troll pulsed several times a second and stayed small because PlayerVisualHider.Hide put the hidden Visual back to scale 1 every frame while Trol_PlayerUpdate_Patch grew it back, and the troll follows that scale. Hide and Show take keepScale now, and the Trol calls pass it. The camera height, which reads the same scale, stops jumping too. The log in the troll's hand is the troll's own log model, hung the way VisEquipment does it, instead of the Trol's, which was built for a person's hand and came out huge and sideways. Punch and slam reach further and hit wider, with a new Troll Attack Reach option (1.3). The player is held still through every attack clip, throw included. The ground slam spawns the troll's own troll_groundslam_aoe with the player's damage, kept off friends, plus its trigger and terrain effects. It carries chop and pickaxe at least equal to its blunt, so it breaks trees and rocks, and with Ground Slam Crater on it digs into the terrain where it lands, never inside a ward without access. --- JotunnModStub/PlayerVisualHider.cs | 12 +- JotunnModStub/Trol/TrolConfig.cs | 6 + JotunnModStub/Trol/TrolTrueFormBehavior.cs | 150 ++++++++++++++++++--- JotunnModStub/Trol/TrolTrueFormModel.cs | 53 ++++++-- 4 files changed, 189 insertions(+), 32 deletions(-) diff --git a/JotunnModStub/PlayerVisualHider.cs b/JotunnModStub/PlayerVisualHider.cs index 0f92cbf..6e753e5 100644 --- a/JotunnModStub/PlayerVisualHider.cs +++ b/JotunnModStub/PlayerVisualHider.cs @@ -37,14 +37,18 @@ namespace RacesOfValheim private float m_nextLog; private string m_context = ""; - public static void Hide(Transform playerVisual, string context) + /// Leave the Visual's scale alone. For a body that is meant to be + /// sized while hidden: the Trol's True Form troll stands as tall as the Visual does, and + /// resetting it here every frame fought Trol_PlayerUpdate_Patch growing it back - the troll + /// pulsed several times a second and never reached full size. + public static void Hide(Transform playerVisual, string context, bool keepScale = false) { if (playerVisual == null) return; // Undo the two older ways this body could have been hidden, so a form entered right // after one of those code paths still starts from a sane state. if (!playerVisual.gameObject.activeSelf) playerVisual.gameObject.SetActive(true); - if (playerVisual.localScale != Vector3.one) playerVisual.localScale = Vector3.one; + if (!keepScale && playerVisual.localScale != Vector3.one) playerVisual.localScale = Vector3.one; // Belt and braces: if anything else ever does deactivate the Visual, at least keep the // animator from snapping back to its spawn state. @@ -68,12 +72,12 @@ namespace RacesOfValheim } } - public static void Show(Transform playerVisual, string context) + public static void Show(Transform playerVisual, string context, bool keepScale = false) { if (playerVisual == null) return; if (!playerVisual.gameObject.activeSelf) playerVisual.gameObject.SetActive(true); - if (playerVisual.localScale != Vector3.one) playerVisual.localScale = Vector3.one; + if (!keepScale && playerVisual.localScale != Vector3.one) playerVisual.localScale = Vector3.one; PlayerVisualHider hider = playerVisual.GetComponent(); if (hider == null || !hider.enabled) return; diff --git a/JotunnModStub/Trol/TrolConfig.cs b/JotunnModStub/Trol/TrolConfig.cs index eaecaae..2588e9a 100644 --- a/JotunnModStub/Trol/TrolConfig.cs +++ b/JotunnModStub/Trol/TrolConfig.cs @@ -54,6 +54,8 @@ namespace RacesOfValheim public static ConfigEntry TrueFormUseTrollModel; public static ConfigEntry TrueFormModelSize; public static ConfigEntry TrueFormTrollDamageShare; + public static ConfigEntry TrueFormAttackReach; + public static ConfigEntry TrueFormSlamCrater; // ─── Log Weapon (tier 7+) ────────────────────────────────────────────── public static ConfigEntry LogWeaponMaxDurability; @@ -142,6 +144,10 @@ namespace RacesOfValheim 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))); + TrueFormAttackReach = config.Bind(trueForm, "Troll Attack Reach", 1.3f, + new ConfigDescription("Multiplies how far the troll's punch and slam reach and how wide they hit. 1 = a real troll's reach at the size you stand.", new AcceptableValueRange(0.5f, 3f))); + TrueFormSlamCrater = config.Bind(trueForm, "Ground Slam Crater", true, + new ConfigDescription("The ground slam digs into the ground where it lands, like a pickaxe blow. Never inside a ward you have no access to.")); const string logWeapon = "Trol - Log Weapon"; LogWeaponMaxDurability = config.Bind(logWeapon, "Max Durability", 6f, diff --git a/JotunnModStub/Trol/TrolTrueFormBehavior.cs b/JotunnModStub/Trol/TrolTrueFormBehavior.cs index 1e52a57..004f99c 100644 --- a/JotunnModStub/Trol/TrolTrueFormBehavior.cs +++ b/JotunnModStub/Trol/TrolTrueFormBehavior.cs @@ -33,6 +33,17 @@ namespace RacesOfValheim public bool IsAttacking => isAttacking; + private void SetAttacking(bool on) + { + isAttacking = on; + TrolTrueFormModel.LocalAttacking = on; + } + + private void OnDestroy() + { + TrolTrueFormModel.LocalAttacking = false; + } + private void Start() { anim = GetComponentInChildren(); @@ -54,7 +65,7 @@ namespace RacesOfValheim { Player player = Player.m_localPlayer; if (player == null) return; - PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-local"); + PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-local", keepScale: true); } private void Update() @@ -70,7 +81,7 @@ namespace RacesOfValheim if (FormAnimGuard.Stuck(isAttacking, ref busySince)) { StopAllCoroutines(); - isAttacking = false; + SetAttacking(false); } if (isAttacking || player.IsDead()) return; @@ -117,15 +128,15 @@ namespace RacesOfValheim private IEnumerator ThrowRoutine(TrolTrueFormModel.Profile profile) { - isAttacking = true; + SetAttacking(true); Fire(profile.Trigger); yield return WaitForClip(); - isAttacking = false; + SetAttacking(false); } private IEnumerator AttackRoutine(TrolTrueFormModel.Profile profile, bool log) { - isAttacking = true; + SetAttacking(true); Player player = Player.m_localPlayer; int baseline = TrolTrueFormModel.AttackEvents; @@ -140,8 +151,18 @@ namespace RacesOfValheim 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); + float scale = transform.localScale.x; + int landed; + if (profile.Type == Attack.AttackType.Area) + { + landed = TrolTrueFormHit.Slam(player, profile, scale); + } + else + { + profile.Shared.m_triggerEffect.Create(player.transform.position, player.transform.rotation, player.transform); + landed = TrolTrueFormHit.Sweep(player, profile, scale); + } + if (landed > 0) { player.RaiseSkill(Skills.SkillType.Clubs, 1f); @@ -150,7 +171,7 @@ namespace RacesOfValheim } yield return WaitForClip(Time.time - started); - isAttacking = false; + SetAttacking(false); } private void Fire(string trigger) @@ -206,24 +227,115 @@ namespace RacesOfValheim "piece_nonsolid", "terrain", "character", "character_net", "character_ghost", "hitbox", "character_noenv", "vehicle"); + private const string SlamAoeFallback = "troll_groundslam_aoe"; + private const string CraterPrefab = "digg_v3"; + + private static readonly int GroundMask = LayerMask.GetMask("terrain", "Default", "static_solid", "piece"); + + /// + /// The ground slam, done the way the troll does it: its attack's own spawn-on-trigger, the + /// troll_groundslam_aoe that carries the dust and the area hit. Set up with this player's + /// damage instead of the troll's (m_useAttackSettings) and kept off friends. The first + /// version swept a sphere and spawned nothing, so a slam that hit no creature looked like + /// nothing had happened at all. + /// + /// It also breaks things: the slam's damage gets chop and pickaxe at least equal to its + /// blunt, so trees, rocks and ore around the fists take the blow. With Ground Slam Crater on, + /// the ground gives way too - a pickaxe's dig, which TerrainOp does not check against wards on + /// its own, so the ward check is done here. + /// + /// 1 if the slam went off, so the caller raises the skill; the AoE does its own hits. + public static int Slam(Player player, TrolTrueFormModel.Profile profile, float costumeScale) + { + float range = Mathf.Max(2f, profile.Range * costumeScale * TrolConfig.TrueFormAttackReach.Value); + Vector3 impact = player.transform.position + player.transform.forward * (range * 0.5f); + + // Down onto whatever is under the fists, so the dust and the crater sit on the ground. + bool onTerrain = false; + if (Physics.Raycast(impact + Vector3.up * 3f, Vector3.down, out RaycastHit ground, 8f, GroundMask)) + { + impact = ground.point; + onTerrain = ground.collider != null && ground.collider.GetComponent() != null; + } + + HitData.DamageTypes damage = TrolTrueFormModel.DamageFor(player, profile); + damage.m_chop = Mathf.Max(damage.m_chop, damage.m_blunt); + damage.m_pickaxe = Mathf.Max(damage.m_pickaxe, damage.m_blunt); + + HitData hitData = new HitData(); + hitData.m_damage = damage; + 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); + + profile.Shared.m_triggerEffect.Create(impact, player.transform.rotation); + profile.Shared.m_hitTerrainEffect.Create(impact, Quaternion.identity); + + GameObject aoePrefab = profile.Shared.m_attack.m_spawnOnTrigger; + if (aoePrefab == null) aoePrefab = Jotunn.Managers.PrefabManager.Cache.GetPrefab(SlamAoeFallback); + + bool spawned = false; + if (aoePrefab != null) + { + GameObject instance = Object.Instantiate(aoePrefab, impact, Quaternion.identity); + Aoe aoe = instance.GetComponent(); + if (aoe != null) + { + aoe.m_useAttackSettings = true; + aoe.m_hitFriendly = false; + aoe.m_hitOwner = false; + aoe.m_hitProps = true; + aoe.m_radius = Mathf.Max(aoe.m_radius, range * 0.6f); + aoe.Setup(player, player.transform.forward, -1f, hitData, null, null); + spawned = true; + } + else + { + Object.Destroy(instance); + } + } + + // No Aoe to borrow: the sphere, centred on the impact, so the slam still hits. + if (!spawned) SphereHit(player, impact + Vector3.up, range * 0.7f, 180f, damage, profile); + + if (TrolConfig.TrueFormSlamCrater.Value && onTerrain && PrivateArea.CheckAccess(impact, 0f, false)) + { + GameObject crater = Jotunn.Managers.PrefabManager.Cache.GetPrefab(CraterPrefab); + if (crater != null) Object.Instantiate(crater, impact, Quaternion.identity); + } + + Jotunn.Logger.LogInfo($"[Trol] Ground slam: aoe '{aoePrefab?.name ?? "none"}' spawned={spawned}, " + + $"range {range:0.0}, onTerrain={onTerrain}."); + return 1; + } + /// 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; + float range = Mathf.Max(2f, profile.Range * costumeScale * TrolConfig.TrueFormAttackReach.Value); - 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); + Vector3 center = pos + forward * (range * 0.55f) + Vector3.up * Mathf.Max(1f, profile.Height * costumeScale); + float radius = range * 0.6f + 0.75f; + float halfAngle = Mathf.Max(75f, profile.Angle * 0.5f); + + return SphereHit(player, center, radius, halfAngle, TrolTrueFormModel.DamageFor(player, profile), profile); + } + + private static int SphereHit(Player player, Vector3 center, float radius, float halfAngle, + HitData.DamageTypes damage, TrolTrueFormModel.Profile profile) + { + Vector3 pos = player.transform.position; + Vector3 forward = player.transform.forward; 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; @@ -298,7 +410,7 @@ namespace RacesOfValheim private void LateUpdate() { if (player == null) return; - PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-remote"); + PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-remote", keepScale: true); } private void Update() @@ -381,7 +493,7 @@ namespace RacesOfValheim { existing.gameObject.SetActive(false); Object.Destroy(existing.gameObject); - PlayerVisualHider.Show(playerVisual, "trol-trueform-remote-revert"); + PlayerVisualHider.Show(playerVisual, "trol-trueform-remote-revert", keepScale: true); } return; } @@ -393,7 +505,7 @@ namespace RacesOfValheim model.AddComponent(); } - PlayerVisualHider.Hide(playerVisual, "trol-trueform-remote"); + PlayerVisualHider.Hide(playerVisual, "trol-trueform-remote", keepScale: true); } } } diff --git a/JotunnModStub/Trol/TrolTrueFormModel.cs b/JotunnModStub/Trol/TrolTrueFormModel.cs index 9748bf8..435d8f2 100644 --- a/JotunnModStub/Trol/TrolTrueFormModel.cs +++ b/JotunnModStub/Trol/TrolTrueFormModel.cs @@ -55,6 +55,10 @@ namespace RacesOfValheim public float PushForce; public int ToolTier; public ItemDrop.ItemData.SharedData Shared; + + // The weapon's own model, as VisEquipment would hang it in the troll's hand. Only the + // log swings have one worth showing. + public GameObject Attach; } private static readonly Dictionary profiles = new Dictionary(); @@ -69,6 +73,10 @@ namespace RacesOfValheim public static bool LocalActive => localModel != null; + /// True while the local troll is in the middle of a swing, a slam or a throw. + /// Trol_TrueFormHoldStill_Patch holds the player still for exactly that long. + public static bool LocalAttacking { get; set; } + /// 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; @@ -101,7 +109,7 @@ namespace RacesOfValheim if (localModel == null) return; localModel.AddComponent(); - PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-local"); + PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-local", keepScale: true); GameObject smoke = PrefabManager.Cache.GetPrefab("vfx_corpse_destruction_medium"); if (smoke != null) Object.Instantiate(smoke, player.transform.position + Vector3.up, Quaternion.identity); @@ -118,8 +126,9 @@ namespace RacesOfValheim localModel.SetActive(false); Object.Destroy(localModel); localModel = null; + LocalAttacking = false; - if (player != null) PlayerVisualHider.Show(player.transform.Find("Visual"), "trol-trueform-revert"); + if (player != null) PlayerVisualHider.Show(player.transform.Find("Visual"), "trol-trueform-revert", keepScale: true); return true; } @@ -253,17 +262,23 @@ namespace RacesOfValheim if (wanted == null || rightHandPath == null) return; Transform hand = model.transform.Find(rightHandPath); - Transform attach = itemPrefab.transform.Find("attach"); - if (hand == null || attach == null) return; + if (hand == null) return; - current = Object.Instantiate(attach.gameObject, hand); + // The troll's OWN log, not the Trol's. The Trol's was built for a person's hand - turned + // 90 degrees, pushed 1.5 m along it, scaled to 0.4 - and in the troll's fist that came + // out huge and pointing the wrong way. The troll's log weapon carries a model made for + // exactly this bone, and hanging it the way VisEquipment.AttachItem does (zero offset, + // no rotation, its own scale) puts it where vanilla puts it. + Profile log = Get(AttackKind.LogSwingH) ?? Get(AttackKind.LogSwingV); + GameObject source = log?.Attach; + if (source == null) return; + + current = Object.Instantiate(source, 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; + current.transform.localScale = source.transform.localScale; + foreach (Collider c in current.GetComponentsInChildren(true)) Object.Destroy(c); } // ─── Attacks ───────────────────────────────────────────────────────── @@ -316,6 +331,7 @@ namespace RacesOfValheim PushForce = shared.m_attackForce, ToolTier = shared.m_toolTier, Shared = shared, + Attach = weapon.transform.Find("attach")?.gameObject, }; profiles[kind.Value] = p; @@ -369,6 +385,25 @@ namespace RacesOfValheim // ─── Native attack loop, shut while the costume is on ──────────────── + /// + /// Holds the troll still through its own attack clips, the way vanilla roots a creature in + /// mid-swing. SkeletonRiseControlsPatch's arrangement: the move direction is the first + /// argument of SetControls, bound by position. + /// + [HarmonyPatch(typeof(Player), "SetControls")] + public static class Trol_TrueFormHoldStill_Patch + { + public static void Prefix(Player __instance, ref Vector3 __0, ref bool jump, ref bool crouch, ref bool dodge) + { + if (__instance != Player.m_localPlayer || !LocalActive || !LocalAttacking) return; + + __0 = Vector3.zero; + jump = false; + crouch = false; + dodge = false; + } + } + [HarmonyPatch(typeof(Humanoid), "StartAttack")] public static class Trol_TrueFormBlockNativeAttack_Patch { From a9e66aeeb7fd8122695fdab1d6817b815b7108ed Mon Sep 17 00:00:00 2001 From: kanym Date: Wed, 14 Oct 2026 17:17:20 +0200 Subject: [PATCH 3/4] fix(trol): True Form log visible, slam reaches the ground, skin tint The log in the troll's fist was there but switched off: an item's attach child is stored inactive in its prefab and VisEquipment turns it on after the Instantiate. It is now switched on, hung with the item's equipoffset, and sized to the costume, since AttachItem keeps an attach at its world size and the costume is not at scale 1. The slam never ran its slam code. troll_groundslam is a Vertical attack in vanilla, not Area, so asking the attack type sent every slam down the punch's sweep: damage, but no AoE, no dust and no crater. The slam now goes by the key that was pressed. The tint multiplied _Color, which the creature shader does not read. It now shifts _Hue, _Saturation and _Value, as LevelEffects does for starred creatures, by the distance from the vanilla troll's colour to the player's skin colour. --- JotunnModStub/Trol/TrolTrueFormBehavior.cs | 10 ++- JotunnModStub/Trol/TrolTrueFormModel.cs | 72 +++++++++++++++++++--- 2 files changed, 69 insertions(+), 13 deletions(-) diff --git a/JotunnModStub/Trol/TrolTrueFormBehavior.cs b/JotunnModStub/Trol/TrolTrueFormBehavior.cs index 004f99c..4cf4acd 100644 --- a/JotunnModStub/Trol/TrolTrueFormBehavior.cs +++ b/JotunnModStub/Trol/TrolTrueFormBehavior.cs @@ -109,7 +109,11 @@ namespace RacesOfValheim if (profile == null) return; bool log = kind == TrolTrueFormModel.AttackKind.LogSwingH || kind == TrolTrueFormModel.AttackKind.LogSwingV; - StartCoroutine(AttackRoutine(profile, log)); + // The slam goes by what the key means, not by the troll's attack type: troll_groundslam + // is a Vertical attack in vanilla, not an Area one, so asking the type sent every slam + // down the punch's sweep - no dust, no crater, only the damage. + bool slam = kind == TrolTrueFormModel.AttackKind.Slam && profile == TrolTrueFormModel.Get(TrolTrueFormModel.AttackKind.Slam); + StartCoroutine(AttackRoutine(profile, log, slam)); } /// @@ -134,7 +138,7 @@ namespace RacesOfValheim SetAttacking(false); } - private IEnumerator AttackRoutine(TrolTrueFormModel.Profile profile, bool log) + private IEnumerator AttackRoutine(TrolTrueFormModel.Profile profile, bool log, bool slam) { SetAttacking(true); Player player = Player.m_localPlayer; @@ -153,7 +157,7 @@ namespace RacesOfValheim { float scale = transform.localScale.x; int landed; - if (profile.Type == Attack.AttackType.Area) + if (slam) { landed = TrolTrueFormHit.Slam(player, profile, scale); } diff --git a/JotunnModStub/Trol/TrolTrueFormModel.cs b/JotunnModStub/Trol/TrolTrueFormModel.cs index 435d8f2..5437696 100644 --- a/JotunnModStub/Trol/TrolTrueFormModel.cs +++ b/JotunnModStub/Trol/TrolTrueFormModel.cs @@ -68,6 +68,8 @@ namespace RacesOfValheim private static float trollHeight = -1f; private static string rightHandPath; + private static readonly HashSet logged = new HashSet(); + private static GameObject localModel; private static int attackEvents; @@ -226,25 +228,48 @@ namespace RacesOfValheim return player == Player.m_localPlayer ? TrolConfig.SkinColor.Value : TrolConfig.DefaultSkinColor; } + // The vanilla forest troll's own colour, as near as a single swatch gets: the same value the + // Skin Color description recommends for "the look of Valheim's own trolls". + private static readonly Color VanillaTrollColor = new Color(0x7F / 255f, 0xA8 / 255f, 0xC9 / 255f, 1f); + /// - /// 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. + /// Shifts the troll's colour toward the player's skin colour, the way Valheim recolours a + /// starred creature: LevelEffects writes _Hue, _Saturation and _Value on the creature + /// shader. The first version multiplied _Color, which this shader does not read, so the + /// troll stayed vanilla blue. The shift is the distance from the vanilla troll's colour to + /// the chosen one, so the default Trol skin gives a troll close to its own colour and the + /// texture's shading survives whatever hue is picked. /// 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); + Color.RGBToHSV(VanillaTrollColor, out float baseH, out float baseS, out float baseV); + Color.RGBToHSV(skin, out float h, out float s, out float v); + float hue = Mathf.Repeat(h - baseH + 0.5f, 1f) - 0.5f; + float saturation = Mathf.Clamp(s - baseS, -1f, 1f); + // Value is halved: the swatch reads darker on the skin than it looks in the picker (the + // Skin Color description says as much), and a full shift took the troll to near black. + float value = Mathf.Clamp((v - baseV) * 0.5f, -1f, 1f); + + int tinted = 0; 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); + if (m == null || !m.HasProperty("_Hue")) continue; + m.SetFloat("_Hue", hue); + if (m.HasProperty("_Saturation")) m.SetFloat("_Saturation", saturation); + if (m.HasProperty("_Value")) m.SetFloat("_Value", value); + tinted++; } } + + if (logged.Add("tint/" + model.name)) + { + Jotunn.Logger.LogInfo($"[Trol] True Form tint: hue {hue:+0.00;-0.00}, saturation {saturation:+0.00;-0.00}, " + + $"value {value:+0.00;-0.00} on {tinted} material(s)."); + } } /// @@ -273,12 +298,39 @@ namespace RacesOfValheim GameObject source = log?.Attach; if (source == null) return; - current = Object.Instantiate(source, hand); + // An item's "attach" child is stored INACTIVE in its prefab; VisEquipment.AttachItem + // switches it on after the Instantiate. Copied as it was, the log hung in the fist + // switched off - invisible, and it looked as if the Trol held nothing. + current = Object.Instantiate(source); + current.SetActive(true); current.name = "TrolTrueFormLog"; + foreach (Collider c in current.GetComponentsInChildren(true)) Object.Destroy(c); + + // Hung the way AttachItem hangs it: on the joint at zero, then the item's equipoffset. + current.transform.SetParent(hand, false); current.transform.localPosition = Vector3.zero; current.transform.localRotation = Quaternion.identity; - current.transform.localScale = source.transform.localScale; - foreach (Collider c in current.GetComponentsInChildren(true)) Object.Destroy(c); + Transform offset = source.transform.parent != null ? source.transform.parent.Find("equipoffset") : null; + if (offset != null) + { + current.transform.localPosition += offset.position; + current.transform.localRotation *= offset.rotation; + } + + // AttachItem keeps the attach at its own WORLD size, and a vanilla troll stands at scale 1. + // This one is worn smaller or bigger, so the log takes the costume's share on top. Once + // set, the hand carries it through the grow and shrink like any child. + float handScale = hand.lossyScale.x; + float costume = model.transform.localScale.x; + current.transform.localScale = handScale > 0.0001f + ? source.transform.localScale * (costume / handScale) + : source.transform.localScale; + + if (logged.Add("log/" + source.name)) + { + Jotunn.Logger.LogInfo($"[Trol] True Form log '{log.Source}' in hand: hand scale {handScale:0.###}, " + + $"costume {costume:0.###}, offset {(offset != null ? "yes" : "no")}."); + } } // ─── Attacks ───────────────────────────────────────────────────────── From b2346c1437e44794b6e68cbc414553452a026c3b Mon Sep 17 00:00:00 2001 From: kanym Date: Sat, 17 Oct 2026 15:32:06 +0200 Subject: [PATCH 4/4] feat(trol): Legacy True Form switch, chosen per player The Troll Model option becomes Legacy True Form, off by default. On, True Form is the old one: the player's own Trol grown bigger, weapons in hand, body untouched, which player model mods such as VRM need. It is a local preference, not a synced one, so a server cannot force the troll costume on a VRM user. The owner publishes the choice on the ZDO and every other client reads it from there, so onlookers see each Trol the way that Trol's owner picked. --- JotunnModStub/ConfigSync.cs | 3 +++ JotunnModStub/Trol/TrolConfig.cs | 6 +++--- JotunnModStub/Trol/TrolTrueFormBehavior.cs | 3 ++- JotunnModStub/Trol/TrolTrueFormModel.cs | 13 ++++++++++++- 4 files changed, 20 insertions(+), 5 deletions(-) diff --git a/JotunnModStub/ConfigSync.cs b/JotunnModStub/ConfigSync.cs index 996168a..f743b4c 100644 --- a/JotunnModStub/ConfigSync.cs +++ b/JotunnModStub/ConfigSync.cs @@ -40,6 +40,9 @@ namespace RacesOfValheim private static readonly string[] LocalKeyParts = { "marker light", "tint", "colour", "color", "glow", "swarm scale", "log rounds", "debug", + // Each player picks their own True Form: a player model mod (VRM and the like) breaks + // under the troll costume, so a server cannot be allowed to force the costume on. + "legacy true form", }; public static void Apply(ConfigFile config) diff --git a/JotunnModStub/Trol/TrolConfig.cs b/JotunnModStub/Trol/TrolConfig.cs index 2588e9a..5521be7 100644 --- a/JotunnModStub/Trol/TrolConfig.cs +++ b/JotunnModStub/Trol/TrolConfig.cs @@ -51,7 +51,7 @@ namespace RacesOfValheim public static ConfigEntry TrueFormCooldown; public static ConfigEntry TrueFormScaleNormal; public static ConfigEntry TrueFormScaleAdvanced; - public static ConfigEntry TrueFormUseTrollModel; + public static ConfigEntry TrueFormLegacy; public static ConfigEntry TrueFormModelSize; public static ConfigEntry TrueFormTrollDamageShare; public static ConfigEntry TrueFormAttackReach; @@ -138,8 +138,8 @@ 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.")); + TrueFormLegacy = config.Bind(trueForm, "Legacy True Form", false, + new ConfigDescription("Off: True Form wears Valheim's own troll, with its punch and ground slam instead of your weapons. On: the old True Form, your own Trol grown bigger with weapons in hand. Turn it on if you use a player model mod such as VRM, which needs the player's body to stay visible. Your own choice: other players see you the way you picked.")); 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, diff --git a/JotunnModStub/Trol/TrolTrueFormBehavior.cs b/JotunnModStub/Trol/TrolTrueFormBehavior.cs index 4cf4acd..4e17311 100644 --- a/JotunnModStub/Trol/TrolTrueFormBehavior.cs +++ b/JotunnModStub/Trol/TrolTrueFormBehavior.cs @@ -483,7 +483,8 @@ namespace RacesOfValheim if (nview == null || !nview.IsValid()) return; ZDO zdo = nview.GetZDO(); - bool active = TrolConfig.TrueFormUseTrollModel.Value && + // The owner's choice, not this client's: see TrolTrueFormModel.LegacyKey. + bool active = !zdo.GetBool(TrolTrueFormModel.LegacyKey, false) && !player.IsDead() && zdo.GetString("RacesOfValheim_Race", "Human") == "Trol" && zdo.GetBool(Trol_PlayerUpdate_Patch.TrueFormKey, false); diff --git a/JotunnModStub/Trol/TrolTrueFormModel.cs b/JotunnModStub/Trol/TrolTrueFormModel.cs index 5437696..ef02c33 100644 --- a/JotunnModStub/Trol/TrolTrueFormModel.cs +++ b/JotunnModStub/Trol/TrolTrueFormModel.cs @@ -37,6 +37,10 @@ namespace RacesOfValheim // 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"; + + // The owner's Legacy True Form choice, so every other client draws this Trol the way its + // owner picked rather than the way the onlooker's own setting says. + public const string LegacyKey = "RacesOfValheim_TrolTrueFormLegacy"; private static int attackSeq; private static readonly int TrueFormHash = "SE_TrolTrueForm".GetStableHashCode(); @@ -96,7 +100,14 @@ namespace RacesOfValheim { if (player == null || player != Player.m_localPlayer) return; - bool wanted = TrolConfig.TrueFormUseTrollModel.Value && + bool legacy = TrolConfig.TrueFormLegacy.Value; + ZNetView nview = player.GetComponent(); + if (nview != null && nview.IsValid() && nview.GetZDO().GetBool(LegacyKey, false) != legacy) + { + nview.GetZDO().Set(LegacyKey, legacy); + } + + bool wanted = !legacy && !player.IsDead() && TrolRace.IsTrol() && player.GetSEMan().HaveStatusEffect(TrueFormHash);