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

817 lines
36 KiB
C#

using HarmonyLib;
using UnityEngine;
using System.Linq;
namespace RacesOfValheim
{
[HarmonyPatch(typeof(VisEquipment), "UpdateColors")]
public static class AswidSkinColorPatch
{
private static readonly Color SkinColor = new Color(0.96f, 0.97f, 0.98f, 1f);
private static readonly Color HairColor = new Color(1f, 1f, 1f, 1f);
public static void Postfix(VisEquipment __instance)
{
if (!__instance.m_isPlayer) return;
Player player = __instance.GetComponent<Player>();
if (player == null) return;
string race = "Human";
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid())
race = nview.GetZDO().GetString("RacesOfValheim_Race", "Human");
else if (player.m_customData != null && player.m_customData.TryGetValue("Race", out string savedRace))
race = savedRace;
// Before the race check, because it takes the eyes off anyone who has stopped being
// an Aswid as well as putting them on anyone who is one.
AswidVisuals.ApplyEyes(player);
if (race != "Aswid") return;
int state = 0;
if (nview != null && nview.IsValid())
state = nview.GetZDO().GetInt("RacesOfValheim_AswidState", 0);
Color currentHairColor = state >= 8 ? new Color(0.02f, 0.02f, 0.02f, 1f) : HairColor;
if (__instance.m_bodyModel != null && __instance.m_bodyModel.material != null)
__instance.m_bodyModel.material.SetColor("_SkinColor", SkinColor);
var hairInst = Traverse.Create(__instance).Field("m_hairItemInstance").GetValue<GameObject>();
if (hairInst != null)
foreach (var r in hairInst.GetComponentsInChildren<Renderer>())
if (r.material != null) r.material.SetColor("_SkinColor", currentHairColor);
var beardInst = Traverse.Create(__instance).Field("m_beardItemInstance").GetValue<GameObject>();
if (beardInst != null)
foreach (var r in beardInst.GetComponentsInChildren<Renderer>())
if (r.material != null) r.material.SetColor("_SkinColor", currentHairColor);
}
}
[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new System.Type[] { typeof(int), typeof(bool), typeof(int), typeof(float) })]
public static class AswidSEManPatch
{
public static bool Prefix(SEMan __instance, ref int nameHash)
{
Character character = Traverse.Create(__instance).Field<Character>("m_character").Value;
if (character == Player.m_localPlayer && AswidRace.IsAswid())
{
int state = BossProgressionManager.GetCurrentProgressionState();
if (state >= 5 && nameHash == "Freezing".GetStableHashCode())
{
return false;
}
// Cold immunity is removed as per user request to test native Cold VFX
// if (nameHash == "Cold".GetStableHashCode())
// {
// return false;
// }
}
return true;
}
}
[HarmonyPatch(typeof(Attack), "Start")]
public static class Aswid_BloodMagicCost_Patch
{
private static float savedHealthCost = 0f;
private static float savedHealthPercentage = 0f;
public static void Prefix(Attack __instance, Humanoid character, ref bool __state)
{
var weapon = Traverse.Create(__instance).Field("m_weapon").GetValue<ItemDrop.ItemData>();
if (weapon == null) weapon = Traverse.Create(__instance).Method("GetWeapon").GetValue<ItemDrop.ItemData>();
if (character == Player.m_localPlayer && AswidRace.IsAswid() && weapon != null && weapon.m_shared.m_skillType == Skills.SkillType.BloodMagic)
{
__state = true;
savedHealthCost = weapon.m_shared.m_attack.m_attackHealth;
savedHealthPercentage = weapon.m_shared.m_attack.m_attackHealthPercentage;
weapon.m_shared.m_attack.m_attackHealth = 0f;
weapon.m_shared.m_attack.m_attackHealthPercentage = 0f;
}
else
{
__state = false;
}
}
public static void Postfix(Attack __instance, Humanoid character, bool __state)
{
var weapon = Traverse.Create(__instance).Field("m_weapon").GetValue<ItemDrop.ItemData>();
if (weapon == null) weapon = Traverse.Create(__instance).Method("GetWeapon").GetValue<ItemDrop.ItemData>();
if (__state && weapon != null)
{
weapon.m_shared.m_attack.m_attackHealth = savedHealthCost;
weapon.m_shared.m_attack.m_attackHealthPercentage = savedHealthPercentage;
}
}
}
public static class AswidPatches
{
public static System.Collections.Generic.Dictionary<ZDOID, float> RecentlyLifeDrained = new System.Collections.Generic.Dictionary<ZDOID, float>();
}
[HarmonyPatch(typeof(Character), "Damage")]
public static class Aswid_LifeDrainKill_Patch
{
public static void Postfix(Character __instance, HitData hit)
{
if (hit != null && hit.m_attacker == Player.m_localPlayer?.GetZDOID())
{
Debug.LogWarning($"[Aswid_Patch] Local player damaged {__instance.name}. IsDead: {__instance.IsDead()}");
}
if (__instance.IsDead() && hit != null)
{
if (Player.m_localPlayer != null && hit.m_attacker == Player.m_localPlayer.GetZDOID())
{
ZNetView cNetView = __instance.GetComponent<ZNetView>();
if (AswidRace.IsAswid() && cNetView != null && cNetView.IsValid())
{
ZDOID zdoid = __instance.GetZDOID();
if (AswidPatches.RecentlyLifeDrained.TryGetValue(zdoid, out float timeHit))
{
if (Time.time - timeHit < 1.0f)
{
Debug.LogWarning($"[Aswid] {__instance.name} died within 1s of LifeDrain. Consuming!");
AswidRace.TryConsumeMob(__instance, __instance.GetMaxHealth());
AswidPatches.RecentlyLifeDrained.Remove(zdoid);
}
}
}
}
}
}
}
[HarmonyPatch(typeof(Character), "Awake")]
public static class Aswid_Awake_Patch
{
public static void Postfix(Character __instance)
{
if (__instance.GetComponent<MonsterAI>() != null && !__instance.IsBoss() && __instance.m_faction != Character.Faction.Demon && __instance.GetComponent<Tameable>() == null)
{
if (__instance.GetComponent<AswidThrall>() == null)
{
__instance.gameObject.AddComponent<AswidThrall>();
}
}
}
}
[HarmonyPatch(typeof(Player), "GetBodyArmor")]
public static class Aswid_ArmorBonus_Patch
{
public static void Postfix(Player __instance, ref float __result)
{
if (__instance == Player.m_localPlayer && AswidRace.IsAswid())
{
int state = BossProgressionManager.GetCurrentProgressionState();
float multiplier = (EnvMan.instance != null && EnvMan.IsNight()) ? AswidConfig.NightMultiplier.Value : 1f;
__result += AswidConfig.ArmorBonusPerState.Value * state * multiplier;
}
}
}
[HarmonyPatch]
public static class Aswid_DamageBonus_Patch
{
[HarmonyTargetMethod]
public static System.Reflection.MethodBase TargetMethod()
{
return System.Linq.Enumerable.FirstOrDefault(
HarmonyLib.AccessTools.GetDeclaredMethods(typeof(ItemDrop.ItemData)),
m => m.Name == "GetDamage" && m.ReturnType == typeof(HitData.DamageTypes)
);
}
public static void Postfix(ItemDrop.ItemData __instance, ref HitData.DamageTypes __result)
{
if (Player.m_localPlayer != null && AswidRace.IsAswid() &&
Player.m_localPlayer.GetInventory().ContainsItem(__instance))
{
int state = BossProgressionManager.GetCurrentProgressionState();
if (state > 0)
{
float multiplier = (EnvMan.instance != null && EnvMan.IsNight()) ? AswidConfig.NightMultiplier.Value : 1f;
float bonus = AswidConfig.DamageBonusPerState.Value * state * multiplier;
// Add flat bonus to physical damage types that the weapon already has
if (__result.m_slash > 0) __result.m_slash += bonus;
if (__result.m_blunt > 0) __result.m_blunt += bonus;
if (__result.m_pierce > 0) __result.m_pierce += bonus;
if (__result.m_chop > 0) __result.m_chop += bonus;
if (__result.m_pickaxe > 0) __result.m_pickaxe += bonus;
}
}
}
}
[HarmonyPatch(typeof(Humanoid), "StartAttack")]
public static class Aswid_Attack_Patch
{
public static bool Prefix(Humanoid __instance)
{
if (__instance == Player.m_localPlayer)
{
if (__instance.GetComponentInChildren<BatFormBehavior>() != null)
{
return false;
}
if (__instance.GetSEMan().HaveStatusEffect("SE_MistForm".GetStableHashCode()))
{
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(Character), "SetRun")]
public static class Aswid_Run_Patch
{
public static void Prefix(Character __instance, ref bool run)
{
if (__instance == Player.m_localPlayer)
{
if (Player.m_localPlayer.GetSEMan().HaveStatusEffect("SE_MistForm".GetStableHashCode()))
{
run = false;
}
}
}
}
[HarmonyPatch(typeof(Character), "Jump")]
public static class Aswid_Jump_Patch
{
public static bool Prefix(Character __instance)
{
if (__instance == Player.m_localPlayer)
{
if (Player.m_localPlayer.GetSEMan().HaveStatusEffect("SE_MistForm".GetStableHashCode()))
{
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(Player), "OnSpawned")]
public static class Aswid_PlayerOnSpawned_Patch
{
public static void Postfix(Player __instance)
{
if (__instance == Player.m_localPlayer)
{
AswidFoodManager.LoadFood(__instance);
}
}
}
[HarmonyPatch(typeof(Player), "CanConsumeItem")]
public static class Aswid_CanConsumeItem_Patch
{
public static void Postfix(Player __instance, ItemDrop.ItemData item, ref bool __result)
{
if (__instance == Player.m_localPlayer && AswidRace.IsAswid() && AswidBloodRefinery.IsAswidMeal(item))
{
var foods = HarmonyLib.Traverse.Create(__instance).Field("m_foods").GetValue<System.Collections.IList>();
if (foods != null)
{
if (foods.Count >= 3)
{
bool canUse4th = BossProgressionManager.GetCurrentProgressionState() >= 8;
bool has4th = AswidFoodManager.ExtraFoods.TryGetValue(__instance, out Player.Food extraFood) && extraFood != null;
if (canUse4th && (!has4th || extraFood.m_time >= (extraFood.m_item.m_shared.m_foodBurnTime * 0.5f)))
{
__result = true; // Consente l'uso del 4° slot se disponibile
}
else
{
bool canRefresh = false;
foreach (object foodObj in foods)
{
Player.Food f = foodObj as Player.Food;
if (f != null && f.m_item.m_shared.m_name == item.m_shared.m_name && f.CanEatAgain())
{
canRefresh = true;
break;
}
}
if (canRefresh)
{
__result = true;
}
else
{
__result = false; // Nessuno spazio disponibile, cibo si disintegra
}
}
}
else
{
__result = true; // Spazio nei primi 3 slot
}
}
}
}
}
[HarmonyPatch(typeof(Player), "EatFood")]
public static class Aswid_EatFood_Patch
{
private static System.Collections.Generic.List<object> hiddenFoods = new System.Collections.Generic.List<object>();
public static bool Prefix(Player __instance, ItemDrop.ItemData item, ref bool __result)
{
hiddenFoods.Clear();
if (__instance == Player.m_localPlayer && AswidRace.IsAswid() && AswidBloodRefinery.IsAswidMeal(item))
{
var m_foods = HarmonyLib.Traverse.Create(__instance).Field("m_foods").GetValue<System.Collections.IList>();
if (m_foods != null)
{
if (m_foods.Count >= 3)
{
bool canUse4th = BossProgressionManager.GetCurrentProgressionState() >= 8;
if (canUse4th)
{
bool has4th = AswidFoodManager.ExtraFoods.TryGetValue(__instance, out Player.Food extraFood) && extraFood != null;
if (!has4th || extraFood.m_time >= (extraFood.m_item.m_shared.m_foodBurnTime * 0.5f))
{
AswidFoodManager.SetExtraFood(__instance, item);
// Play consume effects
var consumeEffects = HarmonyLib.Traverse.Create(__instance).Field("m_consumeItemEffects").GetValue<EffectList>();
if (consumeEffects != null)
{
consumeEffects.Create(__instance.transform.position, Quaternion.identity, __instance.transform, 1f, -1);
}
var zanim = HarmonyLib.Traverse.Create(__instance).Field("m_zanim").GetValue<ZSyncAnimation>();
if (zanim != null)
{
zanim.SetTrigger("eat");
}
if (item.m_shared.m_food > 0f)
{
__instance.Heal(item.m_shared.m_food, true);
}
__result = true;
return false; // Skip native EatFood
}
}
bool refreshed = false;
foreach (object foodObj in m_foods)
{
Player.Food f = foodObj as Player.Food;
if (f != null && f.m_item.m_shared.m_name == item.m_shared.m_name && f.CanEatAgain())
{
f.m_time = 0f;
f.m_item = item;
var consumeEffects = HarmonyLib.Traverse.Create(__instance).Field("m_consumeItemEffects").GetValue<EffectList>();
if (consumeEffects != null) consumeEffects.Create(__instance.transform.position, Quaternion.identity, __instance.transform, 1f, -1);
var zanim = HarmonyLib.Traverse.Create(__instance).Field("m_zanim").GetValue<ZSyncAnimation>();
if (zanim != null) zanim.SetTrigger("eat");
if (item.m_shared.m_food > 0f) __instance.Heal(item.m_shared.m_food, true);
refreshed = true;
break;
}
}
if (refreshed)
{
__result = true;
return false;
}
// Se pieno e senza 4° slot disponibile, fallisce e disintegra
__result = false;
return false;
}
else
{
// Nascondiamo temporaneamente i duplicati nei primi 3 slot per costringere Valheim ad aggiungere un NUOVO slot
for (int i = m_foods.Count - 1; i >= 0; i--)
{
var foodObj = m_foods[i];
var foodItem = HarmonyLib.Traverse.Create(foodObj).Field("m_item").GetValue<ItemDrop.ItemData>();
if (foodItem != null && foodItem.m_shared.m_name == item.m_shared.m_name)
{
hiddenFoods.Add(foodObj);
m_foods.RemoveAt(i);
}
}
}
}
}
return true;
}
public static void Postfix(Player __instance, ItemDrop.ItemData item, ref bool __result)
{
if (hiddenFoods.Count > 0)
{
var m_foods = HarmonyLib.Traverse.Create(__instance).Field("m_foods").GetValue<System.Collections.IList>();
if (m_foods != null)
{
// Ripristiniamo i duplicati nascosti
foreach (var hf in hiddenFoods)
{
m_foods.Add(hf);
}
}
hiddenFoods.Clear();
}
}
}
[HarmonyPatch(typeof(Tameable), "GetHoverText")]
public static class Aswid_TameHoverText_Patch
{
public static void Postfix(Tameable __instance, ref string __result)
{
if (Player.m_localPlayer == null || !AswidRace.IsAswid()) return;
if (__instance.GetComponent<Character>()?.IsTamed() == true) return;
string prefabName = __instance.gameObject.name.ToLower();
int state = BossProgressionManager.GetCurrentProgressionState();
bool canTame = false;
if (state >= 2 && prefabName.Contains("boar")) canTame = true;
if (state >= 5 && prefabName.Contains("wolf")) canTame = true;
if (state >= 6 && prefabName.Contains("lox")) canTame = true;
if (state >= 8 && prefabName.Contains("asksvin")) canTame = true;
if (canTame)
{
// Used to hardcode "[K] Tame" while AswidRace.Update actually checked U (now
// AswidConfig.TameKey) - the hint never matched the working key, and would have
// gone stale again the moment that key was rebound. MainKey.ToString() reads back
// whatever is actually bound.
__result += $"\n[<color=yellow><b>{AswidConfig.TameKey.Value.MainKey}</b></color>] Tame";
}
}
}
[HarmonyPatch(typeof(Hud), "UpdateStamina")]
public static class Aswid_HideStamina_Patch
{
public static bool Prefix(Hud __instance, Player player)
{
if (player == Player.m_localPlayer && (AswidRace.IsAswid() || DraughRace.IsDraugh()))
{
if (__instance.m_staminaBar2Root != null && __instance.m_staminaBar2Root.gameObject.activeSelf)
{
__instance.m_staminaBar2Root.gameObject.SetActive(false);
}
return false;
}
return true;
}
}
[HarmonyPatch(typeof(StatusEffect), "Setup")]
public static class Aswid_ColdStatus_Patch
{
public static void Prefix(StatusEffect __instance, Character character)
{
if (character == Player.m_localPlayer && AswidRace.IsAswid() && (__instance.name.Contains("Cold") || __instance.m_name == "$se_cold_name"))
{
var wraithTrophy = Jotunn.Managers.PrefabManager.Cache.GetPrefab<ItemDrop>("TrophyWraith");
if (wraithTrophy != null && wraithTrophy.m_itemData.m_shared.m_icons.Length > 0)
{
__instance.m_icon = wraithTrophy.m_itemData.m_shared.m_icons[0];
}
else
{
__instance.m_icon = null;
}
__instance.m_name = "Night Aura";
__instance.m_startMessage = ""; // "The darkness empowers you.";
__instance.m_tooltip = "The cold strengthens your beastly senses.";
if (__instance is SE_Stats stats)
{
stats.m_healthRegenMultiplier = 1f;
stats.m_staminaRegenMultiplier = 1f;
stats.m_staminaDrainPerSec = 0f;
stats.m_speedModifier = 0f;
}
}
}
}
[HarmonyPatch(typeof(Player), "Update")]
public static class Aswid_PlayerUpdate_Patch
{
public static void Postfix(Player __instance)
{
if (__instance == null) return;
ZNetView nview = __instance.GetComponent<ZNetView>();
if (nview != null && nview.IsValid() && nview.GetZDO().GetString("RacesOfValheim_Race", "Human") == "Aswid")
{
if (__instance == Player.m_localPlayer && RaceInput.Allowed && AswidConfig.ToggleDevourKey.Value.IsDown())
{
AswidRace.DevourEnabled = !AswidRace.DevourEnabled;
AswidRace.AuraEnabled = AswidRace.DevourEnabled;
string msg = AswidRace.DevourEnabled ? "Vampiric Aura: ENABLED" : "Vampiric Aura: DISABLED";
__instance.Message(MessageHud.MessageType.Center, msg);
}
int state = BossProgressionManager.GetCurrentProgressionState();
var rules = AswidProgression.GetRules(state);
if (AswidRace.Instance != null && !AswidRace.Instance.IsTransformed)
{
if (rules != null && rules.HasSurtlingForm)
{
__instance.transform.localScale = new Vector3(1.1f, 1.1f, 1.1f);
}
else
{
__instance.transform.localScale = Vector3.one;
}
}
}
}
}
[HarmonyPatch(typeof(VisEquipment), "UpdateVisuals")]
public static class Aswid_MultiplayerVisuals_Patch
{
public static void Postfix(VisEquipment __instance)
{
if (!__instance.m_isPlayer) return;
Player player = __instance.GetComponent<Player>();
if (player == null || player.IsOwner()) return; // Only process for remote players
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid() && nview.GetZDO().GetString("RacesOfValheim_Race", "Human") == "Aswid")
{
bool isBat = nview.GetZDO().GetBool("Aswid_IsBatForm", false);
bool isMist = nview.GetZDO().GetBool("Aswid_IsMistForm", false);
Transform playerVisual = player.transform.Find("Visual");
// Bat logic
Transform batBody = player.transform.Find("AswidBody_Bat");
if (isBat && batBody == null) {
GameObject batPrefab = Jotunn.Managers.PrefabManager.Cache.GetPrefab<GameObject>("Bat");
if (batPrefab != null) {
GameObject visualPrefab = batPrefab.GetComponentInChildren<Animator>()?.gameObject;
if (visualPrefab != null) {
GameObject batInstance = UnityEngine.Object.Instantiate(visualPrefab, player.transform.position, player.transform.rotation, player.transform);
batInstance.name = "AswidBody_Bat";
batInstance.transform.localPosition = Vector3.zero;
}
}
} else if (!isBat && batBody != null) {
UnityEngine.Object.Destroy(batBody.gameObject);
}
// Mist logic
Transform mistBody = player.transform.Find("AswidBody_Mist");
if (isMist && mistBody == null) {
GameObject wraithPrefab = Jotunn.Managers.PrefabManager.Cache.GetPrefab<GameObject>("Wraith");
if (wraithPrefab != null) {
GameObject visualPrefab = wraithPrefab.transform.Find("Visual")?.gameObject;
if (visualPrefab != null) {
GameObject mistInstance = UnityEngine.Object.Instantiate(visualPrefab, player.transform.position, player.transform.rotation, player.transform);
mistInstance.name = "AswidBody_Mist";
mistInstance.transform.localPosition = Vector3.zero;
mistInstance.transform.localScale = Vector3.one;
foreach (var r in mistInstance.GetComponentsInChildren<Renderer>())
{
if (r.material != null && r.material.HasProperty("_Color"))
{
Color c = r.material.GetColor("_Color");
c.a = 0.3f; // Make transparent
r.material.SetColor("_Color", c);
}
}
}
}
} else if (!isMist && mistBody != null) {
UnityEngine.Object.Destroy(mistBody.gameObject);
}
// Toggle visibility
if (isBat || isMist) {
PlayerVisualHider.Hide(playerVisual, "aswid-remote-form");
} else {
PlayerVisualHider.Show(playerVisual, "aswid-remote-revert");
}
}
}
}
[HarmonyPatch(typeof(Character), "Damage")]
public static class Aswid_Damage_Patch
{
public static void Prefix(Character __instance, HitData hit, out float __state)
{
__state = (__instance != null) ? __instance.GetHealth() : 0f;
}
public static void Postfix(Character __instance, HitData hit, float __state)
{
if (hit == null || __instance == null || __instance.IsPlayer()) return;
Character attacker = hit.GetAttacker();
if (attacker != null && attacker.IsPlayer() && attacker == Player.m_localPlayer)
{
ZNetView nview = attacker.GetComponent<ZNetView>();
if (nview != null && nview.IsValid() && nview.GetZDO().GetString("RacesOfValheim_Race", "Human") == "Aswid")
{
float physDamage = hit.m_damage.m_blunt + hit.m_damage.m_slash + hit.m_damage.m_pierce + hit.m_damage.m_chop + hit.m_damage.m_pickaxe + hit.m_damage.m_damage;
// On-hit Lifesteal
if (physDamage > 0f)
{
int currentState = BossProgressionManager.GetCurrentProgressionState();
var rules = AswidProgression.GetRules(currentState);
float lifesteal = rules.LifestealPercent;
if (EnvMan.instance != null && EnvMan.IsNight())
{
lifesteal *= AswidConfig.NightMultiplier.Value;
}
if (lifesteal > 0f)
{
float healAmount = physDamage * lifesteal;
Player.m_localPlayer.Heal(healAmount, true);
}
}
// On-death Devour
if (__state > 0f && __instance.GetHealth() <= 0f && physDamage > 0f)
{
AswidRace.TryConsumeMob(__instance, __instance.GetMaxHealth());
}
}
}
}
/// <summary>
/// True while the local Aswid is holding a blood magic item. The three eitr patches below
/// all turn on exactly this condition, so it lives in one place rather than three.
/// </summary>
public static bool IsLocalAswidWieldingBloodMagic(Character character)
{
if (character == null || character != Player.m_localPlayer) return false;
if (!AswidRace.IsAswid()) return false;
ItemDrop.ItemData weapon = Player.m_localPlayer.GetCurrentWeapon();
return weapon != null && weapon.m_shared != null &&
weapon.m_shared.m_skillType == Skills.SkillType.BloodMagic;
}
/// <summary>
/// The gate that actually decides whether a blood magic attack may start, and the reason
/// Blood Magic Mastery did nothing.
///
/// Attack.Start asks Character.TryUseEitr, whose very first test is:
///
/// if (GetMaxEitr() == 0) { Message("$hud_eitrrequired"); return false; }
///
/// An Aswid carrying no eitr food has a maximum of zero, so the attack was refused right
/// there - before HaveEitr was ever consulted, which is why forcing HaveEitr true (below)
/// changed nothing on its own. Freeing the cast has to happen here.
///
/// TryUseEitr only ever gates; the spend happens separately through UseEitr, so returning
/// true costs nothing. The health price of blood magic is charged elsewhere and is left
/// completely alone - it is meant to be the whole price.
/// </summary>
[HarmonyPatch(typeof(Character), "TryUseEitr")]
public static class Character_TryUseEitr_Patch
{
public static bool Prefix(Character __instance, ref bool __result)
{
if (!IsLocalAswidWieldingBloodMagic(__instance)) return true;
__result = true;
return false;
}
}
[HarmonyPatch(typeof(Player), "HaveEitr")]
public static class Player_HaveEitr_Patch
{
public static void Postfix(Player __instance, ref bool __result)
{
// Still needed for the paths that ask HaveEitr directly rather than through
// TryUseEitr - Attack.FireProjectileBurst and the bow/crossbow draw among them.
if (IsLocalAswidWieldingBloodMagic(__instance)) __result = true;
}
}
[HarmonyPatch(typeof(Player), "UseEitr")]
public static class Player_UseEitr_Patch
{
public static bool Prefix(Player __instance)
{
if (IsLocalAswidWieldingBloodMagic(__instance)) return false; // Skip spending Eitr
return true;
}
}
[HarmonyPatch(typeof(Skills), "RaiseSkill")]
public static class Aswid_Skills_RaiseSkill_Patch
{
public static void Prefix(Skills __instance, Skills.SkillType skillType, ref float factor)
{
Player player = HarmonyLib.Traverse.Create(__instance).Field("m_player").GetValue<Player>();
if (player != null && player == Player.m_localPlayer && AswidRace.IsAswid())
{
if (skillType == Skills.SkillType.BloodMagic)
{
factor *= AswidConfig.BloodMagicSkillGainMultiplier.Value; // Benedictus et Afflictus
}
}
}
}
}
[HarmonyPatch(typeof(Player), "UpdateFood")]
public static class Aswid_PlayerUpdateFood_Patch
{
public static void Prefix(Player __instance, float dt, bool forceUpdate)
{
if (__instance != Player.m_localPlayer || !AswidRace.IsAswid()) return;
if (AswidFoodManager.ExtraFoods.TryGetValue(__instance, out Player.Food extraFood) && extraFood != null)
{
extraFood.m_time += dt;
if (extraFood.m_item != null && extraFood.m_item.m_shared != null)
{
if (extraFood.m_time >= extraFood.m_item.m_shared.m_foodBurnTime)
{
AswidFoodManager.ClearFood(__instance);
}
else
{
float factor = extraFood.m_time / extraFood.m_item.m_shared.m_foodBurnTime;
extraFood.m_health = Mathf.Lerp(extraFood.m_item.m_shared.m_food, extraFood.m_item.m_shared.m_food * 0.2f, factor);
extraFood.m_stamina = Mathf.Lerp(extraFood.m_item.m_shared.m_foodStamina, extraFood.m_item.m_shared.m_foodStamina * 0.2f, factor);
extraFood.m_eitr = Mathf.Lerp(extraFood.m_item.m_shared.m_foodEitr, extraFood.m_item.m_shared.m_foodEitr * 0.2f, factor);
}
}
}
}
}
[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
public static class Aswid_PlayerGetTotalFoodValue_Patch
{
public static void Postfix(Player __instance, ref float hp, ref float stamina, ref float eitr)
{
if (__instance != Player.m_localPlayer || !AswidRace.IsAswid()) return;
if (AswidFoodManager.ExtraFoods.TryGetValue(__instance, out Player.Food extraFood) && extraFood != null)
{
hp += extraFood.m_health;
stamina += extraFood.m_stamina;
eitr += extraFood.m_eitr;
}
}
}
[HarmonyPatch(typeof(Player), "ClearFood")]
public static class Aswid_Player_ClearFood_Patch
{
public static bool Prefix(Player __instance)
{
if (__instance == Player.m_localPlayer && AswidRace.IsAswid())
{
// Retain food if the player is dead/dying.
// Allows Bukeperries to still clear food normally.
if (__instance.IsDead() || __instance.GetHealth() <= 0f)
{
Jotunn.Logger.LogInfo("[AswidRace] Preserving food buffs through death (Aswid racial trait).");
return false;
}
}
return true;
}
}
}