RacesOfValheim/JotunnModStub/Skadi/SkadiPatches.cs
2026-08-18 16:51:07 +02:00

521 lines
25 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);
}
}
[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 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;
/// <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; }
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;
bool forward = input && Input.GetKey(KeyCode.W);
// Forward wins a W+S mash rather than the two cancelling into a dead hover.
bool backward = input && !forward && Input.GetKey(KeyCode.S);
bool sprintKey = input && (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift));
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;
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.IsPressed() &&
SkadiRace.Instance != null && SkadiRace.Instance.IsSkadi())
{
var rules = SkadiProgression.GetRules(BossProgressionManager.GetCurrentProgressionState());
if (rules.ColdSpell) return false;
}
return true;
}
}
}