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/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 2a152ae..5521be7 100644
--- a/JotunnModStub/Trol/TrolConfig.cs
+++ b/JotunnModStub/Trol/TrolConfig.cs
@@ -51,6 +51,11 @@ namespace RacesOfValheim
public static ConfigEntry TrueFormCooldown;
public static ConfigEntry TrueFormScaleNormal;
public static ConfigEntry TrueFormScaleAdvanced;
+ public static ConfigEntry TrueFormLegacy;
+ public static ConfigEntry TrueFormModelSize;
+ public static ConfigEntry TrueFormTrollDamageShare;
+ public static ConfigEntry TrueFormAttackReach;
+ public static ConfigEntry TrueFormSlamCrater;
// ─── Log Weapon (tier 7+) ──────────────────────────────────────────────
public static ConfigEntry LogWeaponMaxDurability;
@@ -133,6 +138,16 @@ 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)));
+ 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,
+ 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/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..4e17311
--- /dev/null
+++ b/JotunnModStub/Trol/TrolTrueFormBehavior.cs
@@ -0,0 +1,516 @@
+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 SetAttacking(bool on)
+ {
+ isAttacking = on;
+ TrolTrueFormModel.LocalAttacking = on;
+ }
+
+ private void OnDestroy()
+ {
+ TrolTrueFormModel.LocalAttacking = false;
+ }
+
+ 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", keepScale: true);
+ }
+
+ 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();
+ SetAttacking(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;
+ // 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));
+ }
+
+ ///
+ /// 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)
+ {
+ SetAttacking(true);
+ Fire(profile.Trigger);
+ yield return WaitForClip();
+ SetAttacking(false);
+ }
+
+ private IEnumerator AttackRoutine(TrolTrueFormModel.Profile profile, bool log, bool slam)
+ {
+ SetAttacking(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())
+ {
+ float scale = transform.localScale.x;
+ int landed;
+ if (slam)
+ {
+ 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);
+ if (log) WearLog(player);
+ }
+ }
+
+ yield return WaitForClip(Time.time - started);
+ SetAttacking(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");
+
+ 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(2f, profile.Range * costumeScale * TrolConfig.TrueFormAttackReach.Value);
+
+ 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);
+
+ 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", keepScale: true);
+ }
+
+ 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();
+ // 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);
+
+ 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", keepScale: true);
+ }
+ return;
+ }
+
+ if (existing == null)
+ {
+ GameObject model = TrolTrueFormModel.Spawn(player, TrolTrueFormModel.RemoteModelName);
+ if (model == null) return;
+ model.AddComponent();
+ }
+
+ PlayerVisualHider.Hide(playerVisual, "trol-trueform-remote", keepScale: true);
+ }
+ }
+}
diff --git a/JotunnModStub/Trol/TrolTrueFormModel.cs b/JotunnModStub/Trol/TrolTrueFormModel.cs
new file mode 100644
index 0000000..ef02c33
--- /dev/null
+++ b/JotunnModStub/Trol/TrolTrueFormModel.cs
@@ -0,0 +1,505 @@
+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";
+
+ // 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();
+
+ 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;
+
+ // 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();
+ 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 readonly HashSet logged = new HashSet();
+
+ private static GameObject localModel;
+ private static int attackEvents;
+
+ 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;
+
+ 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 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);
+
+ 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", keepScale: true);
+
+ 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;
+ LocalAttacking = false;
+
+ if (player != null) PlayerVisualHider.Show(player.transform.Find("Visual"), "trol-trueform-revert", keepScale: true);
+ 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;
+ }
+
+ // 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);
+
+ ///
+ /// 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)
+ {
+ 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("_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).");
+ }
+ }
+
+ ///
+ /// 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);
+ if (hand == null) return;
+
+ // 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;
+
+ // 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;
+ 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 ─────────────────────────────────────────────────────────
+
+ 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,
+ Attach = weapon.transform.Find("attach")?.gameObject,
+ };
+ 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 ────────────────
+
+ ///
+ /// 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
+ {
+ 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;
+ }
+ }
+ }
+}