Decompiled source of MeleeRebalance v1.0.0

plugins/MeleeRebalance.dll

Decompiled 3 days ago
using System;
using System.IO;
using System.Reflection;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;

[assembly: TargetFramework(".NETStandard,Version=v2.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HTF.MeleeRebalance;

[BepInPlugin("htf.melee.rebalance", "Melee Rebalance", "1.0.0")]
public sealed class Plugin : BaseUnityPlugin
{
	private static ManualLogSource log;

	private static int[] knife;

	private static int[] knuckles;

	private static float speedStart;

	private static float speedEnd;

	private static FieldInfo damageField;

	private static FieldInfo costField;

	private static bool knifeLogged;

	private static bool knucklesLogged;

	private static bool skipLogged;

	private static bool ready;

	private void Awake()
	{
		//IL_0232: Unknown result type (might be due to invalid IL or missing references)
		//IL_0238: Expected O, but got Unknown
		log = ((BaseUnityPlugin)this).Logger;
		Harmony val = default(Harmony);
		try
		{
			if (!((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable on next game restart.").Value)
			{
				log.LogInfo((object)"[MELEE] DISABLED in config");
				return;
			}
			SHA256 sHA = SHA256.Create();
			string text = BitConverter.ToString(sHA.ComputeHash(File.ReadAllBytes(typeof(Melee).Assembly.Location))).Replace("-", "");
			((IDisposable)sHA).Dispose();
			if (!(text == "E3EC0BEFACC5269EFDECB279F0AE72155FCDE3EBAEED07E361AA15E6F7FC84B1"))
			{
				log.LogWarning((object)"[MELEE] DISABLED: unsupported game build");
				return;
			}
			if ((object)AccessTools.TypeByName("GiantFishMod.Plugin") != null)
			{
				log.LogWarning((object)"[MELEE] DISABLED: Better How To Fish is loaded");
				return;
			}
			knife = ParseCurve(((BaseUnityPlugin)this).Config.Bind<string>("Knife", "DamageByLevel", "16,19,23,28,36,48,65,85,110,145,190,245,320,410,540,700", "16 comma-separated damage values, levels 0..15.").Value);
			knuckles = ParseCurve(((BaseUnityPlugin)this).Config.Bind<string>("Knuckles", "DamageByLevel", "7,9,12,16,21,28,37,49,63,82,105,135,175,225,280,350", "16 comma-separated damage values, levels 0..15.").Value);
			speedStart = ((BaseUnityPlugin)this).Config.Bind<float>("Knuckles", "SpeedAtLevel0", 1.15f, "Forward and return motion multiplier at level 0.").Value;
			speedEnd = ((BaseUnityPlugin)this).Config.Bind<float>("Knuckles", "SpeedAtLevel15", 1.8f, "Forward and return motion multiplier at level 15.").Value;
			if (knife == null || knuckles == null || !(speedStart >= 1f) || !(speedEnd <= 3f) || !(speedEnd >= speedStart))
			{
				log.LogWarning((object)"[MELEE] DISABLED: invalid damage curve or speed setting");
				return;
			}
			damageField = AccessTools.Field(typeof(SharpnessUpgrade), "_damage");
			costField = AccessTools.Field(typeof(SharpnessUpgrade), "_cost");
			if ((object)damageField == null || (object)costField == null)
			{
				log.LogWarning((object)"[MELEE] DISABLED: missing game fields");
				return;
			}
			val = new Harmony("htf.melee.rebalance");
			val.PatchAll();
			ready = true;
			log.LogInfo((object)"[MELEE] PATCH_OK v1.0.0");
		}
		catch (Exception ex)
		{
			ready = false;
			log.LogError((object)ex);
			if (val != null)
			{
				val.UnpatchSelf();
			}
		}
	}

	public static int[] ParseCurve(string text)
	{
		if (text != null)
		{
			string[] array = text.Split(new char[1] { ',' });
			if (array.Length == 16)
			{
				int[] array2 = new int[16];
				int num = 0;
				int result;
				while (int.TryParse(array[num], out result) && result >= 1 && result <= 100000 && (num == 0 || result >= array2[num - 1]))
				{
					array2[num] = result;
					num++;
					if (num >= 16)
					{
						return array2;
					}
				}
			}
		}
		return null;
	}

	public static bool Matches(SharpnessUpgrade[] items, int[] curve)
	{
		if (items != null && curve != null && items.Length == curve.Length)
		{
			int num = 0;
			while (true)
			{
				if (num < curve.Length)
				{
					if (items[num] == null || items[num].Damage != curve[num])
					{
						break;
					}
					num++;
					continue;
				}
				return true;
			}
		}
		return false;
	}

	public static void Ensure(Melee item, ref SharpnessUpgrade[] upgrades)
	{
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Expected O, but got Unknown
		if (!ready || item == null)
		{
			return;
		}
		int iD = ((Item)item).ID;
		if (iD != 57 && iD != 63)
		{
			return;
		}
		bool usePunchSoundOnHit = item.UsePunchSoundOnHit;
		int[] array = ((!usePunchSoundOnHit) ? knife : knuckles);
		SharpnessUpgrade[] array2 = upgrades;
		if (array2 == null || Matches(array2, array))
		{
			return;
		}
		if (array2.Length == 16 && array2[0] != null && array2[15] != null)
		{
			if (usePunchSoundOnHit)
			{
				if (array2[0].Damage == 5 && array2[15].Damage == 60)
				{
					goto IL_00bd;
				}
			}
			else if (array2[0].Damage == 16 && array2[15].Damage == 120)
			{
				goto IL_00bd;
			}
		}
		goto IL_0170;
		IL_0170:
		if (!skipLogged)
		{
			skipLogged = true;
			log.LogWarning((object)"[MELEE] SKIP unexpected melee upgrade table; incompatible mod or prefab");
		}
		return;
		IL_00bd:
		SharpnessUpgrade[] array3 = (SharpnessUpgrade[])(object)new SharpnessUpgrade[16];
		int num = 0;
		while (array2[num] != null)
		{
			SharpnessUpgrade val = new SharpnessUpgrade();
			damageField.SetValue(val, array[num]);
			costField.SetValue(val, array2[num].Cost);
			array3[num] = val;
			num++;
			if (num < 16)
			{
				continue;
			}
			upgrades = array3;
			if (usePunchSoundOnHit)
			{
				if (!knucklesLogged)
				{
					knucklesLogged = true;
					log.LogInfo((object)"[MELEE] APPLIED Knuckles (damage curve and motion speed; prices unchanged)");
				}
			}
			else if (!knifeLogged)
			{
				knifeLogged = true;
				log.LogInfo((object)"[MELEE] APPLIED Knife (damage curve; prices unchanged)");
			}
			return;
		}
		goto IL_0170;
	}

	public static float Speed(Melee item, SharpnessUpgrade[] upgrades)
	{
		if (ready && item != null)
		{
			int iD = ((Item)item).ID;
			if ((iD == 57 || iD == 63) && item.UsePunchSoundOnHit && Matches(upgrades, knuckles))
			{
				int sharpnessIndex = item.SharpnessIndex;
				if (sharpnessIndex <= 15)
				{
					return speedStart + (speedEnd - speedStart) * ((float)sharpnessIndex / 15f);
				}
			}
		}
		return 1f;
	}
}
[HarmonyPatch(typeof(Melee), "Awake")]
public static class Patch_Awake
{
	public static void Postfix(Melee __instance, ref SharpnessUpgrade[] ____sharpnessUpgrades)
	{
		Plugin.Ensure(__instance, ref ____sharpnessUpgrades);
	}
}
[HarmonyPatch(typeof(Melee), "OnPickUp")]
public static class Patch_OnPickUp
{
	public static void Postfix(Melee __instance, ref SharpnessUpgrade[] ____sharpnessUpgrades)
	{
		Plugin.Ensure(__instance, ref ____sharpnessUpgrades);
	}
}
[HarmonyPatch(typeof(Melee), "GetCurSharpness")]
public static class Patch_GetCurSharpness
{
	public static void Prefix(Melee __instance, ref SharpnessUpgrade[] ____sharpnessUpgrades)
	{
		Plugin.Ensure(__instance, ref ____sharpnessUpgrades);
	}
}
[HarmonyPatch(typeof(Melee), "GetNextSharpnessUpgrade")]
public static class Patch_GetNextSharpnessUpgrade
{
	public static void Prefix(Melee __instance, ref SharpnessUpgrade[] ____sharpnessUpgrades)
	{
		Plugin.Ensure(__instance, ref ____sharpnessUpgrades);
	}
}
[HarmonyPatch(typeof(Melee), "HitTarget")]
public static class Patch_HitTarget
{
	public static void Prefix(Melee __instance, ref SharpnessUpgrade[] ____sharpnessUpgrades)
	{
		Plugin.Ensure(__instance, ref ____sharpnessUpgrades);
	}
}
[HarmonyPatch(typeof(Melee), "MoveAttack")]
public static class Patch_MoveAttack
{
	public static void Prefix(Melee __instance, ref SharpnessUpgrade[] ____sharpnessUpgrades, ref float ____moveForwardSpeed, ref float __state)
	{
		__state = ____moveForwardSpeed;
		Plugin.Ensure(__instance, ref ____sharpnessUpgrades);
		____moveForwardSpeed = __state * Plugin.Speed(__instance, ____sharpnessUpgrades);
	}

	public static void Finalizer(ref float ____moveForwardSpeed, float __state)
	{
		____moveForwardSpeed = __state;
	}
}
[HarmonyPatch(typeof(Melee), "MoveReturn")]
public static class Patch_MoveReturn
{
	public static void Prefix(Melee __instance, ref SharpnessUpgrade[] ____sharpnessUpgrades, ref float ____returnSpeed, ref float __state)
	{
		__state = ____returnSpeed;
		Plugin.Ensure(__instance, ref ____sharpnessUpgrades);
		____returnSpeed = __state * Plugin.Speed(__instance, ____sharpnessUpgrades);
	}

	public static void Finalizer(ref float ____returnSpeed, float __state)
	{
		____returnSpeed = __state;
	}
}