The multiplayer visual sync named each spawned model "<form>_multiplayer" but searched for an existing one called "SkadiBody_Form", a name nothing is ever assigned. The lookup therefore missed every time, and since VisEquipment.UpdateVisuals runs each frame off CustomUpdate, observers instantiated a fresh dragon roughly sixty times a second for as long as the Skadi player stayed transformed. The transformed player saw nothing wrong, because owners return early, and the pile only got cleaned up in the reverted-to-human branch, so the lag never let up on its own. Look the model up by the name actually assigned. The scan also destroys any surplus "_multiplayer" children it walks past, so clients that have already accumulated a pile clear it on the first frame after updating instead of needing to rejoin.
294 lines
13 KiB
C#
294 lines
13 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 = 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)
|
|
{
|
|
if (__instance == Player.m_localPlayer && __instance.GetComponentInChildren<DrakeFormBehavior>() != null)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|