From 3ec51aeb45c3be02225a6773d05f84ed27fd0aff Mon Sep 17 00:00:00 2001 From: kanym Date: Sun, 2 Aug 2026 21:45:44 +0200 Subject: [PATCH 1/6] feat(dvergur): add the Dvergur race scaffold An eighth race built on the existing per-race pattern: a MonoBehaviour driver registered from Awake, a progression table keyed on the boss state, an SE_Stats carrier, and Harmony patches for the individual perks. The helmet slot stays free. Whatever the player equips keeps every one of its stats and only its mesh is swapped for the dvergr hood, which is the Skeleton's helmet handling turned into a replacement rather than a plain hide. Every percentage the spec left open lives in DvergurConfig as a named value and is marked TODO there, so tuning the race never means touching the logic. The knobs are static readonly rather than const so that switching a perk off with a zero does not fold its guard into dead code. --- JotunnModStub/Dvergur/DvergurAbilities.cs | 207 ++++++++++++ JotunnModStub/Dvergur/DvergurConfig.cs | 237 ++++++++++++++ JotunnModStub/Dvergur/DvergurPatches.cs | 297 ++++++++++++++++++ JotunnModStub/Dvergur/DvergurProgression.cs | 82 +++++ JotunnModStub/Dvergur/DvergurRace.cs | 72 +++++ JotunnModStub/Dvergur/DvergurStatusEffects.cs | 139 ++++++++ JotunnModStub/Dvergur/DvergurVisuals.cs | 232 ++++++++++++++ JotunnModStub/RaceCompendium.cs | 48 ++- JotunnModStub/RacesOfValheim.cs | 46 +++ JotunnModStub/ZdoVisualSync.cs | 6 + 10 files changed, 1365 insertions(+), 1 deletion(-) create mode 100644 JotunnModStub/Dvergur/DvergurAbilities.cs create mode 100644 JotunnModStub/Dvergur/DvergurConfig.cs create mode 100644 JotunnModStub/Dvergur/DvergurPatches.cs create mode 100644 JotunnModStub/Dvergur/DvergurProgression.cs create mode 100644 JotunnModStub/Dvergur/DvergurRace.cs create mode 100644 JotunnModStub/Dvergur/DvergurStatusEffects.cs create mode 100644 JotunnModStub/Dvergur/DvergurVisuals.cs diff --git a/JotunnModStub/Dvergur/DvergurAbilities.cs b/JotunnModStub/Dvergur/DvergurAbilities.cs new file mode 100644 index 0000000..bd37f69 --- /dev/null +++ b/JotunnModStub/Dvergur/DvergurAbilities.cs @@ -0,0 +1,207 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// The Dvergur's two eitr abilities. + /// + /// Runic Ping (Yagluth) - spend eitr to light up ore veins and hidden enemies nearby. + /// Runic Overcharge (Fader) - spend eitr to load the next blow of a favoured weapon. + /// + /// Both are driven from DvergurRace.Update and both read their cost, radius, duration and + /// cooldown out of DvergurConfig. + /// + public static class DvergurAbilities + { + private static float lastPingTime = -1000f; + private static float lastOverchargeTime = -1000f; + + public static void Tick(Player player, int state) + { + // Ability input is gated exactly like every other race's: RaceInput mirrors + // Player.TakeInput, so nothing fires while a map, chest or chat window has focus. + if (!RaceInput.Allowed) return; + + DvergurProgression.DvergurRules rules = DvergurProgression.GetRules(state); + + if (rules.RunicPing && Input.GetKeyDown(DvergurConfig.RunicPingKey)) + { + TryRunicPing(player); + } + + if (rules.RunicOvercharge && Input.GetKeyDown(DvergurConfig.RunicOverchargeKey)) + { + TryRunicOvercharge(player); + } + } + + // ─── Runic Ping ────────────────────────────────────────────────────── + + private static void TryRunicPing(Player player) + { + if (Time.time - lastPingTime < DvergurConfig.RunicPingCooldown) return; + + if (player.GetEitr() < DvergurConfig.RunicPingEitrCost) + { + player.Message(MessageHud.MessageType.Center, "Not enough eitr"); + return; + } + + player.UseEitr(DvergurConfig.RunicPingEitrCost); + lastPingTime = Time.time; + DvergurStatusEffects.ApplyCooldownIcon(DvergurConfig.RunicPingCdSE, DvergurConfig.RunicPingCooldown); + + int marked = MarkSurroundings(player); + player.Message(MessageHud.MessageType.Center, + marked > 0 ? $"Runic Ping: {marked} echoes answer" : "Runic Ping: the stone is silent"); + } + + /// + /// Lights every ore vein and every hostile within the radius for the duration. The marker + /// is a local point light parented to the target, the same trick the Aswid's Auspex uses - + /// nothing is replicated, so it costs other players nothing. + /// + private static int MarkSurroundings(Player player) + { + Vector3 center = player.transform.position; + HashSet alreadyMarked = new HashSet(); + int marked = 0; + + foreach (Collider collider in Physics.OverlapSphere(center, DvergurConfig.RunicPingRadius)) + { + if (collider == null) continue; + + GameObject vein = FindVeinRoot(collider); + if (vein == null || !alreadyMarked.Add(vein)) continue; + + SpawnMarker(vein.transform, DvergurConfig.RunicPingOreColor); + marked++; + } + + foreach (Character character in Character.GetAllCharacters()) + { + if (character == null || character == player || character.IsDead() || character.IsTamed()) continue; + if (Vector3.Distance(character.transform.position, center) > DvergurConfig.RunicPingRadius) continue; + if (!BaseAI.IsEnemy(player, character)) continue; + if (!alreadyMarked.Add(character.gameObject)) continue; + + SpawnMarker(character.transform, DvergurConfig.RunicPingEnemyColor); + marked++; + } + + return marked; + } + + /// + /// The mineable object a collider belongs to, or null. Both halves matter: the component + /// check keeps ordinary terrain out, and the name check keeps plain rock and trees out of + /// what is meant to read as an ore reading. + /// + private static GameObject FindVeinRoot(Collider collider) + { + GameObject root = null; + + MineRock5 mineRock5 = collider.GetComponentInParent(); + if (mineRock5 != null) root = mineRock5.gameObject; + + if (root == null) + { + MineRock mineRock = collider.GetComponentInParent(); + if (mineRock != null) root = mineRock.gameObject; + } + + if (root == null) + { + Destructible destructible = collider.GetComponentInParent(); + if (destructible != null && destructible.m_destructibleType != DestructibleType.Tree) + { + root = destructible.gameObject; + } + } + + if (root == null) return null; + + string name = root.name.ToLower(); + foreach (string veinName in DvergurConfig.RunicPingVeinNames) + { + if (name.Contains(veinName)) return root; + } + return null; + } + + private static void SpawnMarker(Transform target, Color color) + { + GameObject markerObj = new GameObject("DvergurRunicMark"); + markerObj.transform.SetParent(target, false); + markerObj.transform.localPosition = Vector3.up; + + Light light = markerObj.AddComponent(); + light.type = LightType.Point; + light.color = color; + light.range = DvergurConfig.RunicPingLightRange; + light.intensity = DvergurConfig.RunicPingLightIntensity; + light.shadows = LightShadows.None; + + if (DvergurRace.Instance != null) + { + DvergurRace.Instance.StartCoroutine(DestroyAfter(markerObj, DvergurConfig.RunicPingDuration)); + } + else + { + // No driver to run the coroutine on: better a marker that never appears than one + // that never goes away. + Object.Destroy(markerObj); + } + } + + private static IEnumerator DestroyAfter(GameObject obj, float seconds) + { + yield return new WaitForSeconds(seconds); + if (obj != null) Object.Destroy(obj); + } + + // ─── Runic Overcharge ──────────────────────────────────────────────── + + private static void TryRunicOvercharge(Player player) + { + if (Time.time - lastOverchargeTime < DvergurConfig.RunicOverchargeCooldown) return; + + int overchargeHash = DvergurConfig.OverchargeSE.GetStableHashCode(); + if (player.GetSEMan().HaveStatusEffect(overchargeHash)) return; // already loaded + + if (player.GetEitr() < DvergurConfig.RunicOverchargeEitrCost) + { + player.Message(MessageHud.MessageType.Center, "Not enough eitr"); + return; + } + + player.UseEitr(DvergurConfig.RunicOverchargeEitrCost); + lastOverchargeTime = Time.time; + DvergurStatusEffects.ApplyCooldownIcon(DvergurConfig.OverchargeCdSE, DvergurConfig.RunicOverchargeCooldown); + + player.GetSEMan().AddStatusEffect(overchargeHash, true); + StatusEffect se = player.GetSEMan().GetStatusEffect(overchargeHash); + // The charge is held, not permanent: it lapses if no favoured blow lands in time. + if (se != null) se.m_ttl = DvergurConfig.RunicOverchargeWindow; + + player.Message(MessageHud.MessageType.Center, "Runic Overcharge: your next blow is loaded"); + } + + /// + /// Spends a held charge. Called from the damage patch once it has confirmed the blow was + /// struck with a weapon the Dvergur is at home with. + /// + public static bool ConsumeOvercharge(Player player) + { + if (player == null) return false; + + int hash = DvergurConfig.OverchargeSE.GetStableHashCode(); + if (!player.GetSEMan().HaveStatusEffect(hash)) return false; + + player.GetSEMan().RemoveStatusEffect(hash, true); + return true; + } + } +} diff --git a/JotunnModStub/Dvergur/DvergurConfig.cs b/JotunnModStub/Dvergur/DvergurConfig.cs new file mode 100644 index 0000000..36d9146 --- /dev/null +++ b/JotunnModStub/Dvergur/DvergurConfig.cs @@ -0,0 +1,237 @@ +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// Every tunable number the Dvergur uses, in one place. + /// + /// The race was specced with most percentages still open, so nothing here is baked into the + /// logic: DvergurProgression reads these to build its per-tier rules and the patches read the + /// rules, never a literal. Retuning the race means editing this file only. + /// + /// Values still marked TODO are placeholders chosen to be playable, not final. + /// + public static class DvergurConfig + { + // ─── Identity ──────────────────────────────────────────────────────── + // "Dvergur" is provisional. It is the value stored in m_customData["Race"] and in the + // ZDO, so renaming it after players have chosen the race would orphan their characters. + public const string RaceId = "Dvergur"; + + public const string StatsSE = "SE_DvergurStats"; + public const string OverchargeSE = "SE_DvergurOvercharge"; + public const string RunicPingCdSE = "SE_DvergurRunicPingCooldown"; + public const string OverchargeCdSE = "SE_DvergurOverchargeCooldown"; + + // Mirrors the ZDO key layout the other races use, so remote clients can read the tier + // without having the local player's progression state. + public const string StateZdoKey = "RacesOfValheim_DvergurState"; + + // ─── Model ─────────────────────────────────────────────────────────── + // Applied to the player's "Visual" child rather than the root transform, the way Furling + // does it: scaling the root would drag the collider and camera pivot along with it. + // Tuning knobs are static readonly rather than const throughout: a const folds at compile + // time, which turns "is this perk switched off?" guards into dead code the moment a knob + // 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 + + // ─── 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 + }; + + // 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; + + + // ─── Health malus ──────────────────────────────────────────────────── + // Indexed by progression state; index 0 is unused so the state number indexes directly. + // Base -10, growing to -20 once The Queen falls. + public static readonly float[] HealthMalusByState = + { + 0f, // (unused) + 10f, // 1 Base + 10f, // 2 Eikthyr + 10f, // 3 The Elder + 13f, // 4 Bonemass + 15f, // 5 Moder + 17.5f, // 6 Yagluth TODO: spec says -17/-18, pick one + 20f, // 7 The Queen + 20f // 8 Fader + }; + + // A Dvergur must never be reduced below this, however the malus and food line up. + public static readonly float MinMaxHealth = 5f; + + // ─── Weapon affinity ───────────────────────────────────────────────── + // Bonus damage plus a stamina discount on the attack. Neither scales with the tier - a + // tier only ever adds a new weapon to the list - and skill XP is deliberately untouched. + public struct WeaponAffinity + { + public Skills.SkillType Skill; + public int UnlockState; + public HitData.DamageType FlatDamageType; // channel the flat bonus lands on + public float FlatDamage; // TODO + public float DamagePercent; // TODO, share of physical damage added + public float StaminaPercent; // TODO, share of attack stamina refunded + public float StaminaFlat; // TODO, flat stamina refunded + public string DisplayName; + } + + public static readonly WeaponAffinity[] WeaponAffinities = + { + new WeaponAffinity + { + Skill = Skills.SkillType.Clubs, UnlockState = 1, + FlatDamageType = HitData.DamageType.Blunt, + FlatDamage = 0f, DamagePercent = 0.15f, + StaminaPercent = 0.20f, StaminaFlat = 0f, + DisplayName = "Hammer" + }, + new WeaponAffinity + { + Skill = Skills.SkillType.Bows, UnlockState = 2, + FlatDamageType = HitData.DamageType.Pierce, + FlatDamage = 0f, DamagePercent = 0.15f, + StaminaPercent = 0.20f, StaminaFlat = 0f, + DisplayName = "Bow" + }, + new WeaponAffinity + { + Skill = Skills.SkillType.Axes, UnlockState = 3, + FlatDamageType = HitData.DamageType.Slash, + FlatDamage = 0f, DamagePercent = 0.15f, + StaminaPercent = 0.20f, StaminaFlat = 0f, + DisplayName = "Axe" + }, + new WeaponAffinity + { + Skill = Skills.SkillType.Crossbows, UnlockState = 6, + FlatDamageType = HitData.DamageType.Pierce, + FlatDamage = 0f, DamagePercent = 0.15f, + StaminaPercent = 0.20f, StaminaFlat = 0f, + DisplayName = "Crossbow" + } + }; + + // ─── Mining affinity ───────────────────────────────────────────────── + // Unlocks alongside the antler pickaxe. + public const int MiningAffinityState = 2; + + // Faster mining is modelled as extra pickaxe damage per swing rather than a swing-rate + // change: rock HP is what actually gates how long a vein takes. + public static readonly float MiningDamageMultiplier = 1.20f; // TODO: 20% faster? + public static readonly float MiningStaminaPercent = 0.40f; // TODO: or 40% less stamina? + + // Chance for a mined vein to yield an extra unit of ore. 0 disables the yield half of + // the affinity and leaves it purely a speed/stamina perk. + public static readonly float MiningExtraDropChance = 0.25f; // TODO + + // Matched against the drop prefab name, lowercased, by Contains. + public static readonly string[] OreDropNames = + { + "copperore", "tinore", "ironscrap", "silverore", "blackmetalscrap", "flametalore" + }; + + // ─── Smithing / jewelry ────────────────────────────────────────────── + // Percentage saved on the metal cost of crafting and upgrading. Starts at Bonemass and + // caps at Moder. Indexed by progression state. + public static readonly float[] SmithingDiscountByState = + { + 0f, // (unused) + 0f, // 1 Base + 0f, // 2 Eikthyr + 0f, // 3 The Elder + 0.20f, // 4 Bonemass + 0.40f, // 5 Moder - cap + 0.40f, // 6 Yagluth + 0.40f, // 7 The Queen + 0.40f // 8 Fader + }; + + // Only these resources are discounted, which is what keeps the perk to smithing and + // jewelry rather than quietly cheapening every wooden wall the player puts up. + public static readonly string[] DiscountedResourceNames = + { + "copper", "tin", "bronze", "iron", "silver", "blackmetal", "flametal", + "ironnails", "bronzenails", "copperore", "tinore", "silverore", "flametalore", + "ruby", "amber", "amberpearl", "coins", "silvernecklace" + }; + + // ─── Haldor / Hildir favour ────────────────────────────────────────── + // Both halves of the trade: a discount on what the traders charge, and a bonus on what + // they pay for trophies and hunting rewards. Indexed by progression state. + public static readonly float[] TraderBuyDiscountByState = + { + 0f, // (unused) + 0f, // 1 Base + 0f, // 2 Eikthyr + 0f, // 3 The Elder + 0.10f, // 4 Bonemass - step 1 TODO + 0.15f, // 5 Moder - step 2 TODO + 0.20f, // 6 Yagluth - step 3 TODO + 0.25f, // 7 The Queen - full TODO + 0.25f // 8 Fader + }; + + public static readonly float[] TraderSellBonusByState = + { + 0f, // (unused) + 0f, // 1 Base + 0f, // 2 Eikthyr + 0f, // 3 The Elder + 0.10f, // 4 Bonemass - step 1 TODO + 0.20f, // 5 Moder - step 2 TODO + 0.30f, // 6 Yagluth - step 3 TODO + 0.40f, // 7 The Queen - full TODO + 0.40f // 8 Fader + }; + + // ─── Runic Ping (Yagluth) ──────────────────────────────────────────── + public const int RunicPingState = 6; + public const KeyCode RunicPingKey = KeyCode.G; + + public static readonly float RunicPingEitrCost = 25f; // TODO + public static readonly float RunicPingRadius = 40f; // TODO + public static readonly float RunicPingDuration = 10f; // TODO + public static readonly float RunicPingCooldown = 20f; // TODO + + public static readonly Color RunicPingOreColor = new Color(0.4f, 0.8f, 1f); + public static readonly Color RunicPingEnemyColor = new Color(1f, 0.35f, 0.35f); + public static readonly float RunicPingLightRange = 8f; + public static readonly float RunicPingLightIntensity = 2f; + + // Vein prefabs are matched on name, lowercased, by Contains - MineRock5_Copper, + // silvervein, rock4_copper and friends all fall out of this list. + public static readonly string[] RunicPingVeinNames = + { + "copper", "tin", "silvervein", "obsidian", "meteorite", "flametal", "mudpile", "leviathan" + }; + + // ─── Runic Overcharge (Fader) ──────────────────────────────────────── + public const int RunicOverchargeState = 8; + public const KeyCode RunicOverchargeKey = KeyCode.H; + + public static readonly float RunicOverchargeEitrCost = 60f; // TODO + public static readonly float RunicOverchargeMultiplier = 4f; // TODO, applied to physical damage + public static readonly float RunicOverchargeWindow = 15f; // seconds the charge is held + public static readonly float RunicOverchargeCooldown = 60f; // TODO + + // ─── Helpers ───────────────────────────────────────────────────────── + /// Clamped table lookup, so a state outside 1..8 can never index out of range. + public static float Lookup(float[] table, int state) + { + if (table == null || table.Length == 0) return 0f; + int index = Mathf.Clamp(state, BossProgressionManager.MinState, table.Length - 1); + return table[index]; + } + } +} diff --git a/JotunnModStub/Dvergur/DvergurPatches.cs b/JotunnModStub/Dvergur/DvergurPatches.cs new file mode 100644 index 0000000..bfe4d2e --- /dev/null +++ b/JotunnModStub/Dvergur/DvergurPatches.cs @@ -0,0 +1,297 @@ +using System.Collections.Generic; +using System.Reflection; +using HarmonyLib; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// Every hook the Dvergur needs. The patches only ever decide *whether* a perk applies; *how + /// much* it applies always comes from DvergurProgression, which in turn reads DvergurConfig. + /// + public static class DvergurPatches + { + // ─── 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. + /// + [HarmonyPatch] + public static class Dvergur_GetMaxHealth_Patch + { + public static MethodBase TargetMethod() => AccessTools.Method(typeof(Player), "GetMaxHealth"); + + public static void Postfix(Character __instance, ref float __result) + { + if (__instance == null || __instance != Player.m_localPlayer) return; + if (!DvergurRace.IsDvergur()) return; + + float malus = DvergurProgression.Current.HealthMalus; + if (malus <= 0f) return; + + __result = Mathf.Max(DvergurConfig.MinMaxHealth, __result - malus); + } + } + + // ─── Weapon affinity: damage ───────────────────────────────────────── + + /// + /// Bonus damage with hammer, bow, axe and crossbow as each is unlocked, and the payoff for + /// a held Runic Overcharge. Neither touches skill XP: the Dvergur is at home with these + /// weapons, not faster at learning them. + /// + [HarmonyPatch(typeof(Character), "Damage")] + public static class Dvergur_WeaponAffinity_Damage_Patch + { + public static void Prefix(Character __instance, HitData hit) + { + if (hit == null || Player.m_localPlayer == null) return; + if (hit.GetAttacker() != Player.m_localPlayer) return; + if (!DvergurRace.IsDvergur()) return; + + int state = BossProgressionManager.GetCurrentProgressionState(); + DvergurConfig.WeaponAffinity? found = DvergurProgression.GetAffinity(hit.m_skill, state); + if (!found.HasValue) return; + + DvergurConfig.WeaponAffinity affinity = found.Value; + + if (affinity.DamagePercent > 0f) + { + ScalePhysical(hit, 1f + affinity.DamagePercent); + } + + if (affinity.FlatDamage > 0f) + { + AddFlat(hit, affinity.FlatDamageType, affinity.FlatDamage); + } + + // Overcharge only ever discharges into a favoured weapon, which is why it is + // spent here rather than on the first hit of any kind. + if (DvergurProgression.GetRules(state).RunicOvercharge && + DvergurAbilities.ConsumeOvercharge(Player.m_localPlayer)) + { + ScalePhysical(hit, DvergurConfig.RunicOverchargeMultiplier); + Player.m_localPlayer.Message(MessageHud.MessageType.TopLeft, "Runic Overcharge discharges"); + } + } + + private static void ScalePhysical(HitData hit, float multiplier) + { + hit.m_damage.m_blunt *= multiplier; + hit.m_damage.m_slash *= multiplier; + hit.m_damage.m_pierce *= multiplier; + } + + private static void AddFlat(HitData hit, HitData.DamageType type, float amount) + { + switch (type) + { + case HitData.DamageType.Blunt: hit.m_damage.m_blunt += amount; break; + case HitData.DamageType.Slash: hit.m_damage.m_slash += amount; break; + case HitData.DamageType.Pierce: hit.m_damage.m_pierce += amount; break; + default: hit.m_damage.m_damage += amount; break; + } + } + } + + // ─── Mining affinity ───────────────────────────────────────────────── + + /// + /// Set for the duration of a mining hit so the drop patch below can tell an ore roll made + /// by this player apart from every other DropTable call in the world. Same flag-around-the + /// -call approach the Furling uses for its doubled ore. + /// + private static bool isDvergurMining = false; + + private static bool BeginMiningHit(HitData hit) + { + if (hit == null || Player.m_localPlayer == null) return false; + if (hit.GetAttacker() != Player.m_localPlayer) return false; + if (!DvergurRace.IsDvergur()) return false; + if (!DvergurProgression.Current.MiningAffinity) return false; + + // A pickaxe swing is what the affinity is about - chopping and combat hits on the same + // objects go through here too and must be left alone. + if (hit.m_damage.m_pickaxe <= 0f) return false; + + hit.m_damage.m_pickaxe *= DvergurConfig.MiningDamageMultiplier; + isDvergurMining = true; + return true; + } + + private static void EndMiningHit(bool began) + { + if (began) isDvergurMining = false; + } + + [HarmonyPatch(typeof(MineRock5), "DamageArea")] + public static class Dvergur_MineRock5_DamageArea_Patch + { + public static void Prefix(HitData hit, out bool __state) => __state = BeginMiningHit(hit); + public static void Postfix(bool __state) => EndMiningHit(__state); + } + + [HarmonyPatch(typeof(MineRock), "RPC_Hit")] + public static class Dvergur_MineRock_RPC_Hit_Patch + { + public static void Prefix(HitData hit, out bool __state) => __state = BeginMiningHit(hit); + public static void Postfix(bool __state) => EndMiningHit(__state); + } + + [HarmonyPatch(typeof(Destructible), "RPC_Damage")] + public static class Dvergur_Destructible_RPC_Damage_Patch + { + public static void Prefix(HitData hit, out bool __state) => __state = BeginMiningHit(hit); + public static void Postfix(bool __state) => EndMiningHit(__state); + } + + [HarmonyPatch(typeof(DropTable), "GetDropList", new System.Type[] { typeof(int) })] + public static class Dvergur_DropTable_GetDropList_Patch + { + public static void Postfix(ref List __result) + { + if (!isDvergurMining || __result == null) return; + if (DvergurConfig.MiningExtraDropChance <= 0f) return; + + List extra = new List(); + foreach (GameObject drop in __result) + { + if (drop == null || !IsOre(drop.name)) continue; + if (Random.value <= DvergurConfig.MiningExtraDropChance) extra.Add(drop); + } + __result.AddRange(extra); + } + + private static bool IsOre(string prefabName) + { + string lower = prefabName.ToLower(); + foreach (string ore in DvergurConfig.OreDropNames) + { + if (lower.Contains(ore)) return true; + } + return false; + } + } + + // ─── Smithing and jewelry ──────────────────────────────────────────── + + /// + /// Metal saved when crafting and upgrading. Requirement.GetAmount is the single point both + /// the crafting panel and Player.ConsumeResources go through, so the figure the player is + /// quoted and the figure they are charged can never drift apart. + /// + /// Scoped to the metals and gems in DvergurConfig.DiscountedResourceNames, which is what + /// keeps this a smithing perk rather than a blanket discount on every wooden wall. + /// + [HarmonyPatch(typeof(Piece.Requirement), "GetAmount")] + public static class Dvergur_Requirement_GetAmount_Patch + { + public static void Postfix(Piece.Requirement __instance, ref int __result) + { + if (__result <= 1 || Player.m_localPlayer == null) return; + if (!DvergurRace.IsDvergur()) return; + + float discount = DvergurProgression.Current.SmithingDiscount; + if (discount <= 0f) return; + + if (__instance == null || __instance.m_resItem == null) return; + if (!IsDiscounted(__instance.m_resItem.gameObject.name)) return; + + __result = Mathf.Max(1, Mathf.RoundToInt(__result * (1f - discount))); + } + + private static bool IsDiscounted(string prefabName) + { + string lower = prefabName.ToLower(); + foreach (string resource in DvergurConfig.DiscountedResourceNames) + { + if (lower == resource || lower.Contains(resource)) return true; + } + return false; + } + } + + // ─── Haldor and Hildir's favour ────────────────────────────────────── + + /// + /// The buying half. Both traders are Trader components, so patching the shared source of + /// the stock list covers Haldor and Hildir at once. + /// + /// The discounted entries are fresh TradeItem instances rather than edited originals: the + /// list Valheim hands back holds the trader's own objects, and rewriting their prices in + /// place would permanently mark down the shop for everyone, Dvergur or not. + /// + [HarmonyPatch(typeof(Trader), "GetAvailableItems")] + public static class Dvergur_Trader_GetAvailableItems_Patch + { + public static void Postfix(ref List __result) + { + if (__result == null || Player.m_localPlayer == null) return; + if (!DvergurRace.IsDvergur()) return; + + float discount = DvergurProgression.Current.TraderBuyDiscount; + if (discount <= 0f) return; + + List discounted = new List(__result.Count); + foreach (Trader.TradeItem item in __result) + { + if (item == null) continue; + + discounted.Add(new Trader.TradeItem + { + m_prefab = item.m_prefab, + m_stack = item.m_stack, + m_price = Mathf.Max(1, Mathf.RoundToInt(item.m_price * (1f - discount))), + m_requiredGlobalKey = item.m_requiredGlobalKey + }); + } + + __result = discounted; + } + } + + /// + /// The selling half - trophies and hunting rewards fetch more. GetValue is what the sell + /// button both displays and pays out, and it is not consulted for purchases, so the bonus + /// lands on exactly the side of the counter it is meant to. + /// + [HarmonyPatch(typeof(ItemDrop.ItemData), "GetValue")] + public static class Dvergur_ItemData_GetValue_Patch + { + public static void Postfix(ref int __result) + { + if (__result <= 0 || Player.m_localPlayer == null) return; + if (!DvergurRace.IsDvergur()) return; + + float bonus = DvergurProgression.Current.TraderSellBonus; + if (bonus <= 0f) return; + + __result = Mathf.RoundToInt(__result * (1f + bonus)); + } + } + + // ─── Cosmetic hood ─────────────────────────────────────────────────── + + /// + /// Runs for every player, local and remote, whenever Valheim rebuilds their visuals - the + /// point at which a newly equipped helmet has just been instantiated and needs hiding + /// again behind the hood. + /// + [HarmonyPatch(typeof(VisEquipment), "UpdateVisuals")] + public static class Dvergur_VisEquipment_UpdateVisuals_Patch + { + public static void Postfix(VisEquipment __instance) + { + if (__instance == null || !__instance.m_isPlayer) return; + + Player player = __instance.GetComponent(); + if (player == null) return; + + DvergurVisuals.Apply(player); + } + } + } +} diff --git a/JotunnModStub/Dvergur/DvergurProgression.cs b/JotunnModStub/Dvergur/DvergurProgression.cs new file mode 100644 index 0000000..8687411 --- /dev/null +++ b/JotunnModStub/Dvergur/DvergurProgression.cs @@ -0,0 +1,82 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// Turns a boss progression state into the set of Dvergur perks active at that tier, the same + /// way SkeletonProgression and SkadiProgression do for their races. + /// + /// Nothing is decided here - every figure comes out of DvergurConfig - so the tuning pass can + /// happen without touching a single patch. + /// + public static class DvergurProgression + { + public struct DvergurRules + { + /// Points subtracted from max health at this tier. + public float HealthMalus; + + /// Weapon skills the Dvergur is at home with, already filtered by tier. + public List Affinities; + + public bool MiningAffinity; + public float SmithingDiscount; + public float TraderBuyDiscount; + public float TraderSellBonus; + public bool RunicPing; + public bool RunicOvercharge; + } + + // GetRules runs from Update loops and from damage patches, so the per-state result is + // built once and handed back on every later call. + private static readonly DvergurRules[] cache = new DvergurRules[BossProgressionManager.MaxState + 1]; + private static readonly bool[] cached = new bool[BossProgressionManager.MaxState + 1]; + + public static DvergurRules GetRules(int state) + { + state = Mathf.Clamp(state, BossProgressionManager.MinState, BossProgressionManager.MaxState); + if (cached[state]) return cache[state]; + + List affinities = new List(); + foreach (DvergurConfig.WeaponAffinity affinity in DvergurConfig.WeaponAffinities) + { + if (state >= affinity.UnlockState) affinities.Add(affinity); + } + + DvergurRules rules = new DvergurRules + { + HealthMalus = DvergurConfig.Lookup(DvergurConfig.HealthMalusByState, state), + Affinities = affinities, + MiningAffinity = state >= DvergurConfig.MiningAffinityState, + SmithingDiscount = DvergurConfig.Lookup(DvergurConfig.SmithingDiscountByState, state), + TraderBuyDiscount = DvergurConfig.Lookup(DvergurConfig.TraderBuyDiscountByState, state), + TraderSellBonus = DvergurConfig.Lookup(DvergurConfig.TraderSellBonusByState, state), + RunicPing = state >= DvergurConfig.RunicPingState, + RunicOvercharge = state >= DvergurConfig.RunicOverchargeState + }; + + cache[state] = rules; + cached[state] = true; + return rules; + } + + /// Rules for whatever tier the local player is currently on. + public static DvergurRules Current => GetRules(BossProgressionManager.GetCurrentProgressionState()); + + /// + /// The affinity covering a weapon skill at the current tier, or null when the Dvergur has + /// no particular feel for it. Mining counts as an affinity for stamina purposes only, so + /// it is deliberately not part of this list. + /// + public static DvergurConfig.WeaponAffinity? GetAffinity(Skills.SkillType skill, int state) + { + DvergurRules rules = GetRules(state); + foreach (DvergurConfig.WeaponAffinity affinity in rules.Affinities) + { + if (affinity.Skill == skill) return affinity; + } + return null; + } + } +} diff --git a/JotunnModStub/Dvergur/DvergurRace.cs b/JotunnModStub/Dvergur/DvergurRace.cs new file mode 100644 index 0000000..319d58c --- /dev/null +++ b/JotunnModStub/Dvergur/DvergurRace.cs @@ -0,0 +1,72 @@ +using UnityEngine; + +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. + /// + public class DvergurRace : MonoBehaviour + { + public static DvergurRace Instance; + + private void Awake() + { + Instance = this; + } + + public void CreateModAssets() + { + DvergurStatusEffects.RegisterStatusEffects(); + } + + public static bool IsDvergur() + { + return Player.m_localPlayer != null && + Player.m_localPlayer.m_customData.ContainsKey("Race") && + Player.m_localPlayer.m_customData["Race"] == DvergurConfig.RaceId; + } + + private void Update() + { + Player player = Player.m_localPlayer; + if (player == null) return; + + if (!IsDvergur()) + { + DvergurVisuals.Apply(player); + return; + } + + DvergurVisuals.Apply(player); + + if (player.IsDead()) return; + + int state = BossProgressionManager.GetCurrentProgressionState(); + + // Keep the passive carrier attached. It is re-added rather than assumed because a + // respawn, a death or a world load all clear the player's status effects. + if (DvergurStatusEffects.StatsSE != null) + { + int hash = DvergurConfig.StatsSE.GetStableHashCode(); + if (!player.GetSEMan().HaveStatusEffect(hash)) + { + player.GetSEMan().AddStatusEffect(hash, true); + } + } + + // Published for remote clients, matching how the Skeleton replicates its tier. + ZNetView nview = player.GetComponent(); + if (nview != null && nview.IsValid()) + { + nview.GetZDO().Set(DvergurConfig.StateZdoKey, state); + } + + DvergurAbilities.Tick(player, state); + } + } +} diff --git a/JotunnModStub/Dvergur/DvergurStatusEffects.cs b/JotunnModStub/Dvergur/DvergurStatusEffects.cs new file mode 100644 index 0000000..3e3d0b3 --- /dev/null +++ b/JotunnModStub/Dvergur/DvergurStatusEffects.cs @@ -0,0 +1,139 @@ +using HarmonyLib; +using Jotunn.Entities; +using Jotunn.Managers; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// Passive carrier for the Dvergur. The stamina half of weapon affinity lives here rather than + /// in a Harmony patch because Valheim already routes attack cost through the status effects + /// (SEMan.ModifyAttackStaminaUsage), so there is nothing to intercept. + /// + public class SE_DvergurStats : SE_Stats + { + public override void Setup(Character character) + { + base.Setup(character); + name = DvergurConfig.StatsSE; + m_name = "Stone and Forge"; + m_tooltip = "Small, sturdy, and born to the anvil."; + } + + public override void ModifyAttackStaminaUsage(float baseStaminaUse, ref float staminaUse) + { + base.ModifyAttackStaminaUsage(baseStaminaUse, ref staminaUse); + + if (!(m_character is Player player) || player != Player.m_localPlayer) return; + if (!DvergurRace.IsDvergur()) return; + + int state = BossProgressionManager.GetCurrentProgressionState(); + + // m_rightItem rather than GetCurrentWeapon(): it is what the rest of the mod reaches + // for, and it is the item the swing is actually paying for. + ItemDrop.ItemData weapon = Traverse.Create(player).Field("m_rightItem").Value; + if (weapon == null || weapon.m_shared == null) return; + + Skills.SkillType skill = weapon.m_shared.m_skillType; + + // Mining is a discount on the pickaxe, not a weapon affinity, so it is checked apart. + if (skill == Skills.SkillType.Pickaxes) + { + if (DvergurProgression.GetRules(state).MiningAffinity) + { + staminaUse = Mathf.Max(0f, staminaUse * (1f - DvergurConfig.MiningStaminaPercent)); + } + return; + } + + DvergurConfig.WeaponAffinity? affinity = DvergurProgression.GetAffinity(skill, state); + if (!affinity.HasValue) return; + + // Static by design: the discount is the same the day it unlocks as it is after Fader. + staminaUse = Mathf.Max(0f, staminaUse * (1f - affinity.Value.StaminaPercent) - affinity.Value.StaminaFlat); + } + } + + /// + /// Runic Overcharge, held between the cast and the blow that spends it. Purely a marker with a + /// countdown - DvergurPatches reads it when the next affine hit lands. + /// + public class SE_DvergurOvercharge : StatusEffect + { + } + + /// + /// Ability cooldowns. They exist only so the HUD has something to count down, the way + /// SE_SkadiAbilityCooldown does: Valheim prints the remaining time of any effect with a m_ttl. + /// + public class SE_DvergurAbilityCooldown : StatusEffect + { + } + + public static class DvergurStatusEffects + { + public static SE_DvergurStats StatsSE { get; private set; } + + public static void RegisterStatusEffects() + { + Sprite icon = GetItemIcon("HelmetDverger") ?? GetItemIcon("DvergrKeyFragment") ?? GetItemIcon("Copper"); + + var stats = ScriptableObject.CreateInstance(); + stats.name = DvergurConfig.StatsSE; + stats.m_name = "Stone and Forge"; + stats.m_icon = icon; + CustomStatusEffect customStats = new CustomStatusEffect(stats, fixReference: false); + ItemManager.Instance.AddStatusEffect(customStats); + StatsSE = customStats.StatusEffect as SE_DvergurStats; + + var overcharge = ScriptableObject.CreateInstance(); + overcharge.name = DvergurConfig.OverchargeSE; + overcharge.m_name = "Runic Overcharge"; + overcharge.m_tooltip = "Your next blow with a favoured weapon carries the whole of the charge."; + overcharge.m_icon = GetItemIcon("Eitr") ?? icon; + ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(overcharge, fixReference: false)); + + var pingCd = ScriptableObject.CreateInstance(); + pingCd.name = DvergurConfig.RunicPingCdSE; + pingCd.m_name = "Runic Ping"; + pingCd.m_tooltip = "The runes must settle before you may call on them again."; + pingCd.m_icon = GetItemIcon("DvergrKeyFragment") ?? icon; + ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(pingCd, fixReference: false)); + + var overchargeCd = ScriptableObject.CreateInstance(); + overchargeCd.name = DvergurConfig.OverchargeCdSE; + overchargeCd.m_name = "Overcharge Cooldown"; + overchargeCd.m_tooltip = "The runes are spent."; + overchargeCd.m_icon = GetItemIcon("Eitr") ?? icon; + ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(overchargeCd, fixReference: false)); + } + + /// + /// Drives the HUD countdown for an ability, mirroring SkadiRace.ApplyCooldownIcon: the + /// effect only has to exist with a m_ttl for the icon to tick down by itself. + /// + public static void ApplyCooldownIcon(string effectName, float seconds) + { + if (Player.m_localPlayer == null || seconds <= 0f) return; + + int hash = effectName.GetStableHashCode(); + SEMan seman = Player.m_localPlayer.GetSEMan(); + seman.RemoveStatusEffect(hash, true); + seman.AddStatusEffect(hash, true); + + StatusEffect se = seman.GetStatusEffect(hash); + if (se != null) se.m_ttl = seconds; + } + + private static Sprite GetItemIcon(string prefabName) + { + GameObject prefab = PrefabManager.Cache.GetPrefab(prefabName)?.gameObject; + ItemDrop drop = prefab != null ? prefab.GetComponent() : null; + if (drop != null && drop.m_itemData.m_shared.m_icons.Length > 0) + { + return drop.m_itemData.m_shared.m_icons[0]; + } + return null; + } + } +} diff --git a/JotunnModStub/Dvergur/DvergurVisuals.cs b/JotunnModStub/Dvergur/DvergurVisuals.cs new file mode 100644 index 0000000..fc93a24 --- /dev/null +++ b/JotunnModStub/Dvergur/DvergurVisuals.cs @@ -0,0 +1,232 @@ +using HarmonyLib; +using Jotunn.Managers; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// The Dvergur's looks: a short body 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. + /// + public static class DvergurVisuals + { + private const string HoodName = "DvergurHood"; + + /// + /// 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. + /// + public static string GetPlayerRace(Player player) + { + if (player == null) return "Human"; + + ZNetView nview = player.GetComponent(); + if (nview != null && nview.IsValid()) + { + return nview.GetZDO().GetString("RacesOfValheim_Race", "Human"); + } + + if (player.m_customData != null && player.m_customData.TryGetValue("Race", out string race)) + { + return race; + } + return "Human"; + } + + public static bool IsDvergurPlayer(Player player) => GetPlayerRace(player) == DvergurConfig.RaceId; + + /// + /// 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. + /// + public static void Apply(Player player) + { + if (player == null) return; + + bool isDvergur = IsDvergurPlayer(player) && !player.IsDead(); + + ApplyScale(player, isDvergur); + + VisEquipment visEq = player.GetComponent(); + if (visEq == null) return; + + if (isDvergur) + { + EnsureHood(visEq); + HideEquippedHelmet(visEq); + } + else + { + RemoveHood(visEq); + } + } + + 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 + /// approach the Skeleton already proved out. + /// + private static void HideEquippedHelmet(VisEquipment visEq) + { + GameObject helmet = Traverse.Create(visEq).Field("m_helmetItemInstance").Value; + if (helmet != null && helmet.transform.localScale != Vector3.zero) + { + helmet.transform.localScale = Vector3.zero; + } + } + + private static void EnsureHood(VisEquipment visEq) + { + if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return; + + Transform headBone = FindBoneByName(visEq.m_bodyModel.bones, "Head"); + if (headBone == null) return; + + Transform existing = headBone.Find(HoodName); + if (existing != null) + { + if (!existing.gameObject.activeSelf) existing.gameObject.SetActive(true); + return; + } + + 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; + } + + bool wasActive = source.activeSelf; + source.SetActive(false); + GameObject hood = Object.Instantiate(source, headBone, 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); + } + + 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. + Shader dither = Shader.Find("Custom/Creature"); + if (dither != null) + { + foreach (Renderer renderer in hood.GetComponentsInChildren(true)) + { + if (renderer.material != null) renderer.material.shader = dither; + } + } + } + + /// + /// 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. + /// + private static GameObject ResolveHoodSource() + { + foreach (string candidate in DvergurConfig.HoodPrefabCandidates) + { + GameObject prefab = PrefabManager.Cache.GetPrefab(candidate); + if (prefab == null) continue; + + if (prefab.GetComponent() == null) return prefab; + + foreach (Renderer renderer in prefab.GetComponentsInChildren(true)) + { + string name = renderer.gameObject.name.ToLower(); + if (name.Contains("helmet") || name.Contains("hat") || name.Contains("hood") || name.Contains("cap")) + { + return renderer.gameObject; + } + } + } + return null; + } + + private static void RemoveHood(VisEquipment visEq) + { + if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return; + + Transform headBone = FindBoneByName(visEq.m_bodyModel.bones, "Head"); + if (headBone == null) return; + + 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 + // that, every call until it actually goes away finds it again and re-runs the restore. + hood.name = HoodName + "_Removed"; + Object.Destroy(hood.gameObject); + + GameObject helmet = Traverse.Create(visEq).Field("m_helmetItemInstance").Value; + if (helmet != null && helmet.transform.localScale == Vector3.zero) + { + helmet.transform.localScale = Vector3.one; + } + } + + private static Transform FindBoneByName(Transform[] bones, string targetBoneName) + { + foreach (Transform bone in bones) + { + if (bone != null && bone.name == targetBoneName) return bone; + } + + string target = targetBoneName.ToLower(); + foreach (Transform bone in bones) + { + if (bone != null && bone.name.ToLower().Contains(target)) return bone; + } + return null; + } + } +} diff --git a/JotunnModStub/RaceCompendium.cs b/JotunnModStub/RaceCompendium.cs index 022f25f..eee4c6a 100644 --- a/JotunnModStub/RaceCompendium.cs +++ b/JotunnModStub/RaceCompendium.cs @@ -15,7 +15,8 @@ namespace RacesOfValheim "Skeleton Secrets", "Furling Secrets", "Trol Secrets", - "Draugh Secrets" + "Draugh Secrets", + "Dvergur Secrets" }; public static void UpdateCompendiumText(Player player) @@ -67,6 +68,51 @@ namespace RacesOfValheim { GenerateDraughText(knownTexts, state, player); } + else if (currentRace == DvergurConfig.RaceId) + { + GenerateDvergurText(knownTexts, state); + } + } + + /// + /// Reads its figures straight out of the live rules rather than restating them, so the + /// entry cannot drift from the code the way a hand-written percentage would. + /// + private static void GenerateDvergurText(Dictionary knownTexts, int state) + { + DvergurProgression.DvergurRules rules = DvergurProgression.GetRules(state); + + StringBuilder sb = new StringBuilder(); + sb.AppendLine("The Dvergur's Craft\n"); + + sb.AppendLine($"[Base Passive] Small and Stubborn: You stand a third shorter than a human and carry {rules.HealthMalus:0.#} less health for it. The dvergr hood never leaves your head - wear whatever helm you please and keep every point of its protection, but the runes will always show you as one of the deep folk.\n"); + + List weapons = new List(); + foreach (DvergurConfig.WeaponAffinity affinity in rules.Affinities) + { + weapons.Add(affinity.DisplayName); + } + if (weapons.Count > 0) + { + sb.AppendLine($"Weapon Affinity (Passive): {string.Join(", ", weapons.ToArray())}. Blows struck with these land harder and cost less stamina. The saving never grows - a tier only ever hands you another weapon to feel at home with - and your skill rises no faster than anyone else's.\n"); + } + + if (rules.MiningAffinity) + sb.AppendLine("[Eikthyr Unlock] Mining Affinity (Passive): The pickaxe answers to you. Veins break faster, cost you less stamina to work, and sometimes give up more than they should.\n"); + + if (rules.SmithingDiscount > 0f) + sb.AppendLine($"[Bonemass Unlock] Smithing and Jewelry (Passive): You waste nothing at the anvil. Metal and gems cost you {rules.SmithingDiscount * 100f:0}% less when crafting and upgrading.\n"); + + if (rules.TraderBuyDiscount > 0f || rules.TraderSellBonus > 0f) + sb.AppendLine($"[Bonemass Unlock] Kin of the Traders (Passive): Haldor and Hildir know their own. Their prices drop by {rules.TraderBuyDiscount * 100f:0}% for you, and what they pay for your trophies and hunting rewards rises by {rules.TraderSellBonus * 100f:0}%.\n"); + + if (rules.RunicPing) + sb.AppendLine($"[Yagluth Unlock] Runic Ping ('{DvergurConfig.RunicPingKey}' Key): Spend {DvergurConfig.RunicPingEitrCost:0} eitr to send a pulse through the stone. For {DvergurConfig.RunicPingDuration:0} seconds every ore vein and every hidden enemy within {DvergurConfig.RunicPingRadius:0} meters is lit for you alone.\n"); + + if (rules.RunicOvercharge) + sb.AppendLine($"[Fader Unlock] Runic Overcharge ('{DvergurConfig.RunicOverchargeKey}' Key): Spend {DvergurConfig.RunicOverchargeEitrCost:0} eitr to load the runes. Your next blow with a favoured weapon lands with {DvergurConfig.RunicOverchargeMultiplier:0}x its weight. Hold the charge no longer than {DvergurConfig.RunicOverchargeWindow:0} seconds or it bleeds away.\n"); + + knownTexts["Dvergur Secrets"] = sb.ToString(); } private static void GenerateDraughText(Dictionary knownTexts, int state, Player player) diff --git a/JotunnModStub/RacesOfValheim.cs b/JotunnModStub/RacesOfValheim.cs index 1e1fd61..9b02236 100644 --- a/JotunnModStub/RacesOfValheim.cs +++ b/JotunnModStub/RacesOfValheim.cs @@ -32,6 +32,7 @@ namespace RacesOfValheim gameObject.AddComponent(); gameObject.AddComponent(); gameObject.AddComponent(); + gameObject.AddComponent(); PrefabManager.OnVanillaPrefabsAvailable += CreateAllModAssets; CommandManager.Instance.AddConsoleCommand(new ResetRaceCommand()); CommandManager.Instance.AddConsoleCommand(new CheckProgressionCommand()); @@ -72,6 +73,8 @@ namespace RacesOfValheim player.GetSEMan().RemoveStatusEffect("SE_SkeletonStats".GetStableHashCode()); player.GetSEMan().RemoveStatusEffect("SE_SkadiStats".GetStableHashCode()); player.GetSEMan().RemoveStatusEffect("SE_SkadiCooldown".GetStableHashCode()); + player.GetSEMan().RemoveStatusEffect(DvergurConfig.StatsSE.GetStableHashCode()); + player.GetSEMan().RemoveStatusEffect(DvergurConfig.OverchargeSE.GetStableHashCode()); ZNetView nview = player.GetComponent(); if (nview != null && nview.IsValid()) nview.GetZDO().Set("RacesOfValheim_Race", "Human"); @@ -93,6 +96,7 @@ namespace RacesOfValheim FurlingRace.Instance.CreateModAssets(); TrolRace.Instance.CreateModAssets(); DraughRace.Instance.CreateModAssets(); + DvergurRace.Instance.CreateModAssets(); } // --- RACE SELECTION UI --- public void ShowRaceSelectionMenu() @@ -233,6 +237,9 @@ namespace RacesOfValheim CreateRaceButtonWithConfirm("Trol", new Vector2(150, -20), GetTrolIcon(), "Massive brute strength. Towering over others but slow to react.", SelectTrol); CreateRaceButtonWithConfirm("Draugh", new Vector2(450, -20), GetDraughIcon(), "A decaying undead warrior fueled by dark magic and extreme metal.", SelectDraugh); + // Row 3 (y = -140) + CreateRaceButtonWithConfirm("Dvergur", new Vector2(-450, -140), GetDvergurIcon(), "Small, stubborn smiths of the deep. Frail of frame, but masters of metal, mine and market.", SelectDvergur); + GUIManager.BlockInput(true); } @@ -575,6 +582,45 @@ namespace RacesOfValheim return null; } + private void SelectDvergur() + { + if (Player.m_localPlayer != null) + { + Player.m_localPlayer.m_customData["Race"] = DvergurConfig.RaceId; + ZNetView nview = Player.m_localPlayer.GetComponent(); + if (nview != null && nview.IsValid()) nview.GetZDO().Set("RacesOfValheim_Race", DvergurConfig.RaceId); + + 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. + VisEquipment visEq = Player.m_localPlayer.GetComponent(); + if (visEq != null) + { + visEq.GetType().GetMethod("UpdateVisuals", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public)?.Invoke(visEq, null); + } + + Player.m_localPlayer.Message(MessageHud.MessageType.Center, "You chose the path of the Dvergur."); + CloseRaceSelectionMenu(); + } + } + + private Sprite GetDvergurIcon() + { + GameObject prefab = PrefabManager.Cache.GetPrefab("HelmetDverger")?.gameObject; + if (prefab == null) prefab = PrefabManager.Cache.GetPrefab("DvergrKeyFragment")?.gameObject; + if (prefab == null) prefab = PrefabManager.Cache.GetPrefab("Copper")?.gameObject; + if (prefab != null) + { + ItemDrop drop = prefab.GetComponent(); + if (drop != null && drop.m_itemData.m_shared.m_icons.Length > 0) + { + return drop.m_itemData.m_shared.m_icons[0]; + } + } + return null; + } + public void CloseRaceSelectionMenu() { if (raceSelectionMenu != null) diff --git a/JotunnModStub/ZdoVisualSync.cs b/JotunnModStub/ZdoVisualSync.cs index b2bb17b..a3b1a38 100644 --- a/JotunnModStub/ZdoVisualSync.cs +++ b/JotunnModStub/ZdoVisualSync.cs @@ -81,6 +81,12 @@ namespace RacesOfValheim { // Managed externally in TrolPatches.cs } + 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); + } else { RevertAllVisuals(); From 79a54fb5336f0178c8ea70680b44bc3fe6a832eb Mon Sep 17 00:00:00 2001 From: kanym Date: Sun, 2 Aug 2026 22:58:11 +0200 Subject: [PATCH 2/6] 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 { From 8df7681ceab60086ad84a6ffde3e706ca14858a9 Mon Sep 17 00:00:00 2001 From: kanym Date: Sun, 2 Aug 2026 23:08:12 +0200 Subject: [PATCH 3/6] fix(dvergur): tint the skin from UpdateColors, and raise the height The tint was applied the way the race-selection menu appears to do it, with VisEquipment.SetSkinColor followed by UpdateColors, and had no visible effect. That pair is not what colours a player: UpdateColors rebuilds the body material from Valheim own state each refresh, so a tint only survives if it is written after it runs. Every race here that visibly changes colour already has a postfix on UpdateColors setting _SkinColor on the material, and the SetSkinColor calls in the menu are decorative on their own. The Dvergur now follows the Trol. Reading the race from the ZDO with a m_customData fallback and no local-player check covers the main-menu preview and the first spawn frame, where Player.m_localPlayer is still null. Nothing needs saving or restoring either, since the tint stops being applied the moment the race changes. Beard and hair go pale to match; the hood hides most of the hair but the beard shows. Height goes from 0.70 to 0.78. The spec asked for at least -30% but that read as too small beside a human on screen. --- JotunnModStub/Dvergur/DvergurConfig.cs | 14 +++++--- JotunnModStub/Dvergur/DvergurPatches.cs | 46 +++++++++++++++++++++++++ JotunnModStub/Dvergur/DvergurVisuals.cs | 34 ------------------ JotunnModStub/RacesOfValheim.cs | 13 +++---- 4 files changed, 60 insertions(+), 47 deletions(-) diff --git a/JotunnModStub/Dvergur/DvergurConfig.cs b/JotunnModStub/Dvergur/DvergurConfig.cs index dac8e68..af26423 100644 --- a/JotunnModStub/Dvergur/DvergurConfig.cs +++ b/JotunnModStub/Dvergur/DvergurConfig.cs @@ -33,12 +33,18 @@ namespace RacesOfValheim // Tuning knobs are static readonly rather than const throughout: a const folds at compile // time, which turns "is this perk switched off?" guards into dead code the moment a knob // 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 + // Nudged up from the 0.70 the spec asked for: -30% read as too small next to a human once + // it was actually on screen. + public static readonly float VisualScale = 0.78f; // -22% 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); + // Written straight onto the body material's _SkinColor by the UpdateColors postfix, which + // is the only thing that actually tints a player - see the comment on that patch. + // Ashen grey with a blue cast, to read as one of the deep folk. + public static readonly Color SkinColor = new Color(0.72f, 0.74f, 0.82f, 1f); + + // Dvergr are white-haired. The hood hides most of it, but the beard shows. + public static readonly Color HairColor = new Color(0.88f, 0.88f, 0.90f, 1f); // ─── Cosmetic hood ─────────────────────────────────────────────────── // The helmet slot itself stays free — whatever the player equips keeps all of its stats, diff --git a/JotunnModStub/Dvergur/DvergurPatches.cs b/JotunnModStub/Dvergur/DvergurPatches.cs index 250aae1..b54b3e5 100644 --- a/JotunnModStub/Dvergur/DvergurPatches.cs +++ b/JotunnModStub/Dvergur/DvergurPatches.cs @@ -300,6 +300,52 @@ namespace RacesOfValheim } } + // ─── Skin ──────────────────────────────────────────────────────────── + + /// + /// Tints the Dvergur ashen grey. + /// + /// The first attempt did this the way the race-selection menu appears to - VisEquipment's + /// SetSkinColor followed by UpdateColors - and nothing happened, because that pair is not + /// what actually colours a player. UpdateColors rebuilds the body material from Valheim's + /// own state on every refresh, so any tint has to be written *after* it runs. That is why + /// every race in this mod that visibly changes colour has a postfix here writing + /// _SkinColor onto the material directly, and why the SetSkinColor calls in the selection + /// menu are, on their own, decorative. + /// + /// No local-player check and no saved original: the race is read from the ZDO with a + /// m_customData fallback so the main-menu preview and the first spawn frame are covered + /// too, and the tint simply stops being applied once the player is no longer a Dvergur. + /// + [HarmonyPatch(typeof(VisEquipment), "UpdateColors")] + public static class Dvergur_VisEquipment_UpdateColors_Patch + { + public static void Postfix(VisEquipment __instance) + { + if (__instance == null || !__instance.m_isPlayer) return; + + Player player = __instance.GetComponent(); + if (player == null || !DvergurVisuals.IsDvergurPlayer(player)) return; + + if (__instance.m_bodyModel != null && __instance.m_bodyModel.material != null) + { + __instance.m_bodyModel.material.SetColor("_SkinColor", DvergurConfig.SkinColor); + } + + TintRenderers(Traverse.Create(__instance).Field("m_hairItemInstance").GetValue()); + TintRenderers(Traverse.Create(__instance).Field("m_beardItemInstance").GetValue()); + } + + private static void TintRenderers(GameObject instance) + { + if (instance == null) return; + foreach (Renderer renderer in instance.GetComponentsInChildren()) + { + if (renderer.material != null) renderer.material.SetColor("_SkinColor", DvergurConfig.HairColor); + } + } + } + // ─── Cosmetic hood ─────────────────────────────────────────────────── /// diff --git a/JotunnModStub/Dvergur/DvergurVisuals.cs b/JotunnModStub/Dvergur/DvergurVisuals.cs index 1742ae7..d5c05ec 100644 --- a/JotunnModStub/Dvergur/DvergurVisuals.cs +++ b/JotunnModStub/Dvergur/DvergurVisuals.cs @@ -78,40 +78,6 @@ namespace RacesOfValheim } } - // ─── 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 (!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 ──────────────────────────────────────────────────────────── /// diff --git a/JotunnModStub/RacesOfValheim.cs b/JotunnModStub/RacesOfValheim.cs index ceb30bc..95be5b1 100644 --- a/JotunnModStub/RacesOfValheim.cs +++ b/JotunnModStub/RacesOfValheim.cs @@ -593,9 +593,8 @@ namespace RacesOfValheim Player.m_localPlayer.GetSEMan().AddStatusEffect(DvergurConfig.StatsSE.GetStableHashCode(), true); - // Saves the original skin first, so ResetRace can hand it back. - DvergurVisuals.ApplySkinColor(Player.m_localPlayer); - + // No SetSkinColor here: the tint is written onto the material by the UpdateColors + // postfix in DvergurPatches, which keys off the race and so needs nothing saved. VisEquipment visEq = Player.m_localPlayer.GetComponent(); if (visEq != null) { @@ -692,12 +691,8 @@ 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); - } + // The Dvergur needs no entry here: its tint is applied by the UpdateColors postfix + // every time Valheim refreshes the body, rather than being stored on the player. // Check for Race Selection if (!__instance.m_customData.ContainsKey("Race")) From d157a730a3a843780f32b3f0ace348c3bd8765ce Mon Sep 17 00:00:00 2001 From: kanym Date: Sun, 2 Aug 2026 23:14:07 +0200 Subject: [PATCH 4/6] fix(dvergur): carve the hood out of the dvergr mesh as a submesh The log settled it: the Dverger prefab holds a single renderer, dvergr, with the hood, body and clothes baked into one mesh. There was never a separate object to lift out, so the whole-object search could only ever fail. Resolution now falls through three steps - a separate renderer object, a submesh picked out by its material name, and an index pinned by hand in DvergurConfig - and the submesh path rebuilds the chosen triangles as a standalone skinned renderer. Vertices, bone weights and bindposes are all carried over untouched and only the triangle list is narrowed, so the skinning still lines up and the player rig places the hood without any offsets. The candidate list also covers the mage variants, which wear a different hood and may keep it as its own object. dumpdverger now reports submesh count, per-submesh material and triangle count, which is the part that actually identifies the hood. --- JotunnModStub/Dvergur/DvergurConfig.cs | 22 ++- JotunnModStub/Dvergur/DvergurVisuals.cs | 244 ++++++++++++++++++------ JotunnModStub/RacesOfValheim.cs | 21 +- 3 files changed, 224 insertions(+), 63 deletions(-) diff --git a/JotunnModStub/Dvergur/DvergurConfig.cs b/JotunnModStub/Dvergur/DvergurConfig.cs index af26423..775b605 100644 --- a/JotunnModStub/Dvergur/DvergurConfig.cs +++ b/JotunnModStub/Dvergur/DvergurConfig.cs @@ -52,11 +52,31 @@ namespace RacesOfValheim // // 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. + // + // 'Dverger' turned out to carry a single renderer named 'dvergr' with the hood baked into + // the same mesh as the body, so a whole-object lift was never going to work. Resolution now + // tries, in order: a separate renderer object; a submesh of a combined mesh picked out by + // its material; and finally an index pinned by hand below. public const string DvergerPrefabName = "Dverger"; - // Matched against renderer object names inside that prefab, lowercased, by Contains. + // Scanned in order. The mage variants are included because they wear a different hood and + // may well keep it as its own object. + public static readonly string[] DvergerPrefabCandidates = + { + "Dverger", "DvergerMage", "DvergerMageFire", "DvergerMageIce", "DvergerMageSupport" + }; + + // Matched against renderer object names, lowercased, by Contains. public static readonly string[] HoodRendererNames = { "hat", "hood", "helmet", "cap" }; + // Matched against material names when the hood is a submesh of a combined mesh. + public static readonly string[] HoodMaterialNames = { "hat", "hood", "helm", "cap", "head" }; + + // Escape hatch for when neither name matches: pin the prefab and the submesh index by hand + // from what `dumpdverger` reports. An empty prefab or a negative index means "auto". + public const string HoodForcedPrefab = ""; + public const int HoodForcedSubmeshIndex = -1; + // 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; diff --git a/JotunnModStub/Dvergur/DvergurVisuals.cs b/JotunnModStub/Dvergur/DvergurVisuals.cs index d5c05ec..3110267 100644 --- a/JotunnModStub/Dvergur/DvergurVisuals.cs +++ b/JotunnModStub/Dvergur/DvergurVisuals.cs @@ -20,7 +20,7 @@ namespace RacesOfValheim // 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 HoodSource cachedHoodSource; private static bool hoodSourceResolved; /// @@ -128,65 +128,129 @@ namespace RacesOfValheim return; } - GameObject source = ResolveHoodSource(); - if (source == null) return; // already logged once by the resolver + HoodSource source = ResolveHoodSource(); + if (!source.Valid) return; // already logged once by the resolver + + Transform[] playerBones = visEq.m_bodyModel.bones; + GameObject hood = source.SubmeshIndex >= 0 + ? BuildFromSubmesh(source.Skinned, source.SubmeshIndex, parent, playerBones) + : BuildFromObject(source.Separate, parent, playerBones); + + if (hood == null) return; + + hood.name = HoodName; + hood.transform.localPosition = DvergurConfig.HoodOffsetPosition; + hood.transform.localRotation = Quaternion.Euler(DvergurConfig.HoodOffsetRotation); + hood.transform.localScale = Vector3.one * DvergurConfig.HoodExtraScale; + hood.SetActive(true); + } + + /// + /// Carves one submesh out of a combined skinned mesh and rebuilds it as a standalone + /// renderer bound to the player's rig. + /// + /// This is what the Dvergr needs: its prefab holds a single renderer, 'dvergr', with the + /// hood, the body and the clothes all in one mesh, so there is no object to lift out. Every + /// vertex, bone weight and bindpose is kept - only the triangle list is narrowed to the one + /// submesh - which means the skinning still lines up and the rig places the hood for us. + /// + private static GameObject BuildFromSubmesh(SkinnedMeshRenderer source, int submeshIndex, Transform parent, Transform[] playerBones) + { + Mesh sourceMesh = source.sharedMesh; + if (sourceMesh == null || submeshIndex >= sourceMesh.subMeshCount) return null; + + Mesh mesh = new Mesh(); + // Must be set before the vertex array on meshes above 65535 verts, or the indices + // silently truncate. + mesh.indexFormat = sourceMesh.indexFormat; + mesh.vertices = sourceMesh.vertices; + mesh.normals = sourceMesh.normals; + mesh.tangents = sourceMesh.tangents; + mesh.uv = sourceMesh.uv; + mesh.boneWeights = sourceMesh.boneWeights; + mesh.bindposes = sourceMesh.bindposes; + mesh.subMeshCount = 1; + mesh.SetTriangles(sourceMesh.GetTriangles(submeshIndex), 0); + mesh.RecalculateBounds(); + + GameObject obj = new GameObject(HoodName); + obj.transform.SetParent(parent, false); + + SkinnedMeshRenderer renderer = obj.AddComponent(); + renderer.sharedMesh = mesh; + + Material[] sourceMaterials = source.sharedMaterials; + if (submeshIndex < sourceMaterials.Length) + { + renderer.sharedMaterials = new[] { sourceMaterials[submeshIndex] }; + } + + RebindBones(renderer, source.bones, source.rootBone, playerBones); + ApplyDitherShader(obj); + return obj; + } + + private static GameObject BuildFromObject(GameObject source, Transform parent, Transform[] playerBones) + { + if (source == null) return null; bool wasActive = source.activeSelf; source.SetActive(false); GameObject hood = Object.Instantiate(source, parent, false); source.SetActive(wasActive); - hood.name = HoodName; StripBehaviours(hood); - hood.SetActive(true); - // 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; + // Instantiated as-is, a skinned mesh keeps bones pointing at the source prefab's + // transforms and so renders nowhere; rebinding to the player's own bones by name is + // what the Skeleton does for whole bodies. 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]; - } + RebindBones(smr, smr.bones, smr.rootBone, playerBones); 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. + // A rigid hood 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; + ApplyDitherShader(hood); + return hood; + } - // 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) + private static void RebindBones(SkinnedMeshRenderer renderer, Transform[] sourceBones, Transform sourceRoot, Transform[] playerBones) + { + if (playerBones == null || playerBones.Length == 0 || sourceBones == null) return; + + Transform[] remapped = new Transform[sourceBones.Length]; + for (int i = 0; i < sourceBones.Length; i++) { - foreach (Renderer renderer in hood.GetComponentsInChildren(true)) - { - if (renderer.material != null) renderer.material.shader = dither; - } + Transform match = sourceBones[i] != null ? FindBoneByName(playerBones, sourceBones[i].name) : null; + remapped[i] = match != null ? match : playerBones[0]; + } + renderer.bones = remapped; + renderer.rootBone = sourceRoot != null + ? (FindBoneByName(playerBones, sourceRoot.name) ?? playerBones[0]) + : playerBones[0]; + } + + /// + /// Without the creature shader the hood ignores the camera's dither fade and fills the + /// screen in first person; its own textures are kept. + /// + private static void ApplyDitherShader(GameObject obj) + { + Shader dither = Shader.Find("Custom/Creature"); + if (dither == null) return; + + foreach (Renderer renderer in obj.GetComponentsInChildren(true)) + { + if (renderer.material != null) renderer.material.shader = dither; } } @@ -212,42 +276,100 @@ namespace RacesOfValheim /// 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() + private static HoodSource ResolveHoodSource() { if (hoodSourceResolved) return cachedHoodSource; hoodSourceResolved = true; - GameObject dverger = PrefabManager.Cache.GetPrefab(DvergurConfig.DvergerPrefabName); - if (dverger == null) + // A hand-pinned prefab and index wins outright, for when neither name search finds it. + if (!string.IsNullOrEmpty(DvergurConfig.HoodForcedPrefab) && DvergurConfig.HoodForcedSubmeshIndex >= 0) { - Jotunn.Logger.LogWarning($"[Dvergur] Prefab '{DvergurConfig.DvergerPrefabName}' not found; no hood."); - return null; - } - - foreach (Renderer renderer in dverger.GetComponentsInChildren(true)) - { - string name = renderer.gameObject.name.ToLower(); - foreach (string keyword in DvergurConfig.HoodRendererNames) + GameObject forced = PrefabManager.Cache.GetPrefab(DvergurConfig.HoodForcedPrefab); + SkinnedMeshRenderer forcedRenderer = forced != null ? forced.GetComponentInChildren(true) : null; + if (forcedRenderer != null) { - if (!name.Contains(keyword)) continue; - - Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to '{renderer.gameObject.name}' ({renderer.GetType().Name})."); - cachedHoodSource = renderer.gameObject; + Jotunn.Logger.LogInfo($"[Dvergur] Hood pinned to '{DvergurConfig.HoodForcedPrefab}' submesh {DvergurConfig.HoodForcedSubmeshIndex}."); + cachedHoodSource = HoodSource.FromSubmesh(forcedRenderer, DvergurConfig.HoodForcedSubmeshIndex); 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)) + System.Text.StringBuilder report = new System.Text.StringBuilder(); + + foreach (string prefabName in DvergurConfig.DvergerPrefabCandidates) { - sb.Append(renderer.gameObject.name).Append(" (").Append(renderer.GetType().Name).Append("), "); + GameObject prefab = PrefabManager.Cache.GetPrefab(prefabName); + if (prefab == null) continue; + + // First choice: the hood is its own object. + foreach (Renderer renderer in prefab.GetComponentsInChildren(true)) + { + if (!MatchesAny(renderer.gameObject.name, DvergurConfig.HoodRendererNames)) continue; + + Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to object '{renderer.gameObject.name}' in '{prefabName}'."); + cachedHoodSource = HoodSource.FromObject(renderer.gameObject); + return cachedHoodSource; + } + + // Second choice: it is a submesh of a combined mesh, identified by its material. + foreach (SkinnedMeshRenderer smr in prefab.GetComponentsInChildren(true)) + { + Material[] materials = smr.sharedMaterials; + for (int i = 0; i < materials.Length; i++) + { + if (materials[i] == null || !MatchesAny(materials[i].name, DvergurConfig.HoodMaterialNames)) continue; + + Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to submesh {i} ('{materials[i].name}') of '{smr.name}' in '{prefabName}'."); + cachedHoodSource = HoodSource.FromSubmesh(smr, i); + return cachedHoodSource; + } + + // Nothing matched here, so record what this renderer actually offers. + report.Append($"\n {prefabName}/{smr.name}: submeshes={smr.sharedMesh?.subMeshCount ?? 0} materials=["); + for (int i = 0; i < materials.Length; i++) + { + report.Append(i).Append(':').Append(materials[i] != null ? materials[i].name : "null").Append(' '); + } + report.Append(']'); + } } + + // Say exactly what was on offer: that turns a silently invisible hood into a one-line + // fix in DvergurConfig, either a new keyword or a pinned submesh index. Jotunn.Logger.LogWarning( - $"[Dvergur] No renderer in '{DvergurConfig.DvergerPrefabName}' matched " + - $"[{string.Join(", ", DvergurConfig.HoodRendererNames)}]. Available: {sb}"); - return null; + $"[Dvergur] No hood found. Object names tried [{string.Join(", ", DvergurConfig.HoodRendererNames)}], " + + $"material names tried [{string.Join(", ", DvergurConfig.HoodMaterialNames)}]." + + $" Candidates:{report}"); + return HoodSource.None; + } + + /// Where the hood mesh comes from: a whole object, or one submesh of a shared mesh. + private struct HoodSource + { + public GameObject Separate; + public SkinnedMeshRenderer Skinned; + public int SubmeshIndex; + + public bool Valid => Separate != null || (Skinned != null && SubmeshIndex >= 0); + + public static HoodSource None => new HoodSource { SubmeshIndex = -1 }; + + public static HoodSource FromObject(GameObject obj) => + new HoodSource { Separate = obj, SubmeshIndex = -1 }; + + public static HoodSource FromSubmesh(SkinnedMeshRenderer renderer, int index) => + new HoodSource { Skinned = renderer, SubmeshIndex = index }; + } + + private static bool MatchesAny(string name, string[] keywords) + { + if (string.IsNullOrEmpty(name)) return false; + string lower = name.ToLower(); + foreach (string keyword in keywords) + { + if (lower.Contains(keyword)) return true; + } + return false; } private static void RemoveHood(VisEquipment visEq) diff --git a/JotunnModStub/RacesOfValheim.cs b/JotunnModStub/RacesOfValheim.cs index 95be5b1..600f3ea 100644 --- a/JotunnModStub/RacesOfValheim.cs +++ b/JotunnModStub/RacesOfValheim.cs @@ -795,10 +795,29 @@ namespace RacesOfValheim Jotunn.Logger.LogInfo($"=== {prefabName} HIERARCHY ==="); DumpTransform(prefab.transform, ""); + // Submeshes and their materials are the part that matters: the Dvergr carries its hood, + // body and clothes in one mesh, so the hood can only be picked out by submesh index. 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)}"); + Mesh mesh = null; + if (renderer is SkinnedMeshRenderer skinned) mesh = skinned.sharedMesh; + else + { + MeshFilter filter = renderer.GetComponent(); + if (filter != null) mesh = filter.sharedMesh; + } + + Jotunn.Logger.LogInfo( + $" {renderer.gameObject.name} ({renderer.GetType().Name}) " + + $"submeshes={(mesh != null ? mesh.subMeshCount : 0)} path={GetPath(renderer.transform)}"); + + Material[] materials = renderer.sharedMaterials; + for (int i = 0; i < materials.Length; i++) + { + int tris = (mesh != null && i < mesh.subMeshCount) ? mesh.GetTriangles(i).Length / 3 : 0; + Jotunn.Logger.LogInfo($" submesh {i}: material='{(materials[i] != null ? materials[i].name : "null")}' triangles={tris}"); + } } LevelEffects levelEffects = prefab.GetComponentInChildren(true); From 244f2f5afc2d9b1432780cb26265424dd7fb4508 Mon Sep 17 00:00:00 2001 From: kanym Date: Sun, 2 Aug 2026 23:24:24 +0200 Subject: [PATCH 5/6] fix(dvergur): isolate the hood by bone collapse, and commit to a skin tone The dump settled both. Skin: UpdateColors writes m_bodyModel.materials[0] _SkinColor, which is what the postfix already targeted, so the patch was never wrong - the colour was. _SkinColor multiplies the human skin texture rather than replacing it, and (0.72, 0.74, 0.82) is close enough to white to change nothing anyone can see. Every race that reads clearly commits to a channel, so the Dvergur now does too. Hood: the dvergr mesh reports zero triangles because it ships with Read/Write disabled, so its vertices and indices are unreachable at runtime and no submesh carving could ever have produced geometry. The rig does carry a hat1/hat2/hat3 chain that nothing but the hood is skinned to, so the hood is isolated without touching the mesh at all: instantiate the whole body, detach the hat chain from the skull, and collapse the armature root to zero scale, which pulls every vertex weighted to it into a single point and leaves only the hood standing. Alignment is computed rather than measured - the object is shifted by the gap between the hat bone and the player head bone - so there are no hand-tuned offsets, only optional nudges. Animator and LODGroup are stripped alongside the MonoBehaviours since neither is one and both would keep driving or hiding the rig, and the renderers are set to update when offscreen because the collapsed bones leave the skinned bounds meaningless. --- JotunnModStub/Dvergur/DvergurConfig.cs | 51 ++-- JotunnModStub/Dvergur/DvergurVisuals.cs | 341 +++++++++--------------- 2 files changed, 146 insertions(+), 246 deletions(-) diff --git a/JotunnModStub/Dvergur/DvergurConfig.cs b/JotunnModStub/Dvergur/DvergurConfig.cs index 775b605..11e406c 100644 --- a/JotunnModStub/Dvergur/DvergurConfig.cs +++ b/JotunnModStub/Dvergur/DvergurConfig.cs @@ -40,11 +40,16 @@ namespace RacesOfValheim // ─── Skin ──────────────────────────────────────────────────────────── // Written straight onto the body material's _SkinColor by the UpdateColors postfix, which // is the only thing that actually tints a player - see the comment on that patch. - // Ashen grey with a blue cast, to read as one of the deep folk. - public static readonly Color SkinColor = new Color(0.72f, 0.74f, 0.82f, 1f); + // + // This is a multiplier over the human skin texture, not a replacement, so a value near + // (1,1,1) changes nothing anyone can see. The first attempt at (0.72, 0.74, 0.82) was + // exactly that mistake: correct code, invisible result. Every race that reads clearly + // commits to a channel - Trol (0.1, 0.6, 0.7), Furling (0.3, 0.8, 0.3) - so the Dvergur + // does too: a cold, dark slate blue-grey. + public static readonly Color SkinColor = new Color(0.42f, 0.52f, 0.68f, 1f); // Dvergr are white-haired. The hood hides most of it, but the beard shows. - public static readonly Color HairColor = new Color(0.88f, 0.88f, 0.90f, 1f); + public static readonly Color HairColor = new Color(0.85f, 0.87f, 0.92f, 1f); // ─── Cosmetic hood ─────────────────────────────────────────────────── // The helmet slot itself stays free — whatever the player equips keeps all of its stats, @@ -53,32 +58,30 @@ namespace RacesOfValheim // 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. // - // 'Dverger' turned out to carry a single renderer named 'dvergr' with the hood baked into - // the same mesh as the body, so a whole-object lift was never going to work. Resolution now - // tries, in order: a separate renderer object; a submesh of a combined mesh picked out by - // its material; and finally an index pinned by hand below. + // Two facts out of dumpdverger decide how this is done. + // + // The prefab holds one renderer, 'dvergr', whose mesh reports zero triangles - it ships + // with Read/Write disabled, so its vertices and indices cannot be touched at runtime and + // no amount of submesh carving will ever produce geometry. + // + // But its rig carries a dedicated hat1/hat2/hat3 bone chain under 'head'. The hood is + // skinned to those bones and nothing else is, so the hood can be isolated by collapsing + // every other bone to zero scale rather than by editing the mesh at all. public const string DvergerPrefabName = "Dverger"; - // Scanned in order. The mage variants are included because they wear a different hood and - // may well keep it as its own object. - public static readonly string[] DvergerPrefabCandidates = - { - "Dverger", "DvergerMage", "DvergerMageFire", "DvergerMageIce", "DvergerMageSupport" - }; + // The child of the prefab holding the armature and the renderer. + public const string DvergerVisualName = "Visual"; - // Matched against renderer object names, lowercased, by Contains. - public static readonly string[] HoodRendererNames = { "hat", "hood", "helmet", "cap" }; + // Root of the hat bone chain, and the bone whose collapse hides everything else. + public const string HoodBoneName = "hat1"; + public const string BodyRootBoneName = "Root"; - // Matched against material names when the hood is a submesh of a combined mesh. - public static readonly string[] HoodMaterialNames = { "hat", "hood", "helm", "cap", "head" }; + // Bone the hood is hung from on the player's own rig. + public const string PlayerHeadBoneName = "Head"; - // Escape hatch for when neither name matches: pin the prefab and the submesh index by hand - // from what `dumpdverger` reports. An empty prefab or a negative index means "auto". - public const string HoodForcedPrefab = ""; - public const int HoodForcedSubmeshIndex = -1; - - // 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. + // Nudges on top of the automatic alignment, which already puts the hat bone on the player's + // head bone. Scale is the one most likely to need a look: the hood is authored for a Dvergr + // skull, not a human one. public static readonly Vector3 HoodOffsetPosition = Vector3.zero; public static readonly Vector3 HoodOffsetRotation = Vector3.zero; public static readonly float HoodExtraScale = 1f; diff --git a/JotunnModStub/Dvergur/DvergurVisuals.cs b/JotunnModStub/Dvergur/DvergurVisuals.cs index 3110267..0a8c43f 100644 --- a/JotunnModStub/Dvergur/DvergurVisuals.cs +++ b/JotunnModStub/Dvergur/DvergurVisuals.cs @@ -5,7 +5,7 @@ using UnityEngine; namespace RacesOfValheim { /// - /// The Dvergur's looks: a short body, dverger skin, and a hood that is always worn. + /// The Dvergur's looks: a short body, dvergr 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, so @@ -18,10 +18,11 @@ namespace RacesOfValheim { 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 HoodSource cachedHoodSource; - private static bool hoodSourceResolved; + // The source is looked up once per session; the search walks a whole creature prefab and + // would otherwise run again for every player that comes into view. The failure is cached + // too, so a missing prefab cannot turn into a per-frame log. + private static GameObject cachedVisual; + private static bool visualResolved; /// /// Reads the race off the ZDO so remote players render correctly, falling back to @@ -114,129 +115,103 @@ namespace RacesOfValheim } } + /// + /// Hangs the dvergr hood on the player's head. + /// + /// The Dvergr ships as a single renderer whose mesh has Read/Write disabled - it reports + /// zero triangles - so the hood cannot be carved out of it as a submesh, which is what the + /// previous two attempts tried in one form or another. What the prefab does give us is a + /// hat1/hat2/hat3 bone chain that nothing but the hood is skinned to. + /// + /// So the whole dvergr body is instantiated and then made to disappear: the hat chain is + /// detached from the skull, and the armature root is collapsed to zero scale, which drags + /// every vertex weighted to it into a single point. Only the hood is left standing, and it + /// is still skinned, so it keeps its own shape. + /// private static void EnsureHood(VisEquipment visEq) { if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return; - Transform parent = visEq.m_bodyModel.transform.parent; - if (parent == null) return; + Transform playerHead = FindBoneByName(visEq.m_bodyModel.bones, DvergurConfig.PlayerHeadBoneName); + if (playerHead == null) return; - Transform existing = parent.Find(HoodName); - if (existing != null) + if (playerHead.Find(HoodName) != null) return; // already wearing it + + GameObject sourceVisual = ResolveDvergerVisual(); + if (sourceVisual == null) return; // already logged once by the resolver + + bool wasActive = sourceVisual.activeSelf; + sourceVisual.SetActive(false); + GameObject hood = Object.Instantiate(sourceVisual, playerHead, false); + sourceVisual.SetActive(wasActive); + + hood.name = HoodName; + StripComponents(hood); + hood.SetActive(true); + + Transform hatBone = FindChildByName(hood.transform, DvergurConfig.HoodBoneName); + Transform bodyRoot = FindChildByName(hood.transform, DvergurConfig.BodyRootBoneName); + + if (hatBone == null) { - if (!existing.gameObject.activeSelf) existing.gameObject.SetActive(true); + Jotunn.Logger.LogWarning( + $"[Dvergur] No '{DvergurConfig.HoodBoneName}' bone in the instantiated dvergr; hood dropped."); + Object.Destroy(hood); return; } - HoodSource source = ResolveHoodSource(); - if (!source.Valid) return; // already logged once by the resolver + // Detached first: the hat chain hangs off the skull, so collapsing the body without + // this would collapse the hood along with it. + hatBone.SetParent(hood.transform, true); + if (bodyRoot != null) bodyRoot.localScale = Vector3.zero; - Transform[] playerBones = visEq.m_bodyModel.bones; - GameObject hood = source.SubmeshIndex >= 0 - ? BuildFromSubmesh(source.Skinned, source.SubmeshIndex, parent, playerBones) - : BuildFromObject(source.Separate, parent, playerBones); - - if (hood == null) return; - - hood.name = HoodName; - hood.transform.localPosition = DvergurConfig.HoodOffsetPosition; + // Scale and rotation before alignment, since both move the hat bone. hood.transform.localRotation = Quaternion.Euler(DvergurConfig.HoodOffsetRotation); hood.transform.localScale = Vector3.one * DvergurConfig.HoodExtraScale; - hood.SetActive(true); - } - /// - /// Carves one submesh out of a combined skinned mesh and rebuilds it as a standalone - /// renderer bound to the player's rig. - /// - /// This is what the Dvergr needs: its prefab holds a single renderer, 'dvergr', with the - /// hood, the body and the clothes all in one mesh, so there is no object to lift out. Every - /// vertex, bone weight and bindpose is kept - only the triangle list is narrowed to the one - /// submesh - which means the skinning still lines up and the rig places the hood for us. - /// - private static GameObject BuildFromSubmesh(SkinnedMeshRenderer source, int submeshIndex, Transform parent, Transform[] playerBones) - { - Mesh sourceMesh = source.sharedMesh; - if (sourceMesh == null || submeshIndex >= sourceMesh.subMeshCount) return null; + // The hat now sits wherever the dvergr's own skull was. Shifting the whole object by + // the gap between that and the player's head bone lands it correctly without a single + // hand-measured offset. + hood.transform.position += playerHead.position - hatBone.position; + hood.transform.localPosition += DvergurConfig.HoodOffsetPosition; - Mesh mesh = new Mesh(); - // Must be set before the vertex array on meshes above 65535 verts, or the indices - // silently truncate. - mesh.indexFormat = sourceMesh.indexFormat; - mesh.vertices = sourceMesh.vertices; - mesh.normals = sourceMesh.normals; - mesh.tangents = sourceMesh.tangents; - mesh.uv = sourceMesh.uv; - mesh.boneWeights = sourceMesh.boneWeights; - mesh.bindposes = sourceMesh.bindposes; - mesh.subMeshCount = 1; - mesh.SetTriangles(sourceMesh.GetTriangles(submeshIndex), 0); - mesh.RecalculateBounds(); - - GameObject obj = new GameObject(HoodName); - obj.transform.SetParent(parent, false); - - SkinnedMeshRenderer renderer = obj.AddComponent(); - renderer.sharedMesh = mesh; - - Material[] sourceMaterials = source.sharedMaterials; - if (submeshIndex < sourceMaterials.Length) + foreach (SkinnedMeshRenderer renderer in hood.GetComponentsInChildren(true)) { - renderer.sharedMaterials = new[] { sourceMaterials[submeshIndex] }; - } - - RebindBones(renderer, source.bones, source.rootBone, playerBones); - ApplyDitherShader(obj); - return obj; - } - - private static GameObject BuildFromObject(GameObject source, Transform parent, Transform[] playerBones) - { - if (source == null) return null; - - bool wasActive = source.activeSelf; - source.SetActive(false); - GameObject hood = Object.Instantiate(source, parent, false); - source.SetActive(wasActive); - - StripBehaviours(hood); - - // Instantiated as-is, a skinned mesh keeps bones pointing at the source prefab's - // transforms and so renders nowhere; rebinding to the player's own bones by name is - // what the Skeleton does for whole bodies. - bool rebound = false; - foreach (SkinnedMeshRenderer smr in hood.GetComponentsInChildren(true)) - { - RebindBones(smr, smr.bones, smr.rootBone, playerBones); - rebound = true; - } - - if (!rebound) - { - // A rigid hood 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); + // The collapsed bones leave the mesh's own bounds meaningless, and a skinned + // renderer culls against those - without this the hood vanishes at some angles. + renderer.updateWhenOffscreen = true; } ApplyDitherShader(hood); - return hood; } - private static void RebindBones(SkinnedMeshRenderer renderer, Transform[] sourceBones, Transform sourceRoot, Transform[] playerBones) + /// + /// Strips everything that would make a decorative mesh behave like a creature: AI, hover + /// prompts and physics, plus the Animator and LODGroup, which are not MonoBehaviours and + /// would otherwise keep driving or hiding the rig. + /// + private static void StripComponents(GameObject obj) { - if (playerBones == null || playerBones.Length == 0 || sourceBones == null) return; - - Transform[] remapped = new Transform[sourceBones.Length]; - for (int i = 0; i < sourceBones.Length; i++) + foreach (MonoBehaviour comp in obj.GetComponentsInChildren(true)) { - Transform match = sourceBones[i] != null ? FindBoneByName(playerBones, sourceBones[i].name) : null; - remapped[i] = match != null ? match : playerBones[0]; + Object.DestroyImmediate(comp); + } + foreach (Animator animator in obj.GetComponentsInChildren(true)) + { + Object.DestroyImmediate(animator); + } + foreach (LODGroup lod in obj.GetComponentsInChildren(true)) + { + Object.DestroyImmediate(lod); + } + foreach (Rigidbody body in obj.GetComponentsInChildren(true)) + { + Object.DestroyImmediate(body); + } + foreach (Collider col in obj.GetComponentsInChildren(true)) + { + Object.DestroyImmediate(col); } - renderer.bones = remapped; - renderer.rootBone = sourceRoot != null - ? (FindBoneByName(playerBones, sourceRoot.name) ?? playerBones[0]) - : playerBones[0]; } /// @@ -254,138 +229,44 @@ namespace RacesOfValheim } } - private static void StripBehaviours(GameObject obj) + private static GameObject ResolveDvergerVisual() { - // 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); - } - } + if (visualResolved) return cachedVisual; + visualResolved = true; - /// - /// 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 HoodSource ResolveHoodSource() - { - if (hoodSourceResolved) return cachedHoodSource; - hoodSourceResolved = true; - - // A hand-pinned prefab and index wins outright, for when neither name search finds it. - if (!string.IsNullOrEmpty(DvergurConfig.HoodForcedPrefab) && DvergurConfig.HoodForcedSubmeshIndex >= 0) + GameObject prefab = PrefabManager.Cache.GetPrefab(DvergurConfig.DvergerPrefabName); + if (prefab == null) { - GameObject forced = PrefabManager.Cache.GetPrefab(DvergurConfig.HoodForcedPrefab); - SkinnedMeshRenderer forcedRenderer = forced != null ? forced.GetComponentInChildren(true) : null; - if (forcedRenderer != null) - { - Jotunn.Logger.LogInfo($"[Dvergur] Hood pinned to '{DvergurConfig.HoodForcedPrefab}' submesh {DvergurConfig.HoodForcedSubmeshIndex}."); - cachedHoodSource = HoodSource.FromSubmesh(forcedRenderer, DvergurConfig.HoodForcedSubmeshIndex); - return cachedHoodSource; - } + Jotunn.Logger.LogWarning($"[Dvergur] Prefab '{DvergurConfig.DvergerPrefabName}' not found; no hood."); + return null; } - System.Text.StringBuilder report = new System.Text.StringBuilder(); - - foreach (string prefabName in DvergurConfig.DvergerPrefabCandidates) + Transform visual = prefab.transform.Find(DvergurConfig.DvergerVisualName); + if (visual == null) { - GameObject prefab = PrefabManager.Cache.GetPrefab(prefabName); - if (prefab == null) continue; - - // First choice: the hood is its own object. - foreach (Renderer renderer in prefab.GetComponentsInChildren(true)) - { - if (!MatchesAny(renderer.gameObject.name, DvergurConfig.HoodRendererNames)) continue; - - Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to object '{renderer.gameObject.name}' in '{prefabName}'."); - cachedHoodSource = HoodSource.FromObject(renderer.gameObject); - return cachedHoodSource; - } - - // Second choice: it is a submesh of a combined mesh, identified by its material. - foreach (SkinnedMeshRenderer smr in prefab.GetComponentsInChildren(true)) - { - Material[] materials = smr.sharedMaterials; - for (int i = 0; i < materials.Length; i++) - { - if (materials[i] == null || !MatchesAny(materials[i].name, DvergurConfig.HoodMaterialNames)) continue; - - Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to submesh {i} ('{materials[i].name}') of '{smr.name}' in '{prefabName}'."); - cachedHoodSource = HoodSource.FromSubmesh(smr, i); - return cachedHoodSource; - } - - // Nothing matched here, so record what this renderer actually offers. - report.Append($"\n {prefabName}/{smr.name}: submeshes={smr.sharedMesh?.subMeshCount ?? 0} materials=["); - for (int i = 0; i < materials.Length; i++) - { - report.Append(i).Append(':').Append(materials[i] != null ? materials[i].name : "null").Append(' '); - } - report.Append(']'); - } + // Fall back to whatever holds the renderer, in case the child is ever renamed. + SkinnedMeshRenderer renderer = prefab.GetComponentInChildren(true); + visual = renderer != null ? renderer.transform.parent : null; } - // Say exactly what was on offer: that turns a silently invisible hood into a one-line - // fix in DvergurConfig, either a new keyword or a pinned submesh index. - Jotunn.Logger.LogWarning( - $"[Dvergur] No hood found. Object names tried [{string.Join(", ", DvergurConfig.HoodRendererNames)}], " + - $"material names tried [{string.Join(", ", DvergurConfig.HoodMaterialNames)}]." + - $" Candidates:{report}"); - return HoodSource.None; - } - - /// Where the hood mesh comes from: a whole object, or one submesh of a shared mesh. - private struct HoodSource - { - public GameObject Separate; - public SkinnedMeshRenderer Skinned; - public int SubmeshIndex; - - public bool Valid => Separate != null || (Skinned != null && SubmeshIndex >= 0); - - public static HoodSource None => new HoodSource { SubmeshIndex = -1 }; - - public static HoodSource FromObject(GameObject obj) => - new HoodSource { Separate = obj, SubmeshIndex = -1 }; - - public static HoodSource FromSubmesh(SkinnedMeshRenderer renderer, int index) => - new HoodSource { Skinned = renderer, SubmeshIndex = index }; - } - - private static bool MatchesAny(string name, string[] keywords) - { - if (string.IsNullOrEmpty(name)) return false; - string lower = name.ToLower(); - foreach (string keyword in keywords) + if (visual == null) { - if (lower.Contains(keyword)) return true; + Jotunn.Logger.LogWarning( + $"[Dvergur] '{DvergurConfig.DvergerPrefabName}' has no '{DvergurConfig.DvergerVisualName}' child and no renderer; no hood."); + return null; } - return false; + + Jotunn.Logger.LogInfo($"[Dvergur] Hood source resolved to '{DvergurConfig.DvergerPrefabName}/{visual.name}'."); + cachedVisual = visual.gameObject; + return cachedVisual; } private static void RemoveHood(VisEquipment visEq) { - if (visEq.m_bodyModel == 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); - } + if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return; + Transform playerHead = FindBoneByName(visEq.m_bodyModel.bones, DvergurConfig.PlayerHeadBoneName); + Transform hood = playerHead != null ? playerHead.Find(HoodName) : null; 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 @@ -400,6 +281,8 @@ namespace RacesOfValheim } } + // ─── Bone lookup ───────────────────────────────────────────────────── + private static Transform FindBoneByName(Transform[] bones, string targetBoneName) { if (bones == null || string.IsNullOrEmpty(targetBoneName)) return null; @@ -418,5 +301,19 @@ namespace RacesOfValheim } return null; } + + /// Depth-first search by exact name; the dvergr rig nests bones many levels deep. + private static Transform FindChildByName(Transform root, string name) + { + if (root == null) return null; + if (root.name == name) return root; + + for (int i = 0; i < root.childCount; i++) + { + Transform found = FindChildByName(root.GetChild(i), name); + if (found != null) return found; + } + return null; + } } } From f4b51c85f2f63f36f31be7c6ce851e20e8d1ebde Mon Sep 17 00:00:00 2001 From: kanym Date: Mon, 3 Aug 2026 21:49:35 +0200 Subject: [PATCH 6/6] added most of th dvergur race --- ...im_Thunderstore_1.3.9.zip - collegamento.lnk | Bin 0 -> 1438 bytes dist/icon.png | Bin 0 -> 73630 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 dist/RacesOfValheim_Thunderstore_1.3.9.zip - collegamento.lnk create mode 100644 dist/icon.png diff --git a/dist/RacesOfValheim_Thunderstore_1.3.9.zip - collegamento.lnk b/dist/RacesOfValheim_Thunderstore_1.3.9.zip - collegamento.lnk new file mode 100644 index 0000000000000000000000000000000000000000..61079d793f507dcb9b5177791122302280a31f5c GIT binary patch literal 1438 zcmb_cZAg<*6h7|~QHz>nVzJr~H6?m=`6Ffsj+tN8CexY8J5;t;Hgg~C-J(WmL52Cz z57StG(!vs=FG=x7WI`ZRf6SuDEQ&Db3)!#yRXz8e)9A+}@WOM>J?EbHoOADe?z^9e zxD*8>(S$6iq>~azgSmU`WNm-?J8pF0!Q?gQ1FFe!rsLZq@mwT+Nw#wZq^6!7sV~Hf z!IHkiJ>G(+33s!Iqb!;qPexqfPg_mh%NcG#mHD`e7BXIrUl#9&_mPavtngc)3We2knpFtjOoiOAoLrv0ew0LZu)Z1o9{1;3WA4(bPM5$=>mOfzwIkrR<5R!KC)R8Ed|t-~ooHe^`Vm%fR}E+rJrC5f zeldcg*KynzkRle*rOuqd)ww$rL;W*qar(>04?4}W-V5R6vuD2ZAzxeTO6$EKbRzP1 zBcZmcvg$|P!x;meFCAK#+BhgRr5}Oc&WfplT-k`wKttJN0EGmyfD|Gw$&YIgNDrzR zAq6TX4=5P`0hd=}(KLsZkw+MkHIo<49GfrQqP!kfG<040cFPKX5{qEXWC5|#{V#hq zA)n0qB24IB(joQ(V9s^SW|Qda*I^#VoUDx$Ko3&dKvgFl1w8nL9E5hGJw2eIIw~i; z3^~bqXet7t{}g6F2iS&hG~2QZ`=*meU(tl=P1@8b{M%Rnt7HbECoU~Mh*;+>tw2O! z=}E69VOh6?XBpYhaH^~LcDJ`|sH}(|EIih=6@CW`C<8`ng1ML7pY&Hp_}wOzHcD}} GOn(5#88!F- literal 0 HcmV?d00001 diff --git a/dist/icon.png b/dist/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..90b7b14323a751adfccc8989f45e2d909515774d GIT binary patch literal 73630 zcmV)8K*qm`P)Yiy)Lk|oXW|;AS884Xe#E;-tU_8PLW<2va49w8b z-So7o>e7`mQiTo=*H;{|CARjy_xSNEJlrFr)HK^XZ@S+&VxN8X(%)JOZ~gQC2>Ids zsDH;8hhL^Xn+G?)w@MphwAR)bYppZZYK@FZ<1~)rwAISmtu#$V5{o!uj8)p7Wvz40 zT3cU-A-FFL;wRvzfe@mUqIn~nJNF;v&fgh}{UC(Y&w>yN&pSJsYtsBv#L?yE<8Og6 z4$m7_82&W&{Oe5JmoZv@(|ikr%wM18TWb!&#>a;TuOHtkRZou)5+*#gjLmPbHT4z3 z2)|1^Ue)FZH$;~i#=-ldloCJc>l9TLW>~++sfV3AX%Q&kA%pQD(0iWG)O?GqH`Aq%Nymd`x z7iZj47Xbp8dw%nTsfV9^66f4lIC-`a2xQDZ7_f9@v@Sv75JCiH6k!~VsgPnE&OMJ0 zUtoczN8@Rm58^;VA&bKQ;Xi-Vg}0rfL zK`AV#%O{qy{%}sbI8ffZr^>cv)m{Nu7&$-_>|7>bO;lfiJILwSv zYOOWKAm=KtfrM`o#;4xmSoK7&XH30`rrfNx+a`N6R$p8fhxPdlsX+D0*WX-(|6P38 z$*7ku{JDq|&z>HBna>_BKW1+?^(vcs?8OPY-n}ds1hX7&(f3U@XOQ3^+K6h%SQ)VBORfxtdQ?8q6N^Y6Nipd}gmd%LvXNVLvx@xp3~-2AGnq zVPBq6of~$2O+!u9#o{vp0sGUvitqm>&S9dp2J_d`%y2j~#xTaB2)v?A`{7axbSW1Q zLP#l9->bQ-i(bntsr-uEFBcrm-Oyy!l)h#HKxg&%DfiBzF{LKVyZ&pKbV4cryRy!+71-?|5M91W{xuY-rfo3Da7mN`_DX45h8LQN;bP${7Q; zCOEz=xPnSDD05kr7&*qgAOb2uj=)^U(jyoTeqxJWul3JX%aB?$@da^%#EYG#W^Xh^ zFrsLIUq3uM_KOof=Dmz53PckeLg344JsP{ zX<(NSN}L6q6&XzsVw4~z##eLxaV&5#_@*(H=0;Ktl^9;1cfbe#_*{lE<=vVxIc6zp z_M7nv)aw)eb#hFl$0}~kwZordBY2A9YXX=O3-BcFjCN5=15orQ^DxGcaKDLSeac5M z1U9S}0@hkxm3f}WaSWj)AqeG7NixNXE;|-U%fVm(ej)ER zO@)vX0-jP-E<5I~Y|W3Gv5xYo{$> zW5K}^_H-eUY#)3TadxzBL=$J3Hg? zyqm6czkwVLKo<-?A3jmvjT(!BpiBq<5dvGn27|~MRpp}*=UJAeY3j~;IZpNI*R=a< zKR_)6Ua#f-AL?-RPB<$87L6$f(JZM8cEh#M3yzp?pI!*MK-|P;K1t*rv6ThS0Dg4&jwhu ze`>kfbehA4S@2%aZ)luBgI;8Wz)+J91sVWT*t`3!wG_5EECFLo3K4W96V_s~;fyqZ z0wNqcXPiT-DvCk~v3%As_YKD)A<*PZi?rDPu*ag6LFXPnJ7%~3R5WecqI(^Z=QR#S z__Xv7$S~T#7&bq_+21fF!|XxTF^C|F0k%E)2mcF;Vv9)(@nB+91;GIg0)YweyF&oM zIqIVdx*Q#pqpaIoSy^fIdfM7bX+$Yz95gE}=js4~f<2aDEN6noB^aOkz?7c~y=GkS z^zqNWl_oeosCnTQLV#a zH7&?1SQOD88&&S~Gq5L!iFo5}JP0hX^`ODA3F{{o@-*PxMe+P~2>$-y_Y8h;A4fsR zG~MF0Qx4oGVPa&A{%<~Jokvjz^2ynqaH?ZZ_FprfA()+0FJ-)cðtgQ=HdmT+;O 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 z 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 literal 0 HcmV?d00001