RacesOfValheim/JotunnModStub/Dvergar/DvergarVisuals.cs
kanym 760ddffc27 feat(dvergar): give two stars a stone tone instead of deriving one
Deriving it from the creature's own two-star offset put the tier a shade away
from ordinary human skin, and no amount of clamping fixes that, because the
derivation is asking for something a multiplier cannot do. Those offsets
brighten and desaturate a dverger's own texture. Ours multiplies the human skin
map, where less saturation means less tint, and less tint means more flesh - the
opposite direction from the one intended.

A multiplier can darken and it can bias. It cannot desaturate: the pink lives in
the texture and survives being multiplied by grey, only dimmer. So two stars now
states a colour outright - dark, and cold enough to sit on top of the flesh tone
rather than under it.

One star keeps deriving from the prefab, since that tier reads correctly.
2026-08-05 19:42:38 +02:00

447 lines
20 KiB
C#

using HarmonyLib;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Dvergar'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
/// 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 DvergarVisuals
{
private const string HoodName = "DvergarHood";
// 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;
/// <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 IsDvergarPlayer(Player player) => GetPlayerRace(player) == DvergarConfig.RaceId;
// ─── Star colours ────────────────────────────────────────────────────
// Read once per session, failure included.
private static LevelEffects.LevelSetup[] cachedStarSetups;
private static bool starSetupsResolved;
/// <summary>
/// How many stars the Dvergar's colouring has earned: one at Bonemass, two at Fader.
/// </summary>
public static int GetStarTier(int state)
{
if (state >= DvergarConfig.TwoStarState) return 2;
if (state >= DvergarConfig.OneStarState) return 1;
return 0;
}
/// <summary>
/// The skin tint for a player at their current standing: the race's own slate blue-grey,
/// shifted by the hue/saturation/value offsets a real dverger of that star count wears.
///
/// Valheim does not give a starred creature a different model or a different colour - it
/// gives the same material an HSV offset through LevelEffects. Reading those offsets off
/// the creature prefab rather than picking two colours by eye means the tiers land on the
/// exact tints the game uses, and keeps following them if the prefab ever changes.
/// </summary>
public static Color GetSkinColor(Player player)
{
int tier = GetStarTier(GetProgressionState(player));
// Two stars stops deriving and states a colour outright. The creature's own two-star
// offset brightens and desaturates, which through a multiplier over the human skin
// texture means "tint it less" - and landed the tier a shade away from ordinary
// flesh, which is the opposite of what two stars should read as. Stone grey says it
// in the one language a multiplier speaks.
if (tier >= 2) return DvergarConfig.TwoStarSkinColor;
LevelEffects.LevelSetup setup = GetStarSetup(tier);
if (setup == null) return DvergarConfig.SkinColor;
return ShiftHsv(DvergarConfig.SkinColor, setup.m_hue, setup.m_saturation, setup.m_value);
}
/// <summary>
/// The tier this particular Dvergar should be coloured for. DvergarRace publishes it to
/// the ZDO every frame, so a remote player is shown at their own standing rather than the
/// observer's - which matters the moment anyone runs personal progression. Falls back to
/// this client's own reckoning when there is no ZDO, which is the main-menu preview.
/// </summary>
private static int GetProgressionState(Player player)
{
ZNetView nview = player != null ? player.GetComponent<ZNetView>() : null;
if (nview != null && nview.IsValid())
{
int published = nview.GetZDO().GetInt(DvergarConfig.StateZdoKey, 0);
if (published > 0) return published;
}
return BossProgressionManager.GetCurrentProgressionState();
}
private static LevelEffects.LevelSetup GetStarSetup(int tier)
{
if (tier <= 0) return null;
LevelEffects.LevelSetup[] setups = ResolveStarSetups();
if (setups == null || setups.Length == 0) return null;
// m_levelSetups[0] is one star, [1] is two - the game indexes it as level - 2.
int index = Mathf.Min(tier - 1, setups.Length - 1);
return setups[index];
}
private static LevelEffects.LevelSetup[] ResolveStarSetups()
{
if (starSetupsResolved) return cachedStarSetups;
starSetupsResolved = true;
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(DvergarConfig.DvergerPrefabName);
LevelEffects effects = prefab != null ? prefab.GetComponentInChildren<LevelEffects>(true) : null;
if (effects == null || effects.m_levelSetups == null || effects.m_levelSetups.Count == 0)
{
Jotunn.Logger.LogWarning(
$"[Dvergar] No LevelEffects setups on '{DvergarConfig.DvergerPrefabName}'; " +
"star colouring stays at the base tint.");
return null;
}
cachedStarSetups = effects.m_levelSetups.ToArray();
// The offsets themselves, so a tier that lands on the wrong colour can be tuned
// against the real numbers rather than by eye.
for (int i = 0; i < cachedStarSetups.Length; i++)
{
LevelEffects.LevelSetup setup = cachedStarSetups[i];
Jotunn.Logger.LogInfo(
$"[Dvergar] Star {i + 1}: hue={setup.m_hue:F3} saturation={setup.m_saturation:F3} " +
$"value={setup.m_value:F3} emissive={(setup.m_setEmissiveColor ? setup.m_emissiveColor.ToString() : "none")} " +
$"-> skin {ShiftHsv(DvergarConfig.SkinColor, setup.m_hue, setup.m_saturation, setup.m_value)}");
}
return cachedStarSetups;
}
/// <summary>
/// Applies a star's HSV offset to our tint. Hue wraps the way the creature shader's does;
/// saturation and value are bounded rather than merely clamped to 0..1.
///
/// The bounds are the whole trick. The shader applies these offsets to a dverger's own
/// texture, where a bright desaturated result is a pale dverger. Ours multiplies the human
/// skin texture, where the same result is *white* - and a white multiplier is no tint at
/// all, which is why the two-star Dvergar came out looking like an ordinary pink human.
/// Keeping saturation off the floor and value off the ceiling means every tier stays a
/// colour.
/// </summary>
private static Color ShiftHsv(Color color, float hue, float saturation, float value)
{
Color.RGBToHSV(color, out float h, out float s, out float v);
h = Mathf.Repeat(h + hue, 1f);
s = Mathf.Clamp(s + saturation, DvergarConfig.StarMinSaturation, 1f);
v = Mathf.Clamp(v + value, DvergarConfig.StarMinValue, DvergarConfig.StarMaxValue);
Color shifted = Color.HSVToRGB(h, s, v);
shifted.a = color.a;
return shifted;
}
// ─── 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 isDvergar)
{
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 (isDvergar)
{
float target = DvergarConfig.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 - DvergarConfig.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 (IsDvergarPlayer(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;
}
}
/// <summary>
/// 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.
/// </summary>
private static void EnsureHood(VisEquipment visEq)
{
if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return;
Transform playerHead = FindBoneByName(visEq.m_bodyModel.bones, DvergarConfig.PlayerHeadBoneName);
if (playerHead == null) return;
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, DvergarConfig.HoodBoneName);
Transform bodyRoot = FindChildByName(hood.transform, DvergarConfig.BodyRootBoneName);
if (hatBone == null)
{
Jotunn.Logger.LogWarning(
$"[Dvergar] No '{DvergarConfig.HoodBoneName}' bone in the instantiated dvergr; hood dropped.");
Object.Destroy(hood);
return;
}
// 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;
// Scale and rotation before alignment, since both move the hat bone.
hood.transform.localRotation = Quaternion.Euler(DvergarConfig.HoodOffsetRotation);
hood.transform.localScale = Vector3.one * DvergarConfig.HoodExtraScale;
// 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 += DvergarConfig.HoodOffsetPosition;
foreach (SkinnedMeshRenderer renderer in hood.GetComponentsInChildren<SkinnedMeshRenderer>(true))
{
// 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);
}
/// <summary>
/// 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.
/// </summary>
private static void StripComponents(GameObject obj)
{
foreach (MonoBehaviour comp in obj.GetComponentsInChildren<MonoBehaviour>(true))
{
Object.DestroyImmediate(comp);
}
foreach (Animator animator in obj.GetComponentsInChildren<Animator>(true))
{
Object.DestroyImmediate(animator);
}
foreach (LODGroup lod in obj.GetComponentsInChildren<LODGroup>(true))
{
Object.DestroyImmediate(lod);
}
foreach (Rigidbody body in obj.GetComponentsInChildren<Rigidbody>(true))
{
Object.DestroyImmediate(body);
}
foreach (Collider col in obj.GetComponentsInChildren<Collider>(true))
{
Object.DestroyImmediate(col);
}
}
/// <summary>
/// Without the creature shader the hood ignores the camera's dither fade and fills the
/// screen in first person; its own textures are kept.
/// </summary>
private static void ApplyDitherShader(GameObject obj)
{
Shader dither = Shader.Find("Custom/Creature");
if (dither == null) return;
foreach (Renderer renderer in obj.GetComponentsInChildren<Renderer>(true))
{
if (renderer.material != null) renderer.material.shader = dither;
}
}
private static GameObject ResolveDvergerVisual()
{
if (visualResolved) return cachedVisual;
visualResolved = true;
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(DvergarConfig.DvergerPrefabName);
if (prefab == null)
{
Jotunn.Logger.LogWarning($"[Dvergar] Prefab '{DvergarConfig.DvergerPrefabName}' not found; no hood.");
return null;
}
Transform visual = prefab.transform.Find(DvergarConfig.DvergerVisualName);
if (visual == null)
{
// Fall back to whatever holds the renderer, in case the child is ever renamed.
SkinnedMeshRenderer renderer = prefab.GetComponentInChildren<SkinnedMeshRenderer>(true);
visual = renderer != null ? renderer.transform.parent : null;
}
if (visual == null)
{
Jotunn.Logger.LogWarning(
$"[Dvergar] '{DvergarConfig.DvergerPrefabName}' has no '{DvergarConfig.DvergerVisualName}' child and no renderer; no hood.");
return null;
}
Jotunn.Logger.LogInfo($"[Dvergar] Hood source resolved to '{DvergarConfig.DvergerPrefabName}/{visual.name}'.");
cachedVisual = visual.gameObject;
return cachedVisual;
}
private static void RemoveHood(VisEquipment visEq)
{
if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return;
Transform playerHead = FindBoneByName(visEq.m_bodyModel.bones, DvergarConfig.PlayerHeadBoneName);
Transform hood = playerHead != null ? playerHead.Find(HoodName) : null;
if (hood == null) return; // never was a Dvergar - 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;
}
}
// ─── Bone lookup ─────────────────────────────────────────────────────
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;
}
/// <summary>Depth-first search by exact name; the dvergr rig nests bones many levels deep.</summary>
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;
}
}
}