From 5cf1ae7fb0a4e30a8a30027821c09b3aa33e5c63 Mon Sep 17 00:00:00 2001 From: kanym Date: Sat, 17 Oct 2026 19:42:14 +0200 Subject: [PATCH 1/5] fix(sverm): the Ravager costume no longer keeps a live Humanoid The BepInEx log showed "Can't remove Humanoid (Script) because CharacterDrop (Script) depends on it" right after the Ravager template was built from SeekerBrute. The strip was one pass in component order, and Unity refuses to destroy a component another still requires, so the Brute's Humanoid survived on the costume and on every copy a player wore: the leftover that once broke the hammer for every piece. ModelBorrow.StripBehaviours destroys only what nothing remaining requires through [RequireComponent], round after round, and logs any survivor by name. Used by the Ravager template, by ModelBorrow.Attach and by the Skeleton's rise costume, which had the same single pass. --- JotunnModStub/ModelBorrow.cs | 66 +++++++++++++++++++++++-- JotunnModStub/Skeleton/SkeletonRise.cs | 6 +-- JotunnModStub/Sverm/SvermRavagerForm.cs | 7 ++- 3 files changed, 67 insertions(+), 12 deletions(-) diff --git a/JotunnModStub/ModelBorrow.cs b/JotunnModStub/ModelBorrow.cs index 20b2ded..1bd8fd2 100644 --- a/JotunnModStub/ModelBorrow.cs +++ b/JotunnModStub/ModelBorrow.cs @@ -96,10 +96,7 @@ namespace RacesOfValheim // Everything that is not a Renderer or a Transform. Order matters for the same reason it did // on the Aswid's lights: behaviours first, then the things they hold references to. - foreach (MonoBehaviour behaviour in copy.GetComponentsInChildren(true)) - { - if (behaviour != null) Object.DestroyImmediate(behaviour); - } + StripBehaviours(copy, label); foreach (Collider collider in copy.GetComponentsInChildren(true)) { if (collider != null) Object.DestroyImmediate(collider); @@ -119,6 +116,67 @@ namespace RacesOfValheim return holder; } + /// + /// Destroys every MonoBehaviour under , dependents first. + /// + /// A single pass in component order is not enough, and the log said so: "Can't remove Humanoid + /// (Script) because CharacterDrop (Script) depends on it". Unity refuses to destroy a component + /// another one still requires through [RequireComponent], so the pass that reached Humanoid + /// before CharacterDrop left a live Humanoid on the Sverm's Ravager costume - on every player + /// wearing it - which is the leftover that once broke the hammer for every piece (see + /// SvermHive.MouthCandidates). Each round here destroys only what nothing remaining requires, + /// and rounds repeat until nothing is left or nothing more can go. + /// + public static void StripBehaviours(GameObject root, string label) + { + if (root == null) return; + + for (int round = 0; round < 16; round++) + { + MonoBehaviour[] left = root.GetComponentsInChildren(true); + if (left.Length == 0) return; + + int destroyed = 0; + foreach (MonoBehaviour behaviour in left) + { + if (behaviour == null || IsRequired(behaviour)) continue; + Object.DestroyImmediate(behaviour); + destroyed++; + } + if (destroyed == 0) break; + } + + foreach (MonoBehaviour survivor in root.GetComponentsInChildren(true)) + { + if (survivor != null) + { + Jotunn.Logger.LogWarning($"[{label}] '{survivor.GetType().Name}' on '{survivor.name}' could not be stripped from a borrowed model."); + } + } + } + + /// True if another component on the same GameObject names this one's type in a + /// [RequireComponent]. + private static bool IsRequired(Component target) + { + System.Type type = target.GetType(); + foreach (Component other in target.GetComponents()) + { + if (other == null || other == target) continue; + foreach (object attribute in other.GetType().GetCustomAttributes(typeof(RequireComponent), true)) + { + RequireComponent require = (RequireComponent)attribute; + if (Requires(require.m_Type0, type) || Requires(require.m_Type1, type) || Requires(require.m_Type2, type)) + { + return true; + } + } + } + return false; + } + + private static bool Requires(System.Type required, System.Type type) => required != null && required.IsAssignableFrom(type); + /// /// How tall the borrowed model actually turned out, in the holder's parent's space. Used to stack /// one borrowed model on top of another without a magic offset. diff --git a/JotunnModStub/Skeleton/SkeletonRise.cs b/JotunnModStub/Skeleton/SkeletonRise.cs index d44cd75..7e9827b 100644 --- a/JotunnModStub/Skeleton/SkeletonRise.cs +++ b/JotunnModStub/Skeleton/SkeletonRise.cs @@ -125,10 +125,8 @@ namespace RacesOfValheim // Everything that is not a Renderer, a Transform or the Animator. Animator is a Behaviour, // not a MonoBehaviour, so the first loop never touches it. - foreach (MonoBehaviour behaviour in copy.GetComponentsInChildren(true)) - { - if (behaviour != null) Object.DestroyImmediate(behaviour); - } + // Dependents first, so a Humanoid held down by CharacterDrop cannot survive on the copy. + ModelBorrow.StripBehaviours(copy, "Skeleton"); foreach (Collider collider in copy.GetComponentsInChildren(true)) { if (collider != null) Object.DestroyImmediate(collider); diff --git a/JotunnModStub/Sverm/SvermRavagerForm.cs b/JotunnModStub/Sverm/SvermRavagerForm.cs index f41b7f0..d9b21a7 100644 --- a/JotunnModStub/Sverm/SvermRavagerForm.cs +++ b/JotunnModStub/Sverm/SvermRavagerForm.cs @@ -103,10 +103,9 @@ namespace RacesOfValheim // Everything that is not a Renderer or a Transform. Animator is a Behaviour, not a // MonoBehaviour, so it is never touched by the first loop and survives on purpose - // it is the one live thing this costume is allowed to keep. - foreach (MonoBehaviour behaviour in copy.GetComponentsInChildren(true)) - { - if (behaviour != null) Object.DestroyImmediate(behaviour); - } + // Dependents first: a single pass left the Brute's Humanoid on the costume, because + // CharacterDrop requires it and came later. See ModelBorrow.StripBehaviours. + ModelBorrow.StripBehaviours(copy, "Sverm"); foreach (Collider collider in copy.GetComponentsInChildren(true)) { if (collider != null) Object.DestroyImmediate(collider); From 1c2da77603fd619e1c69d57c7a2ee0c621c65bb5 Mon Sep 17 00:00:00 2001 From: kanym Date: Sat, 17 Oct 2026 19:51:33 +0200 Subject: [PATCH 2/5] fix(sverm): the Ravager stands still to attack and its slam digs The hidden player kept walking under the costume, so every swing slid toward whatever WASD held. A SetControls prefix holds it still while an attack runs, as Fenrir and the True Form troll do. The middle-click slam now digs a crater on bare terrain (digg_v3), never inside a ward without access, behind a new Ground Slam Crater option. --- JotunnModStub/Sverm/SvermConfigManagement.cs | 6 ++ JotunnModStub/Sverm/SvermRavagerForm.cs | 63 ++++++++++++++++++-- 2 files changed, 64 insertions(+), 5 deletions(-) diff --git a/JotunnModStub/Sverm/SvermConfigManagement.cs b/JotunnModStub/Sverm/SvermConfigManagement.cs index a2627f8..a25aec9 100644 --- a/JotunnModStub/Sverm/SvermConfigManagement.cs +++ b/JotunnModStub/Sverm/SvermConfigManagement.cs @@ -45,6 +45,7 @@ namespace RacesOfValheim public static ConfigEntry RavagerScaleMultiplier; public static ConfigEntry RavagerYawDegrees; public static ConfigEntry RavagerAttackOffsetValue; + public static ConfigEntry RavagerSlamCraterValue; // ─── Colony caps ───────────────────────────────────────────────────── // Every ceiling on how many things the colony can have alive at once, in one section, so @@ -226,6 +227,10 @@ namespace RacesOfValheim "Raise it if a swing visibly connects short of the model's mouth/claws; lower it " + "if it connects well past them."); + RavagerSlamCraterValue = config.Bind(ravager, "Ground Slam Crater", true, + "The middle-click slam digs into the ground where it lands, like a pickaxe blow. " + + "Never inside a ward you have no access to."); + EmberGlowStrength = config.Bind(ember, "Glow Strength", SvermConfig.EmberGlowStrength, "How hot the chitin burns at Fader. This multiplies an HDR colour and it is applied " + "to the chest, the legs and the helmet at once, so it goes a very long way. Settled " + @@ -358,6 +363,7 @@ namespace RacesOfValheim public static float RavagerScale => RavagerScaleMultiplier?.Value ?? 1f; public static float RavagerYaw => RavagerYawDegrees?.Value ?? 0f; public static float RavagerAttackOffset => RavagerAttackOffsetValue?.Value ?? 1.5f; + public static bool RavagerSlamCrater => RavagerSlamCraterValue?.Value ?? true; public static bool Spines => SpinesEnabled?.Value ?? false; public static float SizeSmall => SpineSizeSmall?.Value ?? SvermConfig.SpineSizeSmall; diff --git a/JotunnModStub/Sverm/SvermRavagerForm.cs b/JotunnModStub/Sverm/SvermRavagerForm.cs index d9b21a7..68caf14 100644 --- a/JotunnModStub/Sverm/SvermRavagerForm.cs +++ b/JotunnModStub/Sverm/SvermRavagerForm.cs @@ -28,6 +28,10 @@ namespace RacesOfValheim { public static bool IsActive { get; private set; } + /// True while the local Brute is inside a swing or the roar. + /// Sverm_RavagerHoldStill_Patch holds the player still for exactly that long. + public static bool LocalAttacking { get; set; } + // Read by Sverm_RavagerRemoteVisuals_Patch (SvermPatches.cs) so every other client can // tell the form is up at all - without this the whole thing was local-only, exactly like // DrakeFormBehavior's flight flag and Fenrir's own form key, and other players saw nothing @@ -302,6 +306,7 @@ namespace RacesOfValheim private static void Exit(Player player, bool spendCooldown) { IsActive = false; + LocalAttacking = false; ZNetView exitNview = player.GetComponent(); if (exitNview != null && exitNview.IsValid()) exitNview.GetZDO().Set(ActiveKey, false); @@ -471,6 +476,30 @@ namespace RacesOfValheim /// equipped never swings and never deals damage while this is up; RavagerFormBehavior's /// own coroutines are the only thing that can land a hit. /// + /// + /// Holds the Brute still through its attack clips, the way Fenrir_FormHoldStill_Patch and + /// Trol_TrueFormHoldStill_Patch do for their forms. The hidden player kept walking under the + /// costume, so a bite or a slam slid toward whatever WASD held. + /// + [HarmonyPatch(typeof(Player), "SetControls")] + public static class Sverm_RavagerHoldStill_Patch + { + public static void Prefix(Player __instance, ref Vector3 __0, ref bool jump, ref bool crouch, ref bool dodge) + { + if (__instance != Player.m_localPlayer || !LocalAttacking) return; + if (!IsActive) + { + LocalAttacking = false; + return; + } + + __0 = Vector3.zero; + jump = false; + crouch = false; + dodge = false; + } + } + [HarmonyPatch(typeof(Humanoid), "StartAttack")] public static class Sverm_RavagerBlockNativeAttack_Patch { @@ -545,7 +574,8 @@ namespace RacesOfValheim // gate FenrirFormBehavior's own isAttacking flag uses, and the direct answer to "the // animation has to finish before the Brute can move": nothing here can start moving the // model again, or start a second attack, until the coroutine below clears it. - private bool isAttacking; + private bool isAttacking { get => attacking; set { attacking = value; SvermRavagerForm.LocalAttacking = value; } } + private bool attacking; // The taunt's own cooldown - short, and tracked separately from the other three, which // have no cooldown of their own beyond their own lock duration. @@ -655,15 +685,15 @@ namespace RacesOfValheim // be the only reliable option. if (RaceInput.AttackDown(1)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Ram, 2f, 0.3f, 0.7f)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Ram, 2f, 0.3f, 0.7f, false)); } else if (RaceInput.AttackDown(0)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Bite, 2f, 0.3f, 0.6f)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Bite, 2f, 0.3f, 0.6f, false)); } else if (RaceInput.AttackDown(2)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Slam, 1.2f, 0.4f, 1.0f)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Slam, 1.2f, 0.4f, 1.0f, true)); } else if ((SvermConfigManagement.RavagerKey.Value.IsDown() || RaceInput.ConsumePress(SvermConfigManagement.RavagerKey.Value)) && Time.time >= nextTauntAt) @@ -680,7 +710,7 @@ namespace RacesOfValheim /// (SvermRavagerAttacks) instead of one tuned float. /// private System.Collections.IEnumerator AttackRoutine(SvermRavagerAttacks.Profile profile, float radius, - float hitDelay, float lockDuration) + float hitDelay, float lockDuration, bool digs) { isAttacking = true; @@ -695,6 +725,7 @@ namespace RacesOfValheim yield return new WaitForSeconds(hitDelay); ExecuteDamage(profile, radius); + if (digs) DigCrater(); float remaining = lockDuration - hitDelay; if (remaining > 0f) yield return new WaitForSeconds(remaining); @@ -768,6 +799,28 @@ namespace RacesOfValheim ApplyDamageInSphere(attackPoint, radius, profile.Damage); } + private const string CraterPrefab = "digg_v3"; + private static readonly int GroundMask = LayerMask.GetMask("terrain", "Default", "static_solid", "piece"); + + /// + /// The slam digs where it lands, the way the True Form troll's does (TrolTrueFormBehavior.Slam): + /// a pickaxe's dig on bare terrain only. TerrainOp does not check wards on its own, so the + /// ward check is done here. + /// + private static void DigCrater() + { + Player player = Player.m_localPlayer; + if (player == null || !SvermConfigManagement.RavagerSlamCrater) return; + + Vector3 impact = player.transform.position + player.transform.forward * SvermConfigManagement.RavagerAttackOffset; + if (!Physics.Raycast(impact + Vector3.up * 3f, Vector3.down, out RaycastHit ground, 8f, GroundMask)) return; + if (ground.collider == null || ground.collider.GetComponent() == null) return; + if (!PrivateArea.CheckAccess(ground.point, 0f, false)) return; + + GameObject crater = Jotunn.Managers.PrefabManager.Cache.GetPrefab(CraterPrefab); + if (crater != null) Object.Instantiate(crater, ground.point, Quaternion.identity); + } + /// /// The actual sweep, shared by every attack this form has (the three forward swings and /// the taunt's own AoE) - only the sphere's centre and radius differ between them. From 61a74320c5bfccf7b6e5bfc1c94be1055d28aed7 Mon Sep 17 00:00:00 2001 From: kanym Date: Sat, 17 Oct 2026 20:05:36 +0200 Subject: [PATCH 3/5] fix(sverm): Ravager attacks follow the Brute's clips; the slam hits once per claw Hits land on the clip's own Hit events and the hold-still lasts until the animator leaves the attack state, instead of fixed delays. The slam has two Hit events, one per claw: each one hits and digs under the claw that came down. --- JotunnModStub/Sverm/SvermRavagerForm.cs | 219 +++++++++++++++++++----- 1 file changed, 176 insertions(+), 43 deletions(-) diff --git a/JotunnModStub/Sverm/SvermRavagerForm.cs b/JotunnModStub/Sverm/SvermRavagerForm.cs index 68caf14..01ad562 100644 --- a/JotunnModStub/Sverm/SvermRavagerForm.cs +++ b/JotunnModStub/Sverm/SvermRavagerForm.cs @@ -585,8 +585,19 @@ namespace RacesOfValheim // present, so PlayAttack does not pass a name to SetTrigger the controller cannot use. private readonly System.Collections.Generic.HashSet knownTriggers = new System.Collections.Generic.HashSet(); + // The two front claws (bone names read from the SeekerBrute prefab with UnityPy). The slam + // brings one down, then the other; each Hit lands under whichever claw just came down. + private Transform leftClaw; + private Transform rightClaw; + private void Start() { + foreach (Transform bone in GetComponentsInChildren(true)) + { + if (bone.name == "l.frontfoot") leftClaw = bone; + else if (bone.name == "r.frontfoot") rightClaw = bone; + } + anim = GetComponentInChildren(); if (anim == null || anim.runtimeAnimatorController == null) return; @@ -685,15 +696,15 @@ namespace RacesOfValheim // be the only reliable option. if (RaceInput.AttackDown(1)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Ram, 2f, 0.3f, 0.7f, false)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Ram, "Attack Ram", 2f, false)); } else if (RaceInput.AttackDown(0)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Bite, 2f, 0.3f, 0.6f, false)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Bite, "Attack Bite", 2f, false)); } else if (RaceInput.AttackDown(2)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Slam, 1.2f, 0.4f, 1.0f, true)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Slam, "Attack Slam", 1.2f, true)); } else if ((SvermConfigManagement.RavagerKey.Value.IsDown() || RaceInput.ConsumePress(SvermConfigManagement.RavagerKey.Value)) && Time.time >= nextTauntAt) @@ -704,31 +715,33 @@ namespace RacesOfValheim } /// - /// One swing: play the clip, wait for the moment it should land, hit whatever is there, - /// then hold isAttacking until the swing is fully spent. FenrirFormBehavior.ClawRoutine in - /// every particular except the damage itself, which here is the Brute's own real numbers - /// (SvermRavagerAttacks) instead of one tuned float. + /// One swing, timed by the clip itself instead of by fixed delays. Each "Hit" animation + /// event in the clip is a hit here, at the same point of the clip (the bite and the ram + /// have one, the slam has two, one per claw). The player is held still until the + /// animator starts blending out of the attack state, which is when the real Brute can + /// move again. /// - private System.Collections.IEnumerator AttackRoutine(SvermRavagerAttacks.Profile profile, float radius, - float hitDelay, float lockDuration, bool digs) + private System.Collections.IEnumerator AttackRoutine(SvermRavagerAttacks.Profile profile, string stateName, + float radius, bool slam) { isAttacking = true; + bool played = StartAttackState(profile); - if (hasForwardSpeed) anim.SetFloat("forward_speed", 0f); + int dropSamples = 0; + float[] leftY = new float[ClawHistory]; + float[] rightY = new float[ClawHistory]; - if (!string.IsNullOrEmpty(profile.Trigger) && knownTriggers.Contains(profile.Trigger)) + yield return FollowAttackState(stateName, played, 0f, () => { - anim.SetTrigger(profile.Trigger); - SvermRavagerForm.PublishAttackTrigger(Player.m_localPlayer, profile.Trigger); - } - - yield return new WaitForSeconds(hitDelay); - - ExecuteDamage(profile, radius); - if (digs) DigCrater(); - - float remaining = lockDuration - hitDelay; - if (remaining > 0f) yield return new WaitForSeconds(remaining); + if (slam) Slam(profile, radius, leftY, rightY, dropSamples); + else ExecuteDamage(profile, radius); + }, () => + { + if (leftClaw == null || rightClaw == null) return; + leftY[dropSamples % ClawHistory] = leftClaw.position.y; + rightY[dropSamples % ClawHistory] = rightClaw.position.y; + dropSamples++; + }); isAttacking = false; } @@ -738,37 +751,159 @@ namespace RacesOfValheim /// swing - the roar reaches out in every direction, so the sphere is centred on the /// player instead of offset ahead of them the way AttackRoutine's three do. Deliberately /// silent: no message, no status effect, nothing in a corner of the screen - just the - /// animation, the sound if one resolves, and the hit. + /// animation, the sound if one resolves, and the hit. The clip has no Hit event, so the + /// roar lands at TauntHitPoint of the clip. /// private System.Collections.IEnumerator TauntRoutine() { isAttacking = true; SvermRavagerAttacks.Profile profile = SvermRavagerAttacks.Taunt; - - if (hasForwardSpeed) anim.SetFloat("forward_speed", 0f); - - if (!string.IsNullOrEmpty(profile.Trigger) && knownTriggers.Contains(profile.Trigger)) - { - anim.SetTrigger(profile.Trigger); - SvermRavagerForm.PublishAttackTrigger(Player.m_localPlayer, profile.Trigger); - } + bool played = StartAttackState(profile); PlaySound(SvermConfig.RavagerTauntSoundEffects); - yield return new WaitForSeconds(0.3f); - - Player player = Player.m_localPlayer; - if (player != null) + yield return FollowAttackState("Taunt", played, TauntHitPoint, () => { - ApplyDamageInSphere(player.transform.position + Vector3.up, SvermConfig.RavagerTauntRadius, profile.Damage); - } - - yield return new WaitForSeconds(0.4f); + Player player = Player.m_localPlayer; + if (player != null) + ApplyDamageInSphere(player.transform.position + Vector3.up, SvermConfig.RavagerTauntRadius, profile.Damage); + }, null); isAttacking = false; } + // 0.3 s into the 2.67 s taunt clip, where the old fixed delay put the roar's hit. + private const float TauntHitPoint = 0.11f; + + // Frames of claw height kept to tell which claw just came down (about 0.2 s at 60 fps). + private const int ClawHistory = 12; + + private bool StartAttackState(SvermRavagerAttacks.Profile profile) + { + if (hasForwardSpeed) anim.SetFloat("forward_speed", 0f); + + if (string.IsNullOrEmpty(profile.Trigger) || !knownTriggers.Contains(profile.Trigger)) return false; + + anim.SetTrigger(profile.Trigger); + SvermRavagerForm.PublishAttackTrigger(Player.m_localPlayer, profile.Trigger); + return true; + } + + /// + /// Waits out one attack state frame by frame. Calls onHit at every Hit event of the + /// state's clip (or once at fallbackHit, a 0-1 point of the clip, when the clip has + /// none), and returns once the animator starts leaving the state. If the state never + /// starts (trigger missing), it hits once and returns, so the attack still works. + /// + private System.Collections.IEnumerator FollowAttackState(string stateName, bool played, float fallbackHit, + System.Action onHit, System.Action eachFrame) + { + float startedAt = Time.time; + bool entered = false; + float[] hits = null; + int nextHit = 0; + + while (played && Time.time - startedAt < 8f) + { + eachFrame?.Invoke(); + + AnimatorStateInfo state; + AnimatorClipInfo[] clips; + bool leaving; + if (!TryGetAttackState(stateName, out state, out clips, out leaving)) + { + if (entered || Time.time - startedAt > 0.5f) break; + yield return null; + continue; + } + + entered = true; + if (hits == null) hits = ReadHitPoints(clips, fallbackHit); + + while (nextHit < hits.Length && state.normalizedTime >= hits[nextHit]) + { + onHit(); + nextHit++; + } + + if (leaving) break; + yield return null; + } + + if (!entered) onHit(); + } + + private bool TryGetAttackState(string stateName, out AnimatorStateInfo state, out AnimatorClipInfo[] clips, out bool leaving) + { + state = anim.GetCurrentAnimatorStateInfo(0); + if (state.IsName(stateName)) + { + clips = anim.GetCurrentAnimatorClipInfo(0); + leaving = anim.IsInTransition(0); + return true; + } + + leaving = false; + if (anim.IsInTransition(0)) + { + state = anim.GetNextAnimatorStateInfo(0); + if (state.IsName(stateName)) + { + clips = anim.GetNextAnimatorClipInfo(0); + return true; + } + } + + clips = null; + return false; + } + + private static float[] ReadHitPoints(AnimatorClipInfo[] clips, float fallbackHit) + { + var points = new System.Collections.Generic.List(); + if (clips != null && clips.Length > 0 && clips[0].clip != null && clips[0].clip.length > 0f) + { + AnimationClip clip = clips[0].clip; + foreach (AnimationEvent ev in clip.events) + if (ev.functionName == "Hit") points.Add(ev.time / clip.length); + } + + if (points.Count == 0) points.Add(fallbackHit); + points.Sort(); + return points.ToArray(); + } + + /// + /// One claw of the slam landing: the claw that dropped the most over the last few frames + /// is the one that just struck. Damage and crater go under it, not at a fixed point ahead. + /// + private void Slam(SvermRavagerAttacks.Profile profile, float radius, float[] leftY, float[] rightY, int samples) + { + Transform claw = StrikingClaw(leftY, rightY, samples); + if (claw == null) + { + ExecuteDamage(profile, radius); + Player player = Player.m_localPlayer; + if (player != null) + DigCrater(player.transform.position + player.transform.forward * SvermConfigManagement.RavagerAttackOffset); + return; + } + + ApplyDamageInSphere(claw.position + Vector3.up * 0.5f, radius, profile.Damage); + DigCrater(claw.position); + } + + private Transform StrikingClaw(float[] leftY, float[] rightY, int samples) + { + if (leftClaw == null || rightClaw == null || samples == 0) return null; + + int oldest = samples < ClawHistory ? 0 : samples % ClawHistory; + float leftDrop = leftY[oldest] - leftClaw.position.y; + float rightDrop = rightY[oldest] - rightClaw.position.y; + return leftDrop >= rightDrop ? leftClaw : rightClaw; + } + /// Tries each candidate in order and plays the first that resolves, same as SvermRavagerForm.PlayEffect. private static void PlaySound(string[] candidates) { @@ -807,12 +942,10 @@ namespace RacesOfValheim /// a pickaxe's dig on bare terrain only. TerrainOp does not check wards on its own, so the /// ward check is done here. /// - private static void DigCrater() + private static void DigCrater(Vector3 impact) { - Player player = Player.m_localPlayer; - if (player == null || !SvermConfigManagement.RavagerSlamCrater) return; + if (Player.m_localPlayer == null || !SvermConfigManagement.RavagerSlamCrater) return; - Vector3 impact = player.transform.position + player.transform.forward * SvermConfigManagement.RavagerAttackOffset; if (!Physics.Raycast(impact + Vector3.up * 3f, Vector3.down, out RaycastHit ground, 8f, GroundMask)) return; if (ground.collider == null || ground.collider.GetComponent() == null) return; if (!PrivateArea.CheckAccess(ground.point, 0f, false)) return; From d05cea7f083ef7482afa8056935ff8ce56f3d916 Mon Sep 17 00:00:00 2001 From: kanym Date: Sat, 17 Oct 2026 20:24:43 +0200 Subject: [PATCH 4/5] fix(warvulture): strip dependents first, no more Can't remove Humanoid at startup The startup error came from WarVultureVisual.BuildTemplate, not from the Ravager costume: its passes tried Humanoid before CharacterDrop. Components another one still requires now wait for a later pass. --- JotunnModStub/ModelBorrow.cs | 2 +- JotunnModStub/WarVulture/WarVultureItem.cs | 1 + JotunnModStub/WarVulture/WarVultureVisual.cs | 9 +++++++++ 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/JotunnModStub/ModelBorrow.cs b/JotunnModStub/ModelBorrow.cs index 1bd8fd2..08a777b 100644 --- a/JotunnModStub/ModelBorrow.cs +++ b/JotunnModStub/ModelBorrow.cs @@ -157,7 +157,7 @@ namespace RacesOfValheim /// True if another component on the same GameObject names this one's type in a /// [RequireComponent]. - private static bool IsRequired(Component target) + public static bool IsRequired(Component target) { System.Type type = target.GetType(); foreach (Component other in target.GetComponents()) diff --git a/JotunnModStub/WarVulture/WarVultureItem.cs b/JotunnModStub/WarVulture/WarVultureItem.cs index 7b735fa..74fc487 100644 --- a/JotunnModStub/WarVulture/WarVultureItem.cs +++ b/JotunnModStub/WarVulture/WarVultureItem.cs @@ -229,6 +229,7 @@ namespace RacesOfValheim if (component is MeshFilter) continue; if (component is MeshRenderer) continue; if (component is SkinnedMeshRenderer) continue; + if (ModelBorrow.IsRequired(component)) continue; // a later pass, once its dependent is gone Object.DestroyImmediate(component); diff --git a/JotunnModStub/WarVulture/WarVultureVisual.cs b/JotunnModStub/WarVulture/WarVultureVisual.cs index cf42a91..1a944f9 100644 --- a/JotunnModStub/WarVulture/WarVultureVisual.cs +++ b/JotunnModStub/WarVulture/WarVultureVisual.cs @@ -118,6 +118,15 @@ namespace RacesOfValheim if (component == null) continue; if (IsKept(component)) continue; + // Not yet if something still requires it: Unity would refuse and log an error + // ("Can't remove Humanoid because CharacterDrop depends on it"). It goes on a + // later pass, once its dependent is gone. + if (ModelBorrow.IsRequired(component)) + { + stubborn++; + continue; + } + Object.DestroyImmediate(component); if (component == null) destroyedSomething = true; From 63e252d9e94e08ffe2a6468fca01a7e0efd9f376 Mon Sep 17 00:00:00 2001 From: kanym Date: Sat, 17 Oct 2026 20:24:43 +0200 Subject: [PATCH 5/5] feat(sverm): the Ravager's ram lunges with the clip's root motion Vanilla only takes root motion during a native attack, which this form never starts, so a relay on the costume's Animator collects it and a prefix on Character.ApplyRootMotion applies it to the player the same way (x55). --- JotunnModStub/Sverm/SvermRavagerForm.cs | 69 +++++++++++++++++++++++-- 1 file changed, 64 insertions(+), 5 deletions(-) diff --git a/JotunnModStub/Sverm/SvermRavagerForm.cs b/JotunnModStub/Sverm/SvermRavagerForm.cs index 01ad562..bee58bb 100644 --- a/JotunnModStub/Sverm/SvermRavagerForm.cs +++ b/JotunnModStub/Sverm/SvermRavagerForm.cs @@ -500,6 +500,37 @@ namespace RacesOfValheim } } + /// The ram clip's own forward motion, collected by RavagerRootMotionRelay and + /// spent by Sverm_RavagerRootMotion_Patch. + public static Vector3 PendingRootMotion; + + /// + /// Moves the player by the ram clip's root motion, the way vanilla moves a charging Brute. + /// Vanilla's own path (CharacterAnimEvent.OnAnimatorMove into Character.AddRootMotion) only + /// takes motion while Character.InAttack(), and this form never starts a native attack, so + /// the motion comes in here instead and is applied exactly as Character.ApplyRootMotion + /// applies it: delta times 55, used when it is faster than the walk velocity. + /// + [HarmonyPatch(typeof(Character), "ApplyRootMotion")] + public static class Sverm_RavagerRootMotion_Patch + { + public static void Prefix(Character __instance, ref Vector3 vel) + { + if (__instance != Player.m_localPlayer) return; + + Vector3 motion = PendingRootMotion; + PendingRootMotion = Vector3.zero; + if (!IsActive || !LocalAttacking) return; + + Vector3 push = motion * 55f; + push.y = 0f; + if (push.magnitude > new Vector3(vel.x, 0f, vel.z).magnitude) + { + vel = new Vector3(push.x, vel.y, push.z); + } + } + } + [HarmonyPatch(typeof(Humanoid), "StartAttack")] public static class Sverm_RavagerBlockNativeAttack_Patch { @@ -546,6 +577,23 @@ namespace RacesOfValheim } } + /// + /// Sits on the costume's Animator object. Unity calls OnAnimatorMove there instead of moving + /// the costume itself; while Active (the ram), the clip's motion is handed to the player + /// through SvermRavagerForm.PendingRootMotion. Otherwise it is dropped, so the costume stays + /// where the player is. + /// + public class RavagerRootMotionRelay : MonoBehaviour + { + public Animator Animator; + public bool Active; + + private void OnAnimatorMove() + { + if (Active && Animator != null) SvermRavagerForm.PendingRootMotion += Animator.deltaPosition; + } + } + /// /// Locomotion AND combat, both held on every frame while the form is up - built on the same /// method FenrirFormBehavior and DrakeFormBehavior already use for their own transformations, @@ -590,6 +638,8 @@ namespace RacesOfValheim private Transform leftClaw; private Transform rightClaw; + private RavagerRootMotionRelay rootMotion; + private void Start() { foreach (Transform bone in GetComponentsInChildren(true)) @@ -615,6 +665,13 @@ namespace RacesOfValheim anim.fireEvents = false; anim.cullingMode = AnimatorCullingMode.AlwaysAnimate; + // The ram is the exception: its clip's motion moves the PLAYER (see + // Sverm_RavagerRootMotion_Patch). With an OnAnimatorMove receiver on the Animator's + // object, Unity computes the motion and hands it over instead of moving the costume. + rootMotion = anim.gameObject.AddComponent(); + rootMotion.Animator = anim; + anim.applyRootMotion = true; + foreach (AnimatorControllerParameter param in anim.parameters) { if (param.type == AnimatorControllerParameterType.Float && param.name == "forward_speed") @@ -696,15 +753,15 @@ namespace RacesOfValheim // be the only reliable option. if (RaceInput.AttackDown(1)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Ram, "Attack Ram", 2f, false)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Ram, "Attack Ram", 2f, false, true)); } else if (RaceInput.AttackDown(0)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Bite, "Attack Bite", 2f, false)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Bite, "Attack Bite", 2f, false, false)); } else if (RaceInput.AttackDown(2)) { - StartCoroutine(AttackRoutine(SvermRavagerAttacks.Slam, "Attack Slam", 1.2f, true)); + StartCoroutine(AttackRoutine(SvermRavagerAttacks.Slam, "Attack Slam", 1.2f, true, false)); } else if ((SvermConfigManagement.RavagerKey.Value.IsDown() || RaceInput.ConsumePress(SvermConfigManagement.RavagerKey.Value)) && Time.time >= nextTauntAt) @@ -719,13 +776,14 @@ namespace RacesOfValheim /// event in the clip is a hit here, at the same point of the clip (the bite and the ram /// have one, the slam has two, one per claw). The player is held still until the /// animator starts blending out of the attack state, which is when the real Brute can - /// move again. + /// move again. With lunge, the clip's own root motion carries the player forward (the ram). /// private System.Collections.IEnumerator AttackRoutine(SvermRavagerAttacks.Profile profile, string stateName, - float radius, bool slam) + float radius, bool slam, bool lunge) { isAttacking = true; bool played = StartAttackState(profile); + if (rootMotion != null) rootMotion.Active = lunge; int dropSamples = 0; float[] leftY = new float[ClawHistory]; @@ -743,6 +801,7 @@ namespace RacesOfValheim dropSamples++; }); + if (rootMotion != null) rootMotion.Active = false; isAttacking = false; }