RacesOfValheim/JotunnModStub/Skeleton/SkeletonVisuals.cs
kanym 3591b7e375 fix(skeleton): the Summon on Kill aura borrows the torch smoke
The Draugr's evil_smoke is on 'Lux Lit Particles/ Bumped' and showed
nothing in game once tinted dark. The torch's own Smoke, from the
prefab the head flame burns from, is the grey everyone sees above a
torch; darkened to (0.08, 0.08, 0.09) at 0.45 alpha.
2026-10-24 15:44:16 +02:00

642 lines
32 KiB
C#

using System.Collections.Generic;
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>
/// Whether this client draws the skeleton's bones on this player. False for every
/// non-Skeleton, and for every Skeleton when "Body Model Enabled" is off: model-replacement
/// mods (EnhancedValheimVRM and the like) hide the vanilla body and draw their own, so the
/// borrowed bones ended up floating around the replacement model. With the option off the
/// Skeleton keeps every ability and only looks like a plain viking.
/// </summary>
public static bool ShowsSkeletonBody(Player player) =>
SkeletonConfig.BodyModelEnabled.Value && IsSkeletonPlayer(player);
/// <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();
}
public const string LookZdoKey = "RacesOfValheim_SkeletonLook";
public const string LookDataKey = "SkeletonLook";
/// <summary>
/// The body this player chose at the barber, "" if they never did. Read the same way as
/// the race: the ZDO for anyone on the network, m_customData for the menu preview.
/// </summary>
public static string GetLook(Player player)
{
if (player == null) return "";
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid())
{
return nview.GetZDO().GetString(LookZdoKey, "");
}
if (player.m_customData != null && player.m_customData.TryGetValue(LookDataKey, out string look))
{
return look;
}
return "";
}
/// <summary>The model prefab to wear for this player at this tier, look applied.</summary>
public static string GetModel(Player player, int state)
{
return SkeletonProgression.ResolveModel(state, GetLook(player));
}
/// <summary>
/// Fire sources in preference order. BUILDING PIECES ONLY, and that is the bug fix.
///
/// This list used to start with "Torch", which is the ITEM prefab, and an item in Valheim
/// is a live world object: ItemDrop, a Rigidbody and a ZNetView, all of them on the same
/// node the fire particles are on. That the borrow was reaching that node and not a bare
/// flame was already known here - the strip below used to name "the stick mesh, ItemDrop,
/// durability", and the Rigidbody it had to destroy was the one that made an early version
/// of the clone visibly fall away from the skull.
///
/// What was missed is that the copy was made into a holder that was ALREADY SWITCHED ON,
/// so all of it woke up for a frame before the strip could take any of it off - and a woken
/// ZNetView is not a cosmetic mistake. ZNetView.Awake with no init ZDO calls
/// ZDOMan.CreateNewZDO at the object's position, marks it persistent, stamps it with the
/// prefab hash and registers it with the scene; ZNetView.OnDestroy does none of that in
/// reverse - it only releases asset references. So every rebuild of the flame left the
/// world holding a persistent "there is a Torch here" record that nothing was drawing,
/// saved with everything else, and the next time that zone was built from the save every
/// client spawned the torch. That is the whole of the report: a torch dropped on logging
/// in and out, and a portal handing it to everyone.
///
/// A ground torch is a building piece. It has the same fire (both carry fx_Torch_Basic) and
/// no item behaviour at all, so there is nothing on it to bring across by accident. The
/// inactive holder in Build and the two filters below are the lines of defence behind that,
/// for whatever a future source turns out to carry.
/// </summary>
private static readonly string[] FlameSourcePrefabs =
{
"piece_groundtorch_wood", "piece_groundtorch", "fire_pit"
};
/// <summary>
/// Particle systems that are not fire. Matched on the object name, which is how these are
/// named in the prefabs that carry them - an item's pickup glitter above all, which is a
/// ParticleSystem like any other and was worn on the skull along with the flame.
/// </summary>
private static readonly string[] NotFire =
{
"sparkle", "sparcle", "glitter", "pickup", "shine", "twinkle"
};
private static bool IsFire(GameObject candidate)
{
string name = candidate.name.ToLower();
foreach (string word in NotFire)
{
if (name.Contains(word)) return false;
}
return true;
}
// Said once per particle name per session, with everything the borrowed node carries that
// is not a particle. The point is that the next time something rides along, the log names
// it - this bug cost a bug report because nothing ever said "that flame is an item".
private static readonly HashSet<string> loggedParticles = new HashSet<string>();
private static void LogClonedOnce(GameObject source)
{
if (!loggedParticles.Add(source.name)) return;
List<string> passengers = new List<string>();
foreach (Component comp in source.GetComponentsInChildren<Component>(true))
{
if (comp == null || IsPureVfx(comp, true)) continue;
passengers.Add(comp.GetType().Name);
}
Jotunn.Logger.LogInfo(
$"[Skeleton] Head flame: cloned '{source.name}'" +
(passengers.Count == 0 ? "." : ", stripped " + string.Join(", ", passengers.ToArray()) + "."));
}
/// <summary>
/// Says what a borrowed-by-name prefab actually resolved to: which object, where it sits in
/// ITS OWN hierarchy, and the material and shader the first particle on it carries. Once per
/// name per session, so it costs a handful of lines and answers the question that took a
/// bundle extractor to answer the first time.
///
/// READ THE root FLAG FIRST. A root-level object is a real prefab and almost certainly the
/// vanilla one. A parented one is a child node that Jotunn's cache picked up because nothing
/// better in memory answered to that name - which is what happens when the name does not
/// exist in vanilla at all, and is exactly how another mod's weapon trail ended up worn as
/// this race's fire aura. See EnsureFireAura.
/// </summary>
private static readonly HashSet<string> loggedResolutions = new HashSet<string>();
public static void LogResolvedPrefabOnce(string wanted, GameObject resolved)
{
if (!loggedResolutions.Add(wanted)) return;
if (resolved == null)
{
Jotunn.Logger.LogWarning($"[Skeleton] Prefab lookup '{wanted}' resolved to NOTHING.");
return;
}
string path = resolved.name;
for (Transform t = resolved.transform.parent; t != null; t = t.parent)
{
path = t.name + "/" + path;
}
ParticleSystem first = resolved.GetComponentInChildren<ParticleSystem>(true);
ParticleSystemRenderer psr = first != null ? first.GetComponent<ParticleSystemRenderer>() : null;
Material material = psr != null ? psr.sharedMaterial : null;
Jotunn.Logger.LogInfo(
$"[Skeleton] Prefab lookup '{wanted}' resolved to '{path}' " +
$"(root={resolved.transform.parent == null}) " +
$"particle='{(first != null ? first.name : "none")}' " +
$"material='{(material != null ? material.name : "none")}' " +
$"shader='{(material != null && material.shader != null ? material.shader.name : "none")}' " +
$"startColor={(first != null ? first.main.startColor.color.ToString() : "-")}");
}
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;
bool hasFire = false;
foreach (ParticleSystem ps in prefab.GetComponentsInChildren<ParticleSystem>(true))
{
if (IsFire(ps.gameObject)) { hasFire = true; break; }
}
if (!hasFire) 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>
/// Strips a borrowed subtree down to what a pure VFX needs, and nothing else.
///
/// Allowlist, not a blocklist: keep the particle systems, their renderers and the lights
/// (and the loose meshes, for the eye glow), 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 - and a fire node carrying one meant physics
/// kept acting on the clone independently of the holder being repositioned every frame.
///
/// DestroyImmediate rather than Destroy, because the caller is about to switch the holder
/// on and Destroy does not take effect until the end of the frame - by which time every
/// script it was supposed to remove would have had its Awake.
///
/// Repeated passes, because Unity refuses to destroy a component another one still
/// requires ("Can't remove Humanoid because CharacterDrop depends on it"): the dependent
/// goes on one pass and the component it held down goes on the next. Behaviours first
/// within each pass, for the same reason.
/// </summary>
public static void StripToVfx(GameObject root, bool keepMeshes, string label)
{
if (root == null) return;
for (int pass = 0; pass < 4; pass++)
{
bool anyLeft = false;
foreach (MonoBehaviour behaviour in root.GetComponentsInChildren<MonoBehaviour>(true))
{
if (behaviour == null) continue;
Object.DestroyImmediate(behaviour);
}
foreach (Component comp in root.GetComponentsInChildren<Component>(true))
{
if (comp == null || IsPureVfx(comp, keepMeshes)) continue;
Object.DestroyImmediate(comp);
anyLeft = true;
}
if (!anyLeft) return;
}
// Four passes and something is still holding on. Say what it is: a survivor here is the
// exact shape of bug this whole class exists to prevent, and it is about to be woken.
foreach (Component comp in root.GetComponentsInChildren<Component>(true))
{
if (comp == null || IsPureVfx(comp, keepMeshes)) continue;
Jotunn.Logger.LogWarning(
$"[{label}] '{comp.GetType().Name}' on '{comp.gameObject.name}' could not be stripped " +
"off the borrowed effect; it will run on the player.");
}
}
private static bool IsPureVfx(Component comp, bool keepMeshes)
{
if (comp is Transform || comp is ParticleSystem || comp is ParticleSystemRenderer || comp is Light)
{
return true;
}
return keepMeshes && (comp is MeshRenderer || comp is MeshFilter);
}
/// <summary>
/// Clones one node of a vanilla prefab as pure VFX and hangs it under <paramref name="parent"/>.
///
/// The temporary holder is created INACTIVE and the copy is made inside it. That single
/// line is the point of this method: Unity does not run Awake on an object that is not
/// active in its hierarchy, so ItemDrop, ZNetView, Rigidbody and every script on the
/// borrowed node are destroyed before any of them ever exists as far as the game is
/// concerned. Stripping AFTER the copy is already live - which is what the head flame and
/// the eye glow both used to do - is a frame too late, and one frame is all a ZNetView
/// needs to write a persistent object into the save. Same lesson, same fix, as ModelBorrow.
///
/// The copy is handed back parented to <paramref name="parent"/> and switched on, with its
/// pose left to the caller.
/// </summary>
public static GameObject BorrowEffect(GameObject source, Transform parent, string cloneName,
bool keepMeshes, string label)
{
if (source == null || parent == null) return null;
GameObject holder = new GameObject("BorrowedEffectHolder");
holder.SetActive(false); // BEFORE the Instantiate below.
GameObject copy = Object.Instantiate(source, holder.transform);
copy.name = cloneName;
StripToVfx(copy, keepMeshes, label);
copy.transform.SetParent(parent, false);
Object.DestroyImmediate(holder);
// A prefab can leave its own effects switched off for a script to turn on later, and
// that script is exactly what was just destroyed.
copy.SetActive(true);
foreach (Light light in copy.GetComponentsInChildren<Light>(true)) light.enabled = true;
foreach (Renderer renderer in copy.GetComponentsInChildren<Renderer>(true)) renderer.enabled = true;
return copy;
}
/// <summary>
/// The fire aura's visual, and the reason it now has none.
///
/// The aura itself (SkeletonRace.ApplyFireAura) burns everything inside FireAuraRadius from
/// Moder on and is untouched. What is gone is the way it used to try to show itself:
///
/// PrefabManager.Cache.GetPrefab&lt;GameObject&gt;("vfx_smoke")
/// ?? PrefabManager.Cache.GetPrefab&lt;GameObject&gt;("vfx_surtling_death")
///
/// NEITHER NAME EXISTS IN VALHEIM. Checked against the game's own asset manifest: there is no
/// vfx_smoke, and no surtling death effect under any spelling. In a plain install both
/// lookups came back null, no particle system was ever added, and this aura has never been
/// visible to anybody since the day it was written.
///
/// A dead branch would be harmless if the lookup were harmless. It is not. PrefabManager.Cache
/// is, in Jotunn's own words, a "global cache of Unity Objects by asset name" built with
/// Resources.FindObjectsOfTypeAll, so it answers with anything in memory - including the
/// contents of every other mod's asset bundle - and its tie-break for a duplicate name ends
/// in "the newly discovered object replaces the cached one". A name vanilla does not use has
/// no vanilla candidate to beat, which leaves it a free slot for whoever ships one.
///
/// Somebody shipped one. With Magic_Supremacy installed the lookup resolved to
/// 'EncounterCreatureRikoMountain_DO/vfx_smoke' - a CHILD node of one of that mod's
/// creatures, carrying the material 'club_trail_riko_DO' on the shader
/// 'Dreanegade/ParticleAlphaEmission'. A weapon trail, on an emissive shader, sprayed through
/// a 4.5m sphere centred on the player: the purple smoke around the burning skull this race
/// was reported for, on every client that could see the skeleton.
///
/// So the aura is invisible deliberately now, which costs it nothing it ever had. To give it
/// a look, build it the way HeadFlame does: resolve a prefab under a name vanilla really uses
/// (ResolveFlameSource already holds one that works) and clone it through BorrowEffect,
/// instead of hand-rolling a particle system around a material taken by name.
/// </summary>
public static void EnsureFireAura(Player player, bool enable, ref GameObject aura)
{
// Nothing is built, so there is nothing to switch on either way - but a leftover is
// destroyed rather than left riding the player, which is what a session that swapped
// this assembly in mid-flight would otherwise be stuck with.
if (aura == null) return;
Object.Destroy(aura);
aura = null;
}
/// <summary>The owner's Summon on Kill switch, for every other client to read.</summary>
public const string RaisingZdoKey = "RacesOfValheim_SkeletonRaising";
/// <summary>
/// A faint dark smoke rising off the whole body while Summon on Kill is on: the other half
/// of the indicator, beside the Raise the Dead icon, so the community can pick either or
/// both. Cosmetic only.
///
/// The smoke is the torch's own (see Build for why not the Draugr's), cloned through
/// BorrowEffect and tinted near-black. It emits from a box the
/// size of the body rather than from one point, so it comes off the arms and legs too.
/// A mesh-shaped emitter would hug the body closer, but only works on a readable mesh.
///
/// Held per player, like HeadFlame. Call Apply every frame; it builds once.
/// </summary>
public class RaisingAura
{
// The torch smoke is (0.35, 0.35, 0.35, 0.21); darker and a little thicker than that.
private static readonly Color Smoke = new Color(0.08f, 0.08f, 0.09f, 0.45f);
private static readonly Vector3 BodyBox = new Vector3(0.55f, 1.7f, 0.35f);
private const float BodyCentre = 0.95f;
private GameObject m_instance;
public void Apply(Player player, bool enable)
{
if (!enable || player == null)
{
if (m_instance != null && m_instance.activeSelf) m_instance.SetActive(false);
return;
}
if (m_instance == null && !Build(player)) return;
if (!m_instance.activeSelf) m_instance.SetActive(true);
}
private static bool warned;
private bool Build(Player player)
{
// The torch's own 'Smoke', from the same prefab the head flame burns from. The
// Draugr's evil_smoke was tried first: its material is on 'Lux Lit Particles/
// Bumped', which takes its look from the material and the scene light, so a dark
// tint on it showed nothing in game. The torch smoke is the grey everyone sees
// above a torch, so darkening it has something to darken.
GameObject torch = ResolveFlameSource();
ParticleSystem source = null;
if (torch != null)
{
foreach (ParticleSystem ps in torch.GetComponentsInChildren<ParticleSystem>(true))
{
if (ps.gameObject.name.ToLower().Contains("smoke")) { source = ps; break; }
}
}
if (source == null)
{
if (!warned)
{
warned = true;
Jotunn.Logger.LogWarning("[Skeleton] No 'Smoke' particle on the torch; the Summon on Kill aura stays off.");
}
return false;
}
m_instance = BorrowEffect(source.gameObject, player.transform, "SkeletonRaisingAura", false, "Skeleton");
if (m_instance == null) return false;
m_instance.transform.localPosition = new Vector3(0f, BodyCentre, 0f);
m_instance.transform.localRotation = Quaternion.identity;
m_instance.transform.localScale = Vector3.one;
foreach (ParticleSystem ps in m_instance.GetComponentsInChildren<ParticleSystem>(true))
{
ParticleSystem.MainModule main = ps.main;
main.startColor = new ParticleSystem.MinMaxGradient(Smoke);
// World space, so the smoke stays behind as the body moves, like a trail.
main.simulationSpace = ParticleSystemSimulationSpace.World;
main.scalingMode = ParticleSystemScalingMode.Hierarchy;
ParticleSystem.ShapeModule shape = ps.shape;
shape.enabled = true;
shape.shapeType = ParticleSystemShapeType.Box;
shape.scale = BodyBox;
shape.position = Vector3.zero;
shape.rotation = Vector3.zero;
// A tint over the particle's life would put the source's own colour back; keep
// the fade (alpha) and drop the colour.
ParticleSystem.ColorOverLifetimeModule col = ps.colorOverLifetime;
if (col.enabled)
{
Gradient faded = new Gradient();
faded.SetKeys(new[] { new GradientColorKey(Color.white, 0f), new GradientColorKey(Color.white, 1f) },
col.color.gradient != null ? col.color.gradient.alphaKeys
: new[] { new GradientAlphaKey(1f, 0f), new GradientAlphaKey(0f, 1f) });
col.color = new ParticleSystem.MinMaxGradient(faded);
}
}
// The shader decides whether a dark tint can show at all: an additive one adds
// nothing for black. If the aura is invisible in game, this line says why.
Renderer smokeRenderer = m_instance.GetComponentInChildren<Renderer>(true);
Material smokeMaterial = smokeRenderer != null ? smokeRenderer.sharedMaterial : null;
Jotunn.Logger.LogInfo($"[Skeleton] Summon on Kill aura built from '{torch.name}/{source.gameObject.name}', " +
$"material '{(smokeMaterial != null ? smokeMaterial.name : "none")}', " +
$"shader '{(smokeMaterial != null && smokeMaterial.shader != null ? smokeMaterial.shader.name : "none")}'.");
return true;
}
}
/// <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.
//
// Every clone goes through BorrowEffect, which builds it inactive and strips it
// before it can wake. Nothing from the source prefab - a script, a Rigidbody, a
// ZNetView - ever gets a frame of life on the player.
foreach (ParticleSystem ps in source.GetComponentsInChildren<ParticleSystem>(true))
{
if (!IsFire(ps.gameObject)) continue;
GameObject copy = BorrowEffect(ps.gameObject, m_instance.transform,
ps.gameObject.name, false, "Skeleton");
if (copy == null) continue;
LogClonedOnce(ps.gameObject);
copy.transform.localPosition = Vector3.zero;
copy.transform.localRotation = Quaternion.identity;
// 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;
}
return true;
}
}
}
}