RacesOfValheim/JotunnModStub/Skadi/SkadiPatches.cs
kanym fc7fd54404 Rework Skadi combat costs, fix dead melee, add cooldown icons
Dragon melee never dealt damage at all: the damage block sat behind
!isMelee, so bite, claw and spin played an animation, charged eitr and
did nothing. Melee now sweeps for targets the way Fenrir's claws do, and
costs nothing - it is the baseline attack that has to work at every tier.

Everything Skadi casts now runs on stamina rather than eitr. Eitr food
only exists from the Mistlands on, while the Cold Spell unlocks at
Eikthyr and the drake at the Elder, so the old costs were either
unpayable or, in the drake's case, silently ignored because UseEitr
never checked affordability. Ranged volleys are charged per projectile
so the sixty shard breath no longer costs the same as a three shard
spit, capped so the widest one stays castable.

The Cold Spell also stopped borrowing the Staff of Frost's damage, which
handed out Mistlands numbers from Eikthyr and multiplied them by every
shard. It now scales with progression, and the improved cast spreads one
budget across its shards: wider, not stronger.

The kick that played over every cast was Valheim's own SecondaryAttack,
bound to the same Middle Mouse button - suppressed for a Skadi holding
the spell. Moder now keeps its ranged attack on Middle Mouse in the air
as on the ground, with no left hand attack aloft, and Fader's airborne
branch is gone since its form cannot fly.

Ability cooldowns finally show on the HUD, each with its own icon and a
live countdown.
2026-08-01 18:02:24 +02:00

310 lines
14 KiB
C#

using HarmonyLib;
using UnityEngine;
namespace RacesOfValheim
{
[HarmonyPatch(typeof(VisEquipment), "UpdateColors")]
public static class SkadiSkinColorPatch
{
public static void Postfix(VisEquipment __instance)
{
if (!__instance.m_isPlayer) return;
Player player = __instance.GetComponent<Player>();
if (player == null) return;
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid() && nview.GetZDO().GetString("RacesOfValheim_Race", "Human") == "Skadi")
{
if (__instance.m_bodyModel != null && __instance.m_bodyModel.material != null)
{
// Azzurro molto chiaro
Color skadiColor = new Color(0.6f, 0.8f, 1f, 1f);
__instance.m_bodyModel.material.SetColor("_SkinColor", skadiColor);
}
}
}
}
[HarmonyPatch(typeof(VisEquipment), "UpdateVisuals")]
public static class Skadi_MultiplayerVisuals_Patch
{
private const string FormSuffix = "_multiplayer";
public static void Postfix(VisEquipment __instance)
{
if (!__instance.m_isPlayer) return;
Player player = __instance.GetComponent<Player>();
if (player == null || player.IsOwner()) return; // Only process remote players
ZNetView nview = player.GetComponent<ZNetView>();
if (nview == null || !nview.IsValid()) return;
if (nview.GetZDO().GetString("RacesOfValheim_Race", "Human") != "Skadi") return;
string formName = nview.GetZDO().GetString("RacesOfValheim_SkadiForm", "");
Transform playerVisual = player.transform.Find("Visual");
string wanted = formName + FormSuffix;
// VisEquipment.UpdateVisuals runs every frame off CustomUpdate, so the spawned model
// has to be found again by the exact name it was given. This used to search for
// "SkadiBody_Form" - a name nothing is ever assigned - so the lookup missed every
// time and a fresh dragon was instantiated each frame. Remote players watched the
// models pile up on the spot and their client degraded until the Skadi player
// reverted; the transformed player saw nothing, since owners return above.
// Anything left over from that, or from a previous form, is cleaned up here too.
Transform formBody = null;
foreach (Transform child in player.transform)
{
if (!child.name.EndsWith(FormSuffix)) continue;
if (formBody == null && child.name == wanted) formBody = child;
else UnityEngine.Object.Destroy(child.gameObject);
}
if (string.IsNullOrEmpty(formName))
{
if (playerVisual != null) playerVisual.gameObject.SetActive(true);
return;
}
if (formBody == null)
{
GameObject prefab = Jotunn.Managers.PrefabManager.Cache.GetPrefab<GameObject>(formName);
Transform visual = prefab != null ? prefab.transform.Find("Visual") : null;
if (visual != null)
{
GameObject formInstance = UnityEngine.Object.Instantiate(visual.gameObject, player.transform);
formInstance.name = wanted;
formInstance.transform.localPosition = formName == "Hatchling" ? new Vector3(0f, -1.0f, 0f) : Vector3.zero;
formInstance.transform.localRotation = Quaternion.identity;
}
}
if (playerVisual != null) playerVisual.gameObject.SetActive(false);
}
}
[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new System.Type[] { typeof(int), typeof(bool), typeof(int), typeof(float) })]
public static class SkadiSEManPatch
{
public static bool Prefix(SEMan __instance, ref int nameHash)
{
Character character = Traverse.Create(__instance).Field<Character>("m_character").Value;
if (character == Player.m_localPlayer && SkadiRace.Instance != null && SkadiRace.Instance.IsSkadi())
{
var rules = SkadiProgression.GetRules(BossProgressionManager.GetCurrentProgressionState());
if (nameHash == "Cold".GetStableHashCode() && rules.ImmuneToCold)
{
return false;
}
if (nameHash == "Freezing".GetStableHashCode())
{
if (rules.ImmuneToFreezing) return false;
if (rules.FreezingToCold)
{
// Strip any real Freezing that may already be active (e.g. applied
// before this tier's conversion kicked in) so it can't linger
// alongside the converted Cold status.
__instance.RemoveStatusEffect("Freezing".GetStableHashCode(), true);
nameHash = "Cold".GetStableHashCode();
}
}
}
return true;
}
}
// SE_SkadiStats grants a "Resistant" (or higher) Frost damage modifier from tier 1 onward,
// exactly like drinking a Frost Resistance potion. Valheim's own Player.UpdateEnvStatusEffects
// checks that same Frost damage modifier before deciding whether to apply Cold/Freezing at
// all, and skips both entirely once the character is Frost-resistant. That means real Mountain
// exposure (which applies Freezing, not Cold, per vanilla rules) never even reaches
// SkadiSEManPatch above from tier 1 onward, so the tier 2 "Freezing to Cold" conversion never
// gets a chance to run. These two patches scope out just that one environmental check: while
// Player.UpdateEnvStatusEffects is running for the local Skadi player, GetDamageModifiers is
// reported as Normal for Frost, so vanilla always attempts to apply the real status and
// SkadiSEManPatch's per-tier logic (block/convert/allow) is what actually decides the outcome.
// Frost damage resistance from hits (SkadiDamagePatch) is untouched by this.
[HarmonyPatch(typeof(Player), "UpdateEnvStatusEffects")]
public static class SkadiEnvCheckScope
{
public static bool Active = false;
public static void Prefix(Player __instance)
{
Active = __instance == Player.m_localPlayer && SkadiRace.Instance != null && SkadiRace.Instance.IsSkadi();
}
public static void Postfix()
{
Active = false;
}
}
[HarmonyPatch(typeof(Character), "GetDamageModifiers")]
public static class SkadiEnvFrostModifierPatch
{
public static void Postfix(Character __instance, ref HitData.DamageModifiers __result)
{
if (SkadiEnvCheckScope.Active && __instance == Player.m_localPlayer)
{
__result.m_frost = HitData.DamageModifier.Normal;
}
}
}
// Valheim's Player.UpdateEnvStatusEffects always tries RemoveStatusEffect(Cold, quiet:true)
// as the first step of applying Freezing. Since SkadiSEManPatch redirects Freezing into Cold,
// that removal would strip our converted Cold status every other frame (a permanent
// add/remove flicker that cancels the buff out). Blocking just this "quiet" removal for the
// FreezingToCold player forces Valheim to always fall through to AddStatusEffect(Freezing,...),
// which SkadiSEManPatch converts to a stable, non-resetting Cold re-application instead.
[HarmonyPatch(typeof(SEMan), "RemoveStatusEffect", new System.Type[] { typeof(int), typeof(bool) })]
public static class SkadiColdRemovalGuardPatch
{
public static bool Prefix(SEMan __instance, int nameHash, bool quiet, ref bool __result)
{
if (quiet && nameHash == "Cold".GetStableHashCode())
{
Character character = Traverse.Create(__instance).Field<Character>("m_character").Value;
if (character == Player.m_localPlayer && SkadiRace.Instance != null && SkadiRace.Instance.IsSkadi())
{
var rules = SkadiProgression.GetRules(BossProgressionManager.GetCurrentProgressionState());
if (rules.FreezingToCold && !rules.ImmuneToFreezing)
{
__result = false;
return false;
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Character), "ApplyDamage")]
public static class SkadiDamagePatch
{
public static void Prefix(Character __instance, ref HitData hit)
{
if (hit.GetAttacker() != null && hit.GetAttacker() == Player.m_localPlayer)
{
if (SkadiRace.Instance != null && SkadiRace.Instance.IsSkadi())
{
var rules = SkadiProgression.GetRules(BossProgressionManager.GetCurrentProgressionState());
if (rules.BonusFrostDamage)
{
hit.m_damage.m_frost += 2f * BossProgressionManager.GetCurrentProgressionState();
}
}
}
}
}
// DrakeFormBehavior flips the player into Character's native flying-creature movement
// (m_flying = true) instead of the old debug-fly noclip, which lets us feed it a full 3D
// move direction. Character.UpdateFlying normally reads whatever m_moveDir the vanilla input
// pipeline last wrote (ground-plane WASD relative to camera yaw only); this patch overwrites
// it every frame with the camera's actual look direction (pitch included) so the player always
// glides toward wherever the mouse is aiming, with W adding a speed boost (m_run) on top of the
// base glide speed instead of being required just to move.
[HarmonyPatch(typeof(Character), "UpdateFlying")]
public static class SkadiDirectedFlightPatch
{
private const float TURN_SPEED = 120f;
private const float GLIDE_SPEED = 5f;
private const float BOOST_SPEED = 12f;
private const float HOVER_SECONDS = 2f;
// Tangent of the unpowered descent angle: 0.4 sinks at roughly 22 degrees below level.
private const float DESCENT_SLOPE = 0.4f;
public static void Prefix(Character __instance)
{
if (__instance != Player.m_localPlayer) return;
DrakeFormBehavior form = DrakeFormBehavior.Active;
if (form == null || !form.IsFlying) return;
var traverse = Traverse.Create(__instance);
Vector3 lookDir = Player.m_localPlayer.GetLookDir();
bool boost = RaceInput.Allowed && Input.GetKey(KeyCode.W);
bool onGround = __instance.IsOnGround();
traverse.Field("m_run").SetValue(boost);
traverse.Field("m_flyFastSpeed").SetValue(BOOST_SPEED);
// UpdateFlying rotates the body toward m_moveDir on its own, but at m_flyTurnSpeed,
// which sits at Character's 12 deg/s default because the Player prefab was never set
// up as a flying creature - a 90 degree turn would take over seven seconds, so the
// model reads as not turning at all. Give it a speed that suits a flying mount.
traverse.Field("m_flyTurnSpeed").SetValue(TURN_SPEED);
// Powered flight and ground contact both refresh the hover window.
if (boost || onGround) form.LastPoweredTime = Time.time;
Vector3 moveDir = lookDir;
float coastSpeed;
if (onGround || Time.time - form.LastPoweredTime < HOVER_SECONDS)
{
// Holding station: on the ground this keeps a touchdown from sliding the player
// forward forever, and in the air it gives the beat of level flight before the
// form starts to sink. m_moveDir stays full length so the body still turns to
// face the camera, and zeroing the speed (rather than the rigidbody velocity)
// avoids fighting the AddForce UpdateFlying queues, which caused visible jitter.
coastSpeed = 0f;
}
else
{
// Unpowered flight is a glide, not a hover with a joystick: drift along the
// heading the camera faces while losing height, so aiming at the sky without
// holding W no longer climbs.
Vector3 heading = new Vector3(lookDir.x, 0f, lookDir.z);
if (heading.sqrMagnitude < 0.0001f)
{
heading = __instance.transform.forward;
heading.y = 0f;
}
moveDir = (heading.normalized + Vector3.down * DESCENT_SLOPE).normalized;
coastSpeed = GLIDE_SPEED;
}
traverse.Field("m_moveDir").SetValue(moveDir);
traverse.Field("m_flySlowSpeed").SetValue(coastSpeed);
}
}
[HarmonyPatch(typeof(Humanoid), "StartAttack")]
public static class SkadiAttackPatch
{
public static bool Prefix(Humanoid __instance, bool secondaryAttack)
{
if (__instance != Player.m_localPlayer) return true;
if (__instance.GetComponentInChildren<DrakeFormBehavior>() != null)
{
return false;
}
// Valheim binds its own SecondaryAttack action to Middle Mouse, the same button the
// Cold Spell casts on, so pressing it also swung the unarmed secondary - the kick that
// kept showing up alongside the cast no matter which animation trigger we used. For a
// Skadi who has the spell, Middle Mouse belongs to the spell. Keyed off the live button
// state rather than a flag set during our Update, so it does not depend on whether
// PlayerController's FixedUpdate happens to run first.
if (secondaryAttack && Input.GetMouseButton(2) &&
SkadiRace.Instance != null && SkadiRace.Instance.IsSkadi())
{
var rules = SkadiProgression.GetRules(BossProgressionManager.GetCurrentProgressionState());
if (rules.ColdSpell) return false;
}
return true;
}
}
}