RacesOfValheim/JotunnModStub/Alfar/AlfarVisuals.cs
Ferdinando 3f8cf1ee27 feat(alfar): v1.6.0 - the Alfar, an eleventh race
Grey, tall and thin, with black eyes. Eitr is armour and fuel (shield,
diet, soft fall, levitation), Heimkall sends a lethal blow home at one
health every 20 minutes. Caster powers from Skrid to the archon
Sameining, with on-screen cooldowns. Automated base around the
Ljoskjarne: drones, three constructs, crystals, Ljosgard, Prismavard.
Compendium page in EN/IT/RU.

README: New in block, race section, progression, station line, changelog.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 17:38:28 +01:00

495 lines
22 KiB
C#

using System.Collections.Generic;
using HarmonyLib;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// What an Alfr looks like (Alfar_Progettazione.txt sec. 7): ash-grey skin, five percent taller
/// and a little thinner than a Viking, no hair, no beard, and two completely black eyes.
///
/// Everything here is written the way the Sverm and the Dvergar already write theirs, because
/// each of those shapes cost somebody a test session:
/// - the race is read off the ZDO, so remote players render right, falling back to
/// m_customData for the menu preview (same shape as SvermVisuals.GetPlayerRace);
/// - the skin is written AFTER Valheim rebuilds the body material (see AlfarPatches);
/// - the scale goes on the "Visual" child and never the root, and only ever undoes its own;
/// - the eyes are spheres on the head bone with every offset divided by lossyScale, because
/// the player armature is authored at scale 100.
///
/// The eyes are the Sverm's spheres with the glow taken out: same geometry, a matte black
/// material, no emission at all.
/// </summary>
public static class AlfarVisuals
{
private const string EyesName = "AlfarEyes";
private const string HeadBoneName = "Head";
// ─── Race check ──────────────────────────────────────────────────────
public static string GetPlayerRace(Player player)
{
if (player == null) return "Human";
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid())
{
string race = nview.GetZDO().GetString("RacesOfValheim_Race", "");
if (!string.IsNullOrEmpty(race)) return race;
}
if (player.m_customData != null && player.m_customData.TryGetValue("Race", out string custom))
{
return custom;
}
return "Human";
}
public static bool IsAlfarPlayer(Player player) => GetPlayerRace(player) == AlfarConfig.RaceId;
// ─── Scale ───────────────────────────────────────────────────────────
/// <summary>
/// +5% in height and a little less wide. NON-uniform, so the scale is a Vector3 and not the
/// single float the other races write.
///
/// The reset only ever undoes a scale that looks like ours: another race (the Trol, the
/// Dvergar) may be sizing this player and RaceScale exists so the two do not fight.
/// </summary>
public static void ApplyScale(Player player, bool isAlfar)
{
if (player == null) return;
GameObject visual = Traverse.Create(player).Field("m_visual").GetValue<GameObject>();
if (visual == null) return;
Vector3 ours = new Vector3(AlfarConfig.WidthScale.Value, AlfarConfig.HeightScale.Value, AlfarConfig.WidthScale.Value);
// The archon form is bigger: published in the ZDO, so every client sizes it the same.
Vector3 archon = ours * AlfarPowerConfig.ArchonScale.Value;
bool inArchon = isAlfar && AlfarArchon.IsArchon(player);
Vector3 current = visual.transform.localScale;
Vector3 target = inArchon ? archon : ours;
if (!isAlfar)
{
// Undo only a scale that is one of ours, the normal one or the archon's.
if (!LooksLike(current, ours) && !LooksLike(current, archon)) return;
target = Vector3.one;
}
if (!LooksLike(current, target))
{
visual.transform.localScale = target;
}
}
private static bool LooksLike(Vector3 a, Vector3 b)
{
return Mathf.Abs(a.x - b.x) < 0.001f && Mathf.Abs(a.y - b.y) < 0.001f && Mathf.Abs(a.z - b.z) < 0.001f;
}
// ─── Hair and beard ──────────────────────────────────────────────────
/// <summary>
/// Takes the hair and the beard off the VISUAL only. The Skeleton also rewrites the saved
/// profile, which makes the loss permanent; the Alfar do not, so a reset to Human gets the
/// hair back the next time the game rebuilds the equipment visuals.
///
/// Since Valheim 1.0 these take an item hash and not a name: 0 is the empty slot.
/// </summary>
public static void ApplyHairless(Player player)
{
if (player == null) return;
VisEquipment vis = player.GetComponent<VisEquipment>();
if (vis == null) return;
vis.SetHairItem(0);
vis.SetBeardItem(0);
}
// ─── Eyes ────────────────────────────────────────────────────────────
/// <summary>
/// Which way the skull faces, measured once when the eyes are built and kept for as long as
/// they exist (RigBindPose explains why it is read from the bind pose and not live).
/// </summary>
private class EyeFrame : MonoBehaviour
{
public Vector3 LocalForward = Vector3.forward;
public Vector3 LocalUp = Vector3.up;
public Vector3 LocalRight = Vector3.right;
}
private static Shader cachedShader;
private static bool shaderResolved;
public static void ApplyEyes(Player player)
{
if (player == null) return;
Transform headBone = FindBone(player, HeadBoneName);
if (headBone == null) return; // rig not up yet; try again next pass
Transform eyes = headBone.Find(EyesName);
if (!IsAlfarPlayer(player) || player.IsDead())
{
if (eyes != null)
{
// Renamed first: Destroy is deferred to the end of the frame, and every call
// until then would otherwise find it again.
eyes.name = EyesName + "_Removed";
Object.Destroy(eyes.gameObject);
}
return;
}
if (eyes == null)
{
// Sitting, attached, mid-attack or asleep the head can be turned away from the
// body's forward at the instant the frame is measured, which puts the eyes behind
// the skull. Wait for a neutral moment (the same guard as the Sverm's).
if (player.IsAttached() || player.IsAttachedToShip() || player.InAttack() || player.IsSleeping())
{
return;
}
eyes = BuildEyes(player, headBone);
}
if (eyes == null) return;
PlaceEyes(headBone, eyes);
}
private static void PlaceEyes(Transform headBone, Transform holder)
{
Vector3 lossy = headBone.lossyScale;
if (Mathf.Abs(lossy.x) < 0.0001f || Mathf.Abs(lossy.y) < 0.0001f || Mathf.Abs(lossy.z) < 0.0001f) return;
EyeFrame frame = holder.GetComponent<EyeFrame>();
if (frame == null) return;
// The Visual is scaled non-uniformly (thinner than tall), so lossyScale has three
// different components and a single divisor would squash the spheres. Each axis is
// divided by its own.
Vector3 toLocal = new Vector3(1f / lossy.x, 1f / lossy.y, 1f / lossy.z);
float eyeSize = AlfarConfig.EyeSize * AlfarConfig.EyeSizeMultiplier.Value;
Vector3 baseOffset = frame.LocalForward * AlfarConfig.EyeForward + frame.LocalUp * AlfarConfig.EyeHeight;
for (int i = 0; i < holder.childCount; i++)
{
Transform eye = holder.GetChild(i);
// Index 0 is offset against the right axis, so it is the model's left eye.
float side = i == 0 ? -1f : 1f;
Vector3 offset = baseOffset + frame.LocalRight * (side * AlfarConfig.EyeSeparation);
eye.localPosition = Vector3.Scale(offset, toLocal);
eye.localScale = Vector3.Scale(Vector3.one * eyeSize, toLocal);
}
}
private static Transform BuildEyes(Player player, Transform headBone)
{
Shader shader = ResolveShader(player);
if (shader == null) return null;
GameObject holder = new GameObject(EyesName);
holder.transform.SetParent(headBone, false);
holder.transform.localPosition = Vector3.zero;
holder.transform.localRotation = Quaternion.identity;
holder.transform.localScale = Vector3.one;
EyeFrame frame = holder.AddComponent<EyeFrame>();
RigBindPose.MeasureHeadFrame(player, headBone, "Alfar",
out frame.LocalForward, out frame.LocalUp, out frame.LocalRight);
for (int i = 0; i < 2; i++)
{
// Spheres, not quads: a quad seen edge-on is a line and vanishes.
GameObject eye = GameObject.CreatePrimitive(PrimitiveType.Sphere);
eye.name = "Eye" + i;
foreach (Collider collider in eye.GetComponents<Collider>())
{
Object.Destroy(collider);
}
eye.transform.SetParent(holder.transform, false);
eye.transform.localPosition = Vector3.zero;
eye.transform.localRotation = Quaternion.identity;
eye.transform.localScale = Vector3.zero; // PlaceEyes runs immediately after this
Renderer renderer = eye.GetComponent<Renderer>();
renderer.material = BlackMaterial(shader);
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.receiveShadows = false;
}
return holder.transform;
}
/// <summary>
/// Matte black, and nothing else: the colour is black, the emission is black, and the two
/// properties that make a lit shader shine are zeroed where the shader has them. The
/// Sverm's eyes burn; these must read as holes.
/// </summary>
private static Material BlackMaterial(Shader shader)
{
Material material = new Material(shader);
material.color = Color.black;
if (material.HasProperty("_EmissionColor")) material.SetColor("_EmissionColor", Color.black);
if (material.HasProperty("_Glossiness")) material.SetFloat("_Glossiness", 0f);
if (material.HasProperty("_Smoothness")) material.SetFloat("_Smoothness", 0f);
if (material.HasProperty("_Metallic")) material.SetFloat("_Metallic", 0f);
if (material.HasProperty("_SpecColor")) material.SetColor("_SpecColor", Color.black);
return material;
}
/// <summary>
/// Custom/Creature first, for the reason the Sverm's own resolver gives: Valheim dithers the
/// player away when the camera gets inside them, and only the game's own shaders know about
/// it, so eyes on an unlit shader would hang in the air while the face dissolved.
/// </summary>
private static Shader ResolveShader(Player player)
{
if (shaderResolved) return cachedShader;
// CUSTOM/CREATURE, found the one way that works in play. Two earlier attempts failed in
// opposite directions and both are on record in the log:
// 1. Shader.Find("Custom/Creature") returns null in the main-menu preview (Valheim's
// shaders are not all loaded by name until something has used them), so the code
// fell to Sprites/Default and CACHED it for the whole session;
// 2. taking the player's own body shader gave 'Custom/Player', the SKIN shader: it
// paints the skin texture, so the eyes came out white.
// So: ask Shader.Find, and failing that read the shader off a real creature's material
// (the Deathsquito's, the very prefab the drones are cloned from) once the world is up.
// A failure is never cached, and in the menu preview there are simply no eyes yet.
Shader shader = Shader.Find("Custom/Creature");
if (shader == null && ZNetScene.instance != null)
{
GameObject creature = ZNetScene.instance.GetPrefab("Deathsquito");
Renderer renderer = creature != null ? creature.GetComponentInChildren<Renderer>(true) : null;
if (renderer != null && renderer.sharedMaterial != null) shader = renderer.sharedMaterial.shader;
}
if (shader == null)
{
// The main-menu preview has no world and so no creature to read a shader from. Its eyes
// are only for show and are thrown away with the preview, so a plain unlit black will do
// there - and it is NOT cached, so the world gets the real one.
ZNetView preview = player != null ? player.GetComponent<ZNetView>() : null;
if (preview == null || !preview.IsValid()) return Shader.Find("Sprites/Default");
return null;
}
Jotunn.Logger.LogInfo($"[Alfar] Eye shader resolved to '{shader.name}'.");
shaderResolved = true;
cachedShader = shader;
return cachedShader;
}
// ─── Skin ────────────────────────────────────────────────────────────
/// <summary>Ash grey, or the glow colour while the archon form is up.</summary>
public static Color SkinFor(Player player)
{
return AlfarArchon.IsArchon(player) ? AlfarPowerConfig.ArchonColor.Value : AlfarConfig.SkinColor.Value;
}
private const string GlowName = "AlfarArchonGlow";
/// <summary>
/// A blue light on the body while the archon form is up, taken off when it is not. Every
/// client runs this for every Alfr in range, so the glow is seen by everyone.
/// </summary>
public static void ApplyArchonGlow(Player player)
{
if (player == null) return;
Transform existing = player.transform.Find(GlowName);
bool want = IsAlfarPlayer(player) && AlfarArchon.IsArchon(player) && !player.IsDead();
if (!want)
{
if (existing != null) Object.Destroy(existing.gameObject);
return;
}
if (existing == null)
{
GameObject holder = new GameObject(GlowName);
holder.transform.SetParent(player.transform, false);
holder.transform.localPosition = Vector3.up * 1.2f;
existing = holder.transform;
Light light = holder.AddComponent<Light>();
light.type = LightType.Point;
light.range = 9f;
light.intensity = 3f;
light.shadows = LightShadows.None;
}
Light glow = existing.GetComponent<Light>();
if (glow != null) glow.color = AlfarPowerConfig.ArchonColor.Value;
}
/// <summary>
/// The grey, for real. A tint on _SkinColor only MULTIPLIES the skin texture, and that texture is
/// pink: multiplied by a grey it comes out as a darker human skin, not as grey skin (the second
/// test: "the skin is the normal colour"). So the body's texture is replaced by a DESATURATED
/// copy, made once on the GPU and read back, and _SkinColor then only sets how light the grey is.
/// The original texture is remembered per material so a reset to human puts it back.
/// </summary>
private static readonly Dictionary<Texture, Texture2D> greyOf = new Dictionary<Texture, Texture2D>();
private static readonly Dictionary<Material, Texture> originalTexture = new Dictionary<Material, Texture>();
private static Texture2D Desaturated(Texture source)
{
Texture2D grey;
if (greyOf.TryGetValue(source, out grey) && grey != null) return grey;
RenderTexture target = RenderTexture.GetTemporary(source.width, source.height, 0,
RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
RenderTexture previous = RenderTexture.active;
try
{
Graphics.Blit(source, target);
RenderTexture.active = target;
grey = new Texture2D(source.width, source.height, TextureFormat.RGBA32, true);
grey.ReadPixels(new Rect(0, 0, source.width, source.height), 0, 0);
Color32[] pixels = grey.GetPixels32();
for (int i = 0; i < pixels.Length; i++)
{
Color32 c = pixels[i];
byte luma = (byte)(c.r * 0.299f + c.g * 0.587f + c.b * 0.114f);
pixels[i] = new Color32(luma, luma, luma, c.a);
}
grey.SetPixels32(pixels);
grey.Apply(true);
grey.name = source.name + "_AlfarGrey";
}
catch (System.Exception e)
{
Jotunn.Logger.LogWarning("[Alfar] Could not make the grey skin texture: " + e.Message);
grey = null;
}
finally
{
RenderTexture.active = previous;
RenderTexture.ReleaseTemporary(target);
}
if (grey != null) greyOf[source] = grey;
return grey;
}
/// <summary>
/// Puts the grey texture on every skin material of the body (or takes it off again). Runs from the
/// UpdateColors postfix, so it covers the main-menu preview and every client, and from the
/// cosmetic pass, so it survives anything that rebuilds the body.
/// </summary>
public static void ApplyGreyTexture(VisEquipment vis, bool on)
{
if (vis == null || vis.m_bodyModel == null) return;
foreach (Material material in vis.m_bodyModel.materials)
{
if (material == null || !material.HasProperty("_SkinColor") || !material.HasProperty("_MainTex")) continue;
Texture current = material.GetTexture("_MainTex");
if (on)
{
if (current == null) continue;
bool ours = false;
foreach (Texture2D grey in greyOf.Values) if (grey == current) { ours = true; break; }
if (ours) continue;
Texture2D desaturated = Desaturated(current);
if (desaturated == null) continue;
originalTexture[material] = current;
material.SetTexture("_MainTex", desaturated);
}
else
{
Texture original;
if (originalTexture.TryGetValue(material, out original) && original != null)
{
material.SetTexture("_MainTex", original);
}
originalTexture.Remove(material);
}
}
}
/// <summary>
/// Keeps the skin right for whoever it is: the grey and its tint for an Alfr, the original for
/// anyone who stopped being one. The tint is only written when it differs, and UpdateColors is
/// pushed only then, so it costs a colour compare.
/// </summary>
public static void SyncSkin(Player player, bool isAlfar)
{
if (player == null) return;
VisEquipment vis = player.GetComponent<VisEquipment>();
if (vis == null || vis.m_bodyModel == null) return;
if (!isAlfar)
{
if (originalTexture.Count > 0) ApplyGreyTexture(vis, false);
return;
}
ApplyGreyTexture(vis, true);
Material material = vis.m_bodyModel.material;
if (material == null || !material.HasProperty("_SkinColor")) return;
Color wanted = SkinFor(player);
Color current = material.GetColor("_SkinColor");
if (Mathf.Abs(current.r - wanted.r) < 0.01f && Mathf.Abs(current.g - wanted.g) < 0.01f &&
Mathf.Abs(current.b - wanted.b) < 0.01f) return;
Traverse.Create(vis).Method("UpdateColors").GetValue();
}
// ─── Hands ───────────────────────────────────────────────────────────
/// <summary>The right hand bone: where the beam leaves from.</summary>
public static Transform RightHand(Player player)
{
return player != null ? FindBone(player, "RightHand") : null;
}
private static Transform FindBone(Player player, string boneName)
{
VisEquipment visEq = player.GetComponent<VisEquipment>();
if (visEq == null || visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return null;
foreach (Transform bone in visEq.m_bodyModel.bones)
{
if (bone != null && bone.name == boneName) return bone;
}
// Loose match, because rigs are not consistent about capitalisation or prefixes.
string wanted = boneName.ToLowerInvariant();
foreach (Transform bone in visEq.m_bodyModel.bones)
{
if (bone != null && bone.name.ToLowerInvariant().Contains(wanted)) return bone;
}
return null;
}
}
}