The tier-5 fire aura looked for "vfx_smoke", then "vfx_surtling_death". Neither name exists in Valheim, checked against the game's own asset manifests, so both lookups came back null and the aura has never been visible in a plain install. The dead branch was not harmless. PrefabManager.Cache resolves by asset name across everything in memory, other mods' asset bundles included, and its tie-break for a duplicate name ends in "newest wins". A name vanilla does not use has no vanilla candidate to beat, so it is a free slot. Magic_Supremacy fills it. The lookup resolved to 'EncounterCreatureRikoMountain_DO/vfx_smoke', a child node of one of its creatures carrying 'club_trail_riko_DO' on 'Dreanegade/ParticleAlphaEmission' - a weapon trail, on an emissive shader, sprayed through a 4.5m sphere on the player. That is the purple smoke around the burning skull users reported, on every client that could see the skeleton. The aura now draws nothing on purpose, which costs it nothing it had. Its damage, radius and tick are untouched. The two identical EnsureFireAuraVFX copies in SkeletonRace and ZdoVisualSync are replaced by one SkeletonVisuals.EnsureFireAura, shaped like DraughVisuals.EnsureAura; the call sites stay, so reinstating the visual needs no change in either file. The comment on it records the whole chain and the way to build it properly, through BorrowEffect, the way HeadFlame already does. Also keeps a resolution log on the model lookup: every magic mod in the report ships an object called "Skeleton", which is this race's own tier-0 model name. The vanilla creature won during the repro; root=False in that log is what says it stopped winning. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
490 lines
24 KiB
C#
490 lines
24 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>
|
|
/// 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();
|
|
}
|
|
|
|
/// <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<GameObject>("vfx_smoke")
|
|
/// ?? PrefabManager.Cache.GetPrefab<GameObject>("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>
|
|
/// 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;
|
|
}
|
|
}
|
|
}
|
|
}
|