RacesOfValheim/JotunnModStub/Skeleton/SkeletonVisuals.cs
kanym 892b970df4 fix(skeleton): let everyone see the burning skull
The head flame was built inside SkeletonRace, a single MonoBehaviour that only
ever looks at Player.m_localPlayer, so the fire existed on one client and on one
player. Everyone else saw a bare skull. Same shape as the Draugh aura, same fix:
the build moves to SkeletonVisuals.HeadFlame, which takes a Player, and
RacesVisualController grows one for every remote skeleton it can see. Held per
player rather than statically - a static would hand the second skeleton in view
the first one is fire. Nothing is networked and nothing needs to be: the tier is
already on the ZDO, so each client works out for itself who should be alight.

The remote path also still collapsed the jaw at Fader, the charred-twitcher
leftover that was removed from the local path two commits ago - so other players
would have gone on seeing a Fader with no mandible. It is a restore there now
too.
2026-08-05 18:22:57 +02:00

150 lines
6.7 KiB
C#

using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Skeleton's cosmetics that any client can grow for itself.
///
/// The head flame started life inside SkeletonRace, which is a single MonoBehaviour that only
/// ever looks at Player.m_localPlayer - so the fire existed on one client, on one player, and
/// everyone else saw a bare skull. Same shape of bug as the Draugh's aura, and the same fix:
/// the build takes a Player, and each client grows a copy for every skeleton it can see.
///
/// Nothing here is networked and nothing needs to be. The tier is already on the ZDO, so every
/// client can work out for itself whether a given skeleton should be alight.
/// </summary>
public static class SkeletonVisuals
{
// Fire sources in preference order. The torch is an item every world has; the ground
// torch and the fire pit are the building pieces to fall back on.
private static readonly string[] FlameSourcePrefabs =
{
"Torch", "piece_groundtorch_wood", "piece_groundtorch", "fire_pit"
};
private static GameObject cachedFlameSource;
private static bool flameSourceResolved;
/// <summary>
/// Finds a vanilla prefab that carries real fire particles. Resolved once per session,
/// failure included, so a miss cannot turn into a per-frame log.
/// </summary>
private static GameObject ResolveFlameSource()
{
if (flameSourceResolved) return cachedFlameSource;
flameSourceResolved = true;
foreach (string name in FlameSourcePrefabs)
{
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(name);
if (prefab == null) continue;
if (prefab.GetComponentsInChildren<ParticleSystem>(true).Length == 0) continue;
Jotunn.Logger.LogInfo($"[Skeleton] Head flame source resolved to '{name}'.");
cachedFlameSource = prefab;
return cachedFlameSource;
}
Jotunn.Logger.LogWarning(
"[Skeleton] No fire prefab resolved (" + string.Join(", ", FlameSourcePrefabs) +
"); the skull stays unlit.");
return null;
}
/// <summary>
/// One player's burning skull. Cosmetic only - it deals nothing and blocks nothing.
///
/// Held per player rather than statically: a static would hand the second skeleton in view
/// the first one's fire. Call Apply every frame; it builds once and then only follows.
/// </summary>
public class HeadFlame
{
// Above the head bone's own origin, which sits at the base of the skull.
private const float Height = 0.18f;
// Torch flames are authored for a fist-sized fire on a stick, so the skull wears a big
// multiple of one.
private const float Scale = 1.8f;
private GameObject m_instance;
private Transform m_headBone;
public void Apply(Player player, bool enable)
{
if (!enable)
{
if (m_instance != null && m_instance.activeSelf) m_instance.SetActive(false);
return;
}
if (player == null) return;
if (m_instance == null && !Build(player)) return;
if (!m_instance.activeSelf) m_instance.SetActive(true);
// Follows the skull without inheriting its scale.
if (m_headBone != null)
{
m_instance.transform.position = m_headBone.position + Vector3.up * Height;
}
}
/// <summary>Returns false while the pieces it needs are not ready yet.</summary>
private bool Build(Player player)
{
Animator anim = player.GetComponentInChildren<Animator>();
m_headBone = anim != null ? anim.GetBoneTransform(HumanBodyBones.Head) : null;
if (m_headBone == null) return false; // rig not up yet; try again next frame
GameObject source = ResolveFlameSource();
if (source == null) return false; // already logged once by the resolver
// Deliberately not parented to the head bone: the player rig is authored at
// roughly 100x, and a particle system inheriting that would put a bonfire where a
// candle belongs. It hangs off the player and is moved onto the bone each frame.
m_instance = new GameObject("SkeletonHeadFlameVFX");
m_instance.transform.SetParent(player.transform, false);
m_instance.transform.localScale = Vector3.one * Scale;
// Real fire is cloned rather than built by hand. The first attempt at this made a
// particle system from scratch on the smoke material, and a hand-rolled gradient
// over a smoke sprite reads as a wisp, not a burning skull.
foreach (ParticleSystem ps in source.GetComponentsInChildren<ParticleSystem>(true))
{
GameObject copy = Object.Instantiate(ps.gameObject, m_instance.transform);
copy.name = ps.gameObject.name;
copy.transform.localPosition = Vector3.zero;
copy.transform.localRotation = Quaternion.identity;
copy.SetActive(true);
// So the holder's scale actually enlarges the fire rather than just spreading
// out where the particles spawn.
ParticleSystem.MainModule main = copy.GetComponent<ParticleSystem>().main;
main.scalingMode = ParticleSystemScalingMode.Hierarchy;
}
// A torch's own light is tuned to light a corridor from waist height; on a head it
// blows out the whole face. Keep the glow, lose the floodlight.
foreach (Light light in m_instance.GetComponentsInChildren<Light>(true))
{
light.range *= 0.5f;
light.intensity *= 0.6f;
}
// Anything that made the source a torch rather than a fire.
foreach (MonoBehaviour comp in m_instance.GetComponentsInChildren<MonoBehaviour>(true))
{
Object.Destroy(comp);
}
foreach (Collider col in m_instance.GetComponentsInChildren<Collider>(true))
{
Object.Destroy(col);
}
return true;
}
}
}
}