The head-flame VFX clones only the source torch's ParticleSystem subtree, then stripped components with a blocklist (every MonoBehaviour, every Collider) to leave a bare flame. The blocklist missed Rigidbody - not a MonoBehaviour in Unity - so a torch whose fire-particle node carried one kept being acted on by physics independently of the parent GameObject that tracks the head each frame, and visibly fell away from the skull. Switched to an allowlist: keep only Transform/ParticleSystem/ ParticleSystemRenderer/Light, destroy everything else on the clone. Can't miss a component type this way, whatever it turns out to be next.
236 lines
11 KiB
C#
236 lines
11 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
|
|
{
|
|
public const string RaceId = "Skeleton";
|
|
|
|
/// <summary>
|
|
/// Reads the race off the ZDO, falling back to m_customData.
|
|
///
|
|
/// The fallback is what makes the race show up on the main-menu character preview.
|
|
/// FejdStartup.SetupCharacterPreview instantiates a Player and calls
|
|
/// PlayerProfile.LoadPlayerData on it, which restores m_customData - so the preview does
|
|
/// know it is a Skeleton. What it has no business having is a ZNetView, and reading the
|
|
/// race from the ZDO alone meant the body swap gave up before it ever looked.
|
|
/// </summary>
|
|
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 IsSkeletonPlayer(Player player) => GetPlayerRace(player) == RaceId;
|
|
|
|
/// <summary>
|
|
/// Fully hides (or restores) one equipped item instance - a helmet, typically.
|
|
///
|
|
/// Scale-to-zero alone leaves skinned pieces behind: a SkinnedMeshRenderer bound to the
|
|
/// player's own bones (some helmets carry a cloth or chain piece skinned that way) is
|
|
/// deformed by those bone matrices, not by its GameObject's transform, so zeroing the
|
|
/// wrapper's localScale does nothing to it - exactly the "part of the helmet is still
|
|
/// there" artifact reported on the Skeleton. Disabling every Renderer underneath has no
|
|
/// such exception; combined with the scale it hides both plain and skinned pieces, and
|
|
/// is reasserted the same way (Valheim's own visual refresh re-enables the instance and
|
|
/// resets its scale, so both must be redone every time visuals rebuild).
|
|
/// </summary>
|
|
public static void SetEquipmentPieceHidden(GameObject instance, bool hidden)
|
|
{
|
|
if (instance == null) return;
|
|
|
|
Vector3 wantedScale = hidden ? Vector3.zero : Vector3.one;
|
|
if (instance.transform.localScale != wantedScale)
|
|
{
|
|
instance.transform.localScale = wantedScale;
|
|
}
|
|
|
|
foreach (Renderer renderer in instance.GetComponentsInChildren<Renderer>(true))
|
|
{
|
|
if (renderer.enabled == hidden)
|
|
{
|
|
renderer.enabled = !hidden;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The tier a given player's body should be built for. The ZDO carries it so remote
|
|
/// players render at their own standing; without one - the menu preview - fall back to
|
|
/// whatever this client can work out, which in the menu is the base tier, since there is
|
|
/// no world loaded to have killed anything.
|
|
/// </summary>
|
|
public static int GetProgressionState(Player player)
|
|
{
|
|
ZNetView nview = player != null ? player.GetComponent<ZNetView>() : null;
|
|
if (nview != null && nview.IsValid())
|
|
{
|
|
return nview.GetZDO().GetInt("RacesOfValheim_SkeletonState", 0);
|
|
}
|
|
|
|
return BossProgressionManager.GetCurrentProgressionState();
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
// Allowlist, not a blocklist: keep only what a pure VFX actually needs (the
|
|
// particle systems, their renderers, and the light tweaked above) and destroy
|
|
// every other component, whatever it turns out to be. A blocklist of "known bad"
|
|
// types (MonoBehaviour, Collider) missed Rigidbody - not a MonoBehaviour in Unity,
|
|
// so the old loop never touched it - and a torch's fire-particle node carrying one
|
|
// meant physics kept acting on the clone independently of m_instance being
|
|
// repositioned onto the head every frame: it visibly fell away while the empty
|
|
// parent stayed correctly tracked above it. Anything that made the source a torch
|
|
// rather than a bare flame - the stick mesh, ItemDrop, durability, all of it -
|
|
// goes the same way.
|
|
foreach (Component comp in m_instance.GetComponentsInChildren<Component>(true))
|
|
{
|
|
if (comp is Transform || comp is ParticleSystem || comp is ParticleSystemRenderer || comp is Light) continue;
|
|
Object.Destroy(comp);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|