From d142fad33021fba5abf35e9af3bf6871e36be8b8 Mon Sep 17 00:00:00 2001 From: kanym Date: Thu, 29 Oct 2026 14:00:26 +0100 Subject: [PATCH] fix: Cultist fire from the hands, tied to its clip, facing the camera The breath waits for the flame clip's Hit point (1.245 s), holds the casting pose while the button is held and blends back to Movement on release, so a short click no longer leaves the arms raised for the clip's 3.5 s. Eitr drains from the flames on. Each fx_fenring_flames emitter follows its hand bone. While breathing, Player.AlwaysRotateCamera answers true, so the body turns to the camera as when blocking. Onlookers' copies follow the same clip. --- JotunnModStub/Fenrir/FenrirBehaviors.cs | 233 +++++++++++++++++++----- 1 file changed, 192 insertions(+), 41 deletions(-) diff --git a/JotunnModStub/Fenrir/FenrirBehaviors.cs b/JotunnModStub/Fenrir/FenrirBehaviors.cs index 40901e4..8a4871b 100644 --- a/JotunnModStub/Fenrir/FenrirBehaviors.cs +++ b/JotunnModStub/Fenrir/FenrirBehaviors.cs @@ -429,6 +429,8 @@ namespace RacesOfValheim private ZNetView nview; private string lastAttack; private GameObject flames; + private bool breathing; + private float breathStarted; private readonly FormLocomotion locomotion = new FormLocomotion(); // The flames hang off the player, not this model, so they outlive it unless taken down. @@ -469,18 +471,31 @@ namespace RacesOfValheim bool fire = nview.GetZDO().GetBool(FenrirAttackSync.FireKey, false); - // The breath itself: up while the flag is, gone when it drops. Only the cultist ever - // sets the flag, so no other form can grow flames here. - if (fire && flames == null) + // The flag is up for the whole hold, wind-up included, as on the owner's side; the + // flames come at the same point of the same clip (CultistBreathClip). Only the cultist + // ever sets the flag, so no other form can grow flames here. + if (fire && !breathing) { - flames = FenrirAttackSync.SpawnFlames(player); + breathing = true; + breathStarted = Time.time; // The roar that opens the breath, once per start, the same cue the owner hears. // "sfx_cultist_attack_fire_start" was asked for here and there is no sfx_cultist_* // prefab in the game at all; the fenring's own fire-claw snarl is the real one. FenrirCreatureSound.PlayFireRoar(player.transform.position); } - else if (!fire && flames != null) { Destroy(flames); flames = null; } + if (fire) + { + CultistBreathClip.Hold(formAnim); + if (flames == null && CultistBreathClip.FlamesDue(formAnim, breathStarted)) + flames = FenrirAttackSync.SpawnFlames(player); + } + else if (breathing) + { + breathing = false; + CultistBreathClip.Release(formAnim, player); + if (flames != null) { Destroy(flames); flames = null; } + } foreach (AnimatorControllerParameter p in formAnim.parameters) { @@ -841,29 +856,22 @@ namespace RacesOfValheim // still falls through to StopFire() instead of leaving the flames running. bool canAct = RaceInput.Allowed; - // Fire attack on Right Click - if (canAct && RaceInput.AttackHeld(1) && !Player.m_localPlayer.IsStaggering()) + // Fire attack on Right Click, held. + bool wantFire = canAct && RaceInput.AttackHeld(1) && !Player.m_localPlayer.IsStaggering(); + if (wantFire && Player.m_localPlayer.GetEitr() <= 0f) { - if (Player.m_localPlayer.GetEitr() > 0) - { - if (!isShootingFire) - { - StartFire(); - } - else - { - UpdateFire(); - } - } - else - { - // Held with an empty pool. Until now this did nothing whatsoever: no - // flames, no sound, no reason given - and the form's own tier is Yagluth - // while eitr is a Mistlands thing, so a Cultist meets this before it ever - // meets the fire. - SayNoEitr(); - if (isShootingFire) StopFire(); - } + // Held with an empty pool. Until now this did nothing whatsoever: no + // flames, no sound, no reason given - and the form's own tier is Yagluth + // while eitr is a Mistlands thing, so a Cultist meets this before it ever + // meets the fire. + SayNoEitr(); + wantFire = false; + } + + if (wantFire) + { + if (!isShootingFire) StartFire(); + else UpdateFire(); } else if (isShootingFire) { @@ -943,31 +951,50 @@ namespace RacesOfValheim ModText.Get("rov_msg_fenrir_only_breath_comes_out_fire")); } + // The breath runs on the flame clip (CultistBreathClip): pressed, the clip starts; the flames, + // the eitr drain and the damage begin at its own Hit point; released, the clip is cut. + private bool flaming; + private float fireStarted; + + /// True while the local Cultist holds its breath attack, wind-up included. Read by + /// Cultist_BreathFacesCamera_Patch. + public static bool LocalBreathing { get; private set; } + private void StartFire() { if (Player.m_localPlayer == null || isShootingFire) return; isShootingFire = true; + LocalBreathing = true; + flaming = false; + fireStarted = Time.time; + fireTimer = 0f; FormAnimGuard.LeaveHowl(cultistAnim); cultistAnim.SetFloat("forward_speed", 0f); cultistAnim.SetFloat("sideway_speed", 0f); - cultistAnim.SetBool("attack_fire", true); FenrirAttackSync.PublishFire(true); - + // Same cue the remote mirror plays - see the fire branch in the sync behaviour above. FenrirCreatureSound.PlayFireRoar(Player.m_localPlayer.transform.position); cultistAnim.SetTrigger("attack_flames"); FenrirAttackSync.Publish("attack_flames"); - - if (fireEffectInstance == null) fireEffectInstance = FenrirAttackSync.SpawnFlames(Player.m_localPlayer); } private void UpdateFire() { - Player.m_localPlayer.UseEitr(FenrirConfig.CultistFireEitrDrainPerSecond.Value * Time.deltaTime); cultistAnim.SetFloat("forward_speed", 0f); cultistAnim.SetFloat("sideway_speed", 0f); - + CultistBreathClip.Hold(cultistAnim); + + if (!flaming) + { + if (!CultistBreathClip.FlamesDue(cultistAnim, fireStarted)) return; + flaming = true; + if (fireEffectInstance == null) fireEffectInstance = FenrirAttackSync.SpawnFlames(Player.m_localPlayer); + } + + Player.m_localPlayer.UseEitr(FenrirConfig.CultistFireEitrDrainPerSecond.Value * Time.deltaTime); + fireTimer += Time.deltaTime; if (fireTimer >= 0.2f) // Damage tick every 0.2s { @@ -980,14 +1007,18 @@ namespace RacesOfValheim private void OnDestroy() { if (isShootingFire) FenrirAttackSync.PublishFire(false); + LocalBreathing = false; } private void StopFire() { isShootingFire = false; + LocalBreathing = false; + flaming = false; cultistAnim.ResetTrigger("attack_flames"); FenrirAttackSync.PublishFire(false); - + CultistBreathClip.Release(cultistAnim, Player.m_localPlayer); + if (fireEffectInstance != null) { Destroy(fireEffectInstance); @@ -1702,29 +1733,149 @@ namespace RacesOfValheim } /// - /// Keeps the Cultist's breath at its mouth: on the Jaw bone (fenring_cultist rig: - /// .../Neck/Head/Jaw), facing where the player faces. Placed every LateUpdate, after the form's - /// Animator has moved the head, rather than parented to the bone, so the flames point where the - /// player aims and not wherever the jaw happens to tilt. The same on every client's copy. + /// The Cultist's breath, timed by its own clip. fenring_cultist_animator's attack_flames state + /// plays "Flame Spell Attack" (read offline with UnityPy, bundle c4210710): 3.5 s, the hands + /// light at 1.094 s (TrailOn), the vanilla flames come at 1.245 s (Hit) and are taken down at + /// 3.193 s. The state leaves for Movement only when the clip ends, so a short click used to + /// leave the Cultist standing with its arms up for the rest of the 3.5 s, breathing nothing. + /// + /// Now the flames wait for the clip's Hit point, the arms are held in the casting pose for as + /// long as the button is, and letting go blends straight back to Movement. Shared by the + /// owner's Cultist and every onlooker's copy, so both play the same breath. + /// + internal static class CultistBreathClip + { + private static readonly int State = Animator.StringToHash("Base Layer.attack_flames"); + private const string MovementState = "Base Layer.Movement"; + + // The clip's Hit event, where the vanilla Cultist's flames come out. + private const float FlamesAt = 1.245f; + + // Inside the flaming stretch (1.245 to 3.193 s): the Animator stops here while held. + private const float PinAt = 2.6f; + + private const float Fade = 0.25f; + + /// Seconds into the flame clip, or -1 while the Animator is in another state. + private static float ClipTime(Animator anim) + { + AnimatorStateInfo info = anim.IsInTransition(0) ? anim.GetNextAnimatorStateInfo(0) : anim.GetCurrentAnimatorStateInfo(0); + return info.fullPathHash == State ? info.normalizedTime * info.length : -1f; + } + + /// True once the clip has reached its Hit point. If the clip never started (another + /// state took the Animator), the same delay counted from the press stands in for it. + public static bool FlamesDue(Animator anim, float started) + { + float t = ClipTime(anim); + return t >= FlamesAt || (t < 0f && Time.time - started >= FlamesAt + 0.2f); + } + + /// Holds the arms in the casting pose: the Animator stops once the clip reaches PinAt. + public static void Hold(Animator anim) + { + if (!anim.IsInTransition(0) && ClipTime(anim) >= PinAt) anim.speed = 0f; + } + + /// Lets the Animator run again and blends out of the clip, unless a stagger has + /// taken over (FormStagger has fired the form's own). + public static void Release(Animator anim, Player player) + { + if (anim == null) return; + anim.speed = 1f; + if (ClipTime(anim) >= 0f && (player == null || !player.IsStaggering())) + anim.CrossFadeInFixedTime(MovementState, Fade, 0); + } + } + + /// + /// Keeps the Cultist's breath in its hands, where the vanilla Cultist casts it from. fx_fenring_flames + /// has two emitters, "flames_world left" and "flames_world right", set 1.2 to 1.6 m ahead of + /// its own origin; spawned at the creature, the fire began that far in front of it. Each + /// emitter goes on its hand bone (fenring_cultist rig: .../LeftForeArm/LeftHand and the right + /// one), pointing where the player faces, so the two streams leave the palms and run forward. + /// The embers and the light sit between the hands. Placed every LateUpdate, after the form's + /// Animator has moved the arms. The same on every client's copy. + /// + /// A form without hand bones keeps the whole effect at its mouth, as before. /// internal class CultistFlameFollow : MonoBehaviour { + // Ahead of the palm, so the stream does not start inside the hand. + private const float AheadOfHand = 0.15f; + + // The light, further ahead along the stream. + private const float LightAhead = 1.5f; + public Player Player; - private Transform mouth; + private Transform mouth, leftHand, rightHand; + private Transform leftFlames, rightFlames, embers, light; + private bool partsFound; private float nextLook; private void LateUpdate() { if (Player == null) return; + if (!partsFound) + { + partsFound = true; + leftFlames = transform.Find("flames_world left"); + rightFlames = transform.Find("flames_world right"); + embers = transform.Find("FireEmbers"); + light = transform.Find("Point light"); + } + // The form can be rebuilt under the same flames; look again now and then if lost. - if (mouth == null && Time.time >= nextLook) + if ((leftHand == null || rightHand == null || mouth == null) && Time.time >= nextLook) { nextLook = Time.time + 0.5f; + leftHand = FindBone(Player, "LeftHand"); + rightHand = FindBone(Player, "RightHand"); mouth = FenrirAttackSync.FindMouth(Player); } - transform.SetPositionAndRotation(FenrirAttackSync.MouthPoint(Player, mouth), Player.transform.rotation); + Quaternion facing = Player.transform.rotation; + transform.SetPositionAndRotation(FenrirAttackSync.MouthPoint(Player, mouth), facing); + if (leftHand == null || rightHand == null || leftFlames == null || rightFlames == null) return; + + Vector3 forward = Player.transform.forward; + Vector3 left = leftHand.position + forward * AheadOfHand; + Vector3 right = rightHand.position + forward * AheadOfHand; + leftFlames.SetPositionAndRotation(left, facing); + rightFlames.SetPositionAndRotation(right, facing); + + Vector3 between = (left + right) * 0.5f; + if (embers != null) embers.SetPositionAndRotation(between, facing); + if (light != null) light.position = between + forward * LightAhead; + } + + private static Transform FindBone(Player player, string name) + { + foreach (Transform child in player.transform) + { + if (child.name == "Visual" || !child.gameObject.activeInHierarchy) continue; + foreach (Transform t in child.GetComponentsInChildren()) + { + if (t.name == name) return t; + } + } + return null; + } + } + + /// + /// Turns the Cultist toward the camera while it breathes fire, as vanilla turns a player who + /// blocks or draws a bow: Player.AlwaysRotateCamera answers true for those, and Character then + /// turns the body to the look direction at its own turn speed. The breath is not a vanilla + /// attack, so the body stayed facing wherever the movement keys had left it. + /// + [HarmonyPatch(typeof(Player), "AlwaysRotateCamera")] + public static class Cultist_BreathFacesCamera_Patch + { + public static void Postfix(Player __instance, ref bool __result) + { + if (!__result && __instance == Player.m_localPlayer && CultistFormBehavior.LocalBreathing) __result = true; } }