From 79a54fb5336f0178c8ea70680b44bc3fe6a832eb Mon Sep 17 00:00:00 2001 From: kanym Date: Sun, 2 Aug 2026 22:58:11 +0200 Subject: [PATCH] fix(dvergur): correct the health malus, body scale and hood Health: the malus was taken off Character.GetMaxHealth, which only made the getter lie. Character.SetMaxHealth is the one thing that clamps current health to the new maximum and it never saw a lower number, so the bar shrank while the value stayed where it was. Player.SetMaxHealth also flashes the bar whenever the new maximum is above GetMaxHealth(), so against a getter that always read low every food tick looked like an increase and re-triggered the flash. Taking the malus off Player.GetTotalFoodValue instead puts it upstream of both, and leaves Valheim to do its own clamping on an honest number. Scale: applied from the plugin MonoBehaviour, it was overwritten on the same frame by Trol's Player.Update postfix, which forced every non-Trol player back to scale 1. Sizing now happens in a postfix on that same method, the way the Trol does it, and RaceScale records which races size themselves so they stop undoing each other. This also fixes the Furling, which was losing the same race. Hood: the Dverger Circlet is a metal band, not the hood, and instantiating a skinned mesh leaves its bones pointing at the source prefab so it renders nowhere. The headgear is now lifted off the Dvergr NPC and rebound to the player's own bones by name, as the Skeleton does for whole bodies. Skin is tinted to a dvergr grey, saved and restored through the same OriginalSkinColor keys the other tinted races use. Adds a dumpdverger console command: prefab contents live in the asset bundles and cannot be read outside a running game, so this is how the hood mesh and the per-star LevelEffects colours get identified. --- JotunnModStub/Dvergur/DvergurConfig.cs | 30 +-- JotunnModStub/Dvergur/DvergurPatches.cs | 49 ++++- JotunnModStub/Dvergur/DvergurRace.cs | 30 ++- JotunnModStub/Dvergur/DvergurVisuals.cs | 276 ++++++++++++++++-------- JotunnModStub/RaceScale.cs | 35 +++ JotunnModStub/RacesOfValheim.cs | 89 +++++++- JotunnModStub/Trol/TrolPatches.cs | 5 +- JotunnModStub/ZdoVisualSync.cs | 6 +- 8 files changed, 395 insertions(+), 125 deletions(-) create mode 100644 JotunnModStub/RaceScale.cs diff --git a/JotunnModStub/Dvergur/DvergurConfig.cs b/JotunnModStub/Dvergur/DvergurConfig.cs index 36d9146..dac8e68 100644 --- a/JotunnModStub/Dvergur/DvergurConfig.cs +++ b/JotunnModStub/Dvergur/DvergurConfig.cs @@ -35,21 +35,27 @@ namespace RacesOfValheim // is set to zero, and would bake the old value into any assembly built against this one. public static readonly float VisualScale = 0.70f; // -30% versus a human + // ─── Skin ──────────────────────────────────────────────────────────── + // Tint applied over the human skin texture, the same multiplicative m_skinColor the + // Furling and Trol use. Ashen grey with a blue cast, to read as one of the deep folk. + public static readonly Vector3 SkinColor = new Vector3(0.72f, 0.74f, 0.82f); + // ─── Cosmetic hood ─────────────────────────────────────────────────── // The helmet slot itself stays free — whatever the player equips keeps all of its stats, - // only the mesh is swapped. Tried in order; the first prefab that resolves wins. - public static readonly string[] HoodPrefabCandidates = - { - "HelmetDverger", // Dverger circlet item - "helmet_dverger", // its attach visual, if the item prefab is unavailable - "Dverger" // last resort: lift the headgear renderer off the creature - }; + // only the mesh is swapped. + // + // The hood is lifted straight off the Dvergr NPC rather than off the Dverger Circlet item: + // the circlet is a metal band, not the hood the race is meant to wear. + public const string DvergerPrefabName = "Dverger"; - // Valheim rigs are authored at scale 100, hence the very small numbers. Tuned against - // the head bone, same approach as the Furling trophy head. - public static readonly Vector3 HoodLocalPosition = new Vector3(0f, 0.0012f, 0f); - public static readonly Vector3 HoodLocalRotation = new Vector3(-90f, 0f, 90f); - public static readonly float HoodLocalScale = 0.0075f; + // Matched against renderer object names inside that prefab, lowercased, by Contains. + public static readonly string[] HoodRendererNames = { "hat", "hood", "helmet", "cap" }; + + // Applied on top of whatever the rig positions the hood at. Identity is correct when the + // bone remap succeeds; these exist so a stubborn mesh can be nudged without a code change. + public static readonly Vector3 HoodOffsetPosition = Vector3.zero; + public static readonly Vector3 HoodOffsetRotation = Vector3.zero; + public static readonly float HoodExtraScale = 1f; // ─── Health malus ──────────────────────────────────────────────────── diff --git a/JotunnModStub/Dvergur/DvergurPatches.cs b/JotunnModStub/Dvergur/DvergurPatches.cs index bfe4d2e..250aae1 100644 --- a/JotunnModStub/Dvergur/DvergurPatches.cs +++ b/JotunnModStub/Dvergur/DvergurPatches.cs @@ -14,17 +14,25 @@ namespace RacesOfValheim // ─── Health malus ──────────────────────────────────────────────────── /// - /// The Dvergur is a small frame, and carries less health for it. The target is resolved - /// with AccessTools rather than named against a type, because GetMaxHealth may be declared - /// on Character or overridden on Player depending on the game version - AccessTools walks - /// up to whichever one actually runs, and the local-player guard makes either correct. + /// The Dvergur is a small frame, and carries less health for it. + /// + /// The malus is taken off the food total rather than off Character.GetMaxHealth, which is + /// what the first attempt did and what produced the bug where the bar shrank but the + /// number stayed put and the border flashed. Patching the getter makes it lie to the rest + /// of the game: Character.SetMaxHealth is the only thing that clamps current health down + /// to the new maximum, and it never saw a lower number, so m_health stayed at 58. Worse, + /// Player.SetMaxHealth flashes the bar whenever the new maximum is above GetMaxHealth() - + /// against a getter that always read low, every food tick looked like a health *increase* + /// and re-triggered the flash. + /// + /// GetTotalFoodValue is upstream of both: UpdateFood feeds its result straight into + /// SetMaxHealth, so Valheim does its own clamping and its own flash logic on an honest + /// number and bar, value and animation all agree. /// - [HarmonyPatch] - public static class Dvergur_GetMaxHealth_Patch + [HarmonyPatch(typeof(Player), "GetTotalFoodValue")] + public static class Dvergur_GetTotalFoodValue_Patch { - public static MethodBase TargetMethod() => AccessTools.Method(typeof(Player), "GetMaxHealth"); - - public static void Postfix(Character __instance, ref float __result) + public static void Postfix(Player __instance, ref float hp) { if (__instance == null || __instance != Player.m_localPlayer) return; if (!DvergurRace.IsDvergur()) return; @@ -32,7 +40,26 @@ namespace RacesOfValheim float malus = DvergurProgression.Current.HealthMalus; if (malus <= 0f) return; - __result = Mathf.Max(DvergurConfig.MinMaxHealth, __result - malus); + hp = Mathf.Max(DvergurConfig.MinMaxHealth, hp - malus); + } + } + + // ─── Scale ─────────────────────────────────────────────────────────── + + /// + /// Sizing runs off Player.Update, which is where the Trol does it and the only place it + /// holds: Trol's own postfix forces every non-Trol player's visual back to scale 1 on the + /// same frame, so a scale applied from anywhere else was simply overwritten. Being a + /// postfix on the same method puts the Dvergur on equal footing, and RaceScale keeps the + /// two from undoing each other. + /// + [HarmonyPatch(typeof(Player), "Update")] + public static class Dvergur_PlayerUpdate_Scale_Patch + { + public static void Postfix(Player __instance) + { + if (__instance == null) return; + DvergurVisuals.ApplyScale(__instance, DvergurVisuals.IsDvergurPlayer(__instance)); } } @@ -290,7 +317,7 @@ namespace RacesOfValheim Player player = __instance.GetComponent(); if (player == null) return; - DvergurVisuals.Apply(player); + DvergurVisuals.ApplyHood(player); } } } diff --git a/JotunnModStub/Dvergur/DvergurRace.cs b/JotunnModStub/Dvergur/DvergurRace.cs index 319d58c..daa83c0 100644 --- a/JotunnModStub/Dvergur/DvergurRace.cs +++ b/JotunnModStub/Dvergur/DvergurRace.cs @@ -1,3 +1,4 @@ +using HarmonyLib; using UnityEngine; namespace RacesOfValheim @@ -6,14 +7,18 @@ namespace RacesOfValheim /// Driver for the Dvergur: a short, stocky smith who trades a slice of health for an affinity /// with hammer, bow, axe and crossbow, a knack for mining and the ear of Haldor and Hildir. /// - /// Only the per-frame upkeep lives here. The perks themselves are Harmony patches in - /// DvergurPatches, the two eitr abilities are in DvergurAbilities, and every number they use - /// comes from DvergurConfig by way of DvergurProgression. + /// Only the per-frame upkeep lives here. Body scale is a Player.Update postfix in + /// DvergurPatches, since that is the one place it survives; the perks are the other patches in + /// that file; the two eitr abilities are in DvergurAbilities; and every number they use comes + /// from DvergurConfig by way of DvergurProgression. /// public class DvergurRace : MonoBehaviour { public static DvergurRace Instance; + // NaN so that the very first frame always counts as a change and pushes the malus through. + private float lastAppliedMalus = float.NaN; + private void Awake() { Instance = this; @@ -36,15 +41,22 @@ namespace RacesOfValheim Player player = Player.m_localPlayer; if (player == null) return; - if (!IsDvergur()) + bool isDvergur = IsDvergur(); + + DvergurVisuals.ApplyHood(player); + + // Max health is recomputed by Player.UpdateFood, which runs on its own schedule. Left + // to itself the malus would only take effect at the next food tick, so a change of + // race or of tier is pushed through immediately - this is also what makes the health + // bar and the number agree the instant a player becomes (or stops being) a Dvergur. + float desiredMalus = isDvergur ? DvergurProgression.Current.HealthMalus : 0f; + if (!Mathf.Approximately(desiredMalus, lastAppliedMalus)) { - DvergurVisuals.Apply(player); - return; + lastAppliedMalus = desiredMalus; + Traverse.Create(player).Method("UpdateFood", 0f, true).GetValue(); } - DvergurVisuals.Apply(player); - - if (player.IsDead()) return; + if (!isDvergur || player.IsDead()) return; int state = BossProgressionManager.GetCurrentProgressionState(); diff --git a/JotunnModStub/Dvergur/DvergurVisuals.cs b/JotunnModStub/Dvergur/DvergurVisuals.cs index fc93a24..1742ae7 100644 --- a/JotunnModStub/Dvergur/DvergurVisuals.cs +++ b/JotunnModStub/Dvergur/DvergurVisuals.cs @@ -5,22 +5,27 @@ using UnityEngine; namespace RacesOfValheim { /// - /// The Dvergur's looks: a short body and a hood that is always worn. + /// The Dvergur's looks: a short body, dverger skin, and a hood that is always worn. /// /// The hood is a pure cosmetic override, not an equipment lock. The helmet slot stays free and - /// whatever the player equips keeps every one of its stats - only its mesh is swapped out, the - /// way the Skeleton hides helmets outright, so armour, resistances and set bonuses all still - /// count. Everything here runs for local and remote players alike, which is why it takes a - /// Player rather than reading Player.m_localPlayer. + /// whatever the player equips keeps every one of its stats - only its mesh is swapped out, so + /// armour, resistances and set bonuses all still count. + /// + /// Everything here runs for local and remote players alike, which is why it takes a Player + /// rather than reading Player.m_localPlayer. /// public static class DvergurVisuals { private const string HoodName = "DvergurHood"; + // The hood only has to be looked up once per session; the search walks a whole creature + // prefab and would otherwise run again for every player that comes into view. + private static GameObject cachedHoodSource; + private static bool hoodSourceResolved; + /// /// Reads the race off the ZDO so remote players render correctly, falling back to - /// m_customData for the main-menu preview which has no ZNetView. Same shape as - /// FurlingPatches.GetPlayerRace. + /// m_customData for the main-menu preview which has no ZNetView. /// public static string GetPlayerRace(Player player) { @@ -41,22 +46,84 @@ namespace RacesOfValheim public static bool IsDvergurPlayer(Player player) => GetPlayerRace(player) == DvergurConfig.RaceId; + // ─── Scale ─────────────────────────────────────────────────────────── + /// - /// Brings a player's body in line with their race. Safe to call every frame: each step - /// checks the current value first and does nothing when it already matches. + /// Sizes a player, driven from a Player.Update postfix exactly the way the Trol is - which + /// is the arrangement that actually holds. Doing it from the plugin's own MonoBehaviour + /// left the scale in a fight it could not win: Trol's Player.Update postfix resets every + /// non-Trol player's visual to 1 on the same frame, and whichever ran last won. /// - public static void Apply(Player player) + public static void ApplyScale(Player player, bool isDvergur) { if (player == null) return; - bool isDvergur = IsDvergurPlayer(player) && !player.IsDead(); + // The "Visual" child, never the root: the root carries the collider and the camera + // pivot, and shrinking those drops the player through the ground they stand on. + GameObject visual = Traverse.Create(player).Field("m_visual").GetValue(); + if (visual == null) return; - ApplyScale(player, isDvergur); + if (isDvergur) + { + float target = DvergurConfig.VisualScale; + if (Mathf.Abs(visual.transform.localScale.x - target) > 0.001f) + { + visual.transform.localScale = new Vector3(target, target, target); + } + } + else if (Mathf.Abs(visual.transform.localScale.x - DvergurConfig.VisualScale) < 0.001f) + { + // Only ever undo our own scale - another race may legitimately be sizing this player. + visual.transform.localScale = Vector3.one; + } + } + + // ─── Skin ──────────────────────────────────────────────────────────── + + /// + /// Tints the local player's skin, saving the original first so ResetRace can put it back. + /// Same save-then-tint dance the Furling, Trol and Draugh selections do. + /// + public static void ApplySkinColor(Player player) + { + if (player == null) return; VisEquipment visEq = player.GetComponent(); if (visEq == null) return; - if (isDvergur) + if (!player.m_customData.ContainsKey("OriginalSkinColor_X")) + { + Vector3 current = Traverse.Create(visEq).Field("m_skinColor").GetValue(); + player.m_customData["OriginalSkinColor_X"] = current.x.ToString(); + player.m_customData["OriginalSkinColor_Y"] = current.y.ToString(); + player.m_customData["OriginalSkinColor_Z"] = current.z.ToString(); + } + + Traverse.Create(visEq).Method("SetSkinColor", DvergurConfig.SkinColor).GetValue(); + RefreshColors(visEq); + } + + public static void RefreshColors(VisEquipment visEq) + { + if (visEq == null) return; + visEq.GetType().GetMethod("UpdateColors", + System.Reflection.BindingFlags.Instance | + System.Reflection.BindingFlags.NonPublic | + System.Reflection.BindingFlags.Public)?.Invoke(visEq, null); + } + + // ─── Hood ──────────────────────────────────────────────────────────── + + /// + /// Keeps the hood and the hidden helmet in step. Safe to call every frame: each step + /// checks the current value first and does nothing when it already matches. + /// + public static void ApplyHood(Player player) + { + VisEquipment visEq = player != null ? player.GetComponent() : null; + if (visEq == null) return; + + if (IsDvergurPlayer(player) && !player.IsDead()) { EnsureHood(visEq); HideEquippedHelmet(visEq); @@ -67,27 +134,6 @@ namespace RacesOfValheim } } - private static void ApplyScale(Player player, bool isDvergur) - { - // Scaling the "Visual" child rather than the root, as Furling does: the root carries - // the collider and the camera pivot, and shrinking those makes the player fall through - // the world geometry they were standing on. - GameObject visual = Traverse.Create(player).Field("m_visual").GetValue(); - if (visual == null) return; - - Vector3 target = isDvergur ? Vector3.one * DvergurConfig.VisualScale : Vector3.one; - - if (isDvergur) - { - if (visual.transform.localScale != target) visual.transform.localScale = target; - } - else if (visual.transform.localScale == Vector3.one * DvergurConfig.VisualScale) - { - // Only undo our own scale - another race may legitimately be scaling this player. - visual.transform.localScale = Vector3.one; - } - } - /// /// Blanks the mesh of whatever helmet is equipped. Scaled to zero rather than deactivated /// because Valheim re-enables the instance whenever it refreshes visuals, and this is the @@ -106,10 +152,10 @@ namespace RacesOfValheim { if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return; - Transform headBone = FindBoneByName(visEq.m_bodyModel.bones, "Head"); - if (headBone == null) return; + Transform parent = visEq.m_bodyModel.transform.parent; + if (parent == null) return; - Transform existing = headBone.Find(HoodName); + Transform existing = parent.Find(HoodName); if (existing != null) { if (!existing.gameObject.activeSelf) existing.gameObject.SetActive(true); @@ -117,45 +163,57 @@ namespace RacesOfValheim } GameObject source = ResolveHoodSource(); - if (source == null) - { - // Logged once per player rather than per frame: the early return above means we - // only reach here while the hood is genuinely missing. - Jotunn.Logger.LogWarning( - $"[Dvergur] No hood prefab found among [{string.Join(", ", DvergurConfig.HoodPrefabCandidates)}]; " + - "the helmet slot stays cosmetically empty."); - return; - } + if (source == null) return; // already logged once by the resolver bool wasActive = source.activeSelf; source.SetActive(false); - GameObject hood = Object.Instantiate(source, headBone, false); + GameObject hood = Object.Instantiate(source, parent, false); source.SetActive(wasActive); hood.name = HoodName; - - // Strip anything that would make a decorative mesh behave like a world object - - // hover prompts, pickup triggers, physics. Same cleanup the Furling head does. - foreach (MonoBehaviour comp in hood.GetComponentsInChildren(true)) - { - Object.DestroyImmediate(comp); - } - foreach (Rigidbody body in hood.GetComponentsInChildren(true)) - { - Object.DestroyImmediate(body); - } - foreach (Collider col in hood.GetComponentsInChildren(true)) - { - Object.DestroyImmediate(col); - } - + StripBehaviours(hood); hood.SetActive(true); - hood.transform.localPosition = DvergurConfig.HoodLocalPosition; - hood.transform.localRotation = Quaternion.Euler(DvergurConfig.HoodLocalRotation); - hood.transform.localScale = Vector3.one * DvergurConfig.HoodLocalScale; - // Without the creature shader the hood ignores the camera's dither fade and blocks - // the view in first person; its own textures are kept. + // The hood is skinned to the Dvergr rig. Instantiated as-is its bones still point at + // the source prefab's transforms, so it renders at the world origin or not at all - + // which is exactly why the first attempt was invisible. Rebinding it to the player's + // own bones by name is what the Skeleton does for whole bodies, and it means the rig + // positions the hood for us instead of us guessing offsets. + Transform[] playerBones = visEq.m_bodyModel.bones; + bool rebound = false; + + foreach (SkinnedMeshRenderer smr in hood.GetComponentsInChildren(true)) + { + Transform[] bones = smr.bones; + Transform[] remapped = new Transform[bones.Length]; + for (int i = 0; i < bones.Length; i++) + { + Transform match = bones[i] != null ? FindBoneByName(playerBones, bones[i].name) : null; + remapped[i] = match != null ? match : playerBones[0]; + } + smr.bones = remapped; + + if (smr.rootBone != null) + { + smr.rootBone = FindBoneByName(playerBones, smr.rootBone.name) ?? playerBones[0]; + } + rebound = true; + } + + if (!rebound) + { + // A rigid hood rather than a skinned one: it has no bones to rebind, so it is + // simply hung off the head the way the Furling's head is. + Transform headBone = FindBoneByName(playerBones, "Head"); + if (headBone != null) hood.transform.SetParent(headBone, false); + } + + hood.transform.localPosition = DvergurConfig.HoodOffsetPosition; + hood.transform.localRotation = Quaternion.Euler(DvergurConfig.HoodOffsetRotation); + hood.transform.localScale = Vector3.one * DvergurConfig.HoodExtraScale; + + // Without the creature shader the hood ignores the camera's dither fade and fills the + // screen in first person; its own textures are kept. Shader dither = Shader.Find("Custom/Creature"); if (dither != null) { @@ -166,40 +224,80 @@ namespace RacesOfValheim } } + private static void StripBehaviours(GameObject obj) + { + // Anything that would make a decorative mesh behave like a world object - hover + // prompts, pickup triggers, AI, physics. + foreach (MonoBehaviour comp in obj.GetComponentsInChildren(true)) + { + Object.DestroyImmediate(comp); + } + foreach (Rigidbody body in obj.GetComponentsInChildren(true)) + { + Object.DestroyImmediate(body); + } + foreach (Collider col in obj.GetComponentsInChildren(true)) + { + Object.DestroyImmediate(col); + } + } + /// - /// First candidate prefab that resolves wins. A creature prefab is handled specially: the - /// Dvergr's headgear is a child renderer of the creature, not a standalone prefab, so the - /// piece is lifted out rather than the whole NPC being instantiated on the player's head. + /// Digs the headgear out of the Dvergr NPC prefab. Resolved once and remembered, including + /// the failure, so a missing prefab cannot turn into a per-frame log. /// private static GameObject ResolveHoodSource() { - foreach (string candidate in DvergurConfig.HoodPrefabCandidates) + if (hoodSourceResolved) return cachedHoodSource; + hoodSourceResolved = true; + + GameObject dverger = PrefabManager.Cache.GetPrefab(DvergurConfig.DvergerPrefabName); + if (dverger == null) { - GameObject prefab = PrefabManager.Cache.GetPrefab(candidate); - if (prefab == null) continue; + Jotunn.Logger.LogWarning($"[Dvergur] Prefab '{DvergurConfig.DvergerPrefabName}' not found; no hood."); + return null; + } - if (prefab.GetComponent() == null) return prefab; - - foreach (Renderer renderer in prefab.GetComponentsInChildren(true)) + foreach (Renderer renderer in dverger.GetComponentsInChildren(true)) + { + string name = renderer.gameObject.name.ToLower(); + foreach (string keyword in DvergurConfig.HoodRendererNames) { - string name = renderer.gameObject.name.ToLower(); - if (name.Contains("helmet") || name.Contains("hat") || name.Contains("hood") || name.Contains("cap")) - { - return renderer.gameObject; - } + if (!name.Contains(keyword)) continue; + + Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to '{renderer.gameObject.name}' ({renderer.GetType().Name})."); + cachedHoodSource = renderer.gameObject; + return cachedHoodSource; } } + + // Nothing matched, so say exactly what was on offer - that turns a silent invisible + // hood into a one-line fix in DvergurConfig.HoodRendererNames. + System.Text.StringBuilder sb = new System.Text.StringBuilder(); + foreach (Renderer renderer in dverger.GetComponentsInChildren(true)) + { + sb.Append(renderer.gameObject.name).Append(" (").Append(renderer.GetType().Name).Append("), "); + } + Jotunn.Logger.LogWarning( + $"[Dvergur] No renderer in '{DvergurConfig.DvergerPrefabName}' matched " + + $"[{string.Join(", ", DvergurConfig.HoodRendererNames)}]. Available: {sb}"); return null; } private static void RemoveHood(VisEquipment visEq) { - if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return; + if (visEq.m_bodyModel == null) return; - Transform headBone = FindBoneByName(visEq.m_bodyModel.bones, "Head"); - if (headBone == null) return; + Transform parent = visEq.m_bodyModel.transform.parent; + Transform hood = parent != null ? parent.Find(HoodName) : null; + + // Fall back to the head bone for the rigid-hood case, which parents itself there. + if (hood == null && visEq.m_bodyModel.bones != null) + { + Transform headBone = FindBoneByName(visEq.m_bodyModel.bones, "Head"); + if (headBone != null) hood = headBone.Find(HoodName); + } - Transform hood = headBone.Find(HoodName); if (hood == null) return; // never was a Dvergur - leave the helmet alone // Destroy is deferred to the end of the frame, so the object is renamed first: without @@ -216,6 +314,8 @@ namespace RacesOfValheim private static Transform FindBoneByName(Transform[] bones, string targetBoneName) { + if (bones == null || string.IsNullOrEmpty(targetBoneName)) return null; + foreach (Transform bone in bones) { if (bone != null && bone.name == targetBoneName) return bone; @@ -224,7 +324,9 @@ namespace RacesOfValheim string target = targetBoneName.ToLower(); foreach (Transform bone in bones) { - if (bone != null && bone.name.ToLower().Contains(target)) return bone; + if (bone == null) continue; + string name = bone.name.ToLower(); + if (name == target || name.Contains(target) || target.Contains(name)) return bone; } return null; } diff --git a/JotunnModStub/RaceScale.cs b/JotunnModStub/RaceScale.cs new file mode 100644 index 0000000..7c8f5fe --- /dev/null +++ b/JotunnModStub/RaceScale.cs @@ -0,0 +1,35 @@ +namespace RacesOfValheim +{ + /// + /// Which races size their own body. + /// + /// Several races postfix Player.Update and set the player's "Visual" scale from there. Each of + /// them also wants to undo that scale once the player is no longer of their race, and the + /// straightforward way to write that - "if this isn't my race, force the scale back to 1" - + /// makes every such race stamp on every other one, with the winner decided by whichever + /// postfix Harmony happened to run last. + /// + /// That is what left the Dvergur at full height: Trol's reset ran on the same frame and put it + /// straight back to 1. Asking here first means a race only ever resets a player that nobody + /// else is sizing. + /// + public static class RaceScale + { + private static readonly string[] SelfSizingRaces = + { + "Trol", + "Furling", + DvergurConfig.RaceId + }; + + public static bool ManagesOwnScale(string race) + { + if (string.IsNullOrEmpty(race)) return false; + foreach (string self in SelfSizingRaces) + { + if (race == self) return true; + } + return false; + } + } +} diff --git a/JotunnModStub/RacesOfValheim.cs b/JotunnModStub/RacesOfValheim.cs index 9b02236..ceb30bc 100644 --- a/JotunnModStub/RacesOfValheim.cs +++ b/JotunnModStub/RacesOfValheim.cs @@ -38,6 +38,7 @@ namespace RacesOfValheim CommandManager.Instance.AddConsoleCommand(new CheckProgressionCommand()); CommandManager.Instance.AddConsoleCommand(new IncreaseProgressionCommand()); CommandManager.Instance.AddConsoleCommand(new ResetProgressionCommand()); + CommandManager.Instance.AddConsoleCommand(new DumpDvergerCommand()); } /// @@ -592,8 +593,9 @@ namespace RacesOfValheim Player.m_localPlayer.GetSEMan().AddStatusEffect(DvergurConfig.StatsSE.GetStableHashCode(), true); - // The Dvergur keeps its own skin - only the silhouette and the hood change, so - // UpdateVisuals is enough and UpdateColors has nothing to do here. + // Saves the original skin first, so ResetRace can hand it back. + DvergurVisuals.ApplySkinColor(Player.m_localPlayer); + VisEquipment visEq = Player.m_localPlayer.GetComponent(); if (visEq != null) { @@ -690,6 +692,13 @@ namespace RacesOfValheim if (visEq != null) visEq.GetType().GetMethod("UpdateColors", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public)?.Invoke(visEq, null); } + // Re-tinted rather than merely refreshed: the skin colour is the one piece of the + // Dvergur that is not rebuilt from the race id on its own. + if (__instance.m_customData.ContainsKey("Race") && __instance.m_customData["Race"] == DvergurConfig.RaceId) + { + DvergurVisuals.ApplySkinColor(__instance); + } + // Check for Race Selection if (!__instance.m_customData.ContainsKey("Race")) { @@ -768,6 +777,82 @@ namespace RacesOfValheim } } + /// + /// Dumps the Dvergr NPC prefab: its transform tree, every renderer on it, and its per-star + /// LevelEffects colours. Prefab contents live in the asset bundles and cannot be read outside + /// a running game, so this is how the hood mesh and the star tints get identified. + /// + public class DumpDvergerCommand : ConsoleCommand + { + public override string Name => "dumpdverger"; + public override string Help => "[DEBUG] Logs the Dverger prefab hierarchy, renderers and star colours"; + + public override void Run(string[] args) + { + string prefabName = args.Length > 0 ? args[0] : DvergurConfig.DvergerPrefabName; + GameObject prefab = Jotunn.Managers.PrefabManager.Cache.GetPrefab(prefabName); + if (prefab == null) + { + Console.instance.Print($"Prefab '{prefabName}' not found."); + return; + } + + Jotunn.Logger.LogInfo($"=== {prefabName} HIERARCHY ==="); + DumpTransform(prefab.transform, ""); + + Jotunn.Logger.LogInfo($"=== {prefabName} RENDERERS ==="); + foreach (Renderer renderer in prefab.GetComponentsInChildren(true)) + { + Jotunn.Logger.LogInfo($" {renderer.gameObject.name} ({renderer.GetType().Name}) path={GetPath(renderer.transform)}"); + } + + LevelEffects levelEffects = prefab.GetComponentInChildren(true); + if (levelEffects != null && levelEffects.m_levelSetups != null) + { + Jotunn.Logger.LogInfo($"=== {prefabName} LEVEL SETUPS (index 0 = 1 star) ==="); + for (int i = 0; i < levelEffects.m_levelSetups.Count; i++) + { + var setup = levelEffects.m_levelSetups[i]; + if (setup == null) continue; + Jotunn.Logger.LogInfo( + $" [{i}] scale={setup.m_scale} hue={setup.m_hue} sat={setup.m_saturation} val={setup.m_value} " + + $"emissive={setup.m_setEmissiveColor}:{setup.m_emissiveColor}"); + } + } + else + { + Jotunn.Logger.LogInfo($"{prefabName} has no LevelEffects."); + } + + Console.instance.Print($"Dumped '{prefabName}' to the BepInEx log."); + } + + private static void DumpTransform(Transform t, string indent) + { + if (t == null) return; + + System.Text.StringBuilder components = new System.Text.StringBuilder(); + foreach (Component c in t.GetComponents()) + { + if (c != null) components.Append(c.GetType().Name).Append(" "); + } + + Jotunn.Logger.LogInfo($"{indent}{t.name} [{components}]"); + for (int i = 0; i < t.childCount; i++) DumpTransform(t.GetChild(i), indent + " "); + } + + private static string GetPath(Transform t) + { + string path = t.name; + while (t.parent != null) + { + t = t.parent; + path = t.name + "/" + path; + } + return path; + } + } + public class ResetProgressionCommand : ConsoleCommand { public override string Name => "resetprogression"; diff --git a/JotunnModStub/Trol/TrolPatches.cs b/JotunnModStub/Trol/TrolPatches.cs index 4492d82..a049085 100644 --- a/JotunnModStub/Trol/TrolPatches.cs +++ b/JotunnModStub/Trol/TrolPatches.cs @@ -176,8 +176,11 @@ namespace RacesOfValheim } } } - else if (Mathf.Abs(visual.transform.localScale.x - 1f) > 0.001f) + else if (!RaceScale.ManagesOwnScale(race) && Mathf.Abs(visual.transform.localScale.x - 1f) > 0.001f) { + // Races that size themselves are left alone. Without this guard the reset fires on + // every frame for a Furling or a Dvergur too, undoing their scale as fast as they + // set it, because both are applied from a postfix on this same method. visual.transform.localScale = Vector3.one; } } diff --git a/JotunnModStub/ZdoVisualSync.cs b/JotunnModStub/ZdoVisualSync.cs index a3b1a38..77b684b 100644 --- a/JotunnModStub/ZdoVisualSync.cs +++ b/JotunnModStub/ZdoVisualSync.cs @@ -83,9 +83,9 @@ namespace RacesOfValheim } else if (race == DvergurConfig.RaceId) { - // The hood itself is rebuilt by the VisEquipment patch; this keeps the shrunken - // silhouette and the hidden helmet asserted between those rebuilds. - DvergurVisuals.Apply(m_player); + // Scale is handled for every player by the Player.Update postfix; this only keeps + // the hood and the hidden helmet asserted between equipment refreshes. + DvergurVisuals.ApplyHood(m_player); } else {