using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.VoidSurvivor.Weapon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using On.RoR2;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Skills;
using RoR2.UI;
using UnityEngine;
using UnityEngine.AddressableAssets;
[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("SupressRework")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+08bbd3a7d90de663ad916caf69871e85548e44b3")]
[assembly: AssemblyProduct("SupressRework")]
[assembly: AssemblyTitle("SupressRework")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace SuppressRework
{
[BepInPlugin("com.renovice.suppressrework", "Suppress Rework", "1.4.2")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class SuppressRework : BaseUnityPlugin
{
public static ConfigEntry<bool> EnableAllOrNothingScaling;
public static ConfigEntry<bool> EnableEfficientTrades;
public static ConfigEntry<float> MaxHealthSacrifice;
public static ConfigEntry<float> FixedTradeValue;
public static ConfigEntry<int> MaxChargesNormalMode;
public static ConfigEntry<int> MaxChargesCorruptedMode;
public static ConfigEntry<bool> InfiniteChargesNormalMode;
public static ConfigEntry<bool> InfiniteChargesCorruptedMode;
internal static SkillDef _crushHealthDef;
internal static SkillDef _crushCorruptionDef;
internal static ManualLogSource Log;
public static SuppressRework Instance { get; private set; }
public void Awake()
{
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Expected O, but got Unknown
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
try
{
EnableAllOrNothingScaling = ((BaseUnityPlugin)this).Config.Bind<bool>("Main", "Enable All-or-Nothing Scaling", false, "If true, the ability consumes your resource bar for a 1:1 reward. If false, it uses a fixed percentage.");
EnableEfficientTrades = ((BaseUnityPlugin)this).Config.Bind<bool>("Main", "Enable Efficient Trades", true, "If true, the ability will not spend more resources than needed to fill the target bar.");
MaxHealthSacrifice = ((BaseUnityPlugin)this).Config.Bind<float>("All-or-Nothing Mode", "Max Health Sacrifice Percent", 50f, "When 'All-or-Nothing' is ON, this is the MAXIMUM percentage of your health you can sacrifice in one go.");
FixedTradeValue = ((BaseUnityPlugin)this).Config.Bind<float>("Fixed Trade Mode", "Fixed Trade Percentage", 35f, "When 'All-or-Nothing' is OFF, this is the percentage of health/corruption that will be traded.");
MaxChargesNormalMode = ((BaseUnityPlugin)this).Config.Bind<int>("Charge Settings", "Max Charges - Suppress", 1, "Maximum charges for the suppress ability (spend corruption to heal in normal mode). No cooldown - you get this many per transformation.");
MaxChargesCorruptedMode = ((BaseUnityPlugin)this).Config.Bind<int>("Charge Settings", "Max Charges - Corrupted Suppress", 2, "Maximum charges for the corrupted suppress ability (sacrifice health for corruption in void mode). No cooldown - you get this many per transformation.");
InfiniteChargesNormalMode = ((BaseUnityPlugin)this).Config.Bind<bool>("Charge Settings", "Infinite Charges - Suppress", true, "If true, suppress ability has infinite charges in normal mode.");
InfiniteChargesCorruptedMode = ((BaseUnityPlugin)this).Config.Bind<bool>("Charge Settings", "Infinite Charges - Corrupted Suppress", false, "If true, corrupted suppress ability has infinite charges in void mode.");
SetupRiskOfOptions();
Harmony val = new Harmony("com.renovice.suppressrework");
val.PatchAll();
SurvivorCatalog.Init += (hook_Init)delegate(orig_Init orig)
{
orig.Invoke();
OnGameLoaded();
};
((BaseUnityPlugin)this).Logger.LogInfo((object)"Suppress Rework v1.4.2 - Performance-Safe Voidfiend Complete Overhaul loaded successfully!");
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogError((object)$"Error in Awake: {arg}");
}
}
private void SetupRiskOfOptions()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Expected O, but got Unknown
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Expected O, but got Unknown
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Expected O, but got Unknown
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Expected O, but got Unknown
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Expected O, but got Unknown
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Expected O, but got Unknown
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Expected O, but got Unknown
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Expected O, but got Unknown
try
{
ModSettingsManager.SetModDescription("A complete overhaul of Voidfiend's Suppress ability with customizable trading mechanics, charge systems, and dynamic tooltips.");
SetModIcon();
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(EnableAllOrNothingScaling));
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(EnableEfficientTrades));
ModSettingsManager.AddOption((BaseOption)new SliderOption(MaxHealthSacrifice, new SliderConfig
{
min = 1f,
max = 100f,
FormatString = "{0:0}%"
}));
ModSettingsManager.AddOption((BaseOption)new SliderOption(FixedTradeValue, new SliderConfig
{
min = 1f,
max = 100f,
FormatString = "{0:0}%"
}));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(MaxChargesNormalMode, new IntSliderConfig
{
min = 0,
max = 20
}));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(MaxChargesCorruptedMode, new IntSliderConfig
{
min = 0,
max = 20
}));
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(InfiniteChargesNormalMode));
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(InfiniteChargesCorruptedMode));
EnableAllOrNothingScaling.SettingChanged += delegate
{
OnSettingChanged();
};
EnableEfficientTrades.SettingChanged += delegate
{
OnSettingChanged();
};
MaxHealthSacrifice.SettingChanged += delegate
{
OnSettingChanged();
};
FixedTradeValue.SettingChanged += delegate
{
OnSettingChanged();
};
MaxChargesNormalMode.SettingChanged += delegate
{
OnSettingChanged();
};
MaxChargesCorruptedMode.SettingChanged += delegate
{
OnSettingChanged();
};
InfiniteChargesNormalMode.SettingChanged += delegate
{
OnSettingChanged();
};
InfiniteChargesCorruptedMode.SettingChanged += delegate
{
OnSettingChanged();
};
}
catch (Exception arg)
{
Log.LogError((object)$"Error setting up Risk of Options: {arg}");
}
}
private void SetModIcon()
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
try
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
using Stream stream = executingAssembly.GetManifestResourceStream("V8_supressrework.icon.png");
if (stream != null)
{
byte[] array = new byte[stream.Length];
stream.Read(array, 0, array.Length);
Texture2D val = new Texture2D(2, 2);
ImageConversion.LoadImage(val, array);
Sprite modIcon = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
ModSettingsManager.SetModIcon(modIcon);
Log.LogInfo((object)"Mod icon set successfully");
}
}
catch (Exception arg)
{
Log.LogError((object)$"Failed to set mod icon: {arg}");
}
}
private void OnSettingChanged()
{
try
{
ModifySkillDefs();
TooltipRefresher.RefreshTooltipsAfterSettingsChange();
Log.LogInfo((object)"Settings changed - skill descriptions should update dynamically");
}
catch (Exception arg)
{
Log.LogError((object)$"Error in OnSettingChanged: {arg}");
}
}
private void OnGameLoaded()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
try
{
_crushHealthDef = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/DLC1/VoidSurvivor/CrushHealth.asset").WaitForCompletion();
_crushCorruptionDef = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/DLC1/VoidSurvivor/CrushCorruption.asset").WaitForCompletion();
if ((Object)(object)_crushHealthDef != (Object)null)
{
Log.LogInfo((object)("CrushHealth loaded successfully. Token: " + _crushHealthDef.skillDescriptionToken));
}
else
{
Log.LogError((object)"Failed to load CrushHealth skill definition");
}
if ((Object)(object)_crushCorruptionDef != (Object)null)
{
Log.LogInfo((object)("CrushCorruption loaded successfully. Token: " + _crushCorruptionDef.skillDescriptionToken));
}
else
{
Log.LogError((object)"Failed to load CrushCorruption skill definition");
}
ModifySkillDefs();
}
catch (Exception arg)
{
Log.LogError((object)$"Error in OnGameLoaded: {arg}");
}
}
public void ModifySkillDefs()
{
try
{
if ((Object)(object)_crushHealthDef != (Object)null)
{
if (InfiniteChargesCorruptedMode.Value)
{
_crushHealthDef.baseMaxStock = 1;
_crushHealthDef.rechargeStock = 1;
_crushHealthDef.baseRechargeInterval = 0f;
Log.LogInfo((object)"Corrupted Suppress: Infinite charges enabled (instant recharge)");
}
else
{
_crushHealthDef.baseMaxStock = MaxChargesCorruptedMode.Value;
_crushHealthDef.rechargeStock = 0;
_crushHealthDef.baseRechargeInterval = 0f;
Log.LogInfo((object)$"Corrupted Suppress: {MaxChargesCorruptedMode.Value} charges, no recharge");
}
}
if (!((Object)(object)_crushCorruptionDef != (Object)null))
{
return;
}
if (InfiniteChargesNormalMode.Value)
{
_crushCorruptionDef.baseMaxStock = 1;
_crushCorruptionDef.rechargeStock = 1;
_crushCorruptionDef.baseRechargeInterval = 0f;
Log.LogInfo((object)"Suppress: Infinite charges enabled (instant recharge)");
}
else
{
_crushCorruptionDef.baseMaxStock = MaxChargesNormalMode.Value;
_crushCorruptionDef.rechargeStock = 0;
_crushCorruptionDef.baseRechargeInterval = 0f;
Log.LogInfo((object)$"Suppress: {MaxChargesNormalMode.Value} charges, no recharge");
}
if (((object)_crushCorruptionDef).GetType().Name == "VoidSurvivorSkillDef")
{
FieldInfo field = ((object)_crushCorruptionDef).GetType().GetField("minimumCorruption");
FieldInfo field2 = ((object)_crushCorruptionDef).GetType().GetField("maximumCorruption");
if (field != null)
{
field.SetValue(_crushCorruptionDef, 0.1f);
Log.LogInfo((object)"Set CrushCorruption minimumCorruption to: 0.1");
}
if (field2 != null)
{
field2.SetValue(_crushCorruptionDef, 100f);
Log.LogInfo((object)"Set CrushCorruption maximumCorruption to: 100");
}
}
}
catch (Exception arg)
{
Log.LogError((object)$"Error in ModifySkillDefs: {arg}");
}
}
}
[HarmonyPatch(typeof(CrushBase), "OnEnter")]
public static class CrushBase_OnEnter_Patch
{
private static bool Prefix(CrushBase __instance)
{
try
{
CharacterBody characterBody = ((EntityState)__instance).characterBody;
if ((Object)(object)characterBody == (Object)null)
{
return true;
}
if (!SuppressRework.EnableAllOrNothingScaling.Value)
{
float value = SuppressRework.FixedTradeValue.Value;
if (__instance is CrushHealth)
{
HealthComponent healthComponent = characterBody.healthComponent;
if ((Object)(object)healthComponent != (Object)null && healthComponent.fullHealth > 0f)
{
float num = healthComponent.health / healthComponent.fullHealth * 100f;
if (num < value)
{
ManualLogSource log = SuppressRework.Log;
if (log != null)
{
log.LogWarning((object)$"BLOCKED CrushHealth execution: {num:F1}% < {value}% required");
}
((EntityState)__instance).outer.SetNextStateToMain();
return false;
}
}
}
else if (__instance is CrushCorruption)
{
VoidSurvivorController component = ((Component)characterBody).GetComponent<VoidSurvivorController>();
if ((Object)(object)component != (Object)null)
{
float corruption = component.corruption;
if (corruption < value)
{
ManualLogSource log2 = SuppressRework.Log;
if (log2 != null)
{
log2.LogWarning((object)$"BLOCKED CrushCorruption execution: {corruption:F1}% < {value}% required");
}
((EntityState)__instance).outer.SetNextStateToMain();
return false;
}
}
}
}
float num2 = 0f;
float num3 = 0f;
if (SuppressRework.EnableAllOrNothingScaling.Value)
{
if (__instance is CrushHealth)
{
HealthComponent healthComponent2 = characterBody.healthComponent;
if ((Object)(object)healthComponent2 == (Object)null || healthComponent2.fullHealth <= 0f)
{
ManualLogSource log3 = SuppressRework.Log;
if (log3 != null)
{
log3.LogWarning((object)"CrushHealth: No health component, aborting");
}
((EntityState)__instance).outer.SetNextStateToMain();
return false;
}
float num4 = healthComponent2.health - 1f;
if (num4 <= 0f)
{
ManualLogSource log4 = SuppressRework.Log;
if (log4 != null)
{
log4.LogWarning((object)$"CrushHealth: Insufficient health to sacrifice. Current: {healthComponent2.health:F1}, need at least 2 HP");
}
((EntityState)__instance).outer.SetNextStateToMain();
return false;
}
float val = healthComponent2.fullHealth * (SuppressRework.MaxHealthSacrifice.Value / 100f);
float num5 = Math.Min(num4, val);
if (num5 <= 0.1f)
{
ManualLogSource log5 = SuppressRework.Log;
if (log5 != null)
{
log5.LogWarning((object)$"CrushHealth: Health sacrifice too small ({num5:F2} HP), aborting");
}
((EntityState)__instance).outer.SetNextStateToMain();
return false;
}
float num6 = num5 / healthComponent2.fullHealth;
num2 = 0f - num6;
num3 = num6 * 100f;
ManualLogSource log6 = SuppressRework.Log;
if (log6 != null)
{
log6.LogInfo((object)$"CrushHealth All-or-Nothing: Sacrificing {num5:F1} HP ({num6 * 100f:F1}%) for {num3:F1}% corruption");
}
}
else if (__instance is CrushCorruption)
{
VoidSurvivorController component2 = ((Component)characterBody).GetComponent<VoidSurvivorController>();
if ((Object)(object)component2 == (Object)null)
{
ManualLogSource log7 = SuppressRework.Log;
if (log7 != null)
{
log7.LogWarning((object)"CrushCorruption: No void survivor controller, aborting");
}
((EntityState)__instance).outer.SetNextStateToMain();
return false;
}
float corruption2 = component2.corruption;
if (corruption2 <= 0.1f)
{
ManualLogSource log8 = SuppressRework.Log;
if (log8 != null)
{
log8.LogWarning((object)$"CrushCorruption: Insufficient corruption to spend ({corruption2:F1}%), aborting");
}
((EntityState)__instance).outer.SetNextStateToMain();
return false;
}
float num7 = corruption2 / 100f;
num2 = num7;
num3 = 0f - corruption2;
ManualLogSource log9 = SuppressRework.Log;
if (log9 != null)
{
log9.LogInfo((object)$"CrushCorruption All-or-Nothing: Spending {corruption2:F1}% corruption for {num7 * 100f:F1}% heal");
}
}
}
else
{
float value2 = SuppressRework.FixedTradeValue.Value;
if (__instance is CrushHealth)
{
num2 = 0f - value2 / 100f;
num3 = value2;
ManualLogSource log10 = SuppressRework.Log;
if (log10 != null)
{
log10.LogInfo((object)$"CrushHealth Fixed: sacrificing {value2}% health for {value2}% corruption");
}
}
else if (__instance is CrushCorruption)
{
num2 = value2 / 100f;
num3 = 0f - value2;
ManualLogSource log11 = SuppressRework.Log;
if (log11 != null)
{
log11.LogInfo((object)$"CrushCorruption Fixed: spending {value2}% corruption for {value2}% heal");
}
}
}
if (SuppressRework.EnableEfficientTrades.Value)
{
if (__instance is CrushHealth && num3 > 0f)
{
VoidSurvivorController component3 = ((Component)characterBody).GetComponent<VoidSurvivorController>();
if ((Object)(object)component3 == (Object)null)
{
return true;
}
float num8 = 100f - component3.corruption;
if (num3 > num8)
{
float num9 = num8 / num3;
num3 *= num9;
num2 *= num9;
ManualLogSource log12 = SuppressRework.Log;
if (log12 != null)
{
log12.LogInfo((object)$"CrushHealth scaled down due to corruption cap: scale={num9:F2}");
}
}
}
else if (__instance is CrushCorruption && num2 > 0f)
{
HealthComponent healthComponent3 = characterBody.healthComponent;
if ((Object)(object)healthComponent3 == (Object)null)
{
return true;
}
float num10 = healthComponent3.fullHealth - healthComponent3.health;
float num11 = num10 / healthComponent3.fullHealth;
if (num2 > num11)
{
float num12 = num11 / num2;
num2 *= num12;
num3 *= num12;
ManualLogSource log13 = SuppressRework.Log;
if (log13 != null)
{
log13.LogInfo((object)$"CrushCorruption scaled down due to overheal prevention: scale={num12:F2}");
}
}
}
}
__instance.selfHealFraction = num2;
__instance.corruptionChange = num3;
return true;
}
catch (Exception arg)
{
ManualLogSource log14 = SuppressRework.Log;
if (log14 != null)
{
log14.LogError((object)$"Error in CrushBase_OnEnter_Patch: {arg}");
}
return true;
}
}
}
[HarmonyPatch]
public static class VoidSurvivorSkillDef_HasRequiredCorruption_Patch
{
private static MethodBase TargetMethod()
{
Type type = AccessTools.TypeByName("RoR2.Skills.VoidSurvivorSkillDef");
return AccessTools.Method(type, "HasRequiredCorruption", (Type[])null, (Type[])null);
}
private static bool Prefix(object __instance, GenericSkill skillSlot, ref bool __result)
{
try
{
if (SuppressRework.EnableAllOrNothingScaling.Value)
{
return true;
}
if (__instance == SuppressRework._crushHealthDef)
{
CharacterBody val = ((skillSlot != null) ? skillSlot.characterBody : null);
if ((Object)(object)((val != null) ? val.healthComponent : null) != (Object)null)
{
float num = val.healthComponent.health / val.healthComponent.fullHealth * 100f;
float value = SuppressRework.FixedTradeValue.Value;
__result = num >= value;
return false;
}
}
else if (__instance == SuppressRework._crushCorruptionDef)
{
CharacterBody val2 = ((skillSlot != null) ? skillSlot.characterBody : null);
VoidSurvivorController val3 = ((val2 != null) ? ((Component)val2).GetComponent<VoidSurvivorController>() : null);
if ((Object)(object)val3 != (Object)null)
{
float corruption = val3.corruption;
float value2 = SuppressRework.FixedTradeValue.Value;
__result = corruption >= value2;
return false;
}
}
}
catch (Exception arg)
{
ManualLogSource log = SuppressRework.Log;
if (log != null)
{
log.LogError((object)$"Error in HasRequiredCorruption patch: {arg}");
}
}
return true;
}
}
[HarmonyPatch(typeof(Language), "GetString", new Type[] { typeof(string) })]
public static class Language_GetString_Patch
{
private static string? _crushHealthToken = null;
private static string? _crushCorruptionToken = null;
private static string? _corruptionUpgradeToken = null;
private static readonly HashSet<string> _voidSurvivorTokens = new HashSet<string> { "VOIDSURVIVOR_PRIMARY_DESCRIPTION", "VOIDSURVIVOR_SECONDARY_DESCRIPTION", "VOIDSURVIVOR_UTILITY_DESCRIPTION", "VOIDSURVIVOR_SPECIAL_DESCRIPTION" };
private static bool Prefix(string token, ref string __result)
{
try
{
if (string.IsNullOrEmpty(token) || token.Length < 15)
{
return true;
}
if (_crushHealthToken == null && (Object)(object)SuppressRework._crushHealthDef != (Object)null)
{
_crushHealthToken = SuppressRework._crushHealthDef.skillDescriptionToken;
_crushCorruptionToken = SuppressRework._crushCorruptionDef?.skillDescriptionToken;
if (_crushHealthToken != null)
{
_voidSurvivorTokens.Add(_crushHealthToken);
}
if (_crushCorruptionToken != null)
{
_voidSurvivorTokens.Add(_crushCorruptionToken);
}
}
if (_corruptionUpgradeToken == null && token.Length > 25 && token.Contains("Corruption Upgrade") && token.Contains("Transform to crush"))
{
_corruptionUpgradeToken = token;
_voidSurvivorTokens.Add(token);
ManualLogSource log = SuppressRework.Log;
if (log != null)
{
log.LogInfo((object)("Safely cached corruption upgrade token: " + token));
}
}
if (token == _corruptionUpgradeToken)
{
if (SuppressRework.EnableAllOrNothingScaling.Value)
{
__result = "<style=cKeywordName>□Corruption Upgrade□</style><style=cSub>Transform to crush a portion of your maximum health to gain an equal percentage of Corruption instead.</style>";
}
else
{
string text = $"{SuppressRework.FixedTradeValue.Value:0}";
__result = "<style=cKeywordName>□Corruption Upgrade□</style><style=cSub>Transform to crush " + text + "% health to gain " + text + "% Corruption instead.</style>";
}
return false;
}
if (!_voidSurvivorTokens.Contains(token))
{
return true;
}
bool flag = IsPlayerInVoidModeState();
if (token == _crushCorruptionToken && (Object)(object)SuppressRework._crushCorruptionDef != (Object)null)
{
if (flag)
{
if (SuppressRework.EnableAllOrNothingScaling.Value)
{
__result = "Crush a portion of your <style=cIsHealth>maximum health</style> to gain an equal percentage of <style=cIsVoid>Corruption</style>.";
}
else
{
string text2 = $"{SuppressRework.FixedTradeValue.Value:0}";
__result = "Crush <style=cIsHealth>" + text2 + "% maximum health</style> to gain <style=cIsVoid>" + text2 + "% Corruption</style>.";
}
}
else if (SuppressRework.EnableAllOrNothingScaling.Value)
{
__result = "Crush your entire <style=cIsVoid>Corruption</style> bar to heal yourself for an equal percentage of <style=cIsHealing>maximum health</style>.";
}
else
{
string text3 = $"{SuppressRework.FixedTradeValue.Value:0}";
__result = "Crush <style=cIsVoid>" + text3 + "% Corruption</style> to heal yourself for <style=cIsHealing>" + text3 + "% maximum health</style>.";
}
return false;
}
switch (token)
{
case "VOIDSURVIVOR_PRIMARY_DESCRIPTION":
__result = (flag ? "Fire a short-range beam for <style=cIsDamage>300% damage</style>." : "Fire a slowing long-range beam for <style=cIsDamage>300% damage</style>.");
return false;
case "VOIDSURVIVOR_SECONDARY_DESCRIPTION":
__result = (flag ? "Fire an arcing plasma bomb for <style=cIsDamage>1100% damage</style>." : "Fire a plasma missile for <style=cIsDamage>600% damage</style>. Fully charge it for an <style=cIsDamage>explosive plasma ball</style> instead, dealing <style=cIsDamage>1100% damage</style>.");
return false;
case "VOIDSURVIVOR_UTILITY_DESCRIPTION":
__result = (flag ? "Disappear into the Void, <style=cIsUtility>cleansing all debuffs</style> while moving at a fast forward angle." : "Disappear into the Void, <style=cIsUtility>cleansing all debuffs</style> while moving in an upward arc.");
return false;
default:
if (token == _crushHealthToken && (Object)(object)SuppressRework._crushHealthDef != (Object)null)
{
if (SuppressRework.EnableAllOrNothingScaling.Value)
{
__result = "Crush a portion of your <style=cIsHealth>maximum health</style> to gain an equal percentage of <style=cIsVoid>Corruption</style>.";
}
else
{
string text4 = $"{SuppressRework.FixedTradeValue.Value:0}";
__result = "Crush <style=cIsHealth>" + text4 + "% maximum health</style> to gain <style=cIsVoid>" + text4 + "% Corruption</style>.";
}
return false;
}
break;
}
}
catch (Exception arg)
{
ManualLogSource log2 = SuppressRework.Log;
if (log2 != null)
{
log2.LogError((object)$"Error in Language_GetString_Patch: {arg}");
}
}
return true;
}
private static bool IsPlayerInVoidModeState()
{
try
{
LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
object obj;
if (firstLocalUser == null)
{
obj = null;
}
else
{
PlayerCharacterMasterController cachedMasterController = firstLocalUser.cachedMasterController;
if (cachedMasterController == null)
{
obj = null;
}
else
{
CharacterMaster master = cachedMasterController.master;
obj = ((master != null) ? master.GetBody() : null);
}
}
if ((Object)obj == (Object)null)
{
return false;
}
CharacterBody body = firstLocalUser.cachedMasterController.master.GetBody();
if (body.baseNameToken != "VOIDSURVIVOR_BODY_NAME")
{
return false;
}
VoidSurvivorController component = ((Component)body).GetComponent<VoidSurvivorController>();
if ((Object)(object)component == (Object)null)
{
return false;
}
if ((Object)(object)component.corruptedBuffDef != (Object)null && body.HasBuff(component.corruptedBuffDef))
{
return true;
}
EntityStateMachine corruptionModeStateMachine = component.corruptionModeStateMachine;
if (((corruptionModeStateMachine != null) ? corruptionModeStateMachine.state : null) != null)
{
string name = ((object)component.corruptionModeStateMachine.state).GetType().Name;
if (name == "CorruptMode")
{
return true;
}
}
return component.corruption >= 100f;
}
catch (Exception arg)
{
ManualLogSource log = SuppressRework.Log;
if (log != null)
{
log.LogError((object)$"Error in IsPlayerInVoidModeState: {arg}");
}
return false;
}
}
}
public static class TooltipRefresher
{
public static void RefreshTooltipsAfterSettingsChange()
{
//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
try
{
FieldInfo field = typeof(Language).GetField("currentLanguage", BindingFlags.Static | BindingFlags.NonPublic);
if (field != null)
{
object? value = field.GetValue(null);
Language val = (Language)((value is Language) ? value : null);
if (val != null)
{
FieldInfo field2 = typeof(Language).GetField("stringsByToken", BindingFlags.Instance | BindingFlags.NonPublic);
if (field2 != null)
{
object value2 = field2.GetValue(val);
if (value2 != null)
{
MethodInfo method = value2.GetType().GetMethod("Remove");
if (method != null && (Object)(object)SuppressRework._crushCorruptionDef != (Object)null)
{
method.Invoke(value2, new object[1] { SuppressRework._crushCorruptionDef.skillDescriptionToken });
if ((Object)(object)SuppressRework._crushHealthDef != (Object)null)
{
method.Invoke(value2, new object[1] { SuppressRework._crushHealthDef.skillDescriptionToken });
}
}
}
}
}
}
TooltipProvider[] array = Object.FindObjectsOfType<TooltipProvider>();
TooltipProvider[] array2 = array;
foreach (TooltipProvider val2 in array2)
{
if (val2.bodyToken == null || (!val2.bodyToken.Contains("CRUSH") && !val2.bodyToken.Contains("SPECIAL")))
{
continue;
}
MethodInfo method2 = typeof(TooltipProvider).GetMethod("SetContent", BindingFlags.Instance | BindingFlags.Public);
if (method2 != null)
{
TooltipProvider component = ((Component)val2).GetComponent<TooltipProvider>();
if ((Object)(object)component != (Object)null)
{
method2.Invoke(val2, new object[1] { (object)default(TooltipContent) });
}
}
}
ManualLogSource log = SuppressRework.Log;
if (log != null)
{
log.LogInfo((object)"Cleared tooltip cache to force refresh");
}
}
catch (Exception arg)
{
ManualLogSource log2 = SuppressRework.Log;
if (log2 != null)
{
log2.LogError((object)$"Error refreshing tooltips: {arg}");
}
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
