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.
This commit is contained in:
kanym 2026-08-02 22:58:11 +02:00
commit 79a54fb533
8 changed files with 388 additions and 118 deletions

View file

@ -35,21 +35,27 @@ namespace RacesOfValheim
// is set to zero, and would bake the old value into any assembly built against this one. // 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 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 ─────────────────────────────────────────────────── // ─── Cosmetic hood ───────────────────────────────────────────────────
// The helmet slot itself stays free — whatever the player equips keeps all of its stats, // 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. // only the mesh is swapped.
public static readonly string[] HoodPrefabCandidates = //
{ // The hood is lifted straight off the Dvergr NPC rather than off the Dverger Circlet item:
"HelmetDverger", // Dverger circlet item // the circlet is a metal band, not the hood the race is meant to wear.
"helmet_dverger", // its attach visual, if the item prefab is unavailable public const string DvergerPrefabName = "Dverger";
"Dverger" // last resort: lift the headgear renderer off the creature
};
// Valheim rigs are authored at scale 100, hence the very small numbers. Tuned against // Matched against renderer object names inside that prefab, lowercased, by Contains.
// the head bone, same approach as the Furling trophy head. public static readonly string[] HoodRendererNames = { "hat", "hood", "helmet", "cap" };
public static readonly Vector3 HoodLocalPosition = new Vector3(0f, 0.0012f, 0f);
public static readonly Vector3 HoodLocalRotation = new Vector3(-90f, 0f, 90f); // Applied on top of whatever the rig positions the hood at. Identity is correct when the
public static readonly float HoodLocalScale = 0.0075f; // 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 ──────────────────────────────────────────────────── // ─── Health malus ────────────────────────────────────────────────────

View file

@ -14,17 +14,25 @@ namespace RacesOfValheim
// ─── Health malus ──────────────────────────────────────────────────── // ─── Health malus ────────────────────────────────────────────────────
/// <summary> /// <summary>
/// The Dvergur is a small frame, and carries less health for it. The target is resolved /// The Dvergur is a small frame, and carries less health for it.
/// 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 /// The malus is taken off the food total rather than off Character.GetMaxHealth, which is
/// up to whichever one actually runs, and the local-player guard makes either correct. /// 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.
/// </summary> /// </summary>
[HarmonyPatch] [HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
public static class Dvergur_GetMaxHealth_Patch public static class Dvergur_GetTotalFoodValue_Patch
{ {
public static MethodBase TargetMethod() => AccessTools.Method(typeof(Player), "GetMaxHealth"); public static void Postfix(Player __instance, ref float hp)
public static void Postfix(Character __instance, ref float __result)
{ {
if (__instance == null || __instance != Player.m_localPlayer) return; if (__instance == null || __instance != Player.m_localPlayer) return;
if (!DvergurRace.IsDvergur()) return; if (!DvergurRace.IsDvergur()) return;
@ -32,7 +40,26 @@ namespace RacesOfValheim
float malus = DvergurProgression.Current.HealthMalus; float malus = DvergurProgression.Current.HealthMalus;
if (malus <= 0f) return; if (malus <= 0f) return;
__result = Mathf.Max(DvergurConfig.MinMaxHealth, __result - malus); hp = Mathf.Max(DvergurConfig.MinMaxHealth, hp - malus);
}
}
// ─── Scale ───────────────────────────────────────────────────────────
/// <summary>
/// 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.
/// </summary>
[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<Player>(); Player player = __instance.GetComponent<Player>();
if (player == null) return; if (player == null) return;
DvergurVisuals.Apply(player); DvergurVisuals.ApplyHood(player);
} }
} }
} }

View file

@ -1,3 +1,4 @@
using HarmonyLib;
using UnityEngine; using UnityEngine;
namespace RacesOfValheim 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 /// 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. /// 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 /// Only the per-frame upkeep lives here. Body scale is a Player.Update postfix in
/// DvergurPatches, the two eitr abilities are in DvergurAbilities, and every number they use /// DvergurPatches, since that is the one place it survives; the perks are the other patches in
/// comes from DvergurConfig by way of DvergurProgression. /// that file; the two eitr abilities are in DvergurAbilities; and every number they use comes
/// from DvergurConfig by way of DvergurProgression.
/// </summary> /// </summary>
public class DvergurRace : MonoBehaviour public class DvergurRace : MonoBehaviour
{ {
public static DvergurRace Instance; 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() private void Awake()
{ {
Instance = this; Instance = this;
@ -36,15 +41,22 @@ namespace RacesOfValheim
Player player = Player.m_localPlayer; Player player = Player.m_localPlayer;
if (player == null) return; 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); lastAppliedMalus = desiredMalus;
return; Traverse.Create(player).Method("UpdateFood", 0f, true).GetValue();
} }
DvergurVisuals.Apply(player); if (!isDvergur || player.IsDead()) return;
if (player.IsDead()) return;
int state = BossProgressionManager.GetCurrentProgressionState(); int state = BossProgressionManager.GetCurrentProgressionState();

View file

@ -5,22 +5,27 @@ using UnityEngine;
namespace RacesOfValheim namespace RacesOfValheim
{ {
/// <summary> /// <summary>
/// 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 /// 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 /// whatever the player equips keeps every one of its stats - only its mesh is swapped out, so
/// way the Skeleton hides helmets outright, so armour, resistances and set bonuses all still /// armour, resistances and set bonuses all still count.
/// count. Everything here runs for local and remote players alike, which is why it takes a ///
/// Player rather than reading Player.m_localPlayer. /// Everything here runs for local and remote players alike, which is why it takes a Player
/// rather than reading Player.m_localPlayer.
/// </summary> /// </summary>
public static class DvergurVisuals public static class DvergurVisuals
{ {
private const string HoodName = "DvergurHood"; 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;
/// <summary> /// <summary>
/// Reads the race off the ZDO so remote players render correctly, falling back to /// 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 /// m_customData for the main-menu preview which has no ZNetView.
/// FurlingPatches.GetPlayerRace.
/// </summary> /// </summary>
public static string GetPlayerRace(Player player) public static string GetPlayerRace(Player player)
{ {
@ -41,22 +46,84 @@ namespace RacesOfValheim
public static bool IsDvergurPlayer(Player player) => GetPlayerRace(player) == DvergurConfig.RaceId; public static bool IsDvergurPlayer(Player player) => GetPlayerRace(player) == DvergurConfig.RaceId;
// ─── Scale ───────────────────────────────────────────────────────────
/// <summary> /// <summary>
/// Brings a player's body in line with their race. Safe to call every frame: each step /// Sizes a player, driven from a Player.Update postfix exactly the way the Trol is - which
/// checks the current value first and does nothing when it already matches. /// 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.
/// </summary> /// </summary>
public static void Apply(Player player) public static void ApplyScale(Player player, bool isDvergur)
{ {
if (player == null) return; 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<GameObject>();
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 ────────────────────────────────────────────────────────────
/// <summary>
/// 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.
/// </summary>
public static void ApplySkinColor(Player player)
{
if (player == null) return;
VisEquipment visEq = player.GetComponent<VisEquipment>(); VisEquipment visEq = player.GetComponent<VisEquipment>();
if (visEq == null) return; if (visEq == null) return;
if (isDvergur) if (!player.m_customData.ContainsKey("OriginalSkinColor_X"))
{
Vector3 current = Traverse.Create(visEq).Field("m_skinColor").GetValue<Vector3>();
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 ────────────────────────────────────────────────────────────
/// <summary>
/// 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.
/// </summary>
public static void ApplyHood(Player player)
{
VisEquipment visEq = player != null ? player.GetComponent<VisEquipment>() : null;
if (visEq == null) return;
if (IsDvergurPlayer(player) && !player.IsDead())
{ {
EnsureHood(visEq); EnsureHood(visEq);
HideEquippedHelmet(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<GameObject>();
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;
}
}
/// <summary> /// <summary>
/// Blanks the mesh of whatever helmet is equipped. Scaled to zero rather than deactivated /// 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 /// 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; if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return;
Transform headBone = FindBoneByName(visEq.m_bodyModel.bones, "Head"); Transform parent = visEq.m_bodyModel.transform.parent;
if (headBone == null) return; if (parent == null) return;
Transform existing = headBone.Find(HoodName); Transform existing = parent.Find(HoodName);
if (existing != null) if (existing != null)
{ {
if (!existing.gameObject.activeSelf) existing.gameObject.SetActive(true); if (!existing.gameObject.activeSelf) existing.gameObject.SetActive(true);
@ -117,45 +163,57 @@ namespace RacesOfValheim
} }
GameObject source = ResolveHoodSource(); GameObject source = ResolveHoodSource();
if (source == null) if (source == null) return; // already logged once by the resolver
{
// 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; bool wasActive = source.activeSelf;
source.SetActive(false); source.SetActive(false);
GameObject hood = Object.Instantiate(source, headBone, false); GameObject hood = Object.Instantiate(source, parent, false);
source.SetActive(wasActive); source.SetActive(wasActive);
hood.name = HoodName; hood.name = HoodName;
StripBehaviours(hood);
// 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<MonoBehaviour>(true))
{
Object.DestroyImmediate(comp);
}
foreach (Rigidbody body in hood.GetComponentsInChildren<Rigidbody>(true))
{
Object.DestroyImmediate(body);
}
foreach (Collider col in hood.GetComponentsInChildren<Collider>(true))
{
Object.DestroyImmediate(col);
}
hood.SetActive(true); 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 hood is skinned to the Dvergr rig. Instantiated as-is its bones still point at
// the view in first person; its own textures are kept. // 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<SkinnedMeshRenderer>(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"); Shader dither = Shader.Find("Custom/Creature");
if (dither != null) 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<MonoBehaviour>(true))
{
Object.DestroyImmediate(comp);
}
foreach (Rigidbody body in obj.GetComponentsInChildren<Rigidbody>(true))
{
Object.DestroyImmediate(body);
}
foreach (Collider col in obj.GetComponentsInChildren<Collider>(true))
{
Object.DestroyImmediate(col);
}
}
/// <summary> /// <summary>
/// First candidate prefab that resolves wins. A creature prefab is handled specially: the /// Digs the headgear out of the Dvergr NPC prefab. Resolved once and remembered, including
/// Dvergr's headgear is a child renderer of the creature, not a standalone prefab, so the /// the failure, so a missing prefab cannot turn into a per-frame log.
/// piece is lifted out rather than the whole NPC being instantiated on the player's head.
/// </summary> /// </summary>
private static GameObject ResolveHoodSource() private static GameObject ResolveHoodSource()
{ {
foreach (string candidate in DvergurConfig.HoodPrefabCandidates) if (hoodSourceResolved) return cachedHoodSource;
hoodSourceResolved = true;
GameObject dverger = PrefabManager.Cache.GetPrefab<GameObject>(DvergurConfig.DvergerPrefabName);
if (dverger == null)
{ {
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(candidate); Jotunn.Logger.LogWarning($"[Dvergur] Prefab '{DvergurConfig.DvergerPrefabName}' not found; no hood.");
if (prefab == null) continue; return null;
}
if (prefab.GetComponent<Character>() == null) return prefab; foreach (Renderer renderer in dverger.GetComponentsInChildren<Renderer>(true))
{
foreach (Renderer renderer in prefab.GetComponentsInChildren<Renderer>(true)) string name = renderer.gameObject.name.ToLower();
foreach (string keyword in DvergurConfig.HoodRendererNames)
{ {
string name = renderer.gameObject.name.ToLower(); if (!name.Contains(keyword)) continue;
if (name.Contains("helmet") || name.Contains("hat") || name.Contains("hood") || name.Contains("cap"))
{ Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to '{renderer.gameObject.name}' ({renderer.GetType().Name}).");
return renderer.gameObject; 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<Renderer>(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; return null;
} }
private static void RemoveHood(VisEquipment visEq) 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"); Transform parent = visEq.m_bodyModel.transform.parent;
if (headBone == null) return; 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 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 // 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) private static Transform FindBoneByName(Transform[] bones, string targetBoneName)
{ {
if (bones == null || string.IsNullOrEmpty(targetBoneName)) return null;
foreach (Transform bone in bones) foreach (Transform bone in bones)
{ {
if (bone != null && bone.name == targetBoneName) return bone; if (bone != null && bone.name == targetBoneName) return bone;
@ -224,7 +324,9 @@ namespace RacesOfValheim
string target = targetBoneName.ToLower(); string target = targetBoneName.ToLower();
foreach (Transform bone in bones) 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; return null;
} }

View file

@ -0,0 +1,35 @@
namespace RacesOfValheim
{
/// <summary>
/// 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.
/// </summary>
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;
}
}
}

View file

@ -38,6 +38,7 @@ namespace RacesOfValheim
CommandManager.Instance.AddConsoleCommand(new CheckProgressionCommand()); CommandManager.Instance.AddConsoleCommand(new CheckProgressionCommand());
CommandManager.Instance.AddConsoleCommand(new IncreaseProgressionCommand()); CommandManager.Instance.AddConsoleCommand(new IncreaseProgressionCommand());
CommandManager.Instance.AddConsoleCommand(new ResetProgressionCommand()); CommandManager.Instance.AddConsoleCommand(new ResetProgressionCommand());
CommandManager.Instance.AddConsoleCommand(new DumpDvergerCommand());
} }
/// <summary> /// <summary>
@ -592,8 +593,9 @@ namespace RacesOfValheim
Player.m_localPlayer.GetSEMan().AddStatusEffect(DvergurConfig.StatsSE.GetStableHashCode(), true); Player.m_localPlayer.GetSEMan().AddStatusEffect(DvergurConfig.StatsSE.GetStableHashCode(), true);
// The Dvergur keeps its own skin - only the silhouette and the hood change, so // Saves the original skin first, so ResetRace can hand it back.
// UpdateVisuals is enough and UpdateColors has nothing to do here. DvergurVisuals.ApplySkinColor(Player.m_localPlayer);
VisEquipment visEq = Player.m_localPlayer.GetComponent<VisEquipment>(); VisEquipment visEq = Player.m_localPlayer.GetComponent<VisEquipment>();
if (visEq != null) 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); 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 // Check for Race Selection
if (!__instance.m_customData.ContainsKey("Race")) if (!__instance.m_customData.ContainsKey("Race"))
{ {
@ -768,6 +777,82 @@ namespace RacesOfValheim
} }
} }
/// <summary>
/// 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.
/// </summary>
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<GameObject>(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<Renderer>(true))
{
Jotunn.Logger.LogInfo($" {renderer.gameObject.name} ({renderer.GetType().Name}) path={GetPath(renderer.transform)}");
}
LevelEffects levelEffects = prefab.GetComponentInChildren<LevelEffects>(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<Component>())
{
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 class ResetProgressionCommand : ConsoleCommand
{ {
public override string Name => "resetprogression"; public override string Name => "resetprogression";

View file

@ -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; visual.transform.localScale = Vector3.one;
} }
} }

View file

@ -83,9 +83,9 @@ namespace RacesOfValheim
} }
else if (race == DvergurConfig.RaceId) else if (race == DvergurConfig.RaceId)
{ {
// The hood itself is rebuilt by the VisEquipment patch; this keeps the shrunken // Scale is handled for every player by the Player.Update postfix; this only keeps
// silhouette and the hidden helmet asserted between those rebuilds. // the hood and the hidden helmet asserted between equipment refreshes.
DvergurVisuals.Apply(m_player); DvergurVisuals.ApplyHood(m_player);
} }
else else
{ {