RacesOfValheim/JotunnModStub/Skadi/SkadiPatches.cs
Ferdinando c7cbd6bece chore(release): v1.4.18 - Valheim hotfix flight fix, 1.0 shop fixes, Fenrir speed
Drake flight resolves ZInput.GetJoyLeftStickY at runtime, since the
hotfix dropped its bool parameter. Faction merchant TradeItems now set
the 1.0 fields StoreGui dereferences (m_tooltip, m_buyPlayerEffects),
and the Dvergar trader discount clones the whole TradeItem instead of
rebuilding four fields. Trol totem refusals return true so vanilla's
$msg_cantuseon no longer covers them. The Fenrir curse speed modifier
is the bonus alone (SE_Stats adds it), not 1 + bonus. New Discord link.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 17:10:24 +02:00

562 lines
28 KiB
C#

using System.Collections.Generic;
using System.Reflection;
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))
{
PlayerVisualHider.Show(playerVisual, "skadi-remote-revert");
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 (formInstance.GetComponent<RemoteSkadiAnimator>() == null)
{
formInstance.AddComponent<RemoteSkadiAnimator>();
}
}
}
PlayerVisualHider.Hide(playerVisual, "skadi-remote-form");
}
}
public class RemoteSkadiAnimator : MonoBehaviour
{
private Animator anim;
private Player player;
private void Start()
{
anim = GetComponent<Animator>();
if (anim == null) anim = GetComponentInChildren<Animator>();
player = GetComponentInParent<Player>();
}
private void Update()
{
if (anim == null || player == null) return;
bool flying = HarmonyLib.Traverse.Create(player).Field<bool>("m_flying").Value;
bool grounded = !flying && player.IsOnGround();
anim.SetBool("onGround", grounded);
anim.SetBool("flying", flying);
Vector3 vel = player.GetVelocity();
vel.y = 0f;
anim.SetFloat("forward_speed", vel.magnitude);
}
}
// Valheim 1.0 appended a 'short variant' parameter to this overload. The type array has to
// match it exactly or the patch silently fails to bind and PatchAll throws.
[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new System.Type[] { typeof(int), typeof(bool), typeof(int), typeof(float), typeof(short) })]
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 without SE_SkadiStats' own Frost contribution, so vanilla 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.
//
// Only the race's own contribution is discounted. This used to report a flat Normal, which
// also erased Frost resistance coming from a wolf/lox cape, a frost resistance mead or food:
// a Skadi who had beaten Moder still caught the converted Cold on the Mountain while wearing
// gear that makes a human immune, and below tier 4 caught real Freezing through the same gear.
// The tiered ladder is meant to make the race better than a bare human, never worse than an
// equipped one, so anything the player is actually wearing or drinking still counts.
[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
{
private static readonly int SkadiStatsHash = "SE_SkadiStats".GetStableHashCode();
// Handed to the aura in place of its own list while the recompute runs. SE_Stats applies
// m_mods as-is, so an empty list is simply "this effect grants nothing".
private static readonly List<HitData.DamageModPair> NoMods = new List<HitData.DamageModPair>();
private static bool recomputing = false;
public static void Postfix(Character __instance, ref HitData.DamageModifiers __result)
{
if (recomputing) return;
if (!SkadiEnvCheckScope.Active || __instance != Player.m_localPlayer) return;
// Character.GetDamageModifiers composes base modifiers + equipment + status effects,
// and DamageModifiers.Apply keeps the strongest of the lot - there is no way to
// subtract one contributor from a finished result. So the aura is muted and the whole
// thing recomputed: what comes back is exactly what this player would have without
// the race. The recursive call re-enters this postfix, which the flag turns into a
// no-op. The status effect on the player is a clone of the registered prototype
// (SEMan.AddStatusEffect clones on add), hence the lookup by hash rather than
// SkadiRace.skadiCurseSE.
SE_Stats aura = __instance.GetSEMan().GetStatusEffect(SkadiStatsHash) as SE_Stats;
List<HitData.DamageModPair> auraMods = aura != null ? aura.m_mods : null;
recomputing = true;
if (aura != null) aura.m_mods = NoMods;
try
{
__result.m_frost = __instance.GetDamageModifiers(null).m_frost;
}
finally
{
if (aura != null) aura.m_mods = auraMods;
recomputing = false;
}
}
}
// 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 += SkadiConfig.BonusFrostDamagePerState.Value * 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 powering forward, Shift spending stamina
// for a burst of speed, and S beating backwards away from whatever you are looking at.
[HarmonyPatch(typeof(Character), "UpdateFlying")]
public static class SkadiDirectedFlightPatch
{
// Read from SkadiConfig (BepInEx Config) rather than fixed constants, so flight can be
// retuned from Configuration Manager - see CONFIGURATION-MANAGER-HOWTO.md.
private static float TURN_SPEED => SkadiConfig.FlightTurnSpeed.Value;
private static float GLIDE_SPEED => SkadiConfig.FlightGlideSpeed.Value;
private static float BOOST_SPEED => SkadiConfig.FlightBoostSpeed.Value;
private static float SPRINT_SPEED => SkadiConfig.FlightSprintSpeed.Value;
private static float REVERSE_SPEED => SkadiConfig.FlightReverseSpeed.Value;
// Climbing out of water is deliberately slower than a powered climb in open air - the
// wings are dragging themselves free, not racing.
private static float LIFTOFF_SPEED => SkadiConfig.FlightLiftoffSpeed.Value;
private static float HOVER_SECONDS => SkadiConfig.FlightHoverSeconds.Value;
// Per second, drained only while the sprint is actually being granted.
private static float SPRINT_STAMINA_PER_SECOND => SkadiConfig.FlightSprintStaminaPerSecond.Value;
// Tangent of the unpowered descent angle: 0.4 sinks at roughly 22 degrees below level.
private const float DESCENT_SLOPE = 0.4f;
// How much of the aim heading survives the climb out of water. Mostly up, with enough
// forward in it that the player still chooses which shore they surface towards.
private const float LIFTOFF_HEADING_BLEND = 0.35f;
// How far the left stick has to be pushed before it counts as W or S.
private const float StickThreshold = 0.5f;
/// <summary>
/// True while the local player is beating backwards this frame. Read by
/// SkadiReverseFacingPatch, which keeps the body pointed at the camera while it happens.
/// </summary>
public static bool Reversing { get; private set; }
// The September 2026 hotfix dropped the bool parameter from ZInput.GetJoyLeftStickY.
// A direct call binds to whichever signature we compiled against and throws
// MissingMethodException on the other, so resolve it at runtime and accept either.
private static readonly MethodInfo JoyLeftStickYMethod =
AccessTools.Method(typeof(ZInput), "GetJoyLeftStickY", new System.Type[0]) ??
AccessTools.Method(typeof(ZInput), "GetJoyLeftStickY", new[] { typeof(bool) });
private static float JoyLeftStickY()
{
if (JoyLeftStickYMethod == null) return 0f;
return (float)JoyLeftStickYMethod.Invoke(null, JoyLeftStickYArgs);
}
// Old signature: pass smooth = true, which was its default.
private static readonly object[] JoyLeftStickYArgs =
JoyLeftStickYMethod != null && JoyLeftStickYMethod.GetParameters().Length == 1 ? new object[] { true } : null;
public static void Prefix(Character __instance, float dt)
{
if (__instance != Player.m_localPlayer) return;
DrakeFormBehavior form = DrakeFormBehavior.Active;
if (form == null || !form.IsFlying)
{
Reversing = false;
return;
}
var traverse = Traverse.Create(__instance);
Vector3 lookDir = Player.m_localPlayer.GetLookDir();
bool input = RaceInput.Allowed;
// The pad's half of W/S: the left stick, read with vanilla's own sign -
// PlayerController.FixedUpdate takes forward as the NEGATED GetJoyLeftStickY.
// Flight only knows powered forward, reverse or neither, so the stick is a
// threshold, not a throttle. Steering stays on the camera, i.e. the right stick.
float stick = -JoyLeftStickY();
bool forward = input && (Input.GetKey(KeyCode.W) || stick > StickThreshold);
// Forward wins a W+S mash rather than the two cancelling into a dead hover.
bool backward = input && !forward && (Input.GetKey(KeyCode.S) || stick < -StickThreshold);
// Sprint on a pad is vanilla's run button, wherever the chosen layout puts it.
bool sprintKey = input && (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift) ||
ZInput.GetButton("JoyRun"));
bool onGround = __instance.IsOnGround();
// IsSwimming is the exact test UpdateMotion uses to hand the frame to UpdateSwimming
// instead of UpdateFlying, so it is also the one condition SkadiWaterFlightPatch has
// to take back. Its half-second tail past leaving the water is welcome here - it
// keeps the climb going just long enough to clear the surface properly.
bool inWater = __instance.IsSwimming();
Reversing = backward;
// m_run only picks between the two fly speeds. Every mode now has its own speed, so
// leave it off and drive all of them through m_flySlowSpeed.
traverse.Field("m_run").SetValue(false);
// 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, ground contact and clawing out of water all refresh the hover
// window, so none of them can be followed by an immediate sink.
if (forward || backward || onGround || inWater) form.LastPoweredTime = Time.time;
Vector3 moveDir = lookDir;
float speed;
if (inWater)
{
// Wet wings still beat. Water used to be a trap: UpdateMotion hands a swimming
// character to UpdateSwimming before it ever looks at m_flying, so a dragon that
// touched the sea was stuck paddling with the flight controls doing nothing.
// SkadiWaterFlightPatch gives the frame back to flight, and this branch spends it
// climbing regardless of where the camera points, so the surface is always
// something you break out of rather than something you sit in.
moveDir = (Vector3.up + FlatHeading(__instance, lookDir) * LIFTOFF_HEADING_BLEND).normalized;
speed = LIFTOFF_SPEED;
}
else if (backward)
{
// Straight reverse thrust along the aim, pitch included: look down and beat back
// and you rise away from what you are looking at, which is the whole point of
// having a reverse - you can retreat without taking your eyes (or your breath
// attack, which fires along the same vector) off the target.
moveDir = -lookDir;
speed = REVERSE_SPEED;
}
else if (forward)
{
speed = BOOST_SPEED;
// The sprint is the only part of flight that costs anything. Base flight stays
// free on purpose - the drake arrives at the Elder, long before the player has
// the stamina pool to pay for simply staying airborne.
if (sprintKey && TrySpendSprintStamina(dt)) speed = SPRINT_SPEED;
}
else 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 beats 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.
speed = 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.
moveDir = (FlatHeading(__instance, lookDir) + Vector3.down * DESCENT_SLOPE).normalized;
speed = GLIDE_SPEED;
}
traverse.Field("m_moveDir").SetValue(moveDir);
traverse.Field("m_flySlowSpeed").SetValue(speed);
}
/// <summary>Aim flattened onto the ground plane, falling back to the body's own facing
/// when the player is looking straight up or down.</summary>
private static Vector3 FlatHeading(Character character, Vector3 lookDir)
{
Vector3 heading = new Vector3(lookDir.x, 0f, lookDir.z);
if (heading.sqrMagnitude < 0.0001f)
{
heading = character.transform.forward;
heading.y = 0f;
}
return heading.normalized;
}
/// <summary>
/// Charges this frame of sprint. Returns false when the player cannot pay, which drops
/// them back to the free boost speed rather than out of the sky.
/// </summary>
private static bool TrySpendSprintStamina(float dt)
{
Player player = Player.m_localPlayer;
if (player == null) return false;
float cost = SPRINT_STAMINA_PER_SECOND * dt;
if (!player.HaveStamina(cost)) return false;
player.UseStamina(cost);
return true;
}
}
/// <summary>
/// Character.UpdateMotion asks IsSwimming before it asks m_flying, so a flying dragon that
/// touched water was handed to UpdateSwimming every frame: the flight patch above never ran,
/// the form paddled on the surface, and there was no way back into the air short of finding
/// land. (The Aswid's bat escapes this because debug-fly is checked at the very top of
/// UpdateMotion, before water is considered at all - which is exactly why it can take off
/// from the sea.) Hand those frames back to UpdateFlying, which is the only motion path the
/// two methods contend over: nothing else calls either of them, and everything that merely
/// asks IsSwimming - the Wet status, the animator, stamina - is left alone.
/// </summary>
[HarmonyPatch(typeof(Character), "UpdateSwimming")]
public static class SkadiWaterFlightPatch
{
private static readonly MethodInfo UpdateFlyingMethod = AccessTools.Method(typeof(Character), "UpdateFlying");
public static bool Prefix(Character __instance, float dt)
{
if (__instance != Player.m_localPlayer) return true;
DrakeFormBehavior form = DrakeFormBehavior.Active;
if (form == null || !form.IsFlying) return true;
// Fail open: if a game update ever renames the method, swim normally rather than
// freezing the player in place with no motion update at all.
if (UpdateFlyingMethod == null) return true;
UpdateFlyingMethod.Invoke(__instance, new object[] { dt });
return false;
}
}
/// <summary>
/// UpdateFlying turns the body to face m_moveDir, which is right for every direction of
/// travel except backwards - reverse thrust would spin the dragon around to fly nose-first
/// away from the camera, putting its tail where its breath comes out. Claiming
/// AlwaysRotateCamera for the duration switches UpdateRotation over to the camera's yaw
/// instead, so the form keeps facing whatever it is retreating from. Scoped to the frames
/// the reverse is actually held.
/// </summary>
[HarmonyPatch(typeof(Player), "AlwaysRotateCamera")]
public static class SkadiReverseFacingPatch
{
public static bool Prefix(Player __instance, ref bool __result)
{
if (__instance != Player.m_localPlayer) return true;
// A breath in progress holds the body on the aim, whether the player is moving or not.
// Character.UpdateRotation only steers by m_lookYaw when AlwaysRotateCamera() is true
// or the player is standing still - otherwise it faces m_moveDir. So running or
// strafing mid-breath turned the model (and the muzzle VFX baked into its animation)
// towards the run while our projectiles kept going where the player aimed, which is
// how the ice and the poison ended up pointing different ways.
if (DrakeFormBehavior.IsBreathing && DrakeFormBehavior.Active != null)
{
__result = true;
return false;
}
if (!SkadiDirectedFlightPatch.Reversing) return true;
DrakeFormBehavior form = DrakeFormBehavior.Active;
if (form == null || !form.IsFlying) return true;
__result = true;
return false;
}
}
[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 by default, 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, that button belongs to the spell. Keyed off
// the live button state (via the configured shortcut, so a rebind stays in sync)
// rather than a flag set during our Update, so it does not depend on whether
// PlayerController's FixedUpdate happens to run first.
if (secondaryAttack && SkadiConfig.ColdSpellKey.Value.IsPressedIgnoringHeldKeys() &&
SkadiRace.Instance != null && SkadiRace.Instance.IsSkadi())
{
var rules = SkadiProgression.GetRules(BossProgressionManager.GetCurrentProgressionState());
if (rules.ColdSpell) return false;
}
return true;
}
}
}