RacesOfValheim/JotunnModStub/Trenta/TrentaAbilities.cs
kanym e75c7072c4 fix(prefabs): replace every lookup name that does not exist in vanilla
An audit of all 59 prefab names the mod resolves, against the game's own
asset manifests, found nine that are not in Valheim at all. A name vanilla
does not use has no vanilla candidate to beat in Jotunn's name cache, so it
is a free slot for whoever ships one - which is how another mod's weapon
trail became the Skeleton's fire aura in 00d4fd6.

Eight of the nine failed in silence, which is why none of them was ever
reported:

  vfx_corpse_destruction  ->  _medium, _large for the Muspell. The puff that
      covers a transformation. Fenrir and Skadi at least had their sparks;
      the Muspell swapped bodies in plain view with nothing at all.
  vfx_surtling_death      ->  vfx_wraith_death for the Aswid's Mist Form,
      which reads as mist by construction and is the same creature the form
      already borrows its Visual from; vfx_corpse_destruction_medium for the
      thrall, where nothing is misty. Vanilla has no surtling death effect
      under any spelling.
  TrophyTroll             ->  TrophyForestTroll.
  TrophyBat               ->  TrophyDeathsquito. Vanilla ships no bat trophy,
      so the Aswid's two status effects and its radial entry had no icon.
  vfx_smoke               ->  gone. It was the Trenta's fallback for Purple
      Rain's particle material behind Greydwarf_Shaman, and the day the
      Shaman failed to resolve it would have worn whatever a mod supplies.
      Purple Rain is purple by design, so nobody would ever have reported it.

The ninth did not fail in silence. vfx_OozeHit was passed to Instantiate
unguarded, so every successful Draugh parry threw ArgumentException and took
the North Wind nova below it down as well. It is vfx_blob_hit.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-26 00:20:02 +02:00

342 lines
17 KiB
C#

using System.Collections;
using System.Collections.Generic;
using HarmonyLib;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Trenta's active abilities, driven from TrentaRace.Update. Each one reads its cost,
/// radius, duration and cooldown out of TrentaConfig.
/// </summary>
public static class TrentaAbilities
{
public static void Tick(Player player, int state)
{
// Photosynthesis is a passive trigger, not a keypress, so it runs unconditionally -
// unlike the keybound abilities below it is not gated on RaceInput.Allowed. Standing
// still with an inventory screen open is still standing still.
TickPhotosynthesis(player, state);
// Ability input is gated exactly like every other race's: RaceInput mirrors
// Player.TakeInput, so nothing fires while a map, chest or chat window has focus.
if (!RaceInput.Allowed) return;
if (state >= TrentaConfig.PurpleRainUnlockState && TrentaConfigManagement.PurpleRainKey.Value.IsDownIgnoringHeldKeys())
{
TryPurpleRain(player);
}
if (state >= TrentaConfig.PortalUnlockState && TrentaConfigManagement.PortalKey.Value.IsDownIgnoringHeldKeys())
{
TryOpenPortal(player);
}
if (state >= TrentaConfig.MuspellUnlockState && TrentaConfigManagement.MuspellKey.Value.IsDownIgnoringHeldKeys())
{
TrentaMuspell.Toggle(player);
}
// TODO: any further keybound perks, one `if (... && Input.GetKeyDown(...))` each.
}
// ─── Hornet's Nest ──────────────────────────────────────────────────
private static GameObject hornetSwarm;
/// <summary>
/// Called unconditionally from TrentaRace.Update, not from Tick above - a permanent
/// companion has to be torn down the moment it should stop existing (race change, tier
/// drop, death), and Tick only ever runs while the local player still qualifies as a
/// Queen-tier Trenta, which is exactly the case this needs to catch.
/// </summary>
public static void TickHornetsNest(Player player, bool shouldExist)
{
if (shouldExist && hornetSwarm == null)
{
hornetSwarm = TrentaHornetSwarm.Spawn(player);
}
else if (!shouldExist && hornetSwarm != null)
{
Object.Destroy(hornetSwarm);
hornetSwarm = null;
}
}
// ─── Photosynthesis ──────────────────────────────────────────────────
// Seconds of unbroken stillness accumulated so far, and the state of the heal-over-time
// window once a grant has fired. Static because only ever ticked for the local player.
private static float stillTimer = 0f;
private static bool healPhaseActive = false;
private static float healPhaseTimer = 0f;
private static int healTicksApplied = 0;
/// <summary>
/// Daylight, out from under a roof, ten unbroken seconds of standing still: the Trenta
/// gets a Rested buff (Player.SetSleeping's own duration-less grant, given a duration here
/// instead - see the long comment on Trenta_Player_EatFood_Patch-adjacent code style,
/// mirrors DvergarStatusEffects.ApplyCooldownIcon exactly) plus 10% of max health healed
/// once a second for 8 seconds.
///
/// Movement cancels whichever phase is running, on the spot, with no partial credit -
/// including movement from being knocked back by an attack, since this only ever looks at
/// whether the character actually moved, never at why. A hit that does not move the Trenta
/// does not touch either phase.
/// </summary>
private static void TickPhotosynthesis(Player player, int state)
{
bool moving = player.GetVelocity().magnitude > TrentaConfig.PhotosynthesisVelocityEpsilon;
if (healPhaseActive)
{
if (moving)
{
healPhaseActive = false;
healPhaseTimer = 0f;
healTicksApplied = 0;
return;
}
healPhaseTimer += Time.deltaTime;
int targetTicks = Mathf.Min(Mathf.FloorToInt(healPhaseTimer), TrentaConfig.PhotosynthesisHealSeconds);
while (healTicksApplied < targetTicks)
{
player.Heal(player.GetMaxHealth() * TrentaConfig.PhotosynthesisHealPercentPerSecond, true);
healTicksApplied++;
}
if (healTicksApplied >= TrentaConfig.PhotosynthesisHealSeconds)
{
healPhaseActive = false;
healPhaseTimer = 0f;
healTicksApplied = 0;
}
return; // A new stillness channel cannot start while a grant is still healing
}
bool eligible = EnvMan.instance != null && EnvMan.IsDay() &&
!Traverse.Create(player).Field<bool>("m_underRoof").Value;
if (!eligible || moving)
{
stillTimer = 0f;
return;
}
stillTimer += Time.deltaTime;
if (stillTimer < TrentaConfig.PhotosynthesisStillnessSeconds) return;
stillTimer = 0f;
float restMinutes = TrentaConfig.PhotosynthesisRestBaseMinutes +
TrentaConfig.PhotosynthesisRestMinutesPerBoss * (state - BossProgressionManager.MinState);
SEMan seman = player.GetSEMan();
seman.AddStatusEffect(SEMan.s_statusEffectRested, true);
StatusEffect rested = seman.GetStatusEffect(SEMan.s_statusEffectRested);
if (rested != null) rested.m_ttl = restMinutes * 60f;
healPhaseActive = true;
healPhaseTimer = 0f;
healTicksApplied = 0;
}
// ─── Purple Rain ─────────────────────────────────────────────────────
private static float lastPurpleRainTime = -1000f;
private static Material cachedVfxMaterial;
private static bool vfxMaterialResolved;
/// <summary>
/// A burst of toxic-purple pollen centred on the Trenta: heals everything that isn't its
/// enemy, poisons everything that is. "Ally" and "enemy" are read straight off
/// BaseAI.IsEnemy - the same check RaceHostilityManager's Trenta block feeds - so this
/// automatically covers players, tamed companions and the neutral Greyling/Greydwarf/
/// Fuling/Troll/Leech/Deathsquito list without a second, separate species list to keep in
/// sync with the first one.
/// </summary>
private static void TryPurpleRain(Player player)
{
// Muspell (state 8) shortens Purple Rain's own cooldown while transformed - read here
// rather than baked into PurpleRainCooldown, since the normal-form value still applies
// the instant the player reverts.
float cooldown = TrentaMuspell.IsTransformed ? TrentaConfig.MuspellPurpleRainCooldown : TrentaConfig.PurpleRainCooldown;
if (Time.time - lastPurpleRainTime < cooldown) return;
lastPurpleRainTime = Time.time;
TrentaStatusEffects.ApplyCooldownIcon(TrentaConfig.PurpleRainCdSE, cooldown);
// While transformed, The Elder's own root-summon gesture plays on the transformation
// clone's Animator instead - TryPlayRootSummonAnimation returns false (and does
// nothing) when not transformed, so the normal staff_summon path below still covers
// every other case unchanged.
if (!TrentaMuspell.TryPlayRootSummonAnimation())
{
var zanim = Traverse.Create(player).Field("m_zanim").GetValue<ZSyncAnimation>();
if (zanim != null)
{
// "galdr_cast" was never real, and "gpower" turned out to read as the vanilla
// Guardian Power raise (Forsaken Power), not a staff cast - both dead ends, now
// documented so nobody re-walks them. "staff_summon" is the Dead Raiser's own
// attack animation, the actual "raise the staff and call something forth" clip -
// confirmed against WeaponsAttackAnimationManager's own dump of vanilla weapon
// attack animations, since it is weapon data rather than anything hard-coded in
// the assembly's IL the way "gpower" is. Unlike gpower it is not expected to carry
// a baked side effect (per-weapon attack clips resolve their game logic through
// Humanoid.StartAttack, not through Animation Events on the clip), so no suppress
// call before it - flag it if this instead spawns a real skeleton ally.
zanim.SetTrigger("staff_summon");
}
}
SpawnPurpleRainVfx(player);
HashSet<Character> hit = new HashSet<Character>();
foreach (Collider collider in Physics.OverlapSphere(player.transform.position, TrentaConfig.PurpleRainRadius))
{
if (collider == null) continue;
Character character = collider.GetComponentInParent<Character>();
if (character == null || character == player || character.IsDead() || !hit.Add(character)) continue;
if (BaseAI.IsEnemy(player, character))
{
HitData hitData = new HitData();
hitData.m_damage.m_poison = TrentaConfig.PurpleRainPoisonDamage;
hitData.SetAttacker(player);
hitData.m_dir = Vector3.zero;
character.Damage(hitData);
}
else
{
character.Heal(TrentaConfig.PurpleRainHealAmount, true);
}
}
}
/// <summary>
/// Builds the rain burst from scratch - mirrors SkeletonRace.EnsureFireAuraVFX, which
/// borrows only a *material* off an existing prefab and drives everything else (shape,
/// emission, gradient) itself, rather than cloning a specific child particle system
/// wholesale. The clone-a-child approach tried first came up empty: whatever the Shaman's
/// actual spit VFX is, it is not a particle system living permanently on its model (most
/// likely a separate projectile prefab spawned by its attack code instead), so there was
/// nothing there to find. Borrowing just the material sidesteps needing to know that at
/// all - it fails safe to Unity's default particle material if even that comes up empty,
/// so this always renders *something*.
/// </summary>
private static void SpawnPurpleRainVfx(Player player)
{
if (!vfxMaterialResolved)
{
vfxMaterialResolved = true;
// The "vfx_smoke" fallback that used to sit here is gone. That name is not a prefab
// in this game, so it could only ever resolve to another mod's object - and with
// Magic_Supremacy installed it resolved to a weapon trail, which is what put purple
// smoke on the Skeleton (see SkeletonVisuals.EnsureFireAura). Purple Rain is purple
// by design, so the same theft here would never have looked wrong enough to report.
//
// Losing the fallback means a miss is now a miss. Said out loud, because the resolve
// is cached for the session either way and a silent one would be invisible: 1.0
// loads creature assets lazily, so the Shaman is not guaranteed to be in memory.
GameObject source = PrefabManager.Cache.GetPrefab<GameObject>(TrentaConfig.PurpleRainVfxSourcePrefab);
if (source != null)
{
ParticleSystemRenderer sourceRenderer = source.GetComponentInChildren<ParticleSystemRenderer>(true);
if (sourceRenderer != null) cachedVfxMaterial = sourceRenderer.material;
}
else
{
Jotunn.Logger.LogWarning(
$"[Trenta] Purple Rain: '{TrentaConfig.PurpleRainVfxSourcePrefab}' not in the prefab " +
"cache; falling back to Unity's default particle material for this session.");
}
}
GameObject vfx = new GameObject("TrentaPurpleRainVFX");
vfx.transform.SetParent(player.transform, false);
vfx.transform.localPosition = new Vector3(0, 3f, 0);
ParticleSystem ps = vfx.AddComponent<ParticleSystem>();
var main = ps.main;
main.loop = false;
main.duration = 1.2f;
main.startLifetime = new ParticleSystem.MinMaxCurve(1.5f, 2.5f);
main.startSpeed = new ParticleSystem.MinMaxCurve(0.5f, 1.5f);
main.startSize = new ParticleSystem.MinMaxCurve(0.03f, 0.09f); // cherry-sized, not watermelon-sized
main.gravityModifier = 1.2f; // falls like rain rather than hanging in the air
main.simulationSpace = ParticleSystemSimulationSpace.World;
main.maxParticles = 400;
var emission = ps.emission;
emission.rateOverTime = 250f;
var shape = ps.shape;
shape.shapeType = ParticleSystemShapeType.Sphere;
shape.radius = TrentaConfig.PurpleRainRadius * 0.6f;
ParticleSystemRenderer renderer = ps.GetComponent<ParticleSystemRenderer>();
if (cachedVfxMaterial != null) renderer.material = cachedVfxMaterial;
var colorOverLifetime = ps.colorOverLifetime;
colorOverLifetime.enabled = true;
Gradient grad = new Gradient();
grad.SetKeys(
new GradientColorKey[] { new GradientColorKey(TrentaConfig.PurpleRainVfxColor, 0f), new GradientColorKey(TrentaConfig.PurpleRainVfxColor, 1f) },
new GradientAlphaKey[] { new GradientAlphaKey(0f, 0f), new GradientAlphaKey(0.85f, 0.2f), new GradientAlphaKey(0.85f, 0.7f), new GradientAlphaKey(0f, 1f) }
);
colorOverLifetime.color = grad;
ps.Play();
if (TrentaRace.Instance != null)
{
TrentaRace.Instance.StartCoroutine(DestroyAfter(vfx, 4f));
}
else
{
Object.Destroy(vfx, 4f);
}
}
private static IEnumerator DestroyAfter(GameObject obj, float seconds)
{
yield return new WaitForSeconds(seconds);
if (obj != null) Object.Destroy(obj);
}
// ─── Homecoming Portal ──────────────────────────────────────────────
private static float lastPortalTime = -100000f;
/// <summary>
/// Opens a linked portal pair (TrentaPortal.Open does the actual spawning): one where the
/// Trenta is standing, one at their respawn point - a custom spawn point if they have set
/// one by sleeping in a bed, otherwise the world's starting temple, exactly mirroring the
/// choice vanilla respawn itself makes.
/// </summary>
private static void TryOpenPortal(Player player)
{
if (Time.time - lastPortalTime < TrentaConfig.PortalCooldown) return;
PlayerProfile profile = Game.instance != null ? Game.instance.GetPlayerProfile() : null;
if (profile == null) return;
// m_originalSpawnPoint is static on PlayerProfile - one starting temple per world,
// not per profile - unlike everything else read off profile here.
Vector3 homePoint = profile.HaveCustomSpawnPoint() ? profile.GetCustomSpawnPoint() : PlayerProfile.m_originalSpawnPoint;
lastPortalTime = Time.time;
TrentaStatusEffects.ApplyCooldownIcon(TrentaConfig.PortalCdSE, TrentaConfig.PortalCooldown);
var zanim = Traverse.Create(player).Field("m_zanim").GetValue<ZSyncAnimation>();
if (zanim != null) zanim.SetTrigger("staff_summon"); // same cast as Purple Rain - see its comment for why
Vector3 castPoint = player.transform.position + player.transform.forward * TrentaConfig.PortalSpawnDistance;
TrentaPortal.Open(player, castPoint, homePoint);
}
}
}