using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using MonoMod.Utils;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Casualheim")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Casualheim")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("260c10ac-6c86-41da-be4b-e5891db32a21")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Casualheim;
public class AllowClearedBuildingPatch
{
[HarmonyPatch(typeof(Location), "IsInside")]
public class LocationIsInsideLocationPatch
{
public static void Postfix(ref Location __instance, ref bool __result, ref bool buildCheck, ref Vector3 point)
{
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null || !buildCheck || !__instance.m_noBuild || !__result || !ThisPlugin.PluginEnabled.Value || !ThisPlugin.AllowClearedBuilding.Value)
{
return;
}
if (!loc_2_zloc_dict.ContainsKey(((object)__instance).GetHashCode()))
{
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)"Casualheim | Location.IsInside location is not in the dictrionary !!!");
}
return;
}
bool flag = true;
int num = loc_2_zloc_dict[((object)__instance).GetHashCode()];
if (ZoneSystem.m_instance.GetLocation(num) == null)
{
return;
}
foreach (CreatureSpawner creatureSpawner in CreatureSpawner.m_creatureSpawners)
{
if ((Object)(object)creatureSpawner == (Object)null || (Object)(object)creatureSpawner.m_nview == (Object)null)
{
continue;
}
ZDO zDO = creatureSpawner.m_nview.GetZDO();
if (zDO == null)
{
continue;
}
int @int = zDO.GetInt("zloc_hash", 0);
ZDOID connectionZDOID = zDO.GetConnectionZDOID((ConnectionType)3);
if (num == @int && creatureSpawner.SpawnedCreatureStillExists(connectionZDOID))
{
flag = false;
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)("Casualheim | creaturespawner [" + ((object)creatureSpawner).GetHashCode() + "] says char still exists for zloc [" + num + "] !"));
}
break;
}
}
if (!flag)
{
return;
}
foreach (Character s_character in Character.s_characters)
{
if ((Object)(object)s_character == (Object)null || (Object)(object)s_character.m_nview == (Object)null)
{
continue;
}
ZDO zDO2 = s_character.m_nview.GetZDO();
if (zDO2 == null)
{
continue;
}
int int2 = zDO2.GetInt("zloc_hash", 0);
if (num == int2)
{
flag = false;
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)("Casualheim | found char " + s_character.m_name.ToLower() + " that is still alive for zloc [" + num + "] !"));
}
break;
}
}
if (flag)
{
__instance.m_noBuild = false;
}
}
}
[HarmonyPatch(typeof(Location), "Awake")]
public class LocatioAwakenPatch
{
public static void Postfix(ref Location __instance)
{
if (ThisPlugin.PluginEnabled.Value && ThisPlugin.AllowClearedBuilding.Value && check_caller("DMD<ZoneSystem::SpawnLocation>"))
{
loc_2_zloc_dict.Add(((object)__instance).GetHashCode(), last_zone_location_hash);
}
}
}
[HarmonyPatch(typeof(CharacterDrop), "OnDeath")]
public class CharacterDropOnDeathPatch
{
public static void Prefix(ref CharacterDrop __instance)
{
if (!ThisPlugin.PluginEnabled.Value || !ThisPlugin.AllowClearedBuilding.Value)
{
return;
}
last_character_drop_hash = 0;
if (!((Object)(object)__instance.m_character == (Object)null) && !((Object)(object)__instance.m_character.m_nview == (Object)null))
{
ZDO zDO = __instance.m_character.m_nview.GetZDO();
if (zDO != null)
{
last_character_drop_hash = zDO.GetInt("zloc_hash", 0);
}
}
}
}
[HarmonyPatch(typeof(ZoneSystem), "SpawnLocation")]
public class ZoneSystemSpawnLocationPatch
{
public static void Prefix(ref ZoneLocation location)
{
last_zone_location_hash = 0;
last_zone_location_hash = location.Hash;
}
}
[HarmonyPatch(typeof(Character), "Awake")]
public class CharacterAwakePatch
{
public static void Postfix(ref Character __instance)
{
if (!ThisPlugin.PluginEnabled.Value || !ThisPlugin.AllowClearedBuilding.Value)
{
return;
}
bool flag = false;
bool flag2 = false;
if (check_caller("DMD<CreatureSpawner::Spawn>"))
{
flag = true;
}
else if (check_caller("DMD<CharacterDrop::OnDeath>"))
{
flag2 = true;
}
if ((!flag && !flag2) || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsOwner())
{
return;
}
ZDO zDO = __instance.m_nview.GetZDO();
if (zDO != null)
{
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)("Casualheim | setting zloc_hash [" + (flag ? last_creature_spawner_hash : (flag2 ? last_character_drop_hash : (-1))) + "] for char :: " + __instance.m_name.ToLower()));
}
if (flag)
{
zDO.Set("zloc_hash", last_creature_spawner_hash);
}
else if (flag2)
{
zDO.Set("zloc_hash", last_character_drop_hash);
}
}
}
}
[HarmonyPatch(typeof(CreatureSpawner), "Awake")]
public class CreatureSpawnerAwakePatch
{
public static void Postfix(ref CreatureSpawner __instance)
{
if (!ThisPlugin.PluginEnabled.Value || !ThisPlugin.AllowClearedBuilding.Value || !check_caller("DMD<ZoneSystem::SpawnLocation>") || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsOwner())
{
return;
}
ZDO zDO = __instance.m_nview.GetZDO();
if (zDO == null)
{
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)"Casualheim | !!! !!! no ZDO for CreatureSpawner !!! !!!");
}
}
else
{
zDO.Set("zloc_hash", last_zone_location_hash);
}
}
}
[HarmonyPatch(typeof(CreatureSpawner), "UpdateSpawner")]
public class CreatureSpawnerUpdateSpawnerPatch
{
public static bool GetLocation(ref CreatureSpawner cs, out Location loc)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
if (cs.m_checkedLocation)
{
loc = cs.m_location;
}
else
{
cs.m_location = Location.GetLocation(((Component)cs).transform.position, true);
cs.m_checkedLocation = true;
loc = cs.m_location;
}
if ((Object)(object)loc == (Object)null)
{
return false;
}
return true;
}
public static void Prefix(ref CreatureSpawner __instance)
{
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
if (!ThisPlugin.PluginEnabled.Value || !ThisPlugin.AllowClearedBuilding.Value || (Object)(object)__instance.m_nview == (Object)null)
{
return;
}
ZDO zDO = __instance.m_nview.GetZDO();
if (zDO == null)
{
return;
}
int @int = zDO.GetInt("zloc_hash", 0);
if (@int == 0 || GetLocation(ref __instance, out var loc))
{
return;
}
List<CreatureSpawner> list = new List<CreatureSpawner>();
foreach (CreatureSpawner item in (HashSet<CreatureSpawner>)(object)__instance.m_spawnGroup)
{
list.Add(item);
}
for (int i = 0; i < list.Count; i++)
{
CreatureSpawner cs = list[i];
if (!((ZDOID)(ref cs.m_lastSpawnID)).IsNone() && (!cs.CanRespawnNow(cs.m_lastSpawnID) || cs.SpawnedCreatureStillExists(cs.m_lastSpawnID)))
{
continue;
}
if ((Object)(object)cs.m_nview == (Object)null || !cs.m_nview.IsOwner())
{
break;
}
ZDO zDO2 = cs.m_nview.GetZDO();
if (zDO2 != null && zDO2.GetInt("zloc_hash", 0) == 0 && !GetLocation(ref cs, out var loc2))
{
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)"Casualheim | !!! !!! no ZDO for CreatureSpawner !!! !!!");
}
if (((object)loc2).GetHashCode() == ((object)loc).GetHashCode())
{
zDO2.Set("zloc_hash", @int);
}
}
}
}
}
[HarmonyPatch(typeof(CreatureSpawner), "Spawn")]
public class CreatureSpawnerSpawnPatch
{
public static void Prefix(ref CreatureSpawner __instance)
{
if (!ThisPlugin.PluginEnabled.Value || !ThisPlugin.AllowClearedBuilding.Value)
{
return;
}
last_creature_spawner_hash = 0;
if (!((Object)(object)__instance.m_nview == (Object)null))
{
ZDO zDO = __instance.m_nview.GetZDO();
if (zDO != null)
{
last_creature_spawner_hash = zDO.GetInt("zloc_hash", 0);
}
}
}
}
public static int last_zone_location_hash = -1;
public static int last_creature_spawner_hash = -1;
public static int last_character_drop_hash = -1;
public static Dictionary<int, int> loc_2_zloc_dict = new Dictionary<int, int>();
public static bool check_caller(string caller_method)
{
StackFrame[] frames = new StackTrace(fNeedFileInfo: true).GetFrames();
for (int i = 1; i < frames.Length; i++)
{
if (frames[i].GetMethod().Name == caller_method)
{
return true;
}
}
return false;
}
}
public struct BlockInputState
{
public float block_start_time;
public float attack_start_time;
public float dodge_end_time;
public bool block_state;
public bool attack_state;
public bool dodge_state;
}
public struct AttackCancel
{
public float time;
public WeakReference<Attack> atk;
}
public class AttackCancelPatch
{
[HarmonyPatch(typeof(Humanoid), "OnAttackTrigger")]
public class OnAttackTriggerPatch
{
public static void Postfix(Humanoid __instance)
{
if (ThisPlugin.PluginEnabled.Value && !((Object)(object)__instance == (Object)null) && !(((object)__instance).GetType() != typeof(Player)) && __instance.m_currentAttack != null)
{
Humanoid obj = ((__instance is Player) ? __instance : null);
int hashCode = ((object)obj).GetHashCode();
int hashCode2 = ((object)obj.m_currentAttack).GetHashCode();
if (!player_attack_damage_done_dict.ContainsKey(hashCode))
{
player_attack_damage_done_dict.Add(hashCode, hashCode2);
}
else
{
player_attack_damage_done_dict[hashCode] = hashCode2;
}
}
}
}
[HarmonyPatch(typeof(Player), "InAttack")]
public class InAttackCancelPatch
{
private static void CancelFreezeFrame(ref Player __instance)
{
if (((Character)__instance).GetNextOrCurrentAnimHash() != Humanoid.s_animatorTagAttack)
{
return;
}
int hashCode = ((object)__instance).GetHashCode();
if (last_attack_cancel_dict.ContainsKey(hashCode) && last_attack_cancel_dict[hashCode].atk.TryGetTarget(out var target))
{
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)"Casualheim | cancelling freeze frame !");
}
((Character)target.m_character).FreezeFrame(0f);
((Character)__instance).m_zanim.SetSpeed(10000f);
}
}
private static bool CancelAttack(ref Player __instance, float attack_min_time)
{
if (((Humanoid)__instance).m_currentAttack == null)
{
return false;
}
if (((Humanoid)__instance).m_currentAttack.m_time <= attack_min_time)
{
return false;
}
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)"Casualheim | cancelling attack !");
}
((Humanoid)__instance).m_currentAttack.Abort();
((Character)__instance).m_attack = false;
((Character)__instance).m_attackHold = false;
((Character)__instance).m_secondaryAttack = false;
((Character)__instance).m_secondaryAttackHold = false;
((Character)__instance).m_zanim.SetSpeed(10000f);
int hashCode = ((object)__instance).GetHashCode();
if (!last_attack_cancel_dict.ContainsKey(hashCode))
{
last_attack_cancel_dict.Add(hashCode, new AttackCancel
{
time = Time.fixedTime,
atk = new WeakReference<Attack>(((Humanoid)__instance).m_currentAttack)
});
}
else
{
last_attack_cancel_dict[hashCode] = new AttackCancel
{
time = Time.fixedTime,
atk = new WeakReference<Attack>(((Humanoid)__instance).m_currentAttack)
};
}
((Character)((Humanoid)__instance).m_currentAttack.m_character).FreezeFrame(0f);
((Humanoid)__instance).m_previousAttack = null;
((Humanoid)__instance).m_currentAttack = null;
return true;
}
public static void Postfix(Player __instance, ref bool __result)
{
if (!ThisPlugin.PluginEnabled.Value || (Object)(object)__instance == (Object)null)
{
return;
}
int hashCode = ((object)__instance).GetHashCode();
float fixedTime = Time.fixedTime;
if (last_attack_cancel_dict.ContainsKey(hashCode))
{
float num = fixedTime - last_attack_cancel_dict[hashCode].time;
if (num < 0.1f)
{
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)("Casualheim | (in attack) attack canceled recently :: " + num + "s"));
}
CancelFreezeFrame(ref __instance);
__result = false;
return;
}
}
if (((Humanoid)__instance).m_currentAttack == null || (player_attack_damage_done_dict.ContainsKey(hashCode) && player_attack_damage_done_dict[hashCode] == ((object)((Humanoid)__instance).m_currentAttack).GetHashCode()))
{
return;
}
bool flag = ((Humanoid)__instance).m_currentAttack == null || ((Humanoid)__instance).m_currentAttack.IsDone();
StackFrame[] frames = new StackTrace(fNeedFileInfo: true).GetFrames();
bool flag2 = false;
bool flag3 = false;
float attack_min_time = 0f;
for (int i = 1; i < frames.Length; i++)
{
MethodBase method = frames[i].GetMethod();
if (method == null)
{
continue;
}
Type realDeclaringType = ReflectionHelper.GetRealDeclaringType((MemberInfo)method);
string name = method.Name;
if (realDeclaringType == null || name == null)
{
continue;
}
if (realDeclaringType == typeof(Character) && name.Contains("Jump"))
{
flag2 = true;
attack_min_time = 0f;
break;
}
if (realDeclaringType == typeof(Humanoid) && name.Contains("UpdateBlock"))
{
bool flag4 = false;
if (!block_state_dict.ContainsKey(hashCode))
{
flag4 = true;
}
if (!flag4)
{
BlockInputState blockInputState = block_state_dict[hashCode];
if (blockInputState.attack_start_time < blockInputState.block_start_time)
{
flag4 = true;
}
}
if (flag4)
{
flag2 = true;
flag3 = true;
attack_min_time = 0f;
}
break;
}
if (realDeclaringType == typeof(Player) && name.Contains("UpdateDodge"))
{
float num2 = __instance.m_dodgeStaminaUsage - __instance.m_dodgeStaminaUsage * ((Character)__instance).GetEquipmentMovementModifier() + __instance.m_dodgeStaminaUsage * ((Character)__instance).GetEquipmentDodgeStaminaModifier();
((Character)__instance).m_seman.ModifyDodgeStaminaUsage(num2, ref num2, true);
if (((Character)__instance).HaveStamina(num2))
{
flag2 = true;
attack_min_time = 0.1f;
}
break;
}
}
if (!(!flag2 || flag))
{
((Humanoid)__instance).ClearActionQueue();
__result = !CancelAttack(ref __instance, attack_min_time);
if (!__result && flag3)
{
((Character)__instance).m_nview.GetZDO().Set(ZDOVars.s_isBlockingHash, true);
((Character)__instance).m_zanim.SetBool(Humanoid.s_blocking, true);
}
}
}
}
[HarmonyPatch(typeof(Humanoid), "StartAttack")]
public class StartAttackCancelPatch
{
public static bool Prefix(Humanoid __instance, ref bool __result)
{
if (!ThisPlugin.PluginEnabled.Value || (Object)(object)__instance == (Object)null)
{
return true;
}
if (((object)__instance).GetType() != typeof(Player))
{
return true;
}
int hashCode = ((object)((__instance is Player) ? __instance : null)).GetHashCode();
float fixedTime = Time.fixedTime;
if (last_attack_cancel_dict.ContainsKey(hashCode))
{
float num = fixedTime - last_attack_cancel_dict[hashCode].time;
if (num < 0.1f)
{
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)("Casualheim | (start attack) attack canceled recently :: " + num + "s"));
}
__result = false;
return false;
}
}
else if (block_state_dict.ContainsKey(hashCode))
{
BlockInputState blockInputState = block_state_dict[hashCode];
if ((blockInputState.block_state && blockInputState.block_start_time > blockInputState.attack_start_time) || blockInputState.dodge_state || fixedTime - blockInputState.dodge_end_time < 0.15f || !blockInputState.attack_state)
{
__result = false;
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(Player), "SetControls")]
public class SetControlsPatch
{
public static void Prefix(Player __instance, ref bool attack, ref bool attackHold, ref bool secondaryAttack, ref bool secondaryAttackHold, ref bool block, ref bool blockHold, ref bool dodge)
{
if (ThisPlugin.PluginEnabled.Value && !((Object)(object)__instance == (Object)null))
{
int hashCode = ((object)__instance).GetHashCode();
bool flag = block | blockHold;
bool flag2 = attack | attackHold | secondaryAttack | secondaryAttackHold;
bool inDodge = __instance.m_inDodge;
float fixedTime = Time.fixedTime;
float num;
float num2;
float num3;
if (!block_state_dict.ContainsKey(hashCode))
{
num = (flag ? fixedTime : (-2f));
num2 = (inDodge ? fixedTime : (-2f));
num3 = (flag2 ? fixedTime : (-1f));
block_state_dict.Add(hashCode, new BlockInputState
{
block_state = flag,
block_start_time = num,
attack_state = flag2,
attack_start_time = num3,
dodge_state = inDodge,
dodge_end_time = num2
});
}
else
{
BlockInputState blockInputState = block_state_dict[hashCode];
num = ((!blockInputState.block_state && flag) ? fixedTime : blockInputState.block_start_time);
num3 = ((!blockInputState.attack_state && flag2) ? fixedTime : blockInputState.attack_start_time);
num2 = ((!inDodge) ? blockInputState.dodge_end_time : fixedTime);
block_state_dict[hashCode] = new BlockInputState
{
block_state = flag,
block_start_time = num,
attack_state = flag2,
attack_start_time = num3,
dodge_state = inDodge,
dodge_end_time = num2
};
}
if ((flag && num > num3) || inDodge || fixedTime - num2 < 0.15f)
{
attack = false;
attackHold = false;
secondaryAttack = false;
secondaryAttackHold = false;
}
else if (last_attack_cancel_dict.ContainsKey(hashCode) && !(Time.fixedTime - last_attack_cancel_dict[hashCode].time >= 0.1f))
{
attack = false;
attackHold = false;
secondaryAttack = false;
secondaryAttackHold = false;
}
}
}
}
private static Dictionary<int, AttackCancel> last_attack_cancel_dict = new Dictionary<int, AttackCancel>();
private static Dictionary<int, BlockInputState> block_state_dict = new Dictionary<int, BlockInputState>();
private static Dictionary<int, int> player_attack_damage_done_dict = new Dictionary<int, int>();
}
[HarmonyPatch(typeof(Skills), "LowerAllSkills")]
public class DeathPenaltyPatch
{
public static bool Prefix(ref Skills __instance, ref float factor)
{
if (!ThisPlugin.PluginEnabled.Value || (Object)(object)__instance == (Object)null)
{
return true;
}
factor *= ThisPlugin.DeathPenaltyMultiplier.Value;
foreach (KeyValuePair<SkillType, Skill> skillDatum in __instance.m_skillData)
{
if ((double)factor >= 0.01)
{
float num = skillDatum.Value.m_level * factor;
Skill value = skillDatum.Value;
value.m_level -= num;
}
if (ThisPlugin.EnableSkillLevelProgressLoss.Value)
{
skillDatum.Value.m_accumulator = 0f;
}
}
((Character)__instance.m_player).Message((MessageType)1, "$msg_skills_lowered", 0, (Sprite)null);
return false;
}
}
[HarmonyPatch(typeof(SpawnArea), "GetLevelUpChance")]
public class SpawnAreaLevelUpChancePatch
{
public static void Postfix(ref SpawnArea __instance, ref float __result)
{
if (ThisPlugin.PluginEnabled.Value && !((Object)(object)__instance == (Object)null))
{
__result *= ThisPlugin.EnemyLevelChanceMultiplier.Value;
}
}
}
[HarmonyPatch(typeof(SpawnSystem), "GetLevelUpChance", new Type[] { typeof(float) })]
public class SpawnSystemLevelUpChancePatch
{
public static void Postfix(ref float __result)
{
if (ThisPlugin.PluginEnabled.Value)
{
__result *= ThisPlugin.EnemyLevelChanceMultiplier.Value;
}
}
}
[HarmonyPatch(typeof(TriggerSpawner), "Awake")]
public class TriggerSpawnerLevelUpChancePatch
{
public static void Postfix(ref TriggerSpawner __instance)
{
if (ThisPlugin.PluginEnabled.Value && !((Object)(object)__instance == (Object)null))
{
TriggerSpawner obj = __instance;
obj.m_levelupChance *= ThisPlugin.EnemyLevelChanceMultiplier.Value;
}
}
}
[HarmonyPatch(typeof(Character), "SetMaxHealth")]
public class MaxHealthPatch
{
public static void Prefix(Character __instance, ref float health)
{
if (!ThisPlugin.PluginEnabled.Value || (Object)(object)__instance == (Object)null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (__instance.IsBoss() && Player.GetAllPlayers().Count > ThisPlugin.NumberOfPlayersMax.Value))
{
return;
}
string text = __instance.m_name.ToLower();
if (text.StartsWith("$enemy_"))
{
text = text.Substring("$enemy_".Length);
}
ConfigEntry<int> target;
if (!ThisPlugin.MaxHealthPercentDict.TryGetValue(text, out var value))
{
if (ThisPlugin.DebugOutput.Value && text != "human")
{
Debug.Log((object)("Casualheim | !!! unmatched enemy normal max health " + text + " :: " + health));
}
}
else if (value.TryGetTarget(out target))
{
health *= (float)target.Value / 100f;
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)("Casualheim.MaxHealthPatch :: " + text + " :: " + health));
}
}
}
}
[BepInPlugin("Casualheim", "Casualheim", "0.2.0")]
[BepInProcess("valheim.exe")]
public class ThisPlugin : BaseUnityPlugin
{
public const string PluginName = "Casualheim";
public const string PluginAuthor = "k-Knight";
public const string PluginVersion = "0.2.0";
public const string PluginGUID = "Casualheim";
public static ConfigEntry<bool> PluginEnabled;
public static ConfigEntry<bool> DebugOutput;
public static ConfigEntry<int> NumberOfPlayersMax;
public static ConfigEntry<bool> AllowClearedBuilding;
public static ConfigEntry<bool> EasierSkillCurveEnabled;
public static ConfigEntry<float> RequiredExpMultiplier;
public static ConfigEntry<float> DeathPenaltyMultiplier;
public static ConfigEntry<bool> EnableSkillLevelProgressLoss;
public static ConfigEntry<float> EnemyLevelChanceMultiplier;
public static ConfigEntry<int> PercentAttackMovement;
public static ConfigEntry<int> PercentAttackRotation;
public static ConfigEntry<int> PercentCharredTwitcher;
public static ConfigEntry<int> PercentCharredArcher;
public static ConfigEntry<int> PercentCharredMelee;
public static ConfigEntry<int> PercentCharredMage;
public static ConfigEntry<int> PercentCharredTwitcherSummoned;
public static ConfigEntry<int> PercentFallenValkyrie;
public static ConfigEntry<int> PercentBonemawSerpent;
public static ConfigEntry<int> PercentMorgen;
public static ConfigEntry<int> PercentVolture;
public static ConfigEntry<int> PercentPieceCharredBalista;
public static ConfigEntry<int> PercentBlobLava;
public static ConfigEntry<int> PercentDvergerAshlands;
public static ConfigEntry<int> RegenerationMultiplier;
public static ConfigEntry<int> PercentRegenEikthyr;
public static ConfigEntry<int> PercentRegenElder;
public static ConfigEntry<int> PercentRegenBonemass;
public static ConfigEntry<int> PercentRegenModer;
public static ConfigEntry<int> PercentRegenYagluth;
public static ConfigEntry<int> PercentRegenQueen;
public static ConfigEntry<int> PercentRegenFader;
public static ConfigEntry<int> PercentHealthEikthyr;
public static ConfigEntry<int> PercentHealthElder;
public static ConfigEntry<int> PercentHealthBonemass;
public static ConfigEntry<int> PercentHealthModer;
public static ConfigEntry<int> PercentHealthYagluth;
public static ConfigEntry<int> PercentHealthQueen;
public static ConfigEntry<int> PercentHealthFader;
public static Dictionary<string, WeakReference<ConfigEntry<int>>> MaxHealthPercentDict = new Dictionary<string, WeakReference<ConfigEntry<int>>>();
public static Dictionary<string, WeakReference<ConfigEntry<int>>> HealthRegenPercentDict = new Dictionary<string, WeakReference<ConfigEntry<int>>>();
private static ThisPlugin thisInstance;
public static ThisPlugin instance => thisInstance;
public void Awake()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
thisInstance = this;
MaxHealthDictsInit();
LoadSettings();
if (PluginEnabled.Value)
{
new Harmony("Casualheim").PatchAll();
}
if (DebugOutput.Value)
{
DumpConfiguration();
}
}
public void OnDestroy()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
new Harmony("Casualheim").UnpatchSelf();
}
public static void MaxHealthDictsInit()
{
MaxHealthPercentDict.Add("charred_twitcher", new WeakReference<ConfigEntry<int>>(PercentCharredTwitcher));
MaxHealthPercentDict.Add("charred_archer", new WeakReference<ConfigEntry<int>>(PercentCharredArcher));
MaxHealthPercentDict.Add("charred_melee", new WeakReference<ConfigEntry<int>>(PercentCharredMelee));
MaxHealthPercentDict.Add("charred_mage", new WeakReference<ConfigEntry<int>>(PercentCharredMage));
MaxHealthPercentDict.Add("charred_twitcher_summoned", new WeakReference<ConfigEntry<int>>(PercentCharredTwitcherSummoned));
MaxHealthPercentDict.Add("fallenvalkyrie", new WeakReference<ConfigEntry<int>>(PercentFallenValkyrie));
MaxHealthPercentDict.Add("bonemawserpent", new WeakReference<ConfigEntry<int>>(PercentBonemawSerpent));
MaxHealthPercentDict.Add("morgen", new WeakReference<ConfigEntry<int>>(PercentMorgen));
MaxHealthPercentDict.Add("volture", new WeakReference<ConfigEntry<int>>(PercentVolture));
MaxHealthPercentDict.Add("piece_charred_balista", new WeakReference<ConfigEntry<int>>(PercentPieceCharredBalista));
MaxHealthPercentDict.Add("bloblava", new WeakReference<ConfigEntry<int>>(PercentBlobLava));
MaxHealthPercentDict.Add("dvergerashlands", new WeakReference<ConfigEntry<int>>(PercentDvergerAshlands));
MaxHealthPercentDict.Add("eikthyr", new WeakReference<ConfigEntry<int>>(PercentHealthEikthyr));
MaxHealthPercentDict.Add("gdking", new WeakReference<ConfigEntry<int>>(PercentHealthElder));
MaxHealthPercentDict.Add("bonemass", new WeakReference<ConfigEntry<int>>(PercentHealthBonemass));
MaxHealthPercentDict.Add("dragon", new WeakReference<ConfigEntry<int>>(PercentHealthModer));
MaxHealthPercentDict.Add("goblinking", new WeakReference<ConfigEntry<int>>(PercentHealthYagluth));
MaxHealthPercentDict.Add("seekerqueen", new WeakReference<ConfigEntry<int>>(PercentHealthQueen));
MaxHealthPercentDict.Add("fader", new WeakReference<ConfigEntry<int>>(PercentHealthFader));
HealthRegenPercentDict.Add("eikthyr", new WeakReference<ConfigEntry<int>>(PercentRegenEikthyr));
HealthRegenPercentDict.Add("gdking", new WeakReference<ConfigEntry<int>>(PercentRegenElder));
HealthRegenPercentDict.Add("bonemass", new WeakReference<ConfigEntry<int>>(PercentRegenBonemass));
HealthRegenPercentDict.Add("dragon", new WeakReference<ConfigEntry<int>>(PercentRegenModer));
HealthRegenPercentDict.Add("goblinking", new WeakReference<ConfigEntry<int>>(PercentRegenYagluth));
HealthRegenPercentDict.Add("seekerqueen", new WeakReference<ConfigEntry<int>>(PercentRegenQueen));
HealthRegenPercentDict.Add("fader", new WeakReference<ConfigEntry<int>>(PercentRegenFader));
}
public static void LoadSettings()
{
PluginEnabled = ((BaseUnityPlugin)instance).Config.Bind<bool>("General", "Enabled", true, "Enable/disable this pulgin.");
DebugOutput = ((BaseUnityPlugin)instance).Config.Bind<bool>("General", "Debug", false, "Enable/disable debug logging.");
NumberOfPlayersMax = ((BaseUnityPlugin)instance).Config.Bind<int>("General", "NumberOfPlayersMax", 4, "Maximum number of active players to modify boss health and regen.");
EnemyLevelChanceMultiplier = ((BaseUnityPlugin)instance).Config.Bind<float>("General", "EnemyLevelChanceMultiplier", 3f, "My how much the chance of leveling up enemy (stars) is multiplied.");
AllowClearedBuilding = ((BaseUnityPlugin)instance).Config.Bind<bool>("General", "AllowClearedDungeonBuilding", true, "Allow building in dungeons/locations when all enemies are dead. May require a new world (kinda).");
EasierSkillCurveEnabled = ((BaseUnityPlugin)instance).Config.Bind<bool>("Skills", "EasierSkillCurveEnabled", true, "Whether to enable easier skill curve.");
RequiredExpMultiplier = ((BaseUnityPlugin)instance).Config.Bind<float>("Skills", "RequiredExpMultiplier", 1f, "This changes the speed of arithmetic progression in required experience to reach next skill level.");
DeathPenaltyMultiplier = ((BaseUnityPlugin)instance).Config.Bind<float>("Skills", "DeathPenaltyMultiplier", 0f, "This changes the amount of skill loss by multiplying it with this value.");
EnableSkillLevelProgressLoss = ((BaseUnityPlugin)instance).Config.Bind<bool>("Skills", "EnableSkillLevelProgressLoss", false, "Whether to reset the accumulated experience on the current skill level.");
PercentAttackMovement = ((BaseUnityPlugin)instance).Config.Bind<int>("Attacks", "PercentAttackMovementSpeed", 20, "Percent of normal movement speed that remains while attacking.");
PercentAttackRotation = ((BaseUnityPlugin)instance).Config.Bind<int>("Attacks", "PercentAttackRotationSpeed", 20, "Percent of normal rotation speed that remains while attacking.");
PercentCharredTwitcher = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentCharredTwitcherHealth", 100, "Percent of normal health that Charred Twitcher will have.");
PercentCharredArcher = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentCharredArcherHealth", 100, "Percent of normal health that Charred Marksman will have.");
PercentCharredMelee = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentCharredMeleeHealth", 66, "Percent of normal health that Charred Warrior will have.");
PercentCharredMage = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentCharredMageHealth", 66, "Percent of normal health that Charred Warlock will have.");
PercentCharredTwitcherSummoned = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentCharredTwitcherSummonedHealth", 100, "Percent of normal health that Summoned Twitcher will have.");
PercentFallenValkyrie = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentFallenValkyrieHealth", 50, "Percent of normal health that Fallen Valkyrie will have.");
PercentBonemawSerpent = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentBonemawSerpentHealth", 50, "Percent of normal health that Bonemaw Serpent will have.");
PercentMorgen = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentMorgenHealth", 50, "Percent of normal health that Morgen will have.");
PercentVolture = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentVoltureHealth", 100, "Percent of normal health that Volture will have.");
PercentPieceCharredBalista = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentPieceCharredBalistaHealth", 100, "Percent of normal health that Skugg will have.");
PercentBlobLava = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentBlobLavaHealth", 100, "Percent of normal health that Lava Blob will have.");
PercentDvergerAshlands = ((BaseUnityPlugin)instance).Config.Bind<int>("MobHealth", "PercentDvergerAshlandsHealth", 100, "Percent of normal health that Ashlands Dvergr will have.");
PercentRegenEikthyr = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentRegenEikthyr", 0, "Percent of normal Eikthyr health regen.");
PercentRegenElder = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentRegenElder", 0, "Percent of normal Elder health regen.");
PercentRegenBonemass = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentRegenBonemass", 0, "Percent of normal Bonemass health regen.");
PercentRegenModer = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentRegenModer", 0, "Percent of normal Moder health regen.");
PercentRegenYagluth = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentRegenYagluth", 0, "Percent of normal Yagluth health regen.");
PercentRegenQueen = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentRegenQueen", 0, "Percent of normal Queen health regen.");
PercentRegenFader = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentRegenFader", 0, "Percent of normal Fader health regen.");
PercentHealthEikthyr = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentHealthEikthyr", 150, "Percent of normal Eikthyr max health.");
PercentHealthElder = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentHealthElder", 100, "Percent of normal Elder max health.");
PercentHealthBonemass = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentHealthBonemass", 100, "Percent of normal Bonemass max health.");
PercentHealthModer = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentHealthModer", 100, "Percent of normal Moder max health.");
PercentHealthYagluth = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentHealthYagluth", 100, "Percent of normal Yagluth max health.");
PercentHealthQueen = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentHealthQueen", 100, "Percent of normal Queen max health.");
PercentHealthFader = ((BaseUnityPlugin)instance).Config.Bind<int>("Boss Health", "PercentHealthFader", 60, "Percent of normal Fader max health.");
}
public static void DumpConfiguration()
{
Debug.Log((object)"------------ Casualheim CFG START ------------");
if ((Object)(object)ZNet.instance != (Object)null)
{
Debug.Log((object)("Casualheim,IsServer," + ZNet.instance.IsServer()));
}
Debug.Log((object)("Casualheim.GetAllPlayers," + Player.GetAllPlayers().Count));
Debug.Log((object)("Casualheim.NumberOfPlayersMax," + NumberOfPlayersMax.Value));
Debug.Log((object)("Casualheim.AllowClearedBuilding," + AllowClearedBuilding.Value));
Debug.Log((object)("Casualheim.EasierSkillCurveEnabled," + EasierSkillCurveEnabled.Value));
Debug.Log((object)("Casualheim.RequiredExpMultiplier," + RequiredExpMultiplier.Value));
Debug.Log((object)("Casualheim.DeathPenaltyMultiplier," + DeathPenaltyMultiplier.Value));
Debug.Log((object)("Casualheim.EnableSkillLevelProgressLoss," + EnableSkillLevelProgressLoss.Value));
Debug.Log((object)("Casualheim.PercentAttackMovement," + PercentAttackMovement.Value));
Debug.Log((object)("Casualheim.PercentAttackRotation," + PercentAttackRotation.Value));
Debug.Log((object)("Casualheim.PercentCharredTwitcher," + PercentCharredTwitcher.Value));
Debug.Log((object)("Casualheim.PercentCharredArcher," + PercentCharredArcher.Value));
Debug.Log((object)("Casualheim.PercentCharredMelee," + PercentCharredMelee.Value));
Debug.Log((object)("Casualheim.PercentCharredMage," + PercentCharredMage.Value));
Debug.Log((object)("Casualheim.PercentCharredTwitcherSummoned," + PercentCharredTwitcherSummoned.Value));
Debug.Log((object)("Casualheim.PercentFallenValkyrie," + PercentFallenValkyrie.Value));
Debug.Log((object)("Casualheim.PercentBonemawSerpent," + PercentBonemawSerpent.Value));
Debug.Log((object)("Casualheim.PercentMorgen," + PercentMorgen.Value));
Debug.Log((object)("Casualheim.PercentVolture," + PercentVolture.Value));
Debug.Log((object)("Casualheim.PercentPieceCharredBalista," + PercentPieceCharredBalista.Value));
Debug.Log((object)("Casualheim.PercentBlobLava," + PercentBlobLava.Value));
Debug.Log((object)("Casualheim.PercentDvergerAshlands," + PercentDvergerAshlands.Value));
Debug.Log((object)("Casualheim.PercentRegenEikthyr," + PercentRegenEikthyr.Value));
Debug.Log((object)("Casualheim.PercentRegenElder," + PercentRegenElder.Value));
Debug.Log((object)("Casualheim.PercentRegenBonemass," + PercentRegenBonemass.Value));
Debug.Log((object)("Casualheim.PercentRegenModer," + PercentRegenModer.Value));
Debug.Log((object)("Casualheim.PercentRegenYagluth," + PercentRegenYagluth.Value));
Debug.Log((object)("Casualheim.PercentRegenQueen," + PercentRegenQueen.Value));
Debug.Log((object)("Casualheim.PercentRegenFader," + PercentRegenFader.Value));
Debug.Log((object)("Casualheim.PercentHealthEikthyr," + PercentHealthEikthyr.Value));
Debug.Log((object)("Casualheim.PercentHealthElder," + PercentHealthElder.Value));
Debug.Log((object)("Casualheim.PercentHealthBonemass," + PercentHealthBonemass.Value));
Debug.Log((object)("Casualheim.PercentHealthModer," + PercentHealthModer.Value));
Debug.Log((object)("Casualheim.PercentHealthYagluth," + PercentHealthYagluth.Value));
Debug.Log((object)("Casualheim.PercentHealthQueen," + PercentHealthQueen.Value));
Debug.Log((object)("Casualheim.PercentHealthFader," + PercentHealthFader.Value));
Debug.Log((object)"------------- Casualheim CFG END -------------");
}
}
[HarmonyPatch(typeof(Skill), "GetNextLevelRequirement")]
public class SkillCurvePatch
{
public static bool Prefix(Skill __instance, ref float __result)
{
if (!ThisPlugin.PluginEnabled.Value || !ThisPlugin.EasierSkillCurveEnabled.Value || __instance == null)
{
return true;
}
__result = Mathf.Floor(__instance.m_level + 1f) * ThisPlugin.RequiredExpMultiplier.Value;
return false;
}
}
[HarmonyPatch(typeof(Character), "Heal")]
public class RegenPatch
{
public static void Prefix(Character __instance, ref float hp)
{
if (!ThisPlugin.PluginEnabled.Value || (Object)(object)__instance == (Object)null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (__instance.IsBoss() && Player.GetAllPlayers().Count > ThisPlugin.NumberOfPlayersMax.Value))
{
return;
}
string text = __instance.m_name.ToLower();
if (text.StartsWith("$enemy_"))
{
text = text.Substring("$enemy_".Length);
}
if (ThisPlugin.HealthRegenPercentDict.TryGetValue(text, out var value) && value.TryGetTarget(out var target))
{
hp *= (float)target.Value / 100f;
if (ThisPlugin.DebugOutput.Value)
{
Debug.Log((object)("Casualheim.RegenPatch :: " + text + " :: " + __instance.GetHealth() + " / " + __instance.GetMaxHealth() + "(+" + hp + ")"));
}
}
}
}
[HarmonyPatch(typeof(Humanoid), "GetAttackSpeedFactorMovement")]
public class AttackMovementSpeedPatch
{
public static void Postfix(Humanoid __instance, ref float __result)
{
if (ThisPlugin.PluginEnabled.Value && !((Object)(object)__instance == (Object)null) && __result < 0.99f && ((object)__instance).GetType() == typeof(Player) && ThisPlugin.PluginEnabled.Value)
{
__result = (float)ThisPlugin.PercentAttackMovement.Value / 100f;
}
}
}
[HarmonyPatch(typeof(Humanoid), "GetAttackSpeedFactorRotation")]
public class AttackRotationSpeedPatch
{
public static void Postfix(Humanoid __instance, ref float __result)
{
if (ThisPlugin.PluginEnabled.Value && !((Object)(object)__instance == (Object)null) && __result < 0.99f && ((object)__instance).GetType() == typeof(Player) && ThisPlugin.PluginEnabled.Value)
{
__result = (float)ThisPlugin.PercentAttackRotation.Value / 100f;
}
}
}
