Please disclose if any significant portion of your mod was created using AI tools by adding the 'AI Generated' category. Failing to do so may result in the mod being removed from Thunderstore.
Decompiled source of AdditiveDamageModifier v1.2.6
AdditiveDamageModifier.dll
Decompiled 3 days ago
The result has been truncated due to the large size, download it to view full contents!
using System; using System.Collections; using System.Collections.Concurrent; using System.Collections.Generic; using System.Collections.ObjectModel; using System.ComponentModel; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.IO; using System.IO.Compression; using System.Linq; using System.Linq.Expressions; using System.Reflection; using System.Reflection.Emit; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Serialization; using System.Runtime.Versioning; using System.Text; using System.Text.RegularExpressions; using System.Threading; using AdditiveDamageModifier; using BepInEx; using BepInEx.Bootstrap; using BepInEx.Configuration; using BepInEx.Logging; using HarmonyLib; using JetBrains.Annotations; using LocalizationManager; using Microsoft.CodeAnalysis; using ServerSync; using TMPro; using UnityEngine; using YamlDotNet.Core; using YamlDotNet.Core.Events; using YamlDotNet.Core.ObjectPool; using YamlDotNet.Core.Tokens; using YamlDotNet.Helpers; using YamlDotNet.Serialization; using YamlDotNet.Serialization.BufferedDeserialization; using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators; using YamlDotNet.Serialization.Callbacks; using YamlDotNet.Serialization.Converters; using YamlDotNet.Serialization.EventEmitters; using YamlDotNet.Serialization.NamingConventions; using YamlDotNet.Serialization.NodeDeserializers; using YamlDotNet.Serialization.NodeTypeResolvers; using YamlDotNet.Serialization.ObjectFactories; using YamlDotNet.Serialization.ObjectGraphTraversalStrategies; using YamlDotNet.Serialization.ObjectGraphVisitors; using YamlDotNet.Serialization.Schemas; using YamlDotNet.Serialization.TypeInspectors; using YamlDotNet.Serialization.TypeResolvers; using YamlDotNet.Serialization.Utilities; using YamlDotNet.Serialization.ValueDeserializers; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AssemblyTitle("AdditiveDamageModifier")] [assembly: AssemblyCompany("sighsorry")] [assembly: AssemblyProduct("AdditiveDamageModifier")] [assembly: ComVisible(false)] [assembly: AssemblyFileVersion("1.2.6")] [assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")] [assembly: AssemblyVersion("1.2.6.0")] [module: RefSafetyRules(11)] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [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] [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; } } [CompilerGenerated] [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 LocalizationManager { internal static class Localizer { private static readonly string[] FileExtensions = new string[2] { ".json", ".yml" }; private static readonly MethodInfo? AddWordMethod = AccessTools.DeclaredMethod(typeof(Localization), "AddWord", new Type[2] { typeof(string), typeof(string) }, (Type[])null); private static BaseUnityPlugin? _plugin; private static ManualLogSource Logger => AdditiveDamageModifierPlugin.AdditiveDamageModifierLogger; internal static void Load(BaseUnityPlugin plugin) { _plugin = plugin ?? throw new ArgumentNullException("plugin"); Localization instance = Localization.instance; LoadLocalization(instance, instance.GetSelectedLanguage()); } internal static void LoadLocalization(Localization localization, string language) { if ((Object)(object)_plugin == (Object)null || localization == null) { return; } string text = (string.IsNullOrWhiteSpace(language) ? "English" : language); Dictionary<string, string> dictionary = FindExternalLocalizationFiles(); Dictionary<string, string> dictionary2 = LoadEmbeddedTranslation("English", required: true); if (dictionary.TryGetValue("English", out var value)) { TryMergeExternalTranslation(dictionary2, value, "English"); } if (!string.Equals(text, "English", StringComparison.OrdinalIgnoreCase) && (!dictionary.TryGetValue(text, out var value2) || !TryMergeExternalTranslation(dictionary2, value2, text))) { Dictionary<string, string> dictionary3 = LoadEmbeddedTranslation(text, required: false); if (dictionary3 != null) { Merge(dictionary2, dictionary3); } } if (AddWordMethod == null) { throw new MissingMethodException(typeof(Localization).FullName, "AddWord"); } foreach (KeyValuePair<string, string> item in dictionary2) { AddWordMethod.Invoke(localization, new object[2] { item.Key, item.Value }); } } private static Dictionary<string, string> FindExternalLocalizationFiles() { Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); if ((Object)(object)_plugin == (Object)null) { return dictionary; } string directoryName = Path.GetDirectoryName(Paths.PluginPath); if (string.IsNullOrEmpty(directoryName) || !Directory.Exists(directoryName)) { return dictionary; } string text = _plugin.Info.Metadata.Name + "."; string[] array; try { array = (from file in Directory.EnumerateFiles(directoryName, text + "*", SearchOption.AllDirectories) where FileExtensions.Contains<string>(Path.GetExtension(file), StringComparer.OrdinalIgnoreCase) select file).OrderBy<string, string>((string file) => file, StringComparer.OrdinalIgnoreCase).ToArray(); } catch (Exception ex) { Logger.LogWarning((object)("Could not search BepInEx for external " + _plugin.Info.Metadata.Name + " translations: " + ex.Message)); return dictionary; } string[] array2 = array; foreach (string text2 in array2) { string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text2); if (!fileNameWithoutExtension.StartsWith(text, StringComparison.OrdinalIgnoreCase)) { continue; } string text3 = fileNameWithoutExtension.Substring(text.Length); if (!string.IsNullOrWhiteSpace(text3)) { if (dictionary.ContainsKey(text3)) { Logger.LogWarning((object)("Duplicate " + text3 + " translation for " + _plugin.Info.Metadata.Name + ". Skipping " + text2 + "; using " + dictionary[text3] + ".")); } else { dictionary[text3] = text2; } } } return dictionary; } private static Dictionary<string, string>? LoadEmbeddedTranslation(string language, bool required) { byte[] array = LoadTranslationFromAssembly(language); if (array == null) { if (required) { BaseUnityPlugin? plugin = _plugin; throw new InvalidDataException("No embedded English localization was found for " + ((plugin != null) ? plugin.Info.Metadata.Name : null) + ". Expected translations.English.yml or translations.English.json."); } return null; } try { return Deserialize(Encoding.UTF8.GetString(array), "embedded " + language + " translation"); } catch (Exception ex) { if (required) { throw new InvalidDataException("The embedded " + language + " localization could not be loaded.", ex); } Logger.LogWarning((object)("Could not load the embedded " + language + " translation. Falling back to English: " + ex.Message)); return null; } } private static bool TryMergeExternalTranslation(Dictionary<string, string> target, string file, string language) { try { Dictionary<string, string> source = Deserialize(File.ReadAllText(file, Encoding.UTF8), file); Merge(target, source); Logger.LogDebug((object)("Loaded " + _plugin.Info.Metadata.Name + " " + language + " translation from " + file + ".")); return true; } catch (Exception ex) { Logger.LogWarning((object)("Could not load " + _plugin.Info.Metadata.Name + " " + language + " translation at " + file + ". Falling back to an embedded translation or English: " + ex.Message)); return false; } } private static Dictionary<string, string> Deserialize(string sourceText, string sourceName) { Dictionary<string, string> obj = new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(sourceText) ?? throw new InvalidDataException(sourceName + " is empty."); Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal); foreach (KeyValuePair<string, string> item in obj) { string text = item.Key?.Trim() ?? ""; if (text.StartsWith("$", StringComparison.Ordinal)) { text = text.Substring(1); } if (text.Length != 0 && !string.IsNullOrWhiteSpace(item.Value)) { dictionary[text] = item.Value; } } return dictionary; } private static void Merge(Dictionary<string, string> target, Dictionary<string, string> source) { foreach (KeyValuePair<string, string> item in source) { if (target.ContainsKey(item.Key)) { target[item.Key] = item.Value; } } } private static byte[]? LoadTranslationFromAssembly(string language) { string[] fileExtensions = FileExtensions; foreach (string text in fileExtensions) { byte[] array = ReadEmbeddedFileBytes("translations." + language + text); if (array != null) { return array; } } return null; } private static byte[]? ReadEmbeddedFileBytes(string resourceFileName) { Assembly executingAssembly = Assembly.GetExecutingAssembly(); string text = executingAssembly.GetManifestResourceNames().FirstOrDefault((string name) => name.EndsWith(resourceFileName, StringComparison.Ordinal)); if (text == null) { return null; } using Stream stream = executingAssembly.GetManifestResourceStream(text); if (stream == null) { return null; } using MemoryStream memoryStream = new MemoryStream(); stream.CopyTo(memoryStream); return (memoryStream.Length == 0L) ? null : memoryStream.ToArray(); } } [HarmonyPatch(typeof(Localization), "SetupLanguage")] internal static class LocalizationSetupLanguageAdditiveDamagePatch { private static void Postfix(Localization __instance, string language) { Localizer.LoadLocalization(__instance, language); } } } namespace AdditiveDamageModifier { internal static class AdditiveDamageCompendium { private const string PageTopic = "$adm_compendium_title"; internal static void AddPage(List<TextInfo>? texts) { //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Expected O, but got Unknown if (texts != null) { texts.RemoveAll((TextInfo text) => string.Equals(text?.m_topic, "$adm_compendium_title", StringComparison.Ordinal)); texts.Add(new TextInfo("$adm_compendium_title", BuildPageText())); } } private static string BuildPageText() { //IL_0179: Unknown result type (might be due to invalid IL or missing references) //IL_0192: Unknown result type (might be due to invalid IL or missing references) //IL_0239: Unknown result type (might be due to invalid IL or missing references) StringBuilder stringBuilder = new StringBuilder(); if (!AdditiveDamageModifierPlugin.ResistancePatchesEnabled) { AppendHeading(stringBuilder, "$adm_compendium_pov_heading"); AppendParagraph(stringBuilder, Localize("$adm_compendium_pov_intro")); AppendParagraph(stringBuilder, Localize("$adm_compendium_pov_disabled")); AppendParagraph(stringBuilder, Localize("$adm_compendium_pov_settings")); AppendParagraph(stringBuilder, Format("$adm_compendium_pov_retained", "Fall damage remains active: maximum base damage {0}, multiplier {1}x. The adm_* status effects remain registered and supply their native modifier tiers to the active resistance rules, not ADM percentages.", AdditiveDamageModifierPlugin.GetFallDamageCap().ToString("0.##", CultureInfo.InvariantCulture), AdditiveDamageModifierPlugin.GetFallDamageMultiplier().ToString("0.00", CultureInfo.InvariantCulture))); AppendParagraph(stringBuilder, Localize("$adm_compendium_pov_cold")); return stringBuilder.ToString().TrimEnd(Array.Empty<char>()); } AppendParagraph(stringBuilder, Localize("$adm_compendium_intro")); AppendHeading(stringBuilder, "$adm_compendium_current_heading"); AppendParagraph(stringBuilder, Localize("$adm_compendium_current_intro")); AppendHeading(stringBuilder, "$adm_compendium_player_heading"); AppendModifierValues(stringBuilder, DamageModifierProfile.Player); AppendHeading(stringBuilder, "$adm_compendium_nonplayer_heading"); AppendModifierValues(stringBuilder, DamageModifierProfile.NonPlayerCharacter); AppendHeading(stringBuilder, "$adm_compendium_calculation_heading"); AppendParagraph(stringBuilder, Localize("$adm_compendium_sum_rule")); AppendParagraph(stringBuilder, Localize("$adm_compendium_formula")); AppendParagraph(stringBuilder, BuildExample()); AppendHeading(stringBuilder, "$adm_compendium_minimum_heading"); AppendParagraph(stringBuilder, Localize("$adm_compendium_minimum_intro")); DamageTypeDefinition[] damageTypes = AdditiveDamageDefinitions.DamageTypes; for (int i = 0; i < damageTypes.Length; i++) { DamageTypeDefinition damageTypeDefinition = damageTypes[i]; if (damageTypeDefinition.HasPlayerMinimumCap) { string text = FormatUnsignedPercent(AdditiveDamageModifierPlugin.GetMinimumDamageTakenMultiplier(damageTypeDefinition.Type) * 100f); string text2 = AdditiveDamageDisplay.FormatMinimumTotalPercent(damageTypeDefinition.Type); AppendParagraph(stringBuilder, Format("$adm_compendium_minimum_line", "{0}: at least {1} of original damage (MinTotal {2})", Localize(damageTypeDefinition.LocalizationKey, damageTypeDefinition.DisplayName), text, text2)); } } AppendParagraph(stringBuilder, Localize("$adm_compendium_spirit_rule")); AppendHeading(stringBuilder, "$adm_compendium_vanilla_heading"); AppendParagraph(stringBuilder, Localize("$adm_compendium_vanilla_rule")); DamageModifierDefinition[] damageModifiers = AdditiveDamageDefinitions.DamageModifiers; for (int i = 0; i < damageModifiers.Length; i++) { DamageModifierDefinition damageModifierDefinition = damageModifiers[i]; AppendValueLine(stringBuilder, Localize(damageModifierDefinition.LocalizationKey, damageModifierDefinition.DisplayName), AdditiveDamageDisplay.FormatPercent(GetVanillaPercent(damageModifierDefinition.Modifier))); } AppendParagraph(stringBuilder, Localize("$adm_compendium_additive_rule")); AppendHeading(stringBuilder, "$adm_compendium_special_heading"); AppendParagraph(stringBuilder, Format("$adm_compendium_immune_rule", "For players, Immune contributes {0}; other Characters use their own value shown above. Weakness can offset Immune, and player minimums still apply to capped damage types.", AdditiveDamageDisplay.FormatModifierPercent((DamageModifier)3))); AppendParagraph(stringBuilder, Localize("$adm_compendium_ignore_rule")); AppendParagraph(stringBuilder, Format("$adm_compendium_frost_rule", "Cold and Freezing immunity triggers when the combined Frost modifier is {0} or lower.", AdditiveDamageDisplay.FormatPercent(Mathf.RoundToInt(AdditiveDamageModifierPlugin.GetFrostEnvImmunityTriggerDelta() * 100f)))); return stringBuilder.ToString().TrimEnd(Array.Empty<char>()); } private static void AppendModifierValues(StringBuilder builder, DamageModifierProfile profile) { //IL_0028: Unknown result type (might be due to invalid IL or missing references) DamageModifierDefinition[] damageModifiers = AdditiveDamageDefinitions.DamageModifiers; for (int i = 0; i < damageModifiers.Length; i++) { DamageModifierDefinition damageModifierDefinition = damageModifiers[i]; AppendValueLine(builder, Localize(damageModifierDefinition.LocalizationKey, damageModifierDefinition.DisplayName), AdditiveDamageDisplay.FormatModifierPercent(damageModifierDefinition.Modifier, profile)); } } private static string BuildExample() { DamageModifier[] array = new DamageModifier[4]; RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/); DamageModifier[] array2 = (DamageModifier[])(object)array; int num = 0; StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i < array2.Length; i++) { int num2 = Mathf.RoundToInt(AdditiveDamageMath.ModifierToDelta(array2[i], DamageModifierProfile.Player) * 100f); num += num2; if (i == 0) { stringBuilder.Append(AdditiveDamageDisplay.FormatPercent(num2)); } else { stringBuilder.Append((num2 < 0) ? " - " : " + ").Append(Math.Abs(num2).ToString(CultureInfo.InvariantCulture)).Append('%'); } } int num3 = Mathf.Max(0, 100 + num); return Format("$adm_compendium_example", "Player example: {0} = {1}, so {2} of the original damage is taken before any player minimum.", stringBuilder, AdditiveDamageDisplay.FormatPercent(num), FormatUnsignedPercent(num3)); } private static int GetVanillaPercent(DamageModifier modifier) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0028: Expected I4, but got Unknown return (modifier - 1) switch { 6 => -25, 0 => -50, 4 => -75, 7 => 25, 1 => 50, 5 => 100, 2 => -100, _ => 0, }; } private static void AppendHeading(StringBuilder builder, string token) { if (builder.Length > 0) { builder.Append('\n'); } builder.Append("<color=#FFD27A><b>").Append(Localize(token)).Append("</b></color>\n"); } private static void AppendValueLine(StringBuilder builder, string name, string value) { builder.Append("- <color=orange>").Append(name).Append("</color>: ") .Append(value) .Append('\n'); } private static void AppendParagraph(StringBuilder builder, string text) { builder.Append(text).Append('\n'); } private static string Localize(string token) { Localization instance = Localization.instance; return ((instance != null) ? instance.Localize(token) : null) ?? token; } private static string Localize(string token, string fallback) { string text = Localize(token); string text2 = (token.StartsWith("$", StringComparison.Ordinal) ? token.Substring(1) : token); string b = "[" + text2 + "]"; if (!string.IsNullOrWhiteSpace(text) && !string.Equals(text, token, StringComparison.Ordinal) && !string.Equals(text, b, StringComparison.Ordinal)) { return text; } return fallback; } private static string Format(string token, string fallback, params object[] args) { string format = Localize(token, fallback); try { return string.Format(CultureInfo.InvariantCulture, format, args); } catch (FormatException) { return string.Format(CultureInfo.InvariantCulture, fallback, args); } } private static string FormatUnsignedPercent(float value) { return Mathf.RoundToInt(value).ToString(CultureInfo.InvariantCulture) + "%"; } } [HarmonyPatch(typeof(TextsDialog), "UpdateTextsList")] internal static class TextsDialogUpdateTextsListAdditiveDamagePatch { private static void Postfix(List<TextInfo> ___m_texts) { AdditiveDamageCompendium.AddPage(___m_texts); } } internal static class AdditiveDamageDefinitions { public static readonly DamageTypeDefinition[] DamageTypes = new DamageTypeDefinition[10] { new DamageTypeDefinition((DamageType)1, "Blunt", "blunt", "$inventory_blunt", hasStatusEffect: true, hasPlayerMinimumCap: true), new DamageTypeDefinition((DamageType)4, "Pierce", "pierce", "$inventory_pierce", hasStatusEffect: true, hasPlayerMinimumCap: true), new DamageTypeDefinition((DamageType)2, "Slash", "slash", "$inventory_slash", hasStatusEffect: true, hasPlayerMinimumCap: true), new DamageTypeDefinition((DamageType)8, "Chop", "chop", "$inventory_chop", hasStatusEffect: false, hasPlayerMinimumCap: false), new DamageTypeDefinition((DamageType)16, "Pickaxe", "pickaxe", "$inventory_pickaxe", hasStatusEffect: false, hasPlayerMinimumCap: false), new DamageTypeDefinition((DamageType)32, "Fire", "fire", "$inventory_fire", hasStatusEffect: true, hasPlayerMinimumCap: true), new DamageTypeDefinition((DamageType)256, "Poison", "poison", "$inventory_poison", hasStatusEffect: true, hasPlayerMinimumCap: true), new DamageTypeDefinition((DamageType)64, "Frost", "frost", "$inventory_frost", hasStatusEffect: true, hasPlayerMinimumCap: true), new DamageTypeDefinition((DamageType)128, "Lightning", "lightning", "$inventory_lightning", hasStatusEffect: true, hasPlayerMinimumCap: true), new DamageTypeDefinition((DamageType)512, "Spirit", "spirit", "$inventory_spirit", hasStatusEffect: true, hasPlayerMinimumCap: false) }; public static readonly DamageModifierDefinition[] DamageModifiers = new DamageModifierDefinition[7] { new DamageModifierDefinition((DamageModifier)6, "Very Weak", "very_weak", "$inventory_veryweak", 45, 800), new DamageModifierDefinition((DamageModifier)2, "Weak", "weak", "$inventory_weak", 30, 700), new DamageModifierDefinition((DamageModifier)8, "Slightly Weak", "slightly_weak", "$inventory_slightlyweak", 15, 600), new DamageModifierDefinition((DamageModifier)7, "Slightly Resistant", "slightly_resistant", "$inventory_slightlyresistant", -15, 400), new DamageModifierDefinition((DamageModifier)1, "Resistant", "resistant", "$inventory_resistant", -30, 300), new DamageModifierDefinition((DamageModifier)5, "Very Resistant", "very_resistant", "$inventory_veryresistant", -45, 200), new DamageModifierDefinition((DamageModifier)3, "Immune", "immune", "$inventory_immune", -100, 100) }; public static bool TryGetDamageType(DamageType type, out DamageTypeDefinition definition) { //IL_0014: Unknown result type (might be due to invalid IL or missing references) //IL_0019: Unknown result type (might be due to invalid IL or missing references) DamageTypeDefinition[] damageTypes = DamageTypes; for (int i = 0; i < damageTypes.Length; i++) { DamageTypeDefinition damageTypeDefinition = damageTypes[i]; if (damageTypeDefinition.Type == type) { definition = damageTypeDefinition; return true; } } definition = default(DamageTypeDefinition); return false; } public static bool TryGetDamageModifier(DamageModifier modifier, out DamageModifierDefinition definition) { //IL_0014: Unknown result type (might be due to invalid IL or missing references) //IL_0019: Unknown result type (might be due to invalid IL or missing references) DamageModifierDefinition[] damageModifiers = DamageModifiers; for (int i = 0; i < damageModifiers.Length; i++) { DamageModifierDefinition damageModifierDefinition = damageModifiers[i]; if (damageModifierDefinition.Modifier == modifier) { definition = damageModifierDefinition; return true; } } definition = default(DamageModifierDefinition); return false; } } internal readonly struct DamageTypeDefinition { public DamageType Type { get; } public string DisplayName { get; } public string StatusName { get; } public string LocalizationKey { get; } public bool HasStatusEffect { get; } public bool HasPlayerMinimumCap { get; } public DamageTypeDefinition(DamageType type, string displayName, string statusName, string localizationKey, bool hasStatusEffect, bool hasPlayerMinimumCap) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Unknown result type (might be due to invalid IL or missing references) Type = type; DisplayName = displayName; StatusName = statusName; LocalizationKey = localizationKey; HasStatusEffect = hasStatusEffect; HasPlayerMinimumCap = hasPlayerMinimumCap; } } internal readonly struct DamageModifierDefinition { public DamageModifier Modifier { get; } public string DisplayName { get; } public string StatusName { get; } public string LocalizationKey { get; } public int DefaultPercent { get; } public int Order { get; } public DamageModifierDefinition(DamageModifier modifier, string displayName, string statusName, string localizationKey, int defaultPercent, int order) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Unknown result type (might be due to invalid IL or missing references) Modifier = modifier; DisplayName = displayName; StatusName = statusName; LocalizationKey = localizationKey; DefaultPercent = defaultPercent; Order = order; } } internal static class AdditiveDamageStatusEffectCatalog { private const string NamePrefix = "adm_"; private const int IconSize = 32; private static readonly Dictionary<string, Sprite> Icons = new Dictionary<string, Sprite>(); public static void Register(ObjectDB objectDb) { if (objectDb?.m_StatusEffects == null) { return; } int num = 0; DamageTypeDefinition[] damageTypes = AdditiveDamageDefinitions.DamageTypes; for (int i = 0; i < damageTypes.Length; i++) { DamageTypeDefinition damageType = damageTypes[i]; if (!damageType.HasStatusEffect) { continue; } DamageModifierDefinition[] damageModifiers = AdditiveDamageDefinitions.DamageModifiers; for (int j = 0; j < damageModifiers.Length; j++) { DamageModifierDefinition damageModifier = damageModifiers[j]; string statusEffectName = GetStatusEffectName(damageType.StatusName, damageModifier.StatusName); if (!((Object)(object)objectDb.GetStatusEffect(StringExtensionMethods.GetStableHashCode(statusEffectName)) != (Object)null)) { objectDb.m_StatusEffects.Add((StatusEffect)(object)CreateStatusEffect(statusEffectName, damageType, damageModifier)); num++; } } } if (num > 0) { AdditiveDamageModifierPlugin.AdditiveDamageModifierLogger.LogDebug((object)$"Registered {num} additive damage modifier status effects."); } } private static SE_Stats CreateStatusEffect(string statusEffectName, DamageTypeDefinition damageType, DamageModifierDefinition damageModifier) { //IL_0086: 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_00a7: Unknown result type (might be due to invalid IL or missing references) //IL_00b1: Unknown result type (might be due to invalid IL or missing references) //IL_00b6: Unknown result type (might be due to invalid IL or missing references) //IL_00bf: Unknown result type (might be due to invalid IL or missing references) //IL_00c4: Unknown result type (might be due to invalid IL or missing references) //IL_00c9: Unknown result type (might be due to invalid IL or missing references) string text = FormatStatusDisplayName(damageType.StatusName); string text2 = FormatStatusDisplayName(damageModifier.StatusName); SE_AdditiveDamageModifier sE_AdditiveDamageModifier = ScriptableObject.CreateInstance<SE_AdditiveDamageModifier>(); ((Object)sE_AdditiveDamageModifier).name = statusEffectName; ((StatusEffect)sE_AdditiveDamageModifier).m_name = text + " " + text2; ((StatusEffect)sE_AdditiveDamageModifier).m_tooltip = "Applies " + damageModifier.DisplayName + " to " + damageType.DisplayName + " damage."; ((StatusEffect)sE_AdditiveDamageModifier).m_icon = GetIcon(damageType, damageModifier); sE_AdditiveDamageModifier.m_modifier = damageModifier.Modifier; sE_AdditiveDamageModifier.m_damageTypeName = text; sE_AdditiveDamageModifier.m_modifierName = text2; ((SE_Stats)sE_AdditiveDamageModifier).m_mods = new List<DamageModPair> { new DamageModPair { m_type = damageType.Type, m_modifier = damageModifier.Modifier } }; return (SE_Stats)(object)sE_AdditiveDamageModifier; } private static Sprite GetIcon(DamageTypeDefinition damageType, DamageModifierDefinition damageModifier) { //IL_0030: Unknown result type (might be due to invalid IL or missing references) //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_0046: Unknown result type (might be due to invalid IL or missing references) //IL_004d: Unknown result type (might be due to invalid IL or missing references) //IL_0055: Expected O, but got Unknown //IL_0058: Unknown result type (might be due to invalid IL or missing references) //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_0064: Unknown result type (might be due to invalid IL or missing references) //IL_0069: Unknown result type (might be due to invalid IL or missing references) //IL_0070: Unknown result type (might be due to invalid IL or missing references) //IL_0095: Unknown result type (might be due to invalid IL or missing references) //IL_00a4: Unknown result type (might be due to invalid IL or missing references) string text = damageType.StatusName + "_" + damageModifier.StatusName; if (Icons.TryGetValue(text, out Sprite value)) { return value; } Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false) { name = text + "_icon", filterMode = (FilterMode)0, wrapMode = (TextureWrapMode)1 }; DrawIcon(val, GetDamageTypeColor(damageType.Type), GetModifierColor(damageModifier.Modifier), damageModifier.Modifier); val.Apply(); Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f), 100f); ((Object)val2).name = ((Object)val).name; Object.DontDestroyOnLoad((Object)(object)val); Object.DontDestroyOnLoad((Object)(object)val2); Icons[text] = val2; return val2; } private static void DrawIcon(Texture2D texture, Color baseColor, Color modifierColor, DamageModifier modifier) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_000b: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Unknown result type (might be due to invalid IL or missing references) //IL_005e: Unknown result type (might be due to invalid IL or missing references) //IL_0065: Unknown result type (might be due to invalid IL or missing references) //IL_0066: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_003c: Unknown result type (might be due to invalid IL or missing references) Color val = Color.Lerp(baseColor, Color.black, 0.35f); for (int i = 0; i < 32; i++) { for (int j = 0; j < 32; j++) { bool flag = j < 3 || i < 3 || j >= 29 || i >= 29; texture.SetPixel(j, i, flag ? modifierColor : val); } } FillRect(texture, 8, 8, 16, 16, baseColor); DrawModifierGlyph(texture, modifier, modifierColor); } private static void DrawModifierGlyph(Texture2D texture, DamageModifier modifier, Color color) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0028: Expected I4, but got Unknown //IL_0063: Unknown result type (might be due to invalid IL or missing references) //IL_003c: Unknown result type (might be due to invalid IL or missing references) //IL_0070: Unknown result type (might be due to invalid IL or missing references) //IL_002f: Unknown result type (might be due to invalid IL or missing references) //IL_0056: 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_0080: Unknown result type (might be due to invalid IL or missing references) //IL_0090: Unknown result type (might be due to invalid IL or missing references) switch (modifier - 1) { case 5: DrawTextGlyph(texture, "+3", color); break; case 1: DrawTextGlyph(texture, "+2", color); break; case 7: DrawTextGlyph(texture, "+1", color); break; case 6: DrawTextGlyph(texture, "-1", color); break; case 0: DrawTextGlyph(texture, "-2", color); break; case 4: DrawTextGlyph(texture, "-3", color); break; case 2: { for (int i = 8; i < 24; i++) { FillRect(texture, i, i, 3, 3, color); FillRect(texture, i, 32 - i - 3, 3, 3, color); } break; } case 3: break; } } private static void DrawTextGlyph(Texture2D texture, string text, Color color) { //IL_0062: Unknown result type (might be due to invalid IL or missing references) int num = 0; for (int i = 0; i < text.Length; i++) { num += GetGlyphRows(text[i])[0].Length * 2; if (i < text.Length - 1) { num++; } } int num2 = (32 - num) / 2; int bottom = 11; int num3 = num2; for (int j = 0; j < text.Length; j++) { string[] glyphRows = GetGlyphRows(text[j]); DrawGlyph(texture, glyphRows, num3, bottom, 2, color); num3 += glyphRows[0].Length * 2 + 1; } } private static void DrawGlyph(Texture2D texture, string[] rows, int left, int bottom, int scale, Color color) { //IL_0030: Unknown result type (might be due to invalid IL or missing references) for (int i = 0; i < rows.Length; i++) { string text = rows[i]; int bottom2 = bottom + (rows.Length - 1 - i) * scale; for (int j = 0; j < text.Length; j++) { if (text[j] == '1') { FillRect(texture, left + j * scale, bottom2, scale, scale, color); } } } } private static string[] GetGlyphRows(char character) { return character switch { '+' => new string[5] { "010", "010", "111", "010", "010" }, '-' => new string[5] { "000", "000", "111", "000", "000" }, '1' => new string[5] { "010", "110", "010", "010", "111" }, '2' => new string[5] { "111", "001", "111", "100", "111" }, '3' => new string[5] { "111", "001", "111", "001", "111" }, _ => new string[5] { "000", "000", "000", "000", "000" }, }; } private static void FillRect(Texture2D texture, int left, int bottom, int width, int height, Color color) { //IL_000b: Unknown result type (might be due to invalid IL or missing references) for (int i = bottom; i < bottom + height; i++) { for (int j = left; j < left + width; j++) { texture.SetPixel(j, i, color); } } } private static Color GetDamageTypeColor(DamageType damageType) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0003: Invalid comparison between Unknown and I4 //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Invalid comparison between Unknown and I4 //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Unknown result type (might be due to invalid IL or missing references) //IL_001d: Expected I4, but got Unknown //IL_011d: Unknown result type (might be due to invalid IL or missing references) //IL_0122: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Invalid comparison between Unknown and I4 //IL_006c: Unknown result type (might be due to invalid IL or missing references) //IL_0071: Unknown result type (might be due to invalid IL or missing references) //IL_00aa: Unknown result type (might be due to invalid IL or missing references) //IL_00af: Unknown result type (might be due to invalid IL or missing references) //IL_0141: Unknown result type (might be due to invalid IL or missing references) //IL_0146: 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_0090: Unknown result type (might be due to invalid IL or missing references) //IL_001d: Unknown result type (might be due to invalid IL or missing references) //IL_0020: Invalid comparison between Unknown and I4 //IL_0147: Unknown result type (might be due to invalid IL or missing references) //IL_00e5: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: Unknown result type (might be due to invalid IL or missing references) //IL_0048: Unknown result type (might be due to invalid IL or missing references) //IL_004e: Invalid comparison between Unknown and I4 //IL_00c9: Unknown result type (might be due to invalid IL or missing references) //IL_00ce: Unknown result type (might be due to invalid IL or missing references) //IL_0025: Unknown result type (might be due to invalid IL or missing references) //IL_0028: Invalid comparison between Unknown and I4 //IL_0139: Unknown result type (might be due to invalid IL or missing references) //IL_013e: Unknown result type (might be due to invalid IL or missing references) //IL_0101: Unknown result type (might be due to invalid IL or missing references) //IL_0106: Unknown result type (might be due to invalid IL or missing references) if ((int)damageType <= 64) { switch (damageType - 1) { default: if ((int)damageType != 32) { if ((int)damageType != 64) { break; } return new Color(0.32f, 0.72f, 0.95f, 1f); } return new Color(1f, 0.38f, 0.08f, 1f); case 0: return new Color(0.62f, 0.53f, 0.43f, 1f); case 3: return new Color(0.72f, 0.72f, 0.68f, 1f); case 1: return new Color(0.78f, 0.18f, 0.18f, 1f); case 2: break; } } else { if ((int)damageType == 128) { return new Color(0.95f, 0.82f, 0.2f, 1f); } if ((int)damageType == 256) { return new Color(0.28f, 0.72f, 0.22f, 1f); } if ((int)damageType == 512) { return new Color(0.72f, 0.55f, 0.95f, 1f); } } return Color.white; } private static Color GetModifierColor(DamageModifier modifier) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0028: Expected I4, but got Unknown //IL_00b4: Unknown result type (might be due to invalid IL or missing references) //IL_00b9: Unknown result type (might be due to invalid IL or missing references) //IL_0060: Unknown result type (might be due to invalid IL or missing references) //IL_0065: Unknown result type (might be due to invalid IL or missing references) //IL_00d8: Unknown result type (might be due to invalid IL or missing references) //IL_00dd: Unknown result type (might be due to invalid IL or missing references) //IL_00e0: Unknown result type (might be due to invalid IL or missing references) //IL_00e5: 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_00d5: Unknown result type (might be due to invalid IL or missing references) //IL_0041: Unknown result type (might be due to invalid IL or missing references) //IL_0046: Unknown result type (might be due to invalid IL or missing references) //IL_0098: Unknown result type (might be due to invalid IL or missing references) //IL_009d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) //IL_0081: 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) return (Color)((modifier - 1) switch { 5 => new Color(1f, 0.08f, 0.08f, 1f), 1 => new Color(1f, 0.35f, 0.08f, 1f), 7 => new Color(1f, 0.68f, 0.18f, 1f), 6 => new Color(0.3f, 0.85f, 1f, 1f), 0 => new Color(0.12f, 0.45f, 1f, 1f), 4 => new Color(0.24f, 0.2f, 0.95f, 1f), 2 => Color.white, _ => Color.white, }); } private static string GetStatusEffectName(string damageTypeName, string damageModifierName) { return "adm_" + damageTypeName + "_" + damageModifierName; } private static string FormatStatusDisplayName(string statusName) { return statusName.Replace('_', ' '); } } internal sealed class SE_AdditiveDamageModifier : SE_Stats { public DamageModifier m_modifier; public string m_damageTypeName = ""; public string m_modifierName = ""; public override string GetIconText() { //IL_000e: Unknown result type (might be due to invalid IL or missing references) if (!AdditiveDamageModifierPlugin.ResistancePatchesEnabled) { return string.Empty; } return AdditiveDamageDisplay.FormatModifierPercent(m_modifier, (((StatusEffect)this).m_character != null && !(((StatusEffect)this).m_character is Player)) ? DamageModifierProfile.NonPlayerCharacter : DamageModifierProfile.Player); } public string GetHudName() { return m_damageTypeName + "\n" + m_modifierName; } } [HarmonyPatch(typeof(Hud), "UpdateStatusEffects")] internal static class HudUpdateStatusEffectsPatch { private const float HudNameVerticalOffset = 12f; private static void Postfix(List<StatusEffect> statusEffects, List<RectTransform> ___m_statusEffects) { if (statusEffects == null || ___m_statusEffects == null) { return; } int num = Mathf.Min(statusEffects.Count, ___m_statusEffects.Count); for (int i = 0; i < num; i++) { RectTransform val = ___m_statusEffects[i]; if (!Object.op_Implicit((Object)(object)val)) { continue; } HudStatusEffectNamePosition hudStatusEffectNamePosition = ((Component)val).GetComponent<HudStatusEffectNamePosition>(); if (statusEffects[i] is SE_AdditiveDamageModifier statusEffect) { if (!Object.op_Implicit((Object)(object)hudStatusEffectNamePosition)) { hudStatusEffectNamePosition = ((Component)val).gameObject.AddComponent<HudStatusEffectNamePosition>(); } hudStatusEffectNamePosition.Apply(statusEffect, 12f); } else if (Object.op_Implicit((Object)(object)hudStatusEffectNamePosition)) { hudStatusEffectNamePosition.Restore(); } } } } internal sealed class HudStatusEffectNamePosition : MonoBehaviour { private readonly List<TMP_Text> _nameCandidates = new List<TMP_Text>(2); private TMP_Text? _nameText; private RectTransform? _nameTransform; private bool _isOffsetApplied; public Vector2 OriginalPosition { get; private set; } public void Apply(SE_AdditiveDamageModifier statusEffect, float verticalOffset) { //IL_003a: Unknown result type (might be due to invalid IL or missing references) //IL_0045: Unknown result type (might be due to invalid IL or missing references) //IL_004a: Unknown result type (might be due to invalid IL or missing references) //IL_0018: Unknown result type (might be due to invalid IL or missing references) if (TryResolveName()) { if (!_isOffsetApplied) { OriginalPosition = _nameTransform.anchoredPosition; } _nameText.text = statusEffect.GetHudName(); _nameTransform.anchoredPosition = OriginalPosition + new Vector2(0f, verticalOffset); _isOffsetApplied = true; } } public void Restore() { //IL_001d: Unknown result type (might be due to invalid IL or missing references) if (_isOffsetApplied) { if (Object.op_Implicit((Object)(object)_nameTransform)) { _nameTransform.anchoredPosition = OriginalPosition; } _isOffsetApplied = false; } } private bool TryResolveName() { if (Object.op_Implicit((Object)(object)_nameText) && Object.op_Implicit((Object)(object)_nameTransform)) { return true; } Restore(); _nameText = null; _nameTransform = null; ((Component)this).GetComponentsInChildren<TMP_Text>(true, _nameCandidates); foreach (TMP_Text nameCandidate in _nameCandidates) { if (Object.op_Implicit((Object)(object)nameCandidate) && ((Object)((Component)nameCandidate).gameObject).name != "TimeText") { Transform transform = nameCandidate.transform; RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null); if (val != null) { _nameText = nameCandidate; _nameTransform = val; break; } } } _nameCandidates.Clear(); if (Object.op_Implicit((Object)(object)_nameText)) { return Object.op_Implicit((Object)(object)_nameTransform); } return false; } } internal static class AdditiveDamageDisplay { public static string FormatModifierPercent(DamageModifier modifier, DamageModifierProfile profile = DamageModifierProfile.Player) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) return FormatPercent(AdditiveDamageMath.ModifierToDelta(modifier, profile) * 100f); } public static string FormatMinimumTotalPercent(DamageType damageType) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) return FormatPercent((AdditiveDamageModifierPlugin.GetMinimumDamageTakenMultiplier(damageType) - 1f) * 100f); } internal static string FormatPercent(float value) { return Mathf.RoundToInt(value).ToString("+0;-0;0", CultureInfo.InvariantCulture) + "%"; } } [HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[] { typeof(ItemData), typeof(int), typeof(bool), typeof(float), typeof(int), typeof(bool) })] internal static class ItemDataGetTooltipAdditiveDamagePatch { private static void Prefix([HarmonyArgument(0)] ItemData item, out bool __state) { //IL_0032: Unknown result type (might be due to invalid IL or missing references) __state = false; if (item?.m_shared?.m_damageModifiers != null) { Player localPlayer = Player.m_localPlayer; bool isApplied = Object.op_Implicit((Object)(object)localPlayer) && IsPassiveArmor(item.m_shared.m_itemType) && ((Humanoid)localPlayer).IsItemEquiped(item); AdditiveDamageTooltipContext.PushModifierSource(item.m_shared.m_damageModifiers, isApplied); __state = true; } } private static Exception? Finalizer(Exception? __exception, bool __state) { if (__state) { AdditiveDamageTooltipContext.PopModifierSource(); } return __exception; } private static bool IsPassiveArmor(ItemType itemType) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0004: Invalid comparison between Unknown and I4 //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0009: Invalid comparison between Unknown and I4 //IL_000b: Unknown result type (might be due to invalid IL or missing references) //IL_000e: Invalid comparison between Unknown and I4 if (itemType - 6 <= 1 || (int)itemType == 11 || (int)itemType == 17) { return true; } return false; } } [HarmonyPatch(typeof(SE_Stats), "GetTooltipString")] internal static class SEStatsGetTooltipStringAdditiveDamagePatch { private static void Prefix(SE_Stats __instance, out bool __state) { __state = false; if (__instance?.m_mods != null) { Player localPlayer = Player.m_localPlayer; SEMan val = (Object.op_Implicit((Object)(object)localPlayer) ? ((Character)localPlayer).GetSEMan() : null); bool isApplied = val != null && val.HaveStatusEffect(((StatusEffect)__instance).NameHash()); AdditiveDamageTooltipContext.PushModifierSource(__instance.m_mods, isApplied); __state = true; } } private static Exception? Finalizer(Exception? __exception, bool __state) { if (__state) { AdditiveDamageTooltipContext.PopModifierSource(); } return __exception; } } [HarmonyPatch(typeof(SE_Stats), "GetDamageModifiersTooltipString")] internal static class SEStatsDamageModifiersTooltipPatch { private static bool Prefix(List<DamageModPair> mods, ref string __result) { if (!AdditiveDamageTooltipBuilder.TryBuildDamageModifiersTooltipString(mods, AdditiveDamageTooltipContext.IncludeMinimumTotal, out string tooltip)) { return true; } __result = tooltip; return false; } } [HarmonyPatch(typeof(TextsDialog), "AddActiveEffects")] internal static class TextsDialogAddActiveEffectsPatch { private static void Prefix() { AdditiveDamageTooltipContext.PushActiveEffectsCompendium(); } private static Exception? Finalizer(Exception? __exception) { AdditiveDamageTooltipContext.PopActiveEffectsCompendium(); return __exception; } } internal static class AdditiveDamageTooltipContext { private readonly struct ModifierSource { public List<DamageModPair> Modifiers { get; } public bool IsApplied { get; } public ModifierSource(List<DamageModPair> modifiers, bool isApplied) { Modifiers = modifiers; IsApplied = isApplied; } } [ThreadStatic] private static int _activeEffectsCompendiumDepth; [ThreadStatic] private static int _tooltipScopeDepth; [ThreadStatic] private static Stack<ModifierSource>? _modifierSources; [ThreadStatic] private static bool _netModifiersResolved; [ThreadStatic] private static bool _hasNetModifiers; [ThreadStatic] private static DamageModifiers _netModifiers; private static bool _loggedNetCalculationFailure; public static bool IncludeMinimumTotal => _activeEffectsCompendiumDepth > 0; public static void PushActiveEffectsCompendium() { BeginTooltipScope(); _activeEffectsCompendiumDepth++; } public static void PopActiveEffectsCompendium() { if (_activeEffectsCompendiumDepth > 0) { _activeEffectsCompendiumDepth--; EndTooltipScope(); } } public static void PushModifierSource(List<DamageModPair> modifiers, bool isApplied) { BeginTooltipScope(); try { (_modifierSources ?? (_modifierSources = new Stack<ModifierSource>(4))).Push(new ModifierSource(modifiers, isApplied)); } catch { EndTooltipScope(); throw; } } public static void PopModifierSource() { Stack<ModifierSource> modifierSources = _modifierSources; if (modifierSources != null && modifierSources.Count > 0) { _modifierSources.Pop(); } EndTooltipScope(); } public static bool TryGetNetModifiers(List<DamageModPair> modifiers, out DamageModifiers netModifiers) { //IL_0001: 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) //IL_0079: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Unknown result type (might be due to invalid IL or missing references) //IL_0033: Unknown result type (might be due to invalid IL or missing references) netModifiers = default(DamageModifiers); if (!IsAppliedSource(modifiers)) { return false; } if (!_netModifiersResolved) { _netModifiersResolved = true; Player localPlayer = Player.m_localPlayer; if (Object.op_Implicit((Object)(object)localPlayer)) { try { _netModifiers = ((Character)localPlayer).GetDamageModifiers((WeakSpot)null); _hasNetModifiers = true; } catch (Exception ex) { if (!_loggedNetCalculationFailure) { _loggedNetCalculationFailure = true; AdditiveDamageModifierPlugin.AdditiveDamageModifierLogger.LogWarning((object)("Could not calculate current player Net damage modifiers: " + ex.Message)); } } } } if (!_hasNetModifiers) { return false; } netModifiers = _netModifiers; return true; } private static bool IsAppliedSource(List<DamageModPair> modifiers) { Stack<ModifierSource> modifierSources = _modifierSources; if (modifierSources == null || modifierSources.Count <= 0) { return false; } foreach (ModifierSource item in modifierSources) { if (item.Modifiers == modifiers) { return item.IsApplied; } } return false; } private static void BeginTooltipScope() { //IL_0028: Unknown result type (might be due to invalid IL or missing references) if (_tooltipScopeDepth == 0) { _modifierSources?.Clear(); _netModifiersResolved = false; _hasNetModifiers = false; _netModifiers = default(DamageModifiers); } _tooltipScopeDepth++; } private static void EndTooltipScope() { //IL_003c: Unknown result type (might be due to invalid IL or missing references) if (_tooltipScopeDepth != 0) { _tooltipScopeDepth--; if (_tooltipScopeDepth == 0) { _modifierSources?.Clear(); _netModifiersResolved = false; _hasNetModifiers = false; _netModifiers = default(DamageModifiers); } } } } internal static class AdditiveDamageTooltipBuilder { public static bool TryBuildDamageModifiersTooltipString(List<DamageModPair> mods, bool includeMinimumTotal, out string tooltip) { //IL_001f: 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_004e: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Unknown result type (might be due to invalid IL or missing references) //IL_0052: Unknown result type (might be due to invalid IL or missing references) //IL_0058: Invalid comparison between Unknown and I4 //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_005f: Unknown result type (might be due to invalid IL or missing references) //IL_0069: Unknown result type (might be due to invalid IL or missing references) //IL_006b: Unknown result type (might be due to invalid IL or missing references) //IL_0079: Unknown result type (might be due to invalid IL or missing references) //IL_007b: Unknown result type (might be due to invalid IL or missing references) //IL_00f7: Unknown result type (might be due to invalid IL or missing references) //IL_00f9: Unknown result type (might be due to invalid IL or missing references) //IL_00fe: Unknown result type (might be due to invalid IL or missing references) //IL_0100: Unknown result type (might be due to invalid IL or missing references) //IL_0117: Unknown result type (might be due to invalid IL or missing references) //IL_0119: Unknown result type (might be due to invalid IL or missing references) //IL_011e: Unknown result type (might be due to invalid IL or missing references) if (mods.Count == 0) { tooltip = ""; return true; } bool flag = includeMinimumTotal || AdditiveDamageModifierPlugin.ShowModifierPercentInTooltipsOutsideCompendium(); DamageModifiers netModifiers = default(DamageModifiers); bool flag2 = flag && AdditiveDamageTooltipContext.TryGetNetModifiers(mods, out netModifiers); string text = ""; foreach (DamageModPair mod in mods) { if ((int)mod.m_modifier == 4 || (int)mod.m_modifier == 0) { continue; } if (!AdditiveDamageDefinitions.TryGetDamageModifier(mod.m_modifier, out var definition) || !AdditiveDamageDefinitions.TryGetDamageType(mod.m_type, out var definition2)) { tooltip = ""; return false; } if (!string.IsNullOrEmpty(definition.LocalizationKey) && !string.IsNullOrEmpty(definition2.LocalizationKey)) { text += "\n$inventory_dmgmod: "; text = text + "<color=orange>" + definition.LocalizationKey + "</color> VS "; text = text + "<color=orange>" + definition2.LocalizationKey + "</color>"; if (flag) { text += GetModifierTooltipSuffix(mod.m_type, mod.m_modifier, includeMinimumTotal, flag2 ? new DamageModifier?(((DamageModifiers)(ref netModifiers)).GetModifier(mod.m_type)) : ((DamageModifier?)null)); } } } tooltip = text; return true; } private static string GetModifierTooltipSuffix(DamageType damageType, DamageModifier modifier, bool includeMinimumTotal, DamageModifier? netModifier) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_001d: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Invalid comparison between Unknown and I4 //IL_004b: Unknown result type (might be due to invalid IL or missing references) string text = " (" + AdditiveDamageDisplay.FormatModifierPercent(modifier); if (netModifier.HasValue && TryFormatNetModifier(netModifier.Value, out string text2)) { text = text + " / $adm_tooltip_net_label " + text2; } if (includeMinimumTotal && (int)netModifier.GetValueOrDefault() != 4) { text = text + " / $adm_tooltip_min_total_label " + AdditiveDamageDisplay.FormatMinimumTotalPercent(damageType); } return text + ")"; } private static bool TryFormatNetModifier(DamageModifier modifier, out string text) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Invalid comparison between Unknown and I4 //IL_000d: 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) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0018: Unknown result type (might be due to invalid IL or missing references) if ((int)modifier == 4) { text = "$adm_tooltip_ignore"; return true; } if ((int)modifier == 0 || AdditiveDamageMath.IsCustomModifier(modifier) || AdditiveDamageDefinitions.TryGetDamageModifier(modifier, out var _)) { text = AdditiveDamageDisplay.FormatModifierPercent(modifier); return true; } text = ""; return false; } } [HarmonyPatch(typeof(ObjectDB), "Awake")] internal static class ObjectDbAwakeStatusEffectPatch { private static void Postfix(ObjectDB __instance) { AdditiveDamageStatusEffectCatalog.Register(__instance); } } [HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")] internal static class ObjectDbCopyOtherDbStatusEffectPatch { private static void Postfix(ObjectDB __instance) { AdditiveDamageStatusEffectCatalog.Register(__instance); } } internal enum DamageModifierProfile { Player, NonPlayerCharacter } internal static class AdditiveDamageMath { private const int CustomModifierBase = 1000000000; private const int CustomModifierScale = 1000; private const int CombineClampAbs = 100000; private const int CustomModifierZero = 1100000000; private const int CustomModifierMax = 1200000000; public static DamageModifier Combine(DamageModifier current, DamageModifier incoming, DamageModifierProfile profile) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Invalid comparison between Unknown and I4 //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Invalid comparison between Unknown and I4 //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_000d: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Unknown result type (might be due to invalid IL or missing references) //IL_001b: 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) //IL_0012: Unknown result type (might be due to invalid IL or missing references) if ((int)current == 4 || (int)incoming == 4) { return (DamageModifier)4; } if ((int)current == 0) { return incoming; } if ((int)incoming == 0) { return current; } return EncodeCustomDelta(ModifierToDelta(current, profile) + ModifierToDelta(incoming, profile)); } public static float ModifierToDelta(DamageModifier modifier, DamageModifierProfile profile) { //IL_0000: 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) if (TryDecodeCustomDelta(modifier, out var delta)) { return delta; } return AdditiveDamageModifierPlugin.GetConfiguredDelta(modifier, profile); } public static void ApplyModifiers(ref DamageModifiers modifiers, List<DamageModPair> incoming, DamageModifierProfile profile) { //IL_000e: Unknown result type (might be due to invalid IL or missing references) //IL_0013: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001a: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_001e: Invalid comparison between Unknown and I4 //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_0063: Invalid comparison between Unknown and I4 //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_0022: Invalid comparison between Unknown and I4 //IL_007d: Unknown result type (might be due to invalid IL or missing references) //IL_0083: Invalid comparison between Unknown and I4 //IL_0065: Unknown result type (might be due to invalid IL or missing references) //IL_0068: Invalid comparison between Unknown and I4 //IL_0048: Unknown result type (might be due to invalid IL or missing references) //IL_004b: Invalid comparison between Unknown and I4 //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_0026: Unknown result type (might be due to invalid IL or missing references) //IL_003c: Expected I4, but got Unknown //IL_0187: Unknown result type (might be due to invalid IL or missing references) //IL_018c: Unknown result type (might be due to invalid IL or missing references) //IL_018d: Unknown result type (might be due to invalid IL or missing references) //IL_0193: Unknown result type (might be due to invalid IL or missing references) //IL_0198: Unknown result type (might be due to invalid IL or missing references) //IL_0088: Unknown result type (might be due to invalid IL or missing references) //IL_008e: Invalid comparison between Unknown and I4 //IL_0153: Unknown result type (might be due to invalid IL or missing references) //IL_0158: Unknown result type (might be due to invalid IL or missing references) //IL_0159: Unknown result type (might be due to invalid IL or missing references) //IL_015f: Unknown result type (might be due to invalid IL or missing references) //IL_0164: Unknown result type (might be due to invalid IL or missing references) //IL_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0073: Invalid comparison between Unknown and I4 //IL_0119: Unknown result type (might be due to invalid IL or missing references) //IL_011e: Unknown result type (might be due to invalid IL or missing references) //IL_011f: Unknown result type (might be due to invalid IL or missing references) //IL_0125: Unknown result type (might be due to invalid IL or missing references) //IL_012a: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Unknown result type (might be due to invalid IL or missing references) //IL_0053: Invalid comparison between Unknown and I4 //IL_00a5: Unknown result type (might be due to invalid IL or missing references) //IL_00aa: Unknown result type (might be due to invalid IL or missing references) //IL_00ab: Unknown result type (might be due to invalid IL or missing references) //IL_00b1: Unknown result type (might be due to invalid IL or missing references) //IL_00b6: Unknown result type (might be due to invalid IL or missing references) //IL_00c2: Unknown result type (might be due to invalid IL or missing references) //IL_00c7: Unknown result type (might be due to invalid IL or missing references) //IL_00c8: Unknown result type (might be due to invalid IL or missing references) //IL_00ce: Unknown result type (might be due to invalid IL or missing references) //IL_00d3: Unknown result type (might be due to invalid IL or missing references) //IL_00df: Unknown result type (might be due to invalid IL or missing references) //IL_00e4: Unknown result type (might be due to invalid IL or missing references) //IL_00e5: Unknown result type (might be due to invalid IL or missing references) //IL_00eb: Unknown result type (might be due to invalid IL or missing references) //IL_00f0: Unknown result type (might be due to invalid IL or missing references) //IL_003c: Unknown result type (might be due to invalid IL or missing references) //IL_003e: Invalid comparison between Unknown and I4 //IL_01a1: Unknown result type (might be due to invalid IL or missing references) //IL_01a6: Unknown result type (might be due to invalid IL or missing references) //IL_01a7: Unknown result type (might be due to invalid IL or missing references) //IL_01ad: Unknown result type (might be due to invalid IL or missing references) //IL_01b2: Unknown result type (might be due to invalid IL or missing references) //IL_0093: Unknown result type (might be due to invalid IL or missing references) //IL_0099: Invalid comparison between Unknown and I4 //IL_016d: Unknown result type (might be due to invalid IL or missing references) //IL_0172: Unknown result type (might be due to invalid IL or missing references) //IL_0173: Unknown result type (might be due to invalid IL or missing references) //IL_0179: Unknown result type (might be due to invalid IL or missing references) //IL_017e: Unknown result type (might be due to invalid IL or missing references) //IL_0136: Unknown result type (might be due to invalid IL or missing references) //IL_013b: Unknown result type (might be due to invalid IL or missing references) //IL_013c: Unknown result type (might be due to invalid IL or missing references) //IL_0142: Unknown result type (might be due to invalid IL or missing references) //IL_0147: Unknown result type (might be due to invalid IL or missing references) //IL_00fc: Unknown result type (might be due to invalid IL or missing references) //IL_0101: Unknown result type (might be due to invalid IL or missing references) //IL_0102: Unknown result type (might be due to invalid IL or missing references) //IL_0108: Unknown result type (might be due to invalid IL or missing references) //IL_010d: Unknown result type (might be due to invalid IL or missing references) //IL_01bb: Unknown result type (might be due to invalid IL or missing references) //IL_01c0: Unknown result type (might be due to invalid IL or missing references) //IL_01c1: Unknown result type (might be due to invalid IL or missing references) //IL_01c7: Unknown result type (might be due to invalid IL or missing references) //IL_01cc: Unknown result type (might be due to invalid IL or missing references) foreach (DamageModPair item in incoming) { DamageType type = item.m_type; if ((int)type <= 32) { if ((int)type <= 8) { switch (type - 1) { case 0: modifiers.m_blunt = Combine(modifiers.m_blunt, item.m_modifier, profile); continue; case 1: modifiers.m_slash = Combine(modifiers.m_slash, item.m_modifier, profile); continue; case 3: modifiers.m_pierce = Combine(modifiers.m_pierce, item.m_modifier, profile); continue; case 2: continue; } if ((int)type == 8) { modifiers.m_chop = Combine(modifiers.m_chop, item.m_modifier, profile); } } else if ((int)type != 16) { if ((int)type == 32) { modifiers.m_fire = Combine(modifiers.m_fire, item.m_modifier, profile); } } else { modifiers.m_pickaxe = Combine(modifiers.m_pickaxe, item.m_modifier, profile); } } else if ((int)type <= 128) { if ((int)type != 64) { if ((int)type == 128) { modifiers.m_lightning = Combine(modifiers.m_lightning, item.m_modifier, profile); } } else { modifiers.m_frost = Combine(modifiers.m_frost, item.m_modifier, profile); } } else if ((int)type != 256) { if ((int)type != 512) { if ((int)type == 2048) { modifiers.m_nonPlayer = Combine(modifiers.m_nonPlayer, item.m_modifier, profile); } } else { modifiers.m_spirit = Combine(modifiers.m_spirit, item.m_modifier, profile); } } else { modifiers.m_poison = Combine(modifiers.m_poison, item.m_modifier, profile); } } } internal static bool IsCustomModifier(DamageModifier modifier) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Expected I4, but got Unknown return IsCustomModifierRaw((int)modifier); } internal static bool TryDecodeCustomDelta(DamageModifier modifier, out float delta) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Expected I4, but got Unknown int num = (int)modifier; if (!IsCustomModifierRaw(num)) { delta = 0f; return false; } delta = (float)(num - 1100000000) / 1000f; return true; } private static bool IsCustomModifierRaw(int rawValue) { if (rawValue >= 1000000000) { return rawValue <= 1200000000; } return false; } private static DamageModifier EncodeCustomDelta(float delta) { float num = Mathf.Clamp(delta, -100000f, 100000f); return (DamageModifier)(1100000000 + Mathf.RoundToInt(num * 1000f)); } public static float ApplyModifier(float baseDamage, DamageModifier mod, float minimumDamageTakenMultiplier, DamageModifierProfile profile, ref float normalDmg, ref float resistantDmg, ref float weakDmg, ref float immuneDmg) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Invalid comparison between Unknown and I4 //IL_0012: Unknown result type (might be due to invalid IL or missing references) if ((int)mod == 4) { return 0f; } float num = minimumDamageTakenMultiplier - 1f; float num2 = Mathf.Clamp(ModifierToDelta(mod, profile), num, 100f); float num3 = Mathf.Max(minimumDamageTakenMultiplier, 1f + num2); float num4 = Mathf.Max(0f, baseDamage * num3); if (Mathf.Approximately(num2, 0f)) { normalDmg += baseDamage; } else if (num2 < 0f) { if (num4 <= 0f) { immuneDmg += baseDamage; } else { resistantDmg += baseDamage; } } else { weakDmg += baseDamage; } return num4; } } internal static class CharacterDamageContext { private readonly struct HitScope { public HitData Hit { get; } public DamageModifierProfile Profile { get; } public HitScope(HitData hit, DamageModifierProfile profile) { Hit = hit; Profile = profile; } } [ThreadStatic] private static List<HitScope>? _hitStack; public static int Enter(HitData hitData, DamageModifierProfile profile) { if (hitData == null) { throw new ArgumentNullException("hitData"); } List<HitScope>? obj = _hitStack ?? (_hitStack = new List<HitScope>(4)); int count = obj.Count; obj.Add(new HitScope(hitData, profile)); return count; } public static void Exit(int depth) { List<HitScope> hitStack = _hitStack; if (hitStack != null && depth >= 0 && depth < hitStack.Count) { hitStack.RemoveRange(depth, hitStack.Count - depth); } } public static bool TryGetProfile(HitData hitData, out DamageModifierProfile profile) { List<HitScope> hitStack = _hitStack; if (hitStack != null && hitStack.Count > 0 && hitStack[hitStack.Count - 1].Hit == hitData) { profile = hitStack[hitStack.Count - 1].Profile; return true; } profile = DamageModifierProfile.Player; return false; } } [HarmonyPatch(typeof(Player), "Awake")] internal static class PlayerBaseDamageModifiersPatch { private static void Prefix(Player __instance) { ConvertBaseImmunities(ref ((Character)__instance).m_damageModifiers); } internal static void ConvertBaseImmunities(ref DamageModifiers modifiers) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Invalid comparison between Unknown and I4 //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0017: Invalid comparison between Unknown and I4 //IL_000b: Unknown result type (might be due to invalid IL or missing references) //IL_0021: Unknown result type (might be due to invalid IL or missing references) //IL_0027: Invalid comparison between Unknown and I4 //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_002b: Unknown result type (might be due to invalid IL or missing references) if ((int)modifiers.m_spirit == 3) { modifiers.m_spirit = (DamageModifier)4; } if ((int)modifiers.m_chop == 3) { modifiers.m_chop = (DamageModifier)4; } if ((int)modifiers.m_pickaxe == 3) { modifiers.m_pickaxe = (DamageModifier)4; } } } [HarmonyPatch] internal static class CharacterDamageCallSitePatch { private static readonly MethodInfo ApplyListMethod = AccessTools.Method(typeof(DamageModifiers), "Apply", new Type[1] { typeof(List<DamageModPair>) }, (Type[])null); private static readonly MethodInfo ApplyResistanceMethod = AccessTools.Method(typeof(HitData), "ApplyResistance", new Type[2] { typeof(DamageModifiers), typeof(DamageModifier).MakeByRefType() }, (Type[])null); private static readonly MethodInfo ApplyListForCharacterMethod = AccessTools.Method(typeof(CharacterDamageCallSitePatch), "ApplyModifiersForCharacter", (Type[])null, (Type[])null); private static readonly MethodInfo ApplyResistanceForCharacterMethod = AccessTools.Method(typeof(CharacterDamageCallSitePatch), "ApplyResistanceForCharacter", (Type[])null, (Type[])null); private static readonly FieldInfo EffectCharacterField = AccessTools.Field(typeof(StatusEffect), "m_character"); private static IEnumerable<MethodBase> TargetMethods() { yield return RequiredMethod(typeof(Character), "RPC_Damage", typeof(long), typeof(HitData)); yield return RequiredMethod(typeof(Humanoid), "BlockAttack", typeof(HitData), typeof(Character)); yield return RequiredMethod(typeof(Player), "ApplyArmorDamageMods", typeof(DamageModifiers).MakeByRefType()); yield return RequiredMethod(typeof(SE_Stats), "ModifyDamageMods", typeof(DamageModifiers).MakeByRefType()); } private static MethodInfo RequiredMethod(Type type, string name, params Type[] arguments) { return AccessTools.DeclaredMethod(type, name, arguments, (Type[])null) ?? throw new MissingMethodException(type.FullName, name); } private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod) { List<CodeInstruction> list = new List<CodeInstruction>(); int num = 0; int num2 = 0; foreach (CodeInstruction instruction2 in instructions) { CodeInstruction val = new CodeInstruction(instruction2); if (CodeInstructionExtensions.Calls(val, ApplyListMethod)) { num++; } if (CodeInstructionExtensions.Calls(val, ApplyResistanceMethod)) { num2++; } list.Add(val); } bool num3 = __originalMethod.DeclaringType == typeof(Character); bool flag = __originalMethod.DeclaringType == typeof(Humanoid); bool isEffect = __originalMethod.DeclaringType == typeof(SE_Stats); int num4 = ((!num3) ? ((flag || isEffect) ? 1 : 4) : 0); int num5 = ((num3 || flag) ? 1 : 0); if (num != num4 || num2 != num5 || (isEffect && (EffectCharacterField == null || EffectCharacterField.FieldType != typeof(Character)))) { throw new InvalidOperationException($"Unsupported {__originalMethod.DeclaringType?.Name}.{__originalMethod.Name} damage calls: Apply {num}/{num4}, ApplyResistance {num2}/{num5}."); } foreach (CodeInstruction instruction in list) { bool applyList = CodeInstructionExtensions.Calls(instruction, ApplyListMethod); if (applyList || CodeInstructionExtensions.Calls(instruction, ApplyResistanceMethod)) { if (instruction.blocks.Count != 0) { throw new InvalidOperationException("Unsupported exception boundary at " + __originalMethod.Name + " damage call."); } CodeInstruction val2 = new CodeInstruction(OpCodes.Ldarg_0, (object)null); val2.labels.AddRange(instruction.labels); instruction.labels.Clear(); yield return val2; if (isEffect) { yield return new CodeInstruction(OpCodes.Ldfld, (object)EffectCharacterField); } instruction.opcode = OpCodes.Call; instruction.operand = (applyList ? ApplyListForCharacterMethod : ApplyResistanceForCharacterMethod); } yield return instruction; } } internal static void ApplyModifiersForCharacter(ref DamageModifiers modifiers, List<DamageModPair> incoming, Character? character) { if (character == null) { ((DamageModifiers)(ref modifiers)).Apply(incoming); } else { AdditiveDamageMath.ApplyModifiers(ref modifiers, incoming, (!(character is Player)) ? DamageModifierProfile.NonPlayerCharacter : DamageModifierProfile.Player); } } internal static void ApplyResistanceForCharacter(HitData hit, DamageModifiers modifiers, out DamageModifier significantModifier, Character character) { //IL_0014: Unknown result type (might be due to invalid IL or missing references) int depth = CharacterDamageContext.Enter(hit, (!(character is Player)) ? DamageModifierProfile.NonPlayerCharacter : DamageModifierProfile.Player); try { hit.ApplyResistance(modifiers, ref significantModifier); } finally { CharacterDamageContext.Exit(depth); } } } [HarmonyPatch(typeof(Character), "UpdateGroundContact")] internal static class CharacterUpdateGroundContactFallDamagePatch { private static readonly MethodInfo Clamp01Method = AccessTools.Method(typeof(Mathf), "Clamp01", new Type[1] { typeof(float) }, (Type[])null); private static readonly MethodInfo ScaleFallDamageProgressMethod = AccessTools.Method(typeof(CharacterUpdateGroundContactFallDamagePatch), "ScaleFallDamageProgress", (Type[])null, (Type[])null); private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) { List<CodeInstruction> list = new List<CodeInstruction>(instructions); int num = 0; for (int i = 0; i < list.Count; i++) { if (CodeInstructionExtensions.Calls(list[i], Clamp01Method)) { num++; } } if (num != 1) { AdditiveDamageModifierPlugin.AdditiveDamageModifierLogger.LogWarning((object)($"Character.UpdateGroundContact shape changed (expected 1 Mathf.Clamp01 call, found {num}). " + "Disabling fall damage scaling patch for safety.")); foreach (CodeInstruction item in list) { yield return item; } yield break; } bool replaced = false; foreach (CodeInstruction item2 in list) { if (!replaced && CodeInstructionExtensions.Calls(item2, Clamp01Method)) { replaced = true; item2.opcode = OpCodes.Call; item2.operand = ScaleFallDamageProgressMethod; yield return item2; } else { yield return item2; } } } private static float ScaleFallDamageProgress(float normalizedFallDistance) { float num = Mathf.Max(0f, normalizedFallDistance) * AdditiveDamageModifierPlugin.GetFallDamageMultiplier(); float num2 = AdditiveDamageModifierPlugin.GetFallDamageCap() / 100f; return Mathf.Min(num, num2); } } [HarmonyPatch(typeof(HitData), "ApplyResistance")] internal static class HitDataApplyResistancePatch { private static bool Prefix(HitData __instance, DamageModifiers modifiers, ref DamageModifier significantModifier) { //IL_0036: Unknown result type (might be due to invalid IL or missing references) //IL_0037: Unknown result type (might be due to invalid IL or missing references) //IL_0056: Unknown result type (might be due to invalid IL or missing references) //IL_0057: Unknown result type (might be due to invalid IL or missing references) //IL_0076: Unknown result type (might be due to invalid IL or missing references) //IL_0077: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Unknown result type (might be due to invalid IL or missing references) //IL_0097: Unknown result type (might be due to invalid IL or missing references) //IL_00b6: Unknown result type (might be due to invalid IL or missing references) //IL_00b7: 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_00d8: Unknown result type (might be due to invalid IL or missing references) //IL_00f8: Unknown result type (might be due to invalid IL or missing references) //IL_00f9: Unknown result type (might be due to invalid IL or missing references) //IL_0119: Unknown result type (might be due to invalid IL or missing references) //IL_011a: Unknown result type (might be due to invalid IL or missing references) //IL_013d: Unknown result type (might be due to invalid IL or missing references) //IL_013e: Unknown result type (might be due to invalid IL or missing references) //IL_0161: Unknown result type (might be due to invalid IL or missing references) //IL_0162: Unknown result type (might be due to invalid IL or missing references) //IL_0185: Unknown result type (might be due to invalid IL or missing references) //IL_0186: Unknown result type (might be due to invalid IL or missing references) //IL_01a4: Unknown result type (might be due to invalid IL or missing references) //IL_01aa: Expected I4, but got Unknown if (!CharacterDamageContext.TryGetProfile(__instance, out var profile)) { return true; } float normalDmg = __instance.m_damage.m_damage; float resistantDmg = 0f; float weakDmg = 0f; float immuneDmg = 0f; ApplyModifierForType(ref __instance.m_damage.m_blunt, modifiers.m_blunt, (DamageType)1, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_slash, modifiers.m_slash, (DamageType)2, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_pierce, modifiers.m_pierce, (DamageType)4, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_chop, modifiers.m_chop, (DamageType)8, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_pickaxe, modifiers.m_pickaxe, (DamageType)16, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_fire, modifiers.m_fire, (DamageType)32, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_frost, modifiers.m_frost, (DamageType)64, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_lightning, modifiers.m_lightning, (DamageType)128, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_poison, modifiers.m_poison, (DamageType)256, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_spirit, modifiers.m_spirit, (DamageType)512, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); ApplyModifierForType(ref __instance.m_damage.m_nonPlayer, modifiers.m_nonPlayer, (DamageType)2048, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); significantModifier = (DamageModifier)(int)DetermineSignificantModifier(normalDmg, resistantDmg, weakDmg, immuneDmg); return false; } private static void ApplyModifierForType(ref float damage, DamageModifier mod, DamageType damageType, DamageModifierProfile profile, ref float normalDmg, ref float resistantDmg, ref float weakDmg, ref float immuneDmg) { //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Unknown result type (might be due to invalid IL or missing references) float minimumDamageTakenMultiplier = ((profile == DamageModifierProfile.Player) ? AdditiveDamageModifierPlugin.GetMinimumDamageTakenMultiplier(damageType) : 0f); damage = AdditiveDamageMath.ApplyModifier(damage, mod, minimumDamageTakenMultiplier, profile, ref normalDmg, ref resistantDmg, ref weakDmg, ref immuneDmg); } private static DamageModifier DetermineSignificantModifier(float normalDmg, float resistantDmg, float weakDmg, float immuneDmg) { if (weakDmg >= resistantDmg && weakDmg >= immuneDmg && weakDmg >= normalDmg) { return (DamageModifier)2; } if (resistantDmg >= weakDmg && resistantDmg >= immuneDmg && resistantDmg >= normalDmg) { return (DamageModifier)1; } if (normalDmg >= resistantDmg && normalDmg >= weakDmg && normalDmg >= immuneDmg) { return (DamageModifier)0; } return (DamageModifier)3; } } [HarmonyPatch(typeof(Player), "UpdateEnvStatusEffects")] internal static class PlayerEnvStatusImmunityPatch { private static readonly MethodInfo GetModifierMethod = AccessTools.Method(typeof(DamageModifiers), "GetModifier", (Type[])null, (Type[])null); private static readonly MethodInfo GetModifierForEnvMethod = AccessTools.Method(typeof(PlayerEnvStatusImmunityPatch), "GetModifierForEnv", (Type[])null, (Type[])null); private static DamageModifier GetModifierForEnv(ref DamageModifiers modifiers, DamageType damageType) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Unknown result type (might be due to invalid IL or missing references) //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_000b: Invalid comparison between Unknown and I4 //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_000d: Unknown result type (might be due to invalid IL or missing references) DamageModifier modifier = ((DamageModifiers)(ref modifiers)).GetModifier(damageType); if ((int)damageType != 64) { return modifier; } float num = AdditiveDamageMath.ModifierToDelta(modifier, DamageModifierProfile.Player); float frostEnvImmunityTriggerDelta = AdditiveDamageModifierPlugin.GetFrostEnvImmunityTriggerDelta(); if (!(num <= frostEnvImmunityTriggerDelta)) { return (DamageModifier)0; } return (DamageModifier)7; } private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) { int replacementCount = 0; foreach (CodeInstruction instruction in instructions) { if (CodeInstructionExtensions.Calls(instruction, GetModifierMethod)) { replacementCount++; instruction.opcode = OpCodes.Call; instruction.operand = GetModifierForEnvMethod; yield return instruction; } else { yield return instruction; } } if (replacementCount == 0) { AdditiveDamageModifierPlugin.AdditiveDamageModifierLogger.LogWarning((object)"Player.UpdateEnvStatusEffects shape changed (no DamageModifiers.GetModifier calls found). Cold/Freezing immunity threshold patch was not applied."); } } } [BepInPlugin("sighsorry.AdditiveDamageModifier", "AdditiveDamageModifier", "1.2.6")] [BepInDependency(/*Could not decode attribute arguments.*/)] public class AdditiveDamageModifierPlugin : BaseUnityPlugin { public enum Toggle { On = 1, Off = 0 } private sealed class ConfigurationManagerAttributes { public int? Order; } internal const string ModName = "AdditiveDamageModifier"; internal const string ModVersion = "1.2.6"; internal const string Author = "sighsorry"; private const string ModGUID = "sighsorry.AdditiveDamageModifier"; internal const string PathOfValheimanGuid = "treextr.pathofvalheiman"; private readonly Harmony _harmony = new Harmony("sighsorry.AdditiveDamageModifier"); public static readonly ManualLogSource AdditiveDamageModifierLogger = Logger.CreateLogSource("AdditiveDamageModifier"); private static readonly ConfigSync ConfigSync = new ConfigSync("sighsorry.AdditiveDamageModifier") { DisplayName = "AdditiveDamageModifier", CurrentVersion = "1.2.6", MinimumRequiredVersion = "1.2.6" }; private static readonly Dictionary<DamageModifier, ConfigEntry<int>> PlayerModifierPercentConfigs = new Dictionary<DamageModifier, ConfigEntry<int>>(); private static readonly Dictionary<DamageModifier, ConfigEntry<int>> NonPlayerModifierPercentConfigs = new Dictionary<DamageModifier, ConfigEntry<int>>(); private static readonly Dictionary<DamageType, ConfigEntry<int>> PlayerMinimumDamageCapConfigs = new Dictionary<DamageType, ConfigEntry<int>>(); private static ConfigEntry<Toggle> _serverConfigLocked = null; private static ConfigEntry<Toggle> _showModifierPercentInTooltipsOutsideCompendium = null; private static ConfigEntry<int> _fallDamageCap = null; private static ConfigEntry<float> _fallDamageMultiplier = null; private static ConfigEntry<int> _frostEnvImmunityTriggerFrostDeltaPercent = null; internal static bool ResistancePatchesEnabled { get; private set; } = true; public void Awake() { DetectResistanceCompatibility(); Localizer.Load((BaseUnityPlugin)(object)this); bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet; ((BaseUnityPlugin)this).Config.SaveOnConfigSet = false; try { BindConfigEntries(); try { ApplyPatches(); } catch { _harmony.UnpatchSelf(); throw; } ((BaseUnityPlugin)this).Config.Save(); } finally { ((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet; } } private static void DetectResistanceCompatibility() { ResistancePatchesEnabled = !Chainloader.PluginInfos.TryGetValue("treextr.pathofvalheiman", out var value) || value.Instance == null; if (!ResistancePatchesEnabled) { AdditiveDamageModifierLogger.LogInfo((object)($"Path of Valheiman {value.Metadata.Version} is loaded: ADM resistance calculation, player base Ignore conversion, " + "Cold/Freezing threshold and resistance percent/Net/MinTotal displays are disabled. Saved configuration, adm_* status effects and fall damage tuning are retained. Restart after changing the mod set.")); } } private void ApplyPatches() { Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(typeof(AdditiveDamageModifierPlugin).Assembly); foreach (Type type in typesFromAssembly) { if (ShouldApplyPatch(type)) { _harmony.CreateClassProcessor(type).Patch(); } } } internal static bool ShouldApplyPatch(Type patchType) { if (!ResistancePatchesEnabled) { if (patchType != typeof(PlayerBaseDamageModifiersPatch) && patchType != typeof(CharacterDamageCallSitePatch) && patchType != typeof(HitDataApplyResistancePatch) && patchType != typeof(PlayerEnvStatusImmunityPatch) && patchType != typeof(ItemDataGetTooltipAdditiveDamagePatch) && patchType != typeof(SEStatsGetTooltipStringAdditiveDamagePatch) && patchType != typeof(SEStatsDamageModifiersTooltipPatch)) { return patchType != typeof(TextsDialogAddActiveEffectsPatch); } return false; } return true; } private void BindConfigEntries() { //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_0040: Expected O, but got Unknown //IL_0085: Unknown result type (might be due to invalid IL or missing references) //IL_0090: Expected O, but got Unknown //IL_00c8: Unknown result type (might be due to invalid IL or missing references) //IL_00db: Unknown result type (might be due to invalid IL or missing references) //IL_01f5: Unknown result type (might be due to invalid IL or missing references) //IL_0200: Expected O, but got Unknown //IL_0239: Unknown result type (might be due to invalid IL or missing references) //IL_0244: Expected O, but got Unknown //IL_0161: Unknown result type (might be due to invalid IL or missing references) //IL_016b: Expected O, but got Unknown //IL_0190: Unknown result type (might be due to invalid IL or missing references) //IL_02a1: Unknown result type (might be due to invalid IL or missing references) //IL_02ac: Expected O, but got Unknown PlayerModifierPercentConfigs.Clear(); NonPlayerModifierPercentConfigs.Clear(); PlayerMinimumDamageCapConfigs.Clear(); _serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, new ConfigDescription("If on, the configuration is locked and can be changed by server admins only.", (AcceptableValueBase)null, Array.Empty<object>())); ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked); _showModifierPercentInTooltipsOutsideCompendium = config("1 - General", "Show Modifier Percent in Tooltips Outside Compendium", Toggle.On, new ConfigDescription("If on, item and other non-compendium damage modifier tooltip lines include the configured source percent, like (-30%). Applied passive armor and active status effects also show the current player Net. The Active effects compendium always shows percent, Net for active effects, and MinTotal when applicable.", (AcceptableValueBase)null, new object[1] { new ConfigurationManagerAttributes { Order = 900 } }), synchronizedSetting: false); DamageModifierDefinition[] damageModifiers = AdditiveDamageDefinitions.DamageModifiers; for (int i = 0; i < damageModifiers.Length; i++) { DamageModifierDefinition definition = damageModifiers[i]; ConfigEntry<int> val = additivePercentConfig(definition, "2 - Additive Damage", "Player", definition.DefaultPercent); PlayerModifierPercentConfigs[definition.Modifier] = val; NonPlayerModifierPercentConfigs[definition.Modifier] = additivePercentConfig(definition, "2 - Non-Player Character Damage", "Non-player Character", val.Value); } int num = 190; DamageTypeDefinition[] damageTypes = AdditiveDamageDefinitions.DamageTypes; for (int i = 0; i < damageTypes.Length; i++) { DamageTypeDefinition damageTypeDefinition = damageTypes[i]; if (damageTypeDefinition.HasPlayerMinimumCap) { ConfigEntry<int> val2 = ((BaseUnityPlugin)this).Config.Bind<int>("2 - Additive Damage", "Minimum Damage Taken Cap Percent on Player - " + damageTypeDefinition.DisplayName, 10, new ConfigDescription("Legacy player minimum damage setting used for migration.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 50), Array.Empty<object>())); int value = val2.Value; ((BaseUnityPlugin)this).Config.Remove(((ConfigEntryBase)val2).Definition); PlayerMinimumDamageCapConfigs[damageTypeDefinition.Type] = playerMinimumDamageCapConfig("Player Minimum Damage Taken Percent - " + damageTypeDefinition.DisplayName, value, num); num -= 10; } } _fallDamageCap = config("3 - Fall Damage", "Maximum Fall Damage", 100, new ConfigDescription("Maximum fall damage before status effects. Vanilla is 100 damage at 20m. Example: 200 with multiplier 1.00 reaches 200 damage at 36m; 200 with multiplier 2.00 reaches 200 damage at 20m.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(100, 500), new object[1] { configAttributes(120) })); _fallDamageMultiplier = config("3 - Fall Damage", "Fall Damage Multiplier", 1f, new ConfigDescription("Controls how fast fall damage grows. 1.00 is vanilla speed. 2.00 doubles growth speed: 100 damage at 12m, and 200 damage at 20m if Maximum Fall Damage is 200. Values are rounded to 2 decimal places.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 2f), new object[1] { configAttributes(110) })); RoundFallDamageMultiplierConfig(); _fallDamageMultiplier.SettingChanged += delegate { RoundFallDamageMultiplierConfig(); }; _frostEnvImmunityTriggerFrostDeltaPercent = config("2 - Additive Damage", "Cold/Freezing Immunity Trigger Frost Delta Percent", -15, new ConfigDescription("Shared trigger threshold for Cold and Freezing immunity in Player.UpdateEnvStatusEffects. If effective additive frost delta is <= this value, both Cold and Freezing are blocked/cleared by vanilla flow. -15 means -15%.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-100, 0), new object[1] { configAttributes(30) })); } internal static float GetConfiguredDelta(DamageModifier modifier, DamageModifierProfile profile) { //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0019: Unknown result type (might be due to invalid IL or missing references) if (!((profile == DamageModifierProfile.Player) ? PlayerModifierPercentConfigs : NonPlayerModifierPercentConfigs).TryGetValue(modifier, out ConfigEntry<int> value)) { if (!AdditiveDamageDefinitions.TryGetDamageModifier(modifier, out var definition)) { return 0f; } return (float)definition.DefaultPercent / 100f; } return (float)value.Value / 100f; } internal static float GetMinimumDamageTakenMultiplier(DamageType damageType) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) if (!PlayerMinimumDamageCapConfigs.TryGetValue(damageType, out ConfigEntry<int> value)) { return 0f; } return Mathf.Clamp((float)value.Value / 100f, 0f, 0.5f); } internal static float GetFrostEnvImmunityTriggerDelta() { return Mathf.Clamp((float)_frostEnvImmunityTriggerFrostDeltaPercent.Value / 100f, -1f, 0f); } internal static float GetFallDamageCap() { return Mathf.Clamp(_fallDamageCap.Value, 100, 500); } internal static float GetFallDamageMultiplier() { return RoundFallDamageMultiplier(_fallDamageMultiplier.Value); } internal static bool ShowModifierPercentInTooltipsOutsideCompendium() { return _showModifierPercentInTooltipsOutsideCompendium.Value == Toggle.On; } private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true) { //IL_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0073: Expected O, but got Unknown bool flag = group == "2 - Additive Damage" || group == "2 - Non-Player Character Damage" || name == "Show Modifier Percent in Tooltips Outside Compendium"; string text = ((!ResistancePatchesEnabled && flag) ? " [Inactive while Path of Valheiman is loaded; saved value is preserved.]" : string.Empty); ConfigDescription val = new ConfigDescription(description.Description + text + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags); ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val); ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting; return val2; } private ConfigEntry<int> additivePercentConfig(DamageModifierDefinition definition, string group, string target, int initialValue) { //IL_0089: Unknown result type (might be due to invalid IL or missing references) //IL_008f: Invalid comparison between Unknown and I4 //IL_00b0: Unknown result type (might be due to invalid IL or missing references) //IL_00bb: Expected O, but got Unknown string text = definition.DefaultPercent.ToString(CultureInfo.InvariantCulture); string text2 = definition.DefaultPercent.ToString("+0;-0;0", CultureInfo.InvariantCulture); return config(group, definition.DisplayName + " Percent", initialValue, new ConfigDescription(target + " " + definition.DisplayName + " modifier value. Standard default: " + text + " (" + text2 + "% damage taken). Applies only to this Character group, not t