using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("TumbleLaunchRebalance")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+81904c0ac01d4a594d11d7cc2df73b2e9a0eb3e6")]
[assembly: AssemblyProduct("My first plugin")]
[assembly: AssemblyTitle("TumbleLaunchRebalance")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace TumbleLaunchRebalance
{
[BepInPlugin("TumbleLaunchRebalance", "My first plugin", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
private static bool _patchFailed;
private static ConfigEntry<int> _configTumbleDamageOnHitEnemy;
private static ConfigEntry<int> _configTumbleUpgradesNeededForMaxReduction;
private static ConfigEntry<float> _configTumbleUpgradeMaxDamageReduction;
internal static ManualLogSource Logger;
private void LoadConfig()
{
_configTumbleDamageOnHitEnemy = ((BaseUnityPlugin)this).Config.Bind<int>("Balance", "TumbleDamageOnHitEnemy", 0, "The amount of damage the player is dealt when hitting an enemy while tumbling.");
_configTumbleUpgradesNeededForMaxReduction = ((BaseUnityPlugin)this).Config.Bind<int>("Balance", "TumbleUpgradesNeededForMaxReduction", 8, "The number of Tumble Launch upgrades the player needs to reach the max damage reduction. E.g. 5 means the player will reach maximum tumble damage reduction on their 5th upgrade.");
_configTumbleUpgradeMaxDamageReduction = ((BaseUnityPlugin)this).Config.Bind<float>("Balance", "MaxDamageReduction", 1f, "The maximum reduction to damage (while tumbling) that can be attained. E.g. 0.75 means the player can reach 75% reduction in damage, in which 100 damage would become -> 25.");
}
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Logger.LogInfo((object)"Plugin TumbleLaunchRebalance is loading...");
LoadConfig();
Harmony val = Harmony.CreateAndPatchAll(typeof(Plugin), (string)null);
if (_patchFailed)
{
Logger.LogFatal((object)"Failure to patch, reverting!");
Harmony.UnpatchID(val.Id);
}
else
{
Logger.LogInfo((object)"Plugin TumbleLaunchRebalance loaded!");
}
}
[HarmonyPatch(typeof(PlayerTumble), "HitEnemy")]
[HarmonyTranspiler]
public static IEnumerable<CodeInstruction> PatchTumbleDamage(IEnumerable<CodeInstruction> instructions)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Expected O, but got Unknown
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Expected O, but got Unknown
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Expected O, but got Unknown
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Expected O, but got Unknown
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Expected O, but got Unknown
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Expected O, but got Unknown
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Expected O, but got Unknown
try
{
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[4]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_I4_5, (object)null, (string)null)
});
if (!val.IsValid)
{
Logger.LogFatal((object)"Failed to find patch location for first HitEnemy, reverting!");
_patchFailed = true;
return instructions;
}
val.Set(OpCodes.Ldc_I4, (object)_configTumbleDamageOnHitEnemy.Value);
val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[4]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_I4_5, (object)null, (string)null)
});
if (!val.IsValid)
{
Logger.LogFatal((object)"Failed to find patch location for second HitEnemy, reverting!");
_patchFailed = true;
return instructions;
}
val.Set(OpCodes.Ldc_I4, (object)_configTumbleDamageOnHitEnemy.Value);
return val.InstructionEnumeration();
}
catch (Exception ex)
{
Logger.LogFatal((object)("Exception caught while patching HitEnemy, reverting! Message: " + ex.Message));
_patchFailed = true;
return instructions;
}
}
[HarmonyPatch(typeof(PlayerTumble), "BreakImpact")]
[HarmonyTranspiler]
public static IEnumerable<CodeInstruction> PatchTumbleDamageReduction(IEnumerable<CodeInstruction> instructions)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Expected O, but got Unknown
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Expected O, but got Unknown
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Expected O, but got Unknown
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Expected O, but got Unknown
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Expected O, but got Unknown
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Expected O, but got Unknown
try
{
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[5]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerTumble), "playerAvatar"), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerAvatar), "playerHealth"), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerTumble), "impactHurtDamage"), (string)null)
});
val.Advance(1);
if (!val.IsValid)
{
Logger.LogFatal((object)"Failed to find patch location for Damage Reduction Patch, reverting!");
_patchFailed = true;
return instructions;
}
val.Advance(1);
val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Ldarg_0, (object)null)
});
val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "CalculateTumbleDamage", (Type[])null, (Type[])null))
});
val.Start();
return val.InstructionEnumeration();
}
catch (Exception ex)
{
Logger.LogFatal((object)("Exception caught while patching BreakImpact, reverting! Message: " + ex.Message));
_patchFailed = true;
return instructions;
}
}
public static int CalculateTumbleDamage(int damage, PlayerTumble tumble)
{
try
{
if (_configTumbleUpgradesNeededForMaxReduction.Value == 0)
{
return (int)(1f - _configTumbleUpgradeMaxDamageReduction.Value) * damage;
}
int num = StatsManager.instance.playerUpgradeLaunch[SemiFunc.PlayerGetSteamID(tumble.playerAvatar)];
float num2 = 1f - _configTumbleUpgradeMaxDamageReduction.Value * (float)Math.Min(num / _configTumbleUpgradesNeededForMaxReduction.Value, 1);
return (int)num2 * damage;
}
catch (Exception ex)
{
Logger.LogFatal((object)("Exception thrown while calculating tumble damage reduction! Message: " + ex.Message));
return damage;
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "TumbleLaunchRebalance";
public const string PLUGIN_NAME = "My first plugin";
public const string PLUGIN_VERSION = "1.0.0";
}
}
