diff --git a/JotunnModStub/ConfigSync.cs b/JotunnModStub/ConfigSync.cs index f743b4c..0281af6 100644 --- a/JotunnModStub/ConfigSync.cs +++ b/JotunnModStub/ConfigSync.cs @@ -28,6 +28,7 @@ namespace RacesOfValheim { "Aswid - Claws", "Aswid - Eyes", + "Fenrir - Appearance", "Skeleton - Visuals", "Sverm - Dorsal Spines", "Sverm - Emberform", diff --git a/JotunnModStub/Fenrir/FenrirConfig.cs b/JotunnModStub/Fenrir/FenrirConfig.cs index 74795e5..68e9a97 100644 --- a/JotunnModStub/Fenrir/FenrirConfig.cs +++ b/JotunnModStub/Fenrir/FenrirConfig.cs @@ -85,6 +85,12 @@ namespace RacesOfValheim // ─── Debug ───────────────────────────────────────────────────────────── public static ConfigEntry DebugFormHits; + // ─── Appearance (per player, never synced) ────────────────────────────── + public static ConfigEntry ReadyMessage; + public static ConfigEntry EyeGlow; + public static ConfigEntry EyeNightStrength; + public static ConfigEntry EyeReadyStrength; + public static void Bind(ConfigFile config) { const string keybinds = "Fenrir - Keybinds"; @@ -188,6 +194,17 @@ namespace RacesOfValheim UlvPushForce = config.Bind(ulv, "Push Force", 25f, new ConfigDescription("Knockback applied on a hit.", new AcceptableValueRange(0f, 100f))); + // The whole section stays local - see ConfigSync.LocalSections. + const string appearance = "Fenrir - Appearance"; + ReadyMessage = config.Bind(appearance, "Ready Message", true, + new ConfigDescription("Shows \"
is Ready!\" when a form's cooldown ends. The eyes say the same thing; turn this off if they are enough.")); + EyeGlow = config.Bind(appearance, "Eye Glow", true, + new ConfigDescription("Fenrir eyes glow at night in the Fenring's own orange: faint while no form can be taken, bright when one can. Off hides them on every Fenrir you see.")); + EyeNightStrength = config.Bind(appearance, "Eye Night Strength", 0.35f, + new ConfigDescription("Glow at night while no form is ready.", new AcceptableValueRange(0f, 3f))); + EyeReadyStrength = config.Bind(appearance, "Eye Ready Strength", 1.2f, + new ConfigDescription("Glow at night while a form is ready.", new AcceptableValueRange(0f, 3f))); + // "debug" in the key keeps it local - see ConfigSync. DebugFormHits = config.Bind("Fenrir - Debug", "Debug: Log Form Hits", false, new ConfigDescription("Writes one log line per claw or bite: what was in reach, what it hit, and why anything was skipped. For bug reports about attacks that do no damage.")); diff --git a/JotunnModStub/Fenrir/FenrirRace.cs b/JotunnModStub/Fenrir/FenrirRace.cs index 655cb86..9feeb51 100644 --- a/JotunnModStub/Fenrir/FenrirRace.cs +++ b/JotunnModStub/Fenrir/FenrirRace.cs @@ -150,6 +150,8 @@ namespace RacesOfValheim { } wasNight = isNight; + FenrirVisuals.SetReady(Player.m_localPlayer, CanTakeAnyForm()); + if (isTransformed) { bool hasAnyForm = Player.m_localPlayer.GetSEMan().HaveStatusEffect("SE_FenrirForm".GetStableHashCode()) || @@ -171,6 +173,33 @@ namespace RacesOfValheim { if (FenrirConfig.CultistFormKey.Value.IsDownIgnoringHeldKeys()) { TryTransformWithRules(FenrirProgression.GetJKeyRules(state)); return; } } + /// + /// Whether one of the three keys would transform right now. The same gates as + /// TryTransformWithRules below, without its messages: this feeds the eye glow. + /// + private bool CanTakeAnyForm() + { + if (isTransformed) return false; + + int state = BossProgressionManager.GetCurrentProgressionState(); + return CanTake(FenrirProgression.GetGKeyRules(state)) + || CanTake(FenrirProgression.GetHKeyRules(state)) + || CanTake(FenrirProgression.GetJKeyRules(state)); + } + + private bool CanTake(FenrirProgression.FormRules rules) + { + if (rules == null || rules.Form == FenrirProgression.FormType.None) return false; + if (rules.NeedsNight && (sunSicknessTimer > 0f || !EnvMan.IsNight())) return false; + + if (rules.CooldownMinutes > 0) + { + string cdName = rules.Form == FenrirProgression.FormType.Cultist ? "SE_CultistCooldown" : "SE_FenrirCooldown"; + if (Player.m_localPlayer.GetSEMan().HaveStatusEffect(cdName.GetStableHashCode())) return false; + } + return true; + } + private void TryTransformWithRules(FenrirProgression.FormRules rules) { if (rules == null || rules.Form == FenrirProgression.FormType.None) return; diff --git a/JotunnModStub/Fenrir/FenrirStatusEffects.cs b/JotunnModStub/Fenrir/FenrirStatusEffects.cs index 43de139..f08ae33 100644 --- a/JotunnModStub/Fenrir/FenrirStatusEffects.cs +++ b/JotunnModStub/Fenrir/FenrirStatusEffects.cs @@ -15,7 +15,7 @@ namespace RacesOfValheim public override void Stop() { base.Stop(); - if (Player.m_localPlayer != null) + if (Player.m_localPlayer != null && FenrirConfig.ReadyMessage.Value) { Player.m_localPlayer.Message(MessageHud.MessageType.Center, ModText.Get("rov_msg_fenrir_ready", m_name)); } diff --git a/JotunnModStub/Fenrir/FenrirVisuals.cs b/JotunnModStub/Fenrir/FenrirVisuals.cs new file mode 100644 index 0000000..7b901c0 --- /dev/null +++ b/JotunnModStub/Fenrir/FenrirVisuals.cs @@ -0,0 +1,256 @@ +using System.Collections.Generic; +using HarmonyLib; +using Jotunn.Managers; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// The Fenrir's eyes catch the light at night, the way a wolf's do: a faint glow while no form + /// can be taken, a bright one when a key would transform right now. Dark by day and while in a + /// beast form, whose own eyes take over. A community suggestion (lexsonn), meant to say what + /// the "Ready!" text says without the text. + /// + /// Built the way AswidVisuals builds the Aswid's eyes, which is where the long story lives: the + /// vanilla Skeleton's eye_l/eye_r borrowed for mesh and material, placed on the head bone the + /// body mesh is skinned to, sized from the source's world scale. The placement numbers are the + /// Aswid's playtested defaults, fixed here rather than exposed again. + /// + /// The colour is the Fenring's own: its body material's _EmissionColor, (2.0, 0.372, 0.0) in + /// bundle c4210710, read offline with UnityPy rather than picked by eye. + /// + /// Runs for remote players too. Night is the same for everyone; whether a form is ready is + /// only known to the owner, who writes it to the ZDO (SetReady) for everyone else to read. + /// + public static class FenrirVisuals + { + public const string RaceId = "Fenrir"; + public const string ReadyKey = "RacesOfValheim_FenrirReady"; + private const string FormKey = "RacesOfValheim_FenrirForm"; + private const string EyesName = "FenrirEyes"; + private const string SourceModel = "Skeleton"; + private static readonly string[] SourceEyeNames = { "eye_l", "eye_r" }; + + private static readonly Color FenringGlow = new Color(2.0f, 0.372f, 0f, 1f); + + // AswidVisuals' base placement plus its Configuration Manager defaults, which are what + // playtesting settled on for this same pair of eyes on this same rig. + private const float EyeForward = 0.081f + 0.013f; + private const float EyeHeight = 0.181f + 0.004f; + private const float EyeSeparation = 0.032f + 0.007f; + private const float EyeSize = 1.1f; + private const float EyeYaw = 22.068f; + private const float EyeRoll = -180f; + + /// Owner only, and only on a change: one ZDO write per transition, not per frame. + public static void SetReady(Player player, bool ready) + { + ZNetView nview = player != null ? player.GetComponent() : null; + if (nview == null || !nview.IsValid() || !nview.IsOwner()) return; + + ZDO zdo = nview.GetZDO(); + if (zdo.GetBool(ReadyKey, false) != ready) zdo.Set(ReadyKey, ready); + } + + /// + /// Keeps the eyes on a living Fenrir and takes them off anyone else. Called from + /// VisEquipment.UpdateColors, which is what notices a race change; the ticker below then + /// follows night, readiness and forms frame by frame. + /// + public static void ApplyEyes(Player player) + { + if (player == null) return; + + Transform headBone = FindHeadBone(player); + if (headBone == null) return; // rig not up yet; the ticker or the next refresh retries + + Transform eyes = headBone.Find(EyesName); + + if (DvergarVisuals.GetPlayerRace(player) != RaceId || player.IsDead()) + { + if (eyes != null) + { + // Renamed first: Destroy waits for the end of the frame. + eyes.name = EyesName + "_Removed"; + Object.Destroy(eyes.gameObject); + } + EyeTicker ticker = player.GetComponent(); + if (ticker != null) Object.Destroy(ticker); + return; + } + + if (player.GetComponent() == null) player.gameObject.AddComponent(); + + float strength = GetGlowStrength(player); + if (strength <= 0f) + { + if (eyes != null && eyes.gameObject.activeSelf) eyes.gameObject.SetActive(false); + return; + } + + if (eyes == null) + { + // The skull's facing is measured once, at build time. A head turned by sitting, + // an attack or sleep would measure wrong; see AswidVisuals.ApplyEyes. + if (player.IsAttached() || player.IsAttachedToShip() || player.InAttack() || player.IsSleeping()) return; + eyes = BuildEyes(player, headBone); + if (eyes == null) return; + } + + if (!eyes.gameObject.activeSelf) eyes.gameObject.SetActive(true); + PaintEyes(eyes, FenringGlow * strength); + } + + /// 0 means dark: day, a beast form, or the viewer turned the glow off. + private static float GetGlowStrength(Player player) + { + if (!FenrirConfig.EyeGlow.Value) return 0f; + if (EnvMan.instance == null || !EnvMan.IsNight()) return 0f; + + ZNetView nview = player.GetComponent(); + if (nview == null || !nview.IsValid()) return 0f; + + ZDO zdo = nview.GetZDO(); + if (!string.IsNullOrEmpty(zdo.GetString(FormKey, ""))) return 0f; + + return zdo.GetBool(ReadyKey, false) + ? FenrirConfig.EyeReadyStrength.Value + : FenrirConfig.EyeNightStrength.Value; + } + + public class EyeTicker : MonoBehaviour + { + private Player m_player; + + private void Awake() => m_player = GetComponent(); + + private void LateUpdate() + { + if (m_player == null) { Destroy(this); return; } + ApplyEyes(m_player); + } + } + + /// The body mesh's own Head bone, never the Animator's. See AswidVisuals.FindHeadBone. + private static Transform FindHeadBone(Player player) + { + VisEquipment visEq = player.GetComponent(); + if (visEq == null || visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return null; + + foreach (Transform bone in visEq.m_bodyModel.bones) + { + if (bone != null && bone.name == AswidVisuals.PlayerHeadBoneName) return bone; + } + return null; + } + + private static Transform BuildEyes(Player player, Transform headBone) + { + List sources = FindSourceEyes(); + if (sources.Count == 0) return null; + + float lossy = headBone.lossyScale.x; + if (Mathf.Abs(lossy) < 0.0001f) return null; // rig still coming up + float toLocal = 1f / lossy; + + GameObject holder = new GameObject(EyesName); + holder.transform.SetParent(headBone, false); + + RigBindPose.MeasureHeadFrame(player, headBone, RaceId, + out Vector3 forward, out Vector3 up, out Vector3 right); + Quaternion facing = Quaternion.LookRotation(forward, up); + + // The player's own scale cancels the rig's, as in AswidVisuals.PlaceEyes. + float scale = player.transform.localScale.x * toLocal; + + foreach (Transform source in sources) + { + GameObject eye = Object.Instantiate(source.gameObject, holder.transform); + eye.name = source.name; + + float side = source.name.ToLowerInvariant().Contains("_l") ? -1f : 1f; + + eye.transform.localPosition = forward * (EyeForward * scale) + + up * (EyeHeight * scale) + + right * (side * EyeSeparation * scale); + // Yaw mirrored per eye so the pair turns in towards the nose together. + eye.transform.localRotation = Quaternion.Euler(0f, EyeYaw * side, EyeRoll) * facing; + eye.transform.localScale = source.lossyScale * toLocal * EyeSize; + + // Allowlist: whatever else rode along on the skeleton goes. + foreach (Component comp in eye.GetComponentsInChildren(true)) + { + if (comp is Transform || comp is MeshRenderer || comp is MeshFilter) continue; + if (comp is ParticleSystem || comp is ParticleSystemRenderer) + { + // The skeleton's eye smoke, on a child of the eye: too loud for a reflection. + if (comp.gameObject != eye) comp.gameObject.SetActive(false); + continue; + } + Object.Destroy(comp); + } + + foreach (Renderer renderer in eye.GetComponentsInChildren(true)) + { + renderer.enabled = true; + renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; + renderer.receiveShadows = false; + } + + eye.SetActive(true); + } + + return holder.transform; + } + + /// Every colour property the borrowed material has; see AswidVisuals.PaintEyes. + private static void PaintEyes(Transform holder, Color glow) + { + glow.a = 1f; + foreach (Renderer renderer in holder.GetComponentsInChildren(true)) + { + Material material = renderer.material; + if (material == null) continue; + + if (material.HasProperty("_Color")) material.SetColor("_Color", glow); + if (material.HasProperty("_TintColor")) material.SetColor("_TintColor", glow); + if (material.HasProperty("_BaseColor")) material.SetColor("_BaseColor", glow); + if (material.HasProperty("_EmissionColor")) material.SetColor("_EmissionColor", glow); + } + } + + private static bool warnedSource; + + private static List FindSourceEyes() + { + List found = new List(); + + GameObject prefab = PrefabManager.Cache.GetPrefab(SourceModel); + if (prefab != null) + { + foreach (Transform t in prefab.GetComponentsInChildren(true)) + { + string lower = t.name.ToLower(); + if (lower == SourceEyeNames[0] || lower == SourceEyeNames[1]) found.Add(t); + } + } + + if (found.Count == 0 && !warnedSource) + { + warnedSource = true; + Jotunn.Logger.LogWarning($"[Fenrir] No eye_l/eye_r found on '{SourceModel}' - the eyes stay dark."); + } + return found; + } + } + + [HarmonyPatch(typeof(VisEquipment), "UpdateColors")] + public static class FenrirEyesPatch + { + public static void Postfix(VisEquipment __instance) + { + if (!__instance.m_isPlayer) return; + FenrirVisuals.ApplyEyes(__instance.GetComponent()); + } + } +}