RacesOfValheim/JotunnModStub/Dvergur/DvergurVisuals.cs
kanym 8df7681cea 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.
2026-08-02 23:08:12 +02:00

300 lines
13 KiB
C#

using HarmonyLib;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// 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, 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.
/// </summary>
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;
/// <summary>
/// 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.
/// </summary>
public static string GetPlayerRace(Player player)
{
if (player == null) return "Human";
ZNetView nview = player.GetComponent<ZNetView>();
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;
// ─── Scale ───────────────────────────────────────────────────────────
/// <summary>
/// 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.
/// </summary>
public static void ApplyScale(Player player, bool isDvergur)
{
if (player == null) return;
// 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;
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;
}
}
// ─── 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);
HideEquippedHelmet(visEq);
}
else
{
RemoveHood(visEq);
}
}
/// <summary>
/// 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.
/// </summary>
private static void HideEquippedHelmet(VisEquipment visEq)
{
GameObject helmet = Traverse.Create(visEq).Field<GameObject>("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 parent = visEq.m_bodyModel.transform.parent;
if (parent == null) return;
Transform existing = parent.Find(HoodName);
if (existing != null)
{
if (!existing.gameObject.activeSelf) existing.gameObject.SetActive(true);
return;
}
GameObject source = ResolveHoodSource();
if (source == null) return; // already logged once by the resolver
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;
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");
if (dither != null)
{
foreach (Renderer renderer in hood.GetComponentsInChildren<Renderer>(true))
{
if (renderer.material != null) renderer.material.shader = dither;
}
}
}
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>
/// 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.
/// </summary>
private static GameObject ResolveHoodSource()
{
if (hoodSourceResolved) return cachedHoodSource;
hoodSourceResolved = true;
GameObject dverger = PrefabManager.Cache.GetPrefab<GameObject>(DvergurConfig.DvergerPrefabName);
if (dverger == null)
{
Jotunn.Logger.LogWarning($"[Dvergur] Prefab '{DvergurConfig.DvergerPrefabName}' not found; no hood.");
return null;
}
foreach (Renderer renderer in dverger.GetComponentsInChildren<Renderer>(true))
{
string name = renderer.gameObject.name.ToLower();
foreach (string keyword in DvergurConfig.HoodRendererNames)
{
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<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;
}
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 (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<GameObject>("m_helmetItemInstance").Value;
if (helmet != null && helmet.transform.localScale == Vector3.zero)
{
helmet.transform.localScale = Vector3.one;
}
}
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;
}
string target = targetBoneName.ToLower();
foreach (Transform bone in bones)
{
if (bone == null) continue;
string name = bone.name.ToLower();
if (name == target || name.Contains(target) || target.Contains(name)) return bone;
}
return null;
}
}
}