Adds a Skadi - Keybinds config section (bound first, ahead of the other Skadi sections) covering every ability/attack trigger: dragon primary attack, cold spell cast, breath attack, Fader spin, flight toggle, and the three transform keys (Drake/Moder/Fader). Defaults match the previous fixed inputs exactly. SkadiAttackPatch's kick-suppression check now reads the configured Cold Spell key instead of a hardcoded Middle Mouse, so it stays correct if that key is rebound. Entries within Keybinds carry an explicit Order (via the new ConfigurationManagerAttributes shim, per CONFIGURATION-MANAGER-HOWTO.md) so they list as attack -> cast -> breath -> spin -> flight -> the three transform keys, rather than alphabetically.
486 lines
23 KiB
C#
486 lines
23 KiB
C#
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 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 += 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;
|
|
}
|
|
}
|
|
}
|