The hover window that holds a form level after you stop powering goes from 2 seconds to 5, so gliding is a choice rather than something that happens to you the moment you let go. Shift while holding W spends 15 stamina a second for 22 m/s instead of 12. It is the only part of flight that costs anything - base flight stays free, because the drake arrives at The Elder, long before a player has the pool to pay for simply staying airborne - and running dry drops you back to the free boost rather than out of the sky. S beats backwards along the aim, pitch included: look down and press it and you rise away from what you are watching. Reverse thrust alone would have spun the dragon round to fly nose-first away from the camera, putting its tail where its breath comes out, so the form claims AlwaysRotateCamera for exactly those frames and keeps facing what it is retreating from. Water is no longer a trap. Character.UpdateMotion asks IsSwimming before it ever looks at m_flying, so a dragon that touched the sea was handed to UpdateSwimming every frame: the flight patch never ran and there was no way back up short of finding land. The Aswid's bat escapes this only 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 water and Moder could not. Those frames now go back to UpdateFlying, and while in swim depth the form climbs regardless of where the camera points, so the surface is something you break out of rather than something you sit in. Nothing that merely asks IsSwimming - the Wet status, the animator, stamina - is touched. All five speeds now run through m_flySlowSpeed instead of the m_run/m_flyFastSpeed pair, which only ever picked between two of them.
483 lines
22 KiB
C#
483 lines
22 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 += 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 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
|
|
{
|
|
private const float TURN_SPEED = 120f;
|
|
private const float GLIDE_SPEED = 5f;
|
|
private const float BOOST_SPEED = 12f;
|
|
private const float SPRINT_SPEED = 22f;
|
|
private const float REVERSE_SPEED = 7f;
|
|
// Climbing out of water is deliberately slower than a powered climb in open air - the
|
|
// wings are dragging themselves free, not racing.
|
|
private const float LIFTOFF_SPEED = 9f;
|
|
private const float HOVER_SECONDS = 5f;
|
|
// Per second, drained only while the sprint is actually being granted.
|
|
private const float SPRINT_STAMINA_PER_SECOND = 15f;
|
|
// 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, 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;
|
|
}
|
|
}
|
|
}
|