Decompiled source of Venture World Scaling v0.3.0
Plugins/VentureValheim.Scaling.dll
Decompiled 7 months 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.Linq; using System.Linq.Expressions; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Serialization; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text; using System.Text.RegularExpressions; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using HarmonyLib; using JetBrains.Annotations; using Microsoft.CodeAnalysis; using UnityEngine; using UnityEngine.SceneManagement; using YamlDotNet.Core; using YamlDotNet.Core.Events; using YamlDotNet.Core.Tokens; using YamlDotNet.Helpers; using YamlDotNet.Serialization; 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: Guid("DA7A94D9-DD8B-4C13-A7BF-44178396D6DF")] [assembly: ComVisible(false)] [assembly: AssemblyTrademark("")] [assembly: AssemblyCopyright("Copyright © 2022")] [assembly: AssemblyProduct("VentureValheim.Scaling")] [assembly: AssemblyCompany("")] [assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: AssemblyDescription("")] [assembly: AssemblyTitle("VentureValheim.Scaling")] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: CompilationRelaxations(8)] [assembly: AssemblyFileVersion("0.3.0")] [assembly: AssemblyConfiguration("")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("0.3.0.0")] [module: UnverifiableCode] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [<4fbbcef8-8d74-42eb-9a62-1e2a55be03f6>Embedded] internal sealed class <4fbbcef8-8d74-42eb-9a62-1e2a55be03f6>EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)] [<4fbbcef8-8d74-42eb-9a62-1e2a55be03f6>Embedded] internal sealed class <9eed9c0a-9fd3-449f-9769-233bc050d602>NullableAttribute : Attribute { public readonly byte[] NullableFlags; public <9eed9c0a-9fd3-449f-9769-233bc050d602>NullableAttribute(byte P_0) { NullableFlags = new byte[1] { P_0 }; } public <9eed9c0a-9fd3-449f-9769-233bc050d602>NullableAttribute(byte[] P_0) { NullableFlags = P_0; } } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)] [<4fbbcef8-8d74-42eb-9a62-1e2a55be03f6>Embedded] [CompilerGenerated] internal sealed class <b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContextAttribute : Attribute { public readonly byte Flag; public <b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContextAttribute(byte P_0) { Flag = P_0; } } } namespace VentureValheim.Scaling { [BepInPlugin("com.orianaventure.mod.WorldScaling", "WorldScaling", "0.3.0")] [BepInDependency(/*Could not decode attribute arguments.*/)] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] public class ScalingPlugin : BaseUnityPlugin { private static readonly ScalingPlugin _instance; private const string ModName = "WorldScaling"; private const string ModVersion = "0.3.0"; private const string Author = "com.orianaventure.mod"; private const string ModGUID = "com.orianaventure.mod.WorldScaling"; private static string ConfigFileName; private static string ConfigFileFullPath; private readonly Harmony HarmonyInstance = new Harmony("com.orianaventure.mod.WorldScaling"); public static readonly ManualLogSource VentureScalingLogger; public static ConfigEntry<bool> CE_GenerateGameData; public static ConfigEntry<string> CE_AutoScaleType; public static ConfigEntry<float> CE_AutoScaleFactor; public static ConfigEntry<bool> CE_AutoScaleIgnoreOverrides; public static ConfigEntry<bool> CE_AutoScaleCreatures; public static ConfigEntry<string> CE_AutoScaleCreatureHealth; public static ConfigEntry<string> CE_AutoScaleCreatureDamage; public static ConfigEntry<bool> CE_AutoScaleItems; private readonly ConfigurationManagerAttributes AdminConfig = new ConfigurationManagerAttributes { IsAdminOnly = true }; private readonly ConfigurationManagerAttributes ClientConfig = new ConfigurationManagerAttributes { IsAdminOnly = false }; private DateTime _lastReloadTime; private const long RELOAD_DELAY = 10000000L; public static ScalingPlugin Instance => _instance; static ScalingPlugin() { _instance = new ScalingPlugin(); ConfigFileName = "com.orianaventure.mod.WorldScaling.cfg"; string configPath = Paths.ConfigPath; char directorySeparatorChar = Path.DirectorySeparatorChar; ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName; VentureScalingLogger = Logger.CreateLogSource("WorldScaling"); CE_GenerateGameData = null; CE_AutoScaleType = null; CE_AutoScaleFactor = null; CE_AutoScaleIgnoreOverrides = null; CE_AutoScaleCreatures = null; CE_AutoScaleCreatureHealth = null; CE_AutoScaleCreatureDamage = null; CE_AutoScaleItems = null; } private ScalingPlugin() { }//IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Expected O, but got Unknown //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_0022: Expected O, but got Unknown //IL_0023: Unknown result type (might be due to invalid IL or missing references) //IL_0028: Unknown result type (might be due to invalid IL or missing references) //IL_0034: Expected O, but got Unknown private void AddConfig<[<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(2)] T>(string key, string section, string description, bool synced, T value, ref ConfigEntry<T> configEntry) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Expected O, but got Unknown string extendedDescription = GetExtendedDescription(description, synced); configEntry = ((BaseUnityPlugin)this).Config.Bind<T>(section, key, value, new ConfigDescription(extendedDescription, (AcceptableValueBase)null, new object[1] { synced ? AdminConfig : ClientConfig })); } public string GetExtendedDescription(string description, bool synchronizedSetting) { return description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"); } public void Awake() { AddConfig("GenerateGameDataFiles", "General", "Finds all items and creatures and creates data files in your config path for viewing only (boolean).", synced: false, value: false, ref CE_GenerateGameData); AddConfig("AutoScaleType", "General", "Auto-scaling type: Vanilla, Linear, Exponential, or Custom (string).", synced: true, "Linear", ref CE_AutoScaleType); AddConfig("AutoScaleFactor", "General", "Auto-scaling factor used for the Auto-scaling type algorithm (float).", synced: true, 0.75f, ref CE_AutoScaleFactor); AddConfig("AutoScaleIgnoreOverrides", "General", "When true ignores the overrides specified in the yaml files (boolean).", synced: true, value: false, ref CE_AutoScaleIgnoreOverrides); AddConfig("ScaleCreatures", "Creatures", "Enable the scaling of creatures (boolean).", synced: true, value: true, ref CE_AutoScaleCreatures); AddConfig("CreaturesHealth", "Creatures", "Override the Base Health distribution for Creatures (comma-separated list of 6 integers) (string).", synced: true, "", ref CE_AutoScaleCreatureHealth); AddConfig("CreaturesDamage", "Creatures", "Override the Base Damage distribution for Creatures (comma-separated list of 6 integers) (string).", synced: true, "", ref CE_AutoScaleCreatureDamage); AddConfig("AutoScaleItems", "Items", "Enable the scaling of Items (boolean).", synced: true, value: true, ref CE_AutoScaleItems); Assembly executingAssembly = Assembly.GetExecutingAssembly(); HarmonyInstance.PatchAll(executingAssembly); SetupWatcher(); } private void OnDestroy() { ((BaseUnityPlugin)this).Config.Save(); } private void SetupWatcher() { _lastReloadTime = DateTime.Now; FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName); fileSystemWatcher.Changed += ReadConfigValues; fileSystemWatcher.Created += ReadConfigValues; fileSystemWatcher.Renamed += ReadConfigValues; fileSystemWatcher.IncludeSubdirectories = true; fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject; fileSystemWatcher.EnableRaisingEvents = true; } private void ReadConfigValues(object sender, FileSystemEventArgs e) { DateTime now = DateTime.Now; long num = now.Ticks - _lastReloadTime.Ticks; if (File.Exists(ConfigFileFullPath) && num >= 10000000) { try { VentureScalingLogger.LogInfo((object)"Attempting to reload configuration..."); ((BaseUnityPlugin)this).Config.Reload(); } catch { VentureScalingLogger.LogError((object)("There was an issue loading " + ConfigFileName)); return; } _lastReloadTime = now; WorldConfiguration.Instance.SetupScaling(); } } } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] public interface IScalingConfiguration { bool GetGenerateGameData(); string GetAutoScaleType(); float GetAutoScaleFactor(); bool GetAutoScaleIgnoreOverrides(); bool GetAutoScaleCreatures(); string GetAutoScaleCreatureHealth(); string GetAutoScaleCreatureDamage(); bool GetAutoScaleItems(); } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class ScalingConfiguration : IScalingConfiguration { private static IScalingConfiguration _instance; public static IScalingConfiguration Instance => _instance; static ScalingConfiguration() { _instance = new ScalingConfiguration(); } public ScalingConfiguration() { } public ScalingConfiguration(IScalingConfiguration ScalingConfiguration) { _instance = ScalingConfiguration; } public bool GetGenerateGameData() { return ScalingPlugin.CE_GenerateGameData.Value; } public string GetAutoScaleType() { return ScalingPlugin.CE_AutoScaleType.Value; } public float GetAutoScaleFactor() { return ScalingPlugin.CE_AutoScaleFactor.Value; } public bool GetAutoScaleIgnoreOverrides() { return ScalingPlugin.CE_AutoScaleIgnoreOverrides.Value; } public bool GetAutoScaleCreatures() { return ScalingPlugin.CE_AutoScaleCreatures.Value; } public string GetAutoScaleCreatureHealth() { return ScalingPlugin.CE_AutoScaleCreatureHealth.Value; } public string GetAutoScaleCreatureDamage() { return ScalingPlugin.CE_AutoScaleCreatureDamage.Value; } public bool GetAutoScaleItems() { return ScalingPlugin.CE_AutoScaleItems.Value; } } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class CreatureClassification { public string Name { get; private set; } public WorldConfiguration.Biome BiomeType { get; private set; } public WorldConfiguration.Difficulty CreatureDifficulty { get; private set; } public Dictionary<string, DamageTypes> VanillaAttacks { get; private set; } public float? VanillaHealth { get; private set; } public bool Overridden { get; private set; } public Dictionary<string, CreatureOverrides.AttackOverride> OverrideAttacks { get; private set; } public float? OverrideHealth { get; private set; } public CreatureClassification(string name, WorldConfiguration.Biome? biomeType, WorldConfiguration.Difficulty? creatureDifficulty) { Reset(); Name = name; if (biomeType.HasValue) { BiomeType = biomeType.Value; } if (creatureDifficulty.HasValue) { CreatureDifficulty = creatureDifficulty.Value; } VanillaHealth = null; VanillaAttacks = null; } public void Reset() { BiomeType = WorldConfiguration.Biome.Undefined; CreatureDifficulty = WorldConfiguration.Difficulty.Undefined; Overridden = false; OverrideHealth = null; OverrideAttacks = new Dictionary<string, CreatureOverrides.AttackOverride>(); } public virtual bool IgnoreScaling() { if (WorldConfiguration.Instance.WorldScale == WorldConfiguration.Scaling.Vanilla || (WorldConfiguration.Instance.WorldScale == WorldConfiguration.Scaling.Custom && !Overridden) || CreatureDifficulty == WorldConfiguration.Difficulty.Vanilla) { return true; } return false; } public void UpdateCreature(WorldConfiguration.Biome? biomeType, WorldConfiguration.Difficulty? creatureDifficulty) { if (biomeType.HasValue) { BiomeType = biomeType.Value; } if (creatureDifficulty.HasValue) { CreatureDifficulty = creatureDifficulty.Value; } } public void OverrideCreature(CreatureOverrides.CreatureOverride creatureOverride) { Overridden = true; WorldConfiguration.Biome? biomeType = null; if (creatureOverride.biome.HasValue) { biomeType = (WorldConfiguration.Biome)creatureOverride.biome.Value; } WorldConfiguration.Difficulty? creatureDifficulty = null; if (creatureOverride.difficulty.HasValue) { creatureDifficulty = (WorldConfiguration.Difficulty)creatureOverride.difficulty.Value; } UpdateCreature(biomeType, creatureDifficulty); OverrideHealth = creatureOverride.health; OverrideAttacks = new Dictionary<string, CreatureOverrides.AttackOverride>(); if (creatureOverride.attacks == null) { return; } foreach (CreatureOverrides.AttackOverride attack in creatureOverride.attacks) { if (!Utility.IsNullOrWhiteSpace(attack.name)) { SetOverrideAttack(attack); } } } public void SetVanillaData(float health, List<GameObject> attacks) { SetVanillaHealth(health); SetVanillaAttacks(attacks); } private void SetVanillaAttacks(List<GameObject> attacks) { //IL_009d: Unknown result type (might be due to invalid IL or missing references) //IL_00a2: Unknown result type (might be due to invalid IL or missing references) //IL_00a8: Unknown result type (might be due to invalid IL or missing references) //IL_00c1: Unknown result type (might be due to invalid IL or missing references) if (VanillaAttacks != null) { return; } VanillaAttacks = new Dictionary<string, DamageTypes>(); if (attacks == null) { return; } for (int i = 0; i < attacks.Count; i++) { ItemDrop component = attacks[i].GetComponent<ItemDrop>(); if ((Object)(object)component == (Object)null) { ScalingPlugin.VentureScalingLogger.LogWarning((object)("Attack " + ((Object)attacks[i]).name + " not added to creature " + Name + ". ItemDrop not found. Will not override.")); } else if (!VanillaAttacks.ContainsKey(((Object)component).name)) { DamageTypes damages = component.m_itemData.m_shared.m_damages; if (ItemConfiguration.Instance.GetTotalDamage(damages) > 0f) { VanillaAttacks.Add(((Object)component).name, damages); continue; } ScalingPlugin.VentureScalingLogger.LogDebug((object)("Attack for " + ((Object)attacks[i]).name + " not added to creature " + Name + ". Does 0 damage. Will not override.")); } } } private void SetVanillaHealth(float health) { float? vanillaHealth = VanillaHealth; float valueOrDefault = vanillaHealth.GetValueOrDefault(); if (!vanillaHealth.HasValue) { valueOrDefault = health; float? vanillaHealth2 = valueOrDefault; VanillaHealth = vanillaHealth2; } } public bool HealthOverridden() { return OverrideHealth.HasValue; } public float? GetHealth() { if (IgnoreScaling()) { return VanillaHealth; } if (HealthOverridden()) { return OverrideHealth; } float biomeScaling = WorldConfiguration.Instance.GetBiomeScaling(BiomeType); int baseHealth = CreatureConfiguration.Instance.GetBaseHealth(CreatureDifficulty); return ScalingAPI.PrettifyNumber(CreatureConfiguration.Instance.CalculateHealth(biomeScaling, baseHealth)); } public DamageTypes? GetAttack(string name, float maxTotalDamage) { //IL_0027: Unknown result type (might be due to invalid IL or missing references) //IL_002c: 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_0117: Unknown result type (might be due to invalid IL or missing references) //IL_0107: Unknown result type (might be due to invalid IL or missing references) //IL_010c: Unknown result type (might be due to invalid IL or missing references) //IL_008a: Unknown result type (might be due to invalid IL or missing references) //IL_008f: Unknown result type (might be due to invalid IL or missing references) //IL_006a: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Unknown result type (might be due to invalid IL or missing references) //IL_00cb: Unknown result type (might be due to invalid IL or missing references) //IL_00c0: Unknown result type (might be due to invalid IL or missing references) if (Utility.IsNullOrWhiteSpace(name) || !VanillaAttacks.ContainsKey(name)) { return null; } DamageTypes val = VanillaAttacks[name]; if (IgnoreScaling()) { return val; } if (AttackOverridden(name)) { CreatureOverrides.AttackOverride attackOverride = OverrideAttacks[name]; if (attackOverride.totalDamage.HasValue) { return ItemConfiguration.Instance.CalculateDamageTypesFinal(val, attackOverride.totalDamage.Value, 1f); } DamageTypes damageTypes = CreatureOverrides.GetDamageTypes(attackOverride); if (!attackOverride.pickaxe.HasValue) { damageTypes.m_pickaxe = val.m_pickaxe; } if (!attackOverride.chop.HasValue) { damageTypes.m_chop = val.m_chop; } return damageTypes; } int baseTotalDamage = CreatureConfiguration.Instance.GetBaseTotalDamage(CreatureDifficulty); WorldConfiguration.BiomeData biome = WorldConfiguration.Instance.GetBiome(BiomeType); if (biome != null) { return ItemConfiguration.Instance.CalculateCreatureDamageTypes(biome.ScaleValue, val, baseTotalDamage, maxTotalDamage); } return val; } public bool AttackOverridden(string name) { if (OverrideAttacks == null) { return false; } return OverrideAttacks.ContainsKey(name); } public DamageTypes? GetAttackOverride(string name) { //IL_001a: Unknown result type (might be due to invalid IL or missing references) if (OverrideAttacks.ContainsKey(name)) { return CreatureOverrides.GetDamageTypes(OverrideAttacks[name]); } return null; } public float? GetAttackOverrideTotal(string name) { if (OverrideAttacks.ContainsKey(name)) { return OverrideAttacks[name].totalDamage; } return null; } private void SetOverrideAttack(CreatureOverrides.AttackOverride attack) { if (OverrideAttacks.ContainsKey(attack.name)) { OverrideAttacks[attack.name] = attack; } else { OverrideAttacks.Add(attack.name, attack); } } } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] public interface ICreatureConfiguration { bool ContainsCreature(string key); void SetBaseHealth(int[] values); int GetBaseHealth(WorldConfiguration.Difficulty difficulty); void SetBaseDamage(int[] values); int GetBaseTotalDamage(WorldConfiguration.Difficulty difficulty); void AddCreatureConfiguration(string name, WorldConfiguration.Biome? biome, WorldConfiguration.Difficulty? difficulty); void UpdateCreatures(); void VanillaReset(); } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class CreatureConfiguration : ICreatureConfiguration { private static readonly CreatureConfiguration _instance; protected Dictionary<string, CreatureClassification> _creatureData = new Dictionary<string, CreatureClassification>(); private int[] _baseHealth = new int[6] { 5, 10, 30, 50, 200, 500 }; private int[] _baseDamage = new int[6] { 5, 15, 20, 25, 30, 30 }; public static CreatureConfiguration Instance => _instance; static CreatureConfiguration() { _instance = new CreatureConfiguration(); } protected CreatureConfiguration() { } public bool ContainsCreature(string key) { return _creatureData.ContainsKey(key); } public void SetBaseHealth(int[] values) { if (values != null && values.Length == 6) { _baseHealth = values; } } public int GetBaseHealth(WorldConfiguration.Difficulty difficulty) { return difficulty switch { WorldConfiguration.Difficulty.Harmless => _baseHealth[0], WorldConfiguration.Difficulty.Novice => _baseHealth[1], WorldConfiguration.Difficulty.Average => _baseHealth[2], WorldConfiguration.Difficulty.Intermediate => _baseHealth[3], WorldConfiguration.Difficulty.Expert => _baseHealth[4], WorldConfiguration.Difficulty.Boss => _baseHealth[5], _ => _baseHealth[2], }; } public int CalculateHealth(float scale, int baseHealth) { return (int)(scale * (float)baseHealth); } public void SetBaseDamage(int[] values) { if (values != null && values.Length == 6) { _baseDamage = values; } } public int GetBaseTotalDamage(WorldConfiguration.Difficulty difficulty) { return difficulty switch { WorldConfiguration.Difficulty.Harmless => _baseDamage[0], WorldConfiguration.Difficulty.Novice => _baseDamage[1], WorldConfiguration.Difficulty.Average => _baseDamage[2], WorldConfiguration.Difficulty.Intermediate => _baseDamage[3], WorldConfiguration.Difficulty.Expert => _baseDamage[4], WorldConfiguration.Difficulty.Boss => _baseDamage[5], _ => _baseDamage[2], }; } private void ConfigureAttacks(CreatureClassification cc) { if (cc.VanillaAttacks == null || cc.VanillaAttacks.Count < 1) { return; } try { float maxCreatureDamage = GetMaxCreatureDamage(cc.VanillaAttacks); if (maxCreatureDamage <= 0f) { return; } foreach (KeyValuePair<string, DamageTypes> vanillaAttack in cc.VanillaAttacks) { ScalingAPI.GetItemDrop(vanillaAttack.Key, out var item); if ((Object)(object)item != (Object)null) { DamageTypes? attack = cc.GetAttack(vanillaAttack.Key, maxCreatureDamage); ConfigureAttack(ref item, attack); continue; } ScalingPlugin.VentureScalingLogger.LogWarning((object)("Failed to configure \"" + vanillaAttack.Key + "\" for " + cc.Name + ". ItemDrop data does not exist!")); } } catch (Exception ex) { ScalingPlugin.VentureScalingLogger.LogDebug((object)("Error configuring attacks for " + cc.Name + ". Skipping.")); ScalingPlugin.VentureScalingLogger.LogDebug((object)ex); } } private void ConfigureAttack(ref ItemDrop item, DamageTypes? value) { ItemConfiguration.Instance.UpdateWeapon(ref item, value, 1, null, playerItem: false); } protected float GetMaxCreatureDamage(Dictionary<string, DamageTypes> attacks) { //IL_0019: Unknown result type (might be due to invalid IL or missing references) //IL_001e: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Unknown result type (might be due to invalid IL or missing references) float num = 0f; if (attacks != null) { foreach (DamageTypes value in attacks.Values) { float totalDamage = ItemConfiguration.Instance.GetTotalDamage(value); if (totalDamage > num) { num = totalDamage; } } } return num; } public void Initialize() { foreach (CreatureClassification value2 in _creatureData.Values) { value2.Reset(); } WorldConfiguration.Biome value = WorldConfiguration.Biome.Meadow; AddCreatureConfiguration("Eikthyr", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("Boar_piggy", value, WorldConfiguration.Difficulty.Harmless); AddCreatureConfiguration("Boar", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Deer", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Greyling", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Neck", value, WorldConfiguration.Difficulty.Harmless); value = WorldConfiguration.Biome.BlackForest; AddCreatureConfiguration("gd_king", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("Skeleton_Hildir", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("Ghost", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Greydwarf", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Greydwarf_Elite", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Greydwarf_Shaman", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Skeleton", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Skeleton_NoArcher", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Skeleton_Poison", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("TentaRoot", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Troll", value, WorldConfiguration.Difficulty.Expert); value = WorldConfiguration.Biome.Swamp; AddCreatureConfiguration("Bonemass", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("Abomination", value, WorldConfiguration.Difficulty.Expert); AddCreatureConfiguration("Blob", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("BlobElite", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Draugr_Elite", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Draugr", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Draugr_Ranged", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Leech", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Surtling", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Wraith", value, WorldConfiguration.Difficulty.Intermediate); value = WorldConfiguration.Biome.Mountain; AddCreatureConfiguration("Dragon", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("Skeleton_Hildir", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("Bat", value, WorldConfiguration.Difficulty.Harmless); AddCreatureConfiguration("Fenring_Cultist", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Fenring", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Hatchling", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("StoneGolem", value, WorldConfiguration.Difficulty.Expert); AddCreatureConfiguration("Ulv", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Wolf_cub", value, WorldConfiguration.Difficulty.Harmless); AddCreatureConfiguration("Wolf", value, WorldConfiguration.Difficulty.Novice); value = WorldConfiguration.Biome.Plain; AddCreatureConfiguration("GoblinKing", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("BlobTar", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Deathsquito", value, WorldConfiguration.Difficulty.Harmless); AddCreatureConfiguration("Goblin", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("GoblinArcher", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("GoblinShaman", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("GoblinBrute", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Lox_Calf", value, WorldConfiguration.Difficulty.Harmless); AddCreatureConfiguration("Lox", value, WorldConfiguration.Difficulty.Intermediate); value = WorldConfiguration.Biome.Ocean; AddCreatureConfiguration("Serpent", value, WorldConfiguration.Difficulty.Expert); value = WorldConfiguration.Biome.Mistland; AddCreatureConfiguration("SeekerQueen", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("Dverger", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("DvergerMage", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("DvergerMageFire", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("DvergerMageIce", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("DvergerMageSupport", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Gjall", value, WorldConfiguration.Difficulty.Expert); AddCreatureConfiguration("Hare", value, WorldConfiguration.Difficulty.Harmless); AddCreatureConfiguration("Seeker", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("SeekerBrood", value, WorldConfiguration.Difficulty.Harmless); AddCreatureConfiguration("SeekerBrute", value, WorldConfiguration.Difficulty.Expert); AddCreatureConfiguration("Tick", value, WorldConfiguration.Difficulty.Novice); value = WorldConfiguration.Biome.AshLand; AddCreatureConfiguration("Fader", value, WorldConfiguration.Difficulty.Boss); AddCreatureConfiguration("Asksvin", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Asksvin_hatchling", value, WorldConfiguration.Difficulty.Harmless); AddCreatureConfiguration("BlobLava", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("BonemawSerpent", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Charred_Archer", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Charred_Archer_Fader", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Charred_Mage", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Charred_Melee", value, WorldConfiguration.Difficulty.Intermediate); AddCreatureConfiguration("Charred_Melee_Dyrnwyn", value, WorldConfiguration.Difficulty.Expert); AddCreatureConfiguration("Charred_Melee_Fader", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("Charred_Twitcher", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Charred_Twitcher_Summoned", value, WorldConfiguration.Difficulty.Novice); AddCreatureConfiguration("FallenValkyrie", value, WorldConfiguration.Difficulty.Expert); AddCreatureConfiguration("Morgen", value, WorldConfiguration.Difficulty.Expert); AddCreatureConfiguration("Morgen_NonSleeping", value, WorldConfiguration.Difficulty.Expert); AddCreatureConfiguration("Volture", value, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("staff_greenroots_tentaroot", WorldConfiguration.Biome.AshLand, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Skeleton_Friendly", WorldConfiguration.Biome.Mistland, WorldConfiguration.Difficulty.Average); AddCreatureConfiguration("Troll_Summoned", WorldConfiguration.Biome.AshLand, WorldConfiguration.Difficulty.Expert); if (WorldConfiguration.Instance.WorldScale != 0 && !ScalingConfiguration.Instance.GetAutoScaleIgnoreOverrides()) { ReadCustomValues(); } CreateVanillaBackup(); } public void AddCreatureConfiguration(string name, WorldConfiguration.Biome? biome, WorldConfiguration.Difficulty? difficulty) { if (!Utility.IsNullOrWhiteSpace(name)) { if (_creatureData.ContainsKey(name)) { _creatureData[name].UpdateCreature(biome, difficulty); } else { _creatureData.Add(name, new CreatureClassification(name, biome, difficulty)); } } } public void AddCreatureConfiguration(CreatureOverrides.CreatureOverride creatureOverride) { if (creatureOverride != null && !Utility.IsNullOrWhiteSpace(creatureOverride.name)) { AddCreatureConfiguration(creatureOverride.name, null, null); _creatureData[creatureOverride.name].OverrideCreature(creatureOverride); } } public void UpdateCreatures() { foreach (CreatureClassification value in _creatureData.Values) { Humanoid creature = ScalingAPI.GetHumanoid(value.Name); if ((Object)(object)creature != (Object)null) { float? health = value.GetHealth(); if (health.HasValue) { UpdateCreature(health.Value, ref creature); } ConfigureAttacks(value); } } } private void UpdateCreature(float health, ref Humanoid creature) { float health2 = ((Character)creature).m_health; ((Character)creature).m_health = health; ScalingPlugin.VentureScalingLogger.LogDebug((object)$"{((Object)creature).name}: Health updated from {health2} to {((Character)creature).m_health}."); } protected virtual void CreateVanillaBackup() { ScalingPlugin.VentureScalingLogger.LogInfo((object)"Configuring vanilla backup for Creature data..."); foreach (CreatureClassification value in _creatureData.Values) { Humanoid humanoid = ScalingAPI.GetHumanoid(value.Name); if (!((Object)(object)humanoid != (Object)null)) { continue; } List<GameObject> list = new List<GameObject>(); if (humanoid.m_defaultItems != null) { list.AddRange(humanoid.m_defaultItems); } if (humanoid.m_randomWeapon != null) { list.AddRange(humanoid.m_randomWeapon); } if (humanoid.m_randomSets != null) { for (int i = 0; i < humanoid.m_randomSets.Length; i++) { if (humanoid.m_randomSets[i].m_items != null) { list.AddRange(humanoid.m_randomSets[i].m_items); } } } value.SetVanillaData(((Character)humanoid).m_health, list); } } public void VanillaReset() { //IL_0098: Unknown result type (might be due to invalid IL or missing references) foreach (CreatureClassification value in _creatureData.Values) { Humanoid humanoid = ScalingAPI.GetHumanoid(value.Name); if (!((Object)(object)humanoid != (Object)null)) { continue; } if (value.VanillaHealth.HasValue) { ((Character)humanoid).m_health = value.VanillaHealth.Value; } if (value.VanillaAttacks == null) { continue; } foreach (KeyValuePair<string, DamageTypes> vanillaAttack in value.VanillaAttacks) { ScalingAPI.GetItemDrop(vanillaAttack.Key, out var item); if ((Object)(object)item != (Object)null) { ConfigureAttack(ref item, vanillaAttack.Value); } } } } protected virtual void ReadCustomValues() { try { CreatureOverrides.CreatureOverridesList creatureOverridesList = CreatureOverrides.ReadYaml(); if (creatureOverridesList == null) { return; } ScalingPlugin.VentureScalingLogger.LogDebug((object)"Deserializer successfully parsed yaml data."); ScalingPlugin.VentureScalingLogger.LogDebug((object)creatureOverridesList.ToString()); foreach (CreatureOverrides.CreatureOverride creature in creatureOverridesList.creatures) { AddCreatureConfiguration(creature); } } catch (Exception ex) { ScalingPlugin.VentureScalingLogger.LogWarning((object)"Error loading VWS.CreatureOverrides.yaml file."); ScalingPlugin.VentureScalingLogger.LogWarning((object)ex); ScalingPlugin.VentureScalingLogger.LogWarning((object)"Continuing without custom values..."); } } } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class CreatureOverrides { [Serializable] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class CreatureOverridesList { public IEnumerable<CreatureOverride> creatures { get; set; } public override string ToString() { if (creatures == null) { return "No Data."; } string text = $"Creatures in list {creatures.Count()}:\n"; foreach (CreatureOverride creature in creatures) { text += creature.ToString(); } return text; } } [Serializable] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class CreatureOverride { public string name { get; set; } public int? biome { get; set; } public int? difficulty { get; set; } public float? health { get; set; } public IEnumerable<AttackOverride> attacks { get; set; } public override string ToString() { string text = $"{name}: Biome {biome}, Difficulty {difficulty}, Health {health}, Attacks:\n"; if (attacks != null) { foreach (AttackOverride attack in attacks) { text += attack.ToString(); } } return text; } } [Serializable] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class AttackOverride { public string name { get; set; } public float? totalDamage { get; set; } public float? damage { get; set; } public float? blunt { get; set; } public float? slash { get; set; } public float? pierce { get; set; } public float? fire { get; set; } public float? frost { get; set; } public float? lightning { get; set; } public float? poison { get; set; } public float? spirit { get; set; } public float? chop { get; set; } public float? pickaxe { get; set; } public override string ToString() { string text = ""; if (!Utility.IsNullOrWhiteSpace(name)) { text = text + "+" + name + ": "; } if (totalDamage.HasValue) { return text + $"total damage {totalDamage}\n"; } return text + $"damage {damage}, blunt {blunt}, slash {slash}, pierce {pierce}, fire {fire}, frost {frost}, " + $"lightning {lightning}, poison {poison}, spirit {spirit}, chop {chop}, pickaxe {pickaxe}\n"; } } private static string filePath; public static CreatureOverridesList ReadYaml() { if (File.Exists(filePath)) { using (new StreamReader(filePath)) { string input = File.ReadAllText(filePath); return new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).Build().Deserialize<CreatureOverridesList>(input); } } ScalingPlugin.VentureScalingLogger.LogWarning((object)"No yaml file found, to use overrides the VWS.CreatureOverrides.yaml file must be in your bepinex config folder."); return null; } public static DamageTypes GetDamageTypes(AttackOverride attack) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_01ec: Unknown result type (might be due to invalid IL or missing references) DamageTypes result = default(DamageTypes); result.m_damage = ((!attack.damage.HasValue) ? 0f : attack.damage.Value); result.m_blunt = ((!attack.blunt.HasValue) ? 0f : attack.blunt.Value); result.m_slash = ((!attack.slash.HasValue) ? 0f : attack.slash.Value); result.m_pierce = ((!attack.pierce.HasValue) ? 0f : attack.pierce.Value); result.m_fire = ((!attack.fire.HasValue) ? 0f : attack.fire.Value); result.m_frost = ((!attack.frost.HasValue) ? 0f : attack.frost.Value); result.m_lightning = ((!attack.lightning.HasValue) ? 0f : attack.lightning.Value); result.m_poison = ((!attack.poison.HasValue) ? 0f : attack.poison.Value); result.m_spirit = ((!attack.spirit.HasValue) ? 0f : attack.spirit.Value); result.m_chop = ((!attack.chop.HasValue) ? 0f : attack.chop.Value); result.m_pickaxe = ((!attack.pickaxe.HasValue) ? 0f : attack.pickaxe.Value); return result; } static CreatureOverrides() { string configPath = Paths.ConfigPath; char directorySeparatorChar = Path.DirectorySeparatorChar; filePath = configPath + directorySeparatorChar + "VWS.CreatureOverrides.yaml"; } } public enum ItemCategory { Undefined = -1, Weapon, Armor, Shield } public enum ItemType { Undefined = -1, None = 0, Shield = 1, Helmet = 2, Chest = 3, Legs = 4, Shoulder = 5, Utility = 6, Tool = 7, PickAxe = 8, Axe = 9, Bow = 10, Ammo = 11, Sword = 20, Knife = 21, Mace = 22, Sledge = 23, Atgeir = 25, Battleaxe = 26, Primative = 27, Spear = 28, TowerShield = 29, BucklerShield = 30, PrimativeArmor = 31, Bolt = 32, Crossbow = 33, HelmetRobe = 34, ChestRobe = 35, LegsRobe = 36, Fist = 37, TurretBolt = 38, GemAxe = 39, GemBow = 40, GemSword = 41, GemKnife = 42, GemMace = 43, GemSledge = 44, GemAtgeir = 45, GemBattleaxe = 46, GemSpear = 47, GemCrossbow = 48, HelmetMedium = 49, ChestMedium = 50, LegsMedium = 51, StaffRapid = 52, StaffSlow = 53, MagicShield = 54 } [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] public class ItemClassification { public string Name { get; private set; } public WorldConfiguration.Biome BiomeType { get; private set; } public ItemType ItemType { get; private set; } public ItemCategory ItemCategory { get; private set; } public int? VanillaUpgradeLevels { get; private set; } public float? VanillaValue { get; private set; } public float? VanillaUpgradeValue { get; private set; } public DamageTypes? VanillaDamageValue { get; private set; } public DamageTypes? VanillaUpgradeDamageValue { get; private set; } public bool Overridden { get; private set; } public float? OverrideValue { get; private set; } protected CreatureOverrides.AttackOverride OverrideDamageValue { get; private set; } protected CreatureOverrides.AttackOverride OverrideUpgradeDamageValue { get; private set; } protected float? OverrideUpgradeValue { get; private set; } protected int? OverrideUpgradeLevels { get; private set; } public ItemClassification(string name, WorldConfiguration.Biome? biomeType, ItemType? itemType) { Reset(); Name = name; if (biomeType.HasValue) { BiomeType = biomeType.Value; } if (itemType.HasValue) { ItemType = itemType.Value; } ItemCategory = GetItemCategory(itemType); VanillaUpgradeLevels = null; VanillaValue = null; VanillaDamageValue = null; VanillaUpgradeValue = null; VanillaUpgradeDamageValue = null; } public void Reset() { BiomeType = WorldConfiguration.Biome.Undefined; ItemType = ItemType.Undefined; ItemCategory = ItemCategory.Undefined; Overridden = false; OverrideUpgradeLevels = null; OverrideValue = null; OverrideDamageValue = null; OverrideUpgradeValue = null; OverrideUpgradeDamageValue = null; } public virtual bool IgnoreScaling() { if (WorldConfiguration.Instance.WorldScale == WorldConfiguration.Scaling.Vanilla || (WorldConfiguration.Instance.WorldScale == WorldConfiguration.Scaling.Custom && !Overridden)) { return true; } return false; } public void UpdateItem(WorldConfiguration.Biome? biomeType, ItemType? itemType) { if (biomeType.HasValue) { BiomeType = biomeType.Value; } if (itemType.HasValue) { ItemType = itemType.Value; ItemCategory = GetItemCategory(itemType); } } public void OverrideItem(ItemOverrides.ItemOverride item) { Overridden = true; WorldConfiguration.Biome? biomeType = null; if (item.biome.HasValue) { biomeType = (WorldConfiguration.Biome)item.biome.Value; } ItemType? itemType = null; if (item.itemType.HasValue) { itemType = (ItemType)item.itemType.Value; } UpdateItem(biomeType, itemType); OverrideUpgradeLevels = item.quality; OverrideValue = item.value; OverrideDamageValue = item.damageValue; OverrideUpgradeValue = item.upgradeValue; OverrideUpgradeDamageValue = item.upgradeDamageValue; } public static ItemCategory GetItemCategory(ItemType? itemType) { if (!itemType.HasValue) { return ItemCategory.Undefined; } switch (itemType) { case ItemType.Shield: case ItemType.TowerShield: case ItemType.BucklerShield: case ItemType.MagicShield: return ItemCategory.Shield; case ItemType.Helmet: case ItemType.Chest: case ItemType.Legs: case ItemType.Shoulder: case ItemType.Utility: case ItemType.PrimativeArmor: case ItemType.HelmetRobe: case ItemType.ChestRobe: case ItemType.LegsRobe: case ItemType.HelmetMedium: case ItemType.ChestMedium: case ItemType.LegsMedium: return ItemCategory.Armor; case ItemType.Tool: case ItemType.PickAxe: case ItemType.Axe: case ItemType.Bow: case ItemType.Ammo: case ItemType.Sword: case ItemType.Knife: case ItemType.Mace: case ItemType.Sledge: case ItemType.Atgeir: case ItemType.Battleaxe: case ItemType.Primative: case ItemType.Spear: case ItemType.Bolt: case ItemType.Crossbow: case ItemType.Fist: case ItemType.TurretBolt: case ItemType.GemAxe: case ItemType.GemBow: case ItemType.GemSword: case ItemType.GemKnife: case ItemType.GemMace: case ItemType.GemSledge: case ItemType.GemAtgeir: case ItemType.GemBattleaxe: case ItemType.GemSpear: case ItemType.GemCrossbow: case ItemType.StaffRapid: case ItemType.StaffSlow: return ItemCategory.Weapon; default: return ItemCategory.Undefined; } } private bool ItemTypeDefined() { if (ItemType != ItemType.Undefined) { return ItemType != ItemType.None; } return false; } public float? GetValue() { if (IgnoreScaling()) { return VanillaValue; } if (OverrideValue.HasValue) { return OverrideValue; } if (BiomeType != WorldConfiguration.Biome.Undefined && ItemTypeDefined()) { float biomeScaling = WorldConfiguration.Instance.GetBiomeScaling(BiomeType); return (int)(GetBaseValue() * biomeScaling); } return VanillaValue; } private float GetBaseValue() { return ItemConfiguration.Instance.GetBaseItemValue(ItemType); } public float? GetUpgradeValue() { if (IgnoreScaling()) { return VanillaUpgradeValue; } if (OverrideUpgradeValue.HasValue) { return OverrideUpgradeValue; } if (BiomeType != WorldConfiguration.Biome.Undefined && ItemTypeDefined()) { int? upgradeLevels = GetUpgradeLevels(); if (upgradeLevels.HasValue) { return ItemConfiguration.Instance.CalculateUpgradeValue(BiomeType, GetBaseValue(), upgradeLevels.Value); } } return VanillaUpgradeValue; } public int? GetUpgradeLevels() { if (OverrideUpgradeLevels.HasValue) { return OverrideUpgradeLevels; } return VanillaUpgradeLevels; } public DamageTypes? GetDamageValue() { //IL_007b: 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_00ef: 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_006a: 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_0147: 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_00e0: Unknown result type (might be due to invalid IL or missing references) if (IgnoreScaling()) { return VanillaDamageValue; } if (OverrideDamageValue != null) { if (OverrideDamageValue.totalDamage.HasValue && VanillaDamageValue.HasValue) { return ItemConfiguration.Instance.CalculateDamageTypesFinal(VanillaDamageValue.Value, OverrideDamageValue.totalDamage.Value, 1f); } DamageTypes damageTypes = CreatureOverrides.GetDamageTypes(OverrideDamageValue); if (VanillaDamageValue.HasValue) { if (!OverrideDamageValue.pickaxe.HasValue) { damageTypes.m_pickaxe = VanillaDamageValue.Value.m_pickaxe; } if (!OverrideDamageValue.chop.HasValue) { damageTypes.m_chop = VanillaDamageValue.Value.m_chop; } } return damageTypes; } if (BiomeType != WorldConfiguration.Biome.Undefined && VanillaDamageValue.HasValue && ItemTypeDefined()) { WorldConfiguration.BiomeData biome = WorldConfiguration.Instance.GetBiome(BiomeType); return ItemConfiguration.Instance.CalculateItemDamageTypes(biome.ScaleValue, VanillaDamageValue.Value, GetBaseValue()); } return VanillaDamageValue; } public DamageTypes? GetUpgradeDamageValue() { //IL_0078: 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_0067: Unknown result type (might be due to invalid IL or missing references) //IL_00b8: Unknown result type (might be due to invalid IL or missing references) //IL_00d1: Unknown result type (might be due to invalid IL or missing references) if (IgnoreScaling()) { return VanillaUpgradeDamageValue; } if (OverrideUpgradeDamageValue != null) { if (OverrideUpgradeDamageValue.totalDamage.HasValue && VanillaDamageValue.HasValue) { return ItemConfiguration.Instance.CalculateDamageTypesFinal(VanillaUpgradeDamageValue.Value, OverrideUpgradeDamageValue.totalDamage.Value, 1f); } return CreatureOverrides.GetDamageTypes(OverrideUpgradeDamageValue); } if (BiomeType != WorldConfiguration.Biome.Undefined && VanillaDamageValue.HasValue && ItemTypeDefined()) { return ItemConfiguration.Instance.CalculateUpgradeValue(BiomeType, VanillaUpgradeDamageValue.Value, GetBaseValue(), GetUpgradeLevels().Value); } return VanillaUpgradeDamageValue; } public void SetVanillaData(float value, int upgrades, float upgradeValue) { float? vanillaValue = VanillaValue; float valueOrDefault = vanillaValue.GetValueOrDefault(); if (!vanillaValue.HasValue) { valueOrDefault = value; float? vanillaValue2 = valueOrDefault; VanillaValue = vanillaValue2; } int? vanillaUpgradeLevels = VanillaUpgradeLevels; int valueOrDefault2 = vanillaUpgradeLevels.GetValueOrDefault(); if (!vanillaUpgradeLevels.HasValue) { valueOrDefault2 = upgrades; int? vanillaUpgradeLevels2 = valueOrDefault2; VanillaUpgradeLevels = vanillaUpgradeLevels2; } vanillaValue = VanillaUpgradeValue; valueOrDefault = vanillaValue.GetValueOrDefault(); if (!vanillaValue.HasValue) { valueOrDefault = upgradeValue; float? vanillaValue2 = valueOrDefault; VanillaUpgradeValue = vanillaValue2; } } public void SetVanillaData(DamageTypes damage, int upgrades, DamageTypes upgradeDamage) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: 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) //IL_0019: 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_005f: 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_006e: Unknown result type (might be due to invalid IL or missing references) //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0073: Unknown result type (might be due to invalid IL or missing references) DamageTypes? vanillaDamageValue = VanillaDamageValue; DamageTypes valueOrDefault = vanillaDamageValue.GetValueOrDefault(); if (!vanillaDamageValue.HasValue) { valueOrDefault = damage; DamageTypes? vanillaDamageValue2 = valueOrDefault; VanillaDamageValue = vanillaDamageValue2; } int? vanillaUpgradeLevels = VanillaUpgradeLevels; int valueOrDefault2 = vanillaUpgradeLevels.GetValueOrDefault(); if (!vanillaUpgradeLevels.HasValue) { valueOrDefault2 = upgrades; int? vanillaUpgradeLevels2 = valueOrDefault2; VanillaUpgradeLevels = vanillaUpgradeLevels2; } vanillaDamageValue = VanillaUpgradeDamageValue; valueOrDefault = vanillaDamageValue.GetValueOrDefault(); if (!vanillaDamageValue.HasValue) { valueOrDefault = upgradeDamage; DamageTypes? vanillaDamageValue2 = valueOrDefault; VanillaUpgradeDamageValue = vanillaDamageValue2; } } } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] public interface IItemConfiguration { float GetTotalDamage(DamageTypes OriginalDamage); DamageTypes CalculateCreatureDamageTypes(float biomeScale, DamageTypes OriginalDamage, float baseTotalDamage, float maxTotalDamage); DamageTypes CalculateItemDamageTypes(float biomeScale, DamageTypes originalDamage, float baseTotalDamage); void UpdateWeapon(ref ItemDrop item, DamageTypes? value, int? upgrades, DamageTypes? upgradeValue, bool playerItem = true); void UpdateArmor(ref ItemDrop item, float? value, int? upgrades, float? upgradeValue); void UpdateShield(ref ItemDrop item, float? value, int? upgrades, float? upgradeValue); void UpdateItems(); void VanillaReset(); } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class ItemConfiguration : IItemConfiguration { private static readonly IItemConfiguration _instance; protected Dictionary<ItemType, float> _itemBaseValues = new Dictionary<ItemType, float>(); protected Dictionary<string, ItemClassification> _itemData = new Dictionary<string, ItemClassification>(); public static ItemConfiguration Instance => _instance as ItemConfiguration; static ItemConfiguration() { _instance = new ItemConfiguration(); } protected ItemConfiguration() { } public float GetBaseItemValue(ItemType itemType) { if (_itemBaseValues.ContainsKey(itemType)) { return _itemBaseValues[itemType]; } return 0f; } public void AddBaseItemValue(ItemType type, float value) { if (_itemBaseValues.ContainsKey(type)) { _itemBaseValues[type] = value; } else { _itemBaseValues.Add(type, value); } } public void AddBaseItemValue(ItemOverrides.BaseItemValueOverride item) { if (item.itemType.HasValue && item.value.HasValue) { ItemType value = (ItemType)item.itemType.Value; AddBaseItemValue(value, item.value.Value); } } public void Initialize() { foreach (ItemClassification value in _itemData.Values) { value.Reset(); } InitializeBaseArmorValues(); InitializeBaseDamageValues(); InitializeWeapons(); InitializeArmor(); InitializeShields(); if (WorldConfiguration.Instance.WorldScale != 0 && !ScalingConfiguration.Instance.GetAutoScaleIgnoreOverrides()) { ReadCustomValues(); } CreateVanillaBackup(); } public void AddItemConfiguration(string name, WorldConfiguration.Biome? biome, ItemType? itemType) { if (!Utility.IsNullOrWhiteSpace(name)) { if (_itemData.ContainsKey(name)) { _itemData[name].UpdateItem(biome, itemType); } else { _itemData.Add(name, new ItemClassification(name, biome, itemType)); } } } public void AddItemConfiguration(ItemOverrides.ItemOverride itemOverride) { if (itemOverride != null && !Utility.IsNullOrWhiteSpace(itemOverride.name)) { AddItemConfiguration(itemOverride.name, null, null); _itemData[itemOverride.name].OverrideItem(itemOverride); } } public void UpdateItems() { foreach (ItemClassification value in _itemData.Values) { ScalingAPI.GetItemDrop(value.Name, out var item); if ((Object)(object)item == (Object)null) { ScalingPlugin.VentureScalingLogger.LogWarning((object)("Failed to configure Item: " + value.Name + ".")); } else if (value.ItemCategory == ItemCategory.Weapon) { UpdateWeapon(ref item, value.GetDamageValue(), value.GetUpgradeLevels(), value.GetUpgradeDamageValue()); } else if (value.ItemCategory == ItemCategory.Armor) { UpdateArmor(ref item, value.GetValue(), value.GetUpgradeLevels(), value.GetUpgradeValue()); } else if (value.ItemCategory == ItemCategory.Shield) { UpdateShield(ref item, value.GetValue(), value.GetUpgradeLevels(), value.GetUpgradeValue()); } } } protected virtual void CreateVanillaBackup() { //IL_005a: 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_007d: Unknown result type (might be due to invalid IL or missing references) //IL_0082: Unknown result type (might be due to invalid IL or missing references) //IL_0085: 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) ScalingPlugin.VentureScalingLogger.LogInfo((object)"Configuring vanilla backup for Item data..."); foreach (ItemClassification value in _itemData.Values) { ScalingAPI.GetItemDrop(value.Name, out var item); if ((Object)(object)item != (Object)null) { if (value.ItemCategory == ItemCategory.Weapon) { DamageTypes damages = item.m_itemData.m_shared.m_damages; int maxQuality = item.m_itemData.m_shared.m_maxQuality; DamageTypes damagesPerLevel = item.m_itemData.m_shared.m_damagesPerLevel; value.SetVanillaData(damages, maxQuality, damagesPerLevel); } else if (value.ItemCategory == ItemCategory.Armor) { float armor = item.m_itemData.m_shared.m_armor; int maxQuality2 = item.m_itemData.m_shared.m_maxQuality; float armorPerLevel = item.m_itemData.m_shared.m_armorPerLevel; value.SetVanillaData(armor, maxQuality2, armorPerLevel); } else if (value.ItemCategory == ItemCategory.Shield) { float blockPower = item.m_itemData.m_shared.m_blockPower; int maxQuality3 = item.m_itemData.m_shared.m_maxQuality; float blockPowerPerLevel = item.m_itemData.m_shared.m_blockPowerPerLevel; value.SetVanillaData(blockPower, maxQuality3, blockPowerPerLevel); } } else { ScalingPlugin.VentureScalingLogger.LogDebug((object)("Vanilla backup for " + value.Name + " not created, ItemDrop not found.")); } } } public void VanillaReset() { foreach (ItemClassification value in _itemData.Values) { ScalingAPI.GetItemDrop(value.Name, out var item); if ((Object)(object)item != (Object)null) { if (value.ItemCategory == ItemCategory.Weapon) { UpdateWeapon(ref item, value.VanillaDamageValue, value.VanillaUpgradeLevels, value.VanillaUpgradeDamageValue); } else if (value.ItemCategory == ItemCategory.Armor) { UpdateArmor(ref item, value.VanillaValue, value.VanillaUpgradeLevels, value.VanillaUpgradeValue); } else if (value.ItemCategory == ItemCategory.Shield) { UpdateShield(ref item, value.VanillaValue, value.VanillaUpgradeLevels, value.VanillaUpgradeValue); } } } } protected virtual void ReadCustomValues() { try { ItemOverrides.ItemOverridesList itemOverridesList = ItemOverrides.ReadYaml(); if (itemOverridesList == null) { return; } ScalingPlugin.VentureScalingLogger.LogDebug((object)"Deserializer successfully parsed yaml data."); ScalingPlugin.VentureScalingLogger.LogDebug((object)itemOverridesList.ToString()); foreach (ItemOverrides.ItemOverride item in itemOverridesList.items) { AddItemConfiguration(item); } foreach (ItemOverrides.BaseItemValueOverride baseItemValue in itemOverridesList.baseItemValues) { AddBaseItemValue(baseItemValue); } } catch (Exception ex) { ScalingPlugin.VentureScalingLogger.LogWarning((object)"Error loading VWS.ItemOverrides.yaml file."); ScalingPlugin.VentureScalingLogger.LogWarning((object)ex); ScalingPlugin.VentureScalingLogger.LogWarning((object)"Continuing without custom values..."); } } private void InitializeBaseArmorValues() { AddBaseItemValue(ItemType.Shoulder, 1f); AddBaseItemValue(ItemType.PrimativeArmor, 2f); AddBaseItemValue(ItemType.Helmet, 4f); AddBaseItemValue(ItemType.Chest, 4f); AddBaseItemValue(ItemType.Legs, 4f); AddBaseItemValue(ItemType.HelmetMedium, 3f); AddBaseItemValue(ItemType.ChestMedium, 3f); AddBaseItemValue(ItemType.LegsMedium, 3f); AddBaseItemValue(ItemType.HelmetRobe, 2f); AddBaseItemValue(ItemType.ChestRobe, 2f); AddBaseItemValue(ItemType.LegsRobe, 2f); AddBaseItemValue(ItemType.BucklerShield, 8f); AddBaseItemValue(ItemType.Shield, 10f); AddBaseItemValue(ItemType.TowerShield, 15f); AddBaseItemValue(ItemType.MagicShield, 10f); } private void InitializeArmor() { AddItemConfiguration("ArmorRagsChest", WorldConfiguration.Biome.Meadow, ItemType.PrimativeArmor); AddItemConfiguration("ArmorRagsLegs", WorldConfiguration.Biome.Meadow, ItemType.PrimativeArmor); AddItemConfiguration("HelmetLeather", WorldConfiguration.Biome.Meadow, ItemType.Helmet); AddItemConfiguration("ArmorLeatherChest", WorldConfiguration.Biome.Meadow, ItemType.Chest); AddItemConfiguration("ArmorLeatherLegs", WorldConfiguration.Biome.Meadow, ItemType.Legs); AddItemConfiguration("HelmetBronze", WorldConfiguration.Biome.BlackForest, ItemType.Helmet); AddItemConfiguration("ArmorBronzeChest", WorldConfiguration.Biome.BlackForest, ItemType.Chest); AddItemConfiguration("ArmorBronzeLegs", WorldConfiguration.Biome.BlackForest, ItemType.Legs); AddItemConfiguration("HelmetTrollLeather", WorldConfiguration.Biome.BlackForest, ItemType.HelmetRobe); AddItemConfiguration("ArmorTrollLeatherChest", WorldConfiguration.Biome.BlackForest, ItemType.ChestRobe); AddItemConfiguration("ArmorTrollLeatherLegs", WorldConfiguration.Biome.BlackForest, ItemType.LegsRobe); AddItemConfiguration("HelmetIron", WorldConfiguration.Biome.Swamp, ItemType.Helmet); AddItemConfiguration("ArmorIronChest", WorldConfiguration.Biome.Swamp, ItemType.Chest); AddItemConfiguration("ArmorIronLegs", WorldConfiguration.Biome.Swamp, ItemType.Legs); AddItemConfiguration("HelmetRoot", WorldConfiguration.Biome.Swamp, ItemType.HelmetRobe); AddItemConfiguration("ArmorRootChest", WorldConfiguration.Biome.Swamp, ItemType.ChestRobe); AddItemConfiguration("ArmorRootLegs", WorldConfiguration.Biome.Swamp, ItemType.LegsRobe); AddItemConfiguration("HelmetFenring", WorldConfiguration.Biome.Mountain, ItemType.HelmetRobe); AddItemConfiguration("ArmorFenringChest", WorldConfiguration.Biome.Mountain, ItemType.ChestRobe); AddItemConfiguration("ArmorFenringLegs", WorldConfiguration.Biome.Mountain, ItemType.LegsRobe); AddItemConfiguration("HelmetDrake", WorldConfiguration.Biome.Mountain, ItemType.Helmet); AddItemConfiguration("ArmorWolfChest", WorldConfiguration.Biome.Mountain, ItemType.Chest); AddItemConfiguration("ArmorWolfLegs", WorldConfiguration.Biome.Mountain, ItemType.Legs); AddItemConfiguration("HelmetPadded", WorldConfiguration.Biome.Plain, ItemType.Helmet); AddItemConfiguration("ArmorPaddedCuirass", WorldConfiguration.Biome.Plain, ItemType.Chest); AddItemConfiguration("ArmorPaddedGreaves", WorldConfiguration.Biome.Plain, ItemType.Legs); AddItemConfiguration("HelmetMage", WorldConfiguration.Biome.Mistland, ItemType.HelmetRobe); AddItemConfiguration("ArmorMageChest", WorldConfiguration.Biome.Mistland, ItemType.ChestRobe); AddItemConfiguration("ArmorMageLegs", WorldConfiguration.Biome.Mistland, ItemType.LegsRobe); AddItemConfiguration("HelmetCarapace", WorldConfiguration.Biome.Mistland, ItemType.Helmet); AddItemConfiguration("ArmorCarapaceChest", WorldConfiguration.Biome.Mistland, ItemType.Chest); AddItemConfiguration("ArmorCarapaceLegs", WorldConfiguration.Biome.Mistland, ItemType.Legs); AddItemConfiguration("HelmetFlametal", WorldConfiguration.Biome.AshLand, ItemType.Helmet); AddItemConfiguration("ArmorFlametalChest", WorldConfiguration.Biome.AshLand, ItemType.Chest); AddItemConfiguration("ArmorFlametalLegs", WorldConfiguration.Biome.AshLand, ItemType.Legs); AddItemConfiguration("HelmetAshlandsMediumHood", WorldConfiguration.Biome.AshLand, ItemType.HelmetMedium); AddItemConfiguration("ArmorAshlandsMediumChest", WorldConfiguration.Biome.AshLand, ItemType.ChestMedium); AddItemConfiguration("ArmorAshlandsMediumlegs", WorldConfiguration.Biome.AshLand, ItemType.LegsMedium); AddItemConfiguration("HelmetMage_Ashlands", WorldConfiguration.Biome.AshLand, ItemType.HelmetRobe); AddItemConfiguration("ArmorMageChest_Ashlands", WorldConfiguration.Biome.AshLand, ItemType.ChestRobe); AddItemConfiguration("ArmorMageLegs_Ashlands", WorldConfiguration.Biome.AshLand, ItemType.LegsRobe); } private void InitializeShields() { AddItemConfiguration("ShieldBronzeBuckler", WorldConfiguration.Biome.BlackForest, ItemType.BucklerShield); AddItemConfiguration("ShieldIronBuckler", WorldConfiguration.Biome.Swamp, ItemType.BucklerShield); AddItemConfiguration("ShieldCarapaceBuckler", WorldConfiguration.Biome.Mistland, ItemType.BucklerShield); AddItemConfiguration("ShieldWood", WorldConfiguration.Biome.Meadow, ItemType.Shield); AddItemConfiguration("ShieldBanded", WorldConfiguration.Biome.Swamp, ItemType.Shield); AddItemConfiguration("ShieldSilver", WorldConfiguration.Biome.Swamp, ItemType.Shield); AddItemConfiguration("ShieldBlackmetal", WorldConfiguration.Biome.Plain, ItemType.Shield); AddItemConfiguration("ShieldCarapace", WorldConfiguration.Biome.Mistland, ItemType.Shield); AddItemConfiguration("ShieldFlametal", WorldConfiguration.Biome.AshLand, ItemType.Shield); AddItemConfiguration("ShieldSerpentscale", WorldConfiguration.Biome.Ocean, ItemType.TowerShield); AddItemConfiguration("ShieldWoodTower", WorldConfiguration.Biome.Meadow, ItemType.TowerShield); AddItemConfiguration("ShieldBoneTower", WorldConfiguration.Biome.BlackForest, ItemType.TowerShield); AddItemConfiguration("ShieldIronTower", WorldConfiguration.Biome.Swamp, ItemType.TowerShield); AddItemConfiguration("ShieldBlackmetalTower", WorldConfiguration.Biome.Plain, ItemType.TowerShield); AddItemConfiguration("ShieldFlametalTower", WorldConfiguration.Biome.AshLand, ItemType.TowerShield); AddItemConfiguration("StaffShield", WorldConfiguration.Biome.Mistland, ItemType.MagicShield); } public float CalculateUpgradeValue(WorldConfiguration.Biome biome, float baseValue, int quality) { float biomeScaling = WorldConfiguration.Instance.GetBiomeScaling(biome); float nextBiomeScale = WorldConfiguration.Instance.GetNextBiomeScale(biome); return CalculateUpgradeValue(biomeScaling, nextBiomeScale, baseValue, quality); } protected float CalculateUpgradeValue(float scale, float nextScale, float baseValue, int quality) { if (quality <= 1) { return 0f; } float num = baseValue * scale; float num2 = baseValue * nextScale - num; if (num2 > 0f) { return (float)Math.Round(num2 / (float)quality, 1); } return 0f; } public void UpdateArmor(ref ItemDrop item, float? value, int? upgrades, float? upgradeValue) { if (!value.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new armor value. Value undefined.")); return; } float armor = item.m_itemData.m_shared.m_armor; item.m_itemData.m_shared.m_armor = value.Value; ScalingPlugin.VentureScalingLogger.LogDebug((object)$"{((Object)item).name}: Total armor changed from {armor} to {value}."); if (!upgrades.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new upgrade value. Total upgrades undefined.")); return; } if (!upgradeValue.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new upgrade value. Value for item upgrade undefined.")); return; } int maxQuality = item.m_itemData.m_shared.m_maxQuality; float armorPerLevel = item.m_itemData.m_shared.m_armorPerLevel; item.m_itemData.m_shared.m_maxQuality = upgrades.Value; item.m_itemData.m_shared.m_armorPerLevel = upgradeValue.Value; ScalingPlugin.VentureScalingLogger.LogDebug((object)($"{((Object)item).name}: Total item upgrades changed from {maxQuality} to {upgrades}. " + $"Total upgrade armor changed from {armorPerLevel} to {upgradeValue}.")); } public void UpdateShield(ref ItemDrop item, float? value, int? upgrades, float? upgradeValue) { if (!value.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new block value. Value undefined.")); return; } float blockPower = item.m_itemData.m_shared.m_blockPower; item.m_itemData.m_shared.m_blockPower = value.Value; ScalingPlugin.VentureScalingLogger.LogDebug((object)$"{((Object)item).name}: Total block changed from {blockPower} to {value}."); if (!upgrades.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new upgrade value. Total upgrades undefined.")); return; } if (!upgradeValue.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new upgrade value. Value for item upgrade undefined.")); return; } int maxQuality = item.m_itemData.m_shared.m_maxQuality; float blockPowerPerLevel = item.m_itemData.m_shared.m_blockPowerPerLevel; item.m_itemData.m_shared.m_maxQuality = upgrades.Value; item.m_itemData.m_shared.m_blockPowerPerLevel = upgradeValue.Value; ScalingPlugin.VentureScalingLogger.LogDebug((object)($"{((Object)item).name}: Total item upgrades changed from {maxQuality} to {upgrades}. " + $"Total upgrade block changed from {blockPowerPerLevel} to {upgradeValue}.")); } private void InitializeBaseDamageValues() { AddBaseItemValue(ItemType.Primative, 8f); AddBaseItemValue(ItemType.Knife, 8f); AddBaseItemValue(ItemType.GemKnife, 9f); AddBaseItemValue(ItemType.Fist, 8f); AddBaseItemValue(ItemType.Ammo, 12f); AddBaseItemValue(ItemType.Bolt, 12f); AddBaseItemValue(ItemType.TurretBolt, 25f); AddBaseItemValue(ItemType.PickAxe, 10f); AddBaseItemValue(ItemType.Sword, 12f); AddBaseItemValue(ItemType.GemSword, 13f); AddBaseItemValue(ItemType.Mace, 12f); AddBaseItemValue(ItemType.GemMace, 13f); AddBaseItemValue(ItemType.Spear, 12f); AddBaseItemValue(ItemType.GemSpear, 13f); AddBaseItemValue(ItemType.Axe, 12f); AddBaseItemValue(ItemType.GemAxe, 13f); AddBaseItemValue(ItemType.Sledge, 15f); AddBaseItemValue(ItemType.GemSledge, 16f); AddBaseItemValue(ItemType.Atgeir, 15f); AddBaseItemValue(ItemType.GemAtgeir, 16f); AddBaseItemValue(ItemType.Battleaxe, 15f); AddBaseItemValue(ItemType.GemBattleaxe, 16f); AddBaseItemValue(ItemType.Bow, 18f); AddBaseItemValue(ItemType.GemBow, 19f); AddBaseItemValue(ItemType.Crossbow, 40f); AddBaseItemValue(ItemType.GemCrossbow, 42f); AddBaseItemValue(ItemType.StaffRapid, 5f); AddBaseItemValue(ItemType.StaffSlow, 24f); AddBaseItemValue(ItemType.Tool, 0f); AddBaseItemValue(ItemType.Utility, 0f); AddBaseItemValue(ItemType.None, 0f); AddBaseItemValue(ItemType.Undefined, 0f); } private void InitializeWeapons() { AddItemConfiguration("PlayerUnarmed", WorldConfiguration.Biome.Meadow, ItemType.Fist); AddItemConfiguration("Club", WorldConfiguration.Biome.Meadow, ItemType.Primative); AddItemConfiguration("AxeStone", WorldConfiguration.Biome.Meadow, ItemType.Primative); AddItemConfiguration("PickaxeStone", WorldConfiguration.Biome.Meadow, ItemType.Primative); AddItemConfiguration("Torch", WorldConfiguration.Biome.Meadow, ItemType.Primative); AddItemConfiguration("AxeFlint", WorldConfiguration.Biome.Meadow, ItemType.Axe); AddItemConfiguration("AxeBronze", WorldConfiguration.Biome.BlackForest, ItemType.Axe); AddItemConfiguration("AxeIron", WorldConfiguration.Biome.Swamp, ItemType.Axe); AddItemConfiguration("AxeBlackMetal", WorldConfiguration.Biome.Plain, ItemType.Axe); AddItemConfiguration("AxeJotunBane", WorldConfiguration.Biome.Mistland, ItemType.Axe); AddItemConfiguration("AxeBerzerkr", WorldConfiguration.Biome.AshLand, ItemType.Axe); AddItemConfiguration("AxeBerzerkrBlood", WorldConfiguration.Biome.AshLand, ItemType.Axe); AddItemConfiguration("AxeBerzerkrLightning", WorldConfiguration.Biome.AshLand, ItemType.GemAxe); AddItemConfiguration("AxeBerzerkrNature", WorldConfiguration.Biome.AshLand, ItemType.GemAxe); AddItemConfiguration("PickaxeAntler", WorldConfiguration.Biome.Meadow, ItemType.PickAxe); AddItemConfiguration("PickaxeBronze", WorldConfiguration.Biome.BlackForest, ItemType.PickAxe); AddItemConfiguration("PickaxeIron", WorldConfiguration.Biome.Swamp, ItemType.PickAxe); AddItemConfiguration("PickaxeBlackMetal", WorldConfiguration.Biome.Plain, ItemType.PickAxe); AddItemConfiguration("KnifeChitin", WorldConfiguration.Biome.Ocean, ItemType.Knife); AddItemConfiguration("KnifeFlint", WorldConfiguration.Biome.Meadow, ItemType.Knife); AddItemConfiguration("KnifeCopper", WorldConfiguration.Biome.BlackForest, ItemType.Knife); AddItemConfiguration("KnifeSilver", WorldConfiguration.Biome.Mountain, ItemType.Knife); AddItemConfiguration("KnifeBlackMetal", WorldConfiguration.Biome.Plain, ItemType.Knife); AddItemConfiguration("KnifeSkollAndHati", WorldConfiguration.Biome.Mistland, ItemType.Knife); AddItemConfiguration("MaceBronze", WorldConfiguration.Biome.BlackForest, ItemType.Mace); AddItemConfiguration("MaceIron", WorldConfiguration.Biome.Swamp, ItemType.Mace); AddItemConfiguration("MaceSilver", WorldConfiguration.Biome.Mountain, ItemType.Mace); AddItemConfiguration("MaceNeedle", WorldConfiguration.Biome.Plain, ItemType.Mace); AddItemConfiguration("MaceEldner", WorldConfiguration.Biome.AshLand, ItemType.Mace); AddItemConfiguration("MaceEldnerBlood", WorldConfiguration.Biome.AshLand, ItemType.Mace); AddItemConfiguration("MaceEldnerLightning", WorldConfiguration.Biome.AshLand, ItemType.GemMace); AddItemConfiguration("MaceEldnerNature", WorldConfiguration.Biome.AshLand, ItemType.GemMace); AddItemConfiguration("SwordBronze", WorldConfiguration.Biome.BlackForest, ItemType.Sword); AddItemConfiguration("SwordIron", WorldConfiguration.Biome.Swamp, ItemType.Sword); AddItemConfiguration("SwordIronFire", WorldConfiguration.Biome.Swamp, ItemType.Sword); AddItemConfiguration("SwordSilver", WorldConfiguration.Biome.Mountain, ItemType.Sword); AddItemConfiguration("SwordBlackmetal", WorldConfiguration.Biome.Plain, ItemType.Sword); AddItemConfiguration("SwordMistwalker", WorldConfiguration.Biome.Mistland, ItemType.Sword); AddItemConfiguration("SwordDyrnwyn", WorldConfiguration.Biome.AshLand, ItemType.GemSword); AddItemConfiguration("SwordNiedhogg", WorldConfiguration.Biome.AshLand, ItemType.Sword); AddItemConfiguration("SwordNiedhoggBlood", WorldConfiguration.Biome.AshLand, ItemType.Sword); AddItemConfiguration("SwordNiedhoggLightning", WorldConfiguration.Biome.AshLand, ItemType.GemSword); AddItemConfiguration("SwordNiedhoggNature", WorldConfiguration.Biome.AshLand, ItemType.GemSword); AddItemConfiguration("AtgeirBronze", WorldConfiguration.Biome.BlackForest, ItemType.Atgeir); AddItemConfiguration("AtgeirIron", WorldConfiguration.Biome.Swamp, ItemType.Atgeir); AddItemConfiguration("AtgeirBlackmetal", WorldConfiguration.Biome.Plain, ItemType.Atgeir); AddItemConfiguration("AtgeirHimminAfl", WorldConfiguration.Biome.Mistland, ItemType.Atgeir); AddItemConfiguration("Battleaxe", WorldConfiguration.Biome.Swamp, ItemType.Battleaxe); AddItemConfiguration("BattleaxeCrystal", WorldConfiguration.Biome.Mountain, ItemType.Battleaxe); AddItemConfiguration("THSwordKrom", WorldConfiguration.Biome.Mistland, ItemType.Battleaxe); AddItemConfiguration("THSwordSlayer", WorldConfiguration.Biome.AshLand, ItemType.Battleaxe); AddItemConfiguration("THSwordSlayerBlood", WorldConfiguration.Biome.AshLand, ItemType.Battleaxe); AddItemConfiguration("THSwordSlayerLightning", WorldConfiguration.Biome.AshLand, ItemType.GemBattleaxe); AddItemConfiguration("THSwordSlayerNature", WorldConfiguration.Biome.AshLand, ItemType.GemBattleaxe); AddItemConfiguration("SledgeStagbreaker", WorldConfiguration.Biome.Meadow, ItemType.Sledge); AddItemConfiguration("SledgeIron", WorldConfiguration.Biome.Swamp, ItemType.Sledge); AddItemConfiguration("SledgeDemolisher", WorldConfiguration.Biome.Mistland, ItemType.Sledge); AddItemConfiguration("SpearChitin", WorldConfiguration.Biome.Ocean, ItemType.Spear); AddItemConfiguration("SpearFlint", WorldConfiguration.Biome.Meadow, ItemType.Spear); AddItemConfiguration("SpearBronze", WorldConfiguration.Biome.BlackForest, ItemType.Spear); AddItemConfiguration("SpearElderbark", WorldConfiguration.Biome.Swamp, ItemType.Spear); AddItemConfiguration("SpearWolfFang", WorldConfiguration.Biome.Mountain, ItemType.Spear); AddItemConfiguration("SpearCarapace", WorldConfiguration.Biome.Mistland, ItemType.Spear); AddItemConfiguration("SpearSplitner", WorldConfiguration.Biome.AshLand, ItemType.Spear); AddItemConfiguration("SpearSplitner_Blood", WorldConfiguration.Biome.AshLand, ItemType.Spear); AddItemConfiguration("SpearSplitner_Lightning", WorldConfiguration.Biome.AshLand, ItemType.GemSpear); AddItemConfiguration("SpearSplitner_Nature", WorldConfiguration.Biome.AshLand, ItemType.GemSpear); AddItemConfiguration("FistFenrirClaw", WorldConfiguration.Biome.Mountain, ItemType.Fist); AddItemConfiguration("Bow", WorldConfiguration.Biome.Meadow, ItemType.Bow); AddItemConfiguration("BowFineWood", WorldConfiguration.Biome.BlackForest, ItemType.Bow); AddItemConfiguration("BowHuntsman", WorldConfiguration.Biome.Swamp, ItemType.Bow); AddItemConfiguration("BowDraugrFang", WorldConfiguration.Biome.Mountain, ItemType.Bow); AddItemConfiguration("BowSpineSnap", WorldConfiguration.Biome.Mistland, ItemType.Bow); AddItemConfiguration("BowAshlands", WorldConfiguration.Biome.AshLand, ItemType.Bow); AddItemConfiguration("BowAshlandsBlood", WorldConfiguration.Biome.AshLand, ItemType.Bow); AddItemConfiguration("BowAshlandsRoot", WorldConfiguration.Biome.AshLand, ItemType.GemBow); AddItemConfiguration("BowAshlandsStorm", WorldConfiguration.Biome.AshLand, ItemType.GemBow); AddItemConfiguration("ArrowWood", WorldConfiguration.Biome.Meadow, ItemType.Ammo); AddItemConfiguration("ArrowFlint", WorldConfiguration.Biome.Meadow, ItemType.Ammo); AddItemConfiguration("ArrowFire", WorldConfiguration.Biome.Meadow, ItemType.Ammo); AddItemConfiguration("ArrowBronze", WorldConfiguration.Biome.BlackForest, ItemType.Ammo); AddItemConfiguration("ArrowIron", WorldConfiguration.Biome.Plain, ItemType.Ammo); AddItemConfiguration("ArrowSilver", WorldConfiguration.Biome.Mountain, ItemType.Ammo); AddItemConfiguration("ArrowPoison", WorldConfiguration.Biome.Mountain, ItemType.Ammo); AddItemConfiguration("ArrowObsidian", WorldConfiguration.Biome.Mountain, ItemType.Ammo); AddItemConfiguration("ArrowFrost", WorldConfiguration.Biome.Mountain, ItemType.Ammo); AddItemConfiguration("ArrowNeedle", WorldConfiguration.Biome.Plain, ItemType.Ammo); AddItemConfiguration("ArrowCarapace", WorldConfiguration.Biome.Mistland, ItemType.Ammo); AddItemConfiguration("ArrowCharred", WorldConfiguration.Biome.AshLand, ItemType.Ammo); AddItemConfiguration("CrossbowArbalest", WorldConfiguration.Biome.Mistland, ItemType.Crossbow); AddItemConfiguration("CrossbowRipper", WorldConfiguration.Biome.AshLand, ItemType.Crossbow); AddItemConfiguration("CrossbowRipperBlood", WorldConfiguration.Biome.AshLand, ItemType.Crossbow); AddItemConfiguration("CrossbowRipperLightning", WorldConfiguration.Biome.AshLand, ItemType.GemCrossbow); AddItemConfiguration("CrossbowRipperNature", WorldConfiguration.Biome.AshLand, ItemType.GemCrossbow); AddItemConfiguration("BoltBone", WorldConfiguration.Biome.BlackForest, ItemType.Bolt); AddItemConfiguration("BoltIron", WorldConfiguration.Biome.Swamp, ItemType.Bolt); AddItemConfiguration("BoltBlackmetal", WorldConfiguration.Biome.Plain, ItemType.Bolt); AddItemConfiguration("BoltCarapace", WorldConfiguration.Biome.Mistland, ItemType.Bolt); AddItemConfiguration("BoltCharred", WorldConfiguration.Biome.AshLand, ItemType.Bolt); AddItemConfiguration("TurretBoltWood", WorldConfiguration.Biome.BlackForest, ItemType.TurretBolt); AddItemConfiguration("TurretBolt", WorldConfiguration.Biome.Plain, ItemType.TurretBolt); AddItemConfiguration("TurretBoltFlametal", WorldConfiguration.Biome.AshLand, ItemType.TurretBolt); AddItemConfiguration("StaffIceShards", WorldConfiguration.Biome.Mistland, ItemType.StaffRapid); AddItemConfiguration("StaffFireball", WorldConfiguration.Biome.Mistland, ItemType.StaffSlow); AddItemConfiguration("StaffClusterbomb", WorldConfiguration.Biome.AshLand, ItemType.StaffRapid); AddItemConfiguration("StaffLightning", WorldConfiguration.Biome.AshLand, ItemType.StaffRapid); } public float GetTotalDamage(DamageTypes originalDamage) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0006: 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_0022: Unknown result type (might be due to invalid IL or missing references) //IL_0029: Unknown result type (might be due to invalid IL or missing references) //IL_0030: 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) return originalDamage.m_damage + originalDamage.m_blunt + originalDamage.m_slash + originalDamage.m_pierce + originalDamage.m_fire + originalDamage.m_frost + originalDamage.m_lightning + originalDamage.m_poison + originalDamage.m_spirit; } public DamageTypes CalculateCreatureDamageTypes(float biomeScale, DamageTypes originalDamage, float baseTotalDamage, float maxTotalDamage) { //IL_000a: 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: Unknown result type (might be due to invalid IL or missing references) Normalize(ref originalDamage); float multiplier = DamageRatio(GetTotalDamage(originalDamage), maxTotalDamage) * biomeScale; return CalculateDamageTypesFinal(originalDamage, baseTotalDamage, multiplier); } public DamageTypes CalculateItemDamageTypes(float biomeScale, DamageTypes originalDamage, float baseTotalDamage) { //IL_0009: 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) Normalize(ref originalDamage); return CalculateDamageTypesFinal(originalDamage, baseTotalDamage, biomeScale); } public DamageTypes CalculateDamageTypesFinal(DamageTypes OriginalDamage, float baseTotalDamage, float multiplier) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0009: 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_001f: 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_0044: Unknown result type (might be due to invalid IL or missing references) //IL_005a: 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_0086: Unknown result type (might be due to invalid IL or missing references) //IL_009c: Unknown result type (might be due to invalid IL or missing references) //IL_00b2: 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_00de: 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) DamageTypes result = default(DamageTypes); float totalDamage = GetTotalDamage(OriginalDamage); result.m_chop = OriginalDamage.m_chop; result.m_pickaxe = OriginalDamage.m_pickaxe; result.m_damage = ScaleDamage(totalDamage, OriginalDamage.m_damage, baseTotalDamage, multiplier); result.m_blunt = ScaleDamage(totalDamage, OriginalDamage.m_blunt, baseTotalDamage, multiplier); result.m_slash = ScaleDamage(totalDamage, OriginalDamage.m_slash, baseTotalDamage, multiplier); result.m_pierce = ScaleDamage(totalDamage, OriginalDamage.m_pierce, baseTotalDamage, multiplier); result.m_fire = ScaleDamage(totalDamage, OriginalDamage.m_fire, baseTotalDamage, multiplier); result.m_frost = ScaleDamage(totalDamage, OriginalDamage.m_frost, baseTotalDamage, multiplier); result.m_lightning = ScaleDamage(totalDamage, OriginalDamage.m_lightning, baseTotalDamage, multiplier); result.m_poison = ScaleDamage(totalDamage, OriginalDamage.m_poison, baseTotalDamage, multiplier); result.m_spirit = ScaleDamage(totalDamage, OriginalDamage.m_spirit, baseTotalDamage, multiplier); return result; } protected float DamageRatio(float totalDamage, float maxDamageOfAnyAttackType) { if (totalDamage == 0f || maxDamageOfAnyAttackType == 0f) { return 0f; } return totalDamage / maxDamageOfAnyAttackType; } protected float ScaleDamage(float originalSum, float original, float baseTotalDamage, float multiplier) { if (original <= 0f || baseTotalDamage <= 0f) { return 0f; } return (float)Math.Round(baseTotalDamage * multiplier * (original / originalSum), 1); } private void Normalize(ref DamageTypes OriginalDamage) { OriginalDamage.m_damage = Normalize(OriginalDamage.m_damage); OriginalDamage.m_blunt = Normalize(OriginalDamage.m_blunt); OriginalDamage.m_slash = Normalize(OriginalDamage.m_slash); OriginalDamage.m_pierce = Normalize(OriginalDamage.m_pierce); OriginalDamage.m_chop = Normalize(OriginalDamage.m_chop); OriginalDamage.m_pickaxe = Normalize(OriginalDamage.m_pickaxe); OriginalDamage.m_fire = Normalize(OriginalDamage.m_fire); OriginalDamage.m_frost = Normalize(OriginalDamage.m_frost); OriginalDamage.m_lightning = Normalize(OriginalDamage.m_lightning); OriginalDamage.m_poison = Normalize(OriginalDamage.m_poison); OriginalDamage.m_spirit = Normalize(OriginalDamage.m_spirit); } private float Normalize(float num) { if (num < 0f) { return 0f; } return num; } public DamageTypes CalculateUpgradeValue(WorldConfiguration.Biome biome, DamageTypes original, float baseTotalDamage, int quality) { //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Unknown result type (might be due to invalid IL or missing references) float biomeScaling = WorldConfiguration.Instance.GetBiomeScaling(biome); float nextBiomeScale = WorldConfiguration.Instance.GetNextBiomeScale(biome); return CalculateUpgradeValue(biomeScaling, nextBiomeScale, original, baseTotalDamage, quality); } protected DamageTypes CalculateUpgradeValue(float scale, float nextScale, DamageTypes original, float baseTotalDamage, int quality) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0030: 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_002a: Unknown result type (might be due to invalid IL or missing references) if (quality <= 1) { return original; } float num = baseTotalDamage * scale; float num2 = baseTotalDamage * nextScale - num; if (num2 > 0f) { float baseTotalDamage2 = num2 / (float)quality; return CalculateDamageTypesFinal(original, baseTotalDamage2, 1f); } return original; } public void UpdateWeapon(ref ItemDrop item, DamageTypes? value, int? upgrades, DamageTypes? upgradeValue, bool playerItem = true) { //IL_0031: Unknown result type (might be due to invalid IL or missing references) //IL_0036: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Unknown result type (might be due to invalid IL or missing references) //IL_0042: Unknown result type (might be due to invalid IL or missing references) //IL_005b: 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_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_0101: 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_013f: Unknown result type (might be due to invalid IL or missing references) //IL_0144: Unknown result type (might be due to invalid IL or missing references) if (!value.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new scaled damage values. DamageTypes undefined.")); return; } DamageTypes damages = item.m_itemData.m_shared.m_damages; float totalDamage = GetTotalDamage(damages); float totalDamage2 = GetTotalDamage(value.Value); item.m_itemData.m_shared.m_damages = value.Value; ScalingPlugin.VentureScalingLogger.LogDebug((object)$"{((Object)item).name}: Total damage changed from {totalDamage} to {totalDamage2}."); if (playerItem) { if (!upgrades.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new scaled upgrade damage values. Total upgrades undefined.")); return; } if (!upgradeValue.HasValue) { ScalingPlugin.VentureScalingLogger.LogWarning((object)(((Object)item).name + " NOT updated with new scaled upgrade damage values. DamageTypes for item upgrades undefined.")); return; } int maxQuality = item.m_itemData.m_shared.m_maxQuality; DamageTypes damagesPerLevel = item.m_itemData.m_shared.m_damagesPerLevel; float totalDamage3 = GetTotalDamage(damagesPerLevel); float totalDamage4 = GetTotalDamage(upgradeValue.Value); item.m_itemData.m_shared.m_maxQuality = upgrades.Value; item.m_itemData.m_shared.m_damagesPerLevel = upgradeValue.Value; ScalingPlugin.VentureScalingLogger.LogDebug((object)($"{((Object)item).name}: Total item upgrades changed from {maxQuality} to {upgrades}." + $"Total upgrade damage changed from {totalDamage3} to {totalDamage4}")); } } } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class ItemOverrides { [Serializable] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class ItemOverridesList { public IEnumerable<ItemOverride> items { get; set; } public IEnumerable<BaseItemValueOverride> baseItemValues { get; set; } public override string ToString() { if (items == null) { return "No Data."; } string text = $"Items in list {items.Count()}:\n"; foreach (ItemOverride item in items) { text += item.ToString(); } return text; } } [Serializable] [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] public class ItemOverride { public string name { get; set; } public int? biome { get; set; } public int? itemType { get; set; } public float? value { get; set; } public int? quality { get; set; } public float? upgradeValue { get; set; } public CreatureOverrides.AttackOverride damageValue { get; set; } public CreatureOverrides.AttackOverride upgradeDamageValue { get; set; } public override string ToString() { string text = $"{name}: Biome {biome}, Item Type {itemType}, Value {value}, Quality {quality}, Upgrade Value {upgradeValue}\n"; if (damageValue != null) { text = text + "+Damage Value: " + damageValue.ToString(); } if (upgradeDamageValue != null) { text = text + "+Upgrade Damage Value: " + upgradeDamageValue.ToString(); } return text; } } [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(0)] public class BaseItemValueOverride { public int? itemType { get; set; } public float? value { get; set; } } private static string filePath; public static ItemOverridesList ReadYaml() { if (File.Exists(filePath)) { using (new StreamReader(filePath)) { string input = File.ReadAllText(filePath); return new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).Build().Deserialize<ItemOverridesList>(input); } } ScalingPlugin.VentureScalingLogger.LogWarning((object)"No yaml file found, to use overrides the VWS.ItemOverrides.yaml file must be in your bepinex config folder."); return null; } static ItemOverrides() { string configPath = Paths.ConfigPath; char directorySeparatorChar = Path.DirectorySeparatorChar; filePath = configPath + directorySeparatorChar + "VWS.ItemOverrides.yaml"; } } public interface IScalingAPI { } [<9eed9c0a-9fd3-449f-9769-233bc050d602>Nullable(0)] [PublicAPI] [<b9fea6d5-68cd-496d-aaa1-f4835254cf4a>NullableContext(1)] public class ScalingAPI : IScalingAPI { private static readonly ScalingAPI _instance; public static ScalingAPI Instance => _instance; static ScalingAPI() { _instance = new ScalingAPI(); } protected ScalingAPI() { } public static void AddCustomBiome(Biome biome, int order, bool overrideBiome = false) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) WorldConfiguration.Biome progressionBiome = GetProgressionBiome(biome); WorldConfiguration.Instance.AddBiome(progressionBiome, order, overrideBiome); } public static void AddCustomBiome(Biome biome, int order, float scale, bool overrideBiome = false) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) WorldConfiguration.Biome progressionBiome = GetProgressionBiome(biome); WorldConfiguration.Instance.AddCustomBiome(progressionBiome, scale, order, overrideBiome); } public static WorldConfiguration.Biome GetProgressionBiome(Biome biome) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0003: Invalid comparison between Unknown and I4 //IL_0028: Unknown result type (might be due to invalid IL or missing references) //IL_002b: 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_0039: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Invalid comparison between Unknown and I4 //IL_002d: Unknown result type (might be due to invalid IL or missing references) //IL_0030: Invalid comparison between Unknown and I4 //IL_001d: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Invalid comparison between Unknown and I4 //IL_0041: Unknown result type (might be due to invalid IL or missing references) //IL_0047: Invalid comparison between Unknown and I4 //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0035: Invalid comparison between Unknown and I4 //IL_0021: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Invalid comparison between Unknown and I4 if ((int)biome <= 16) { switch (biome - 1) { default: if ((int)biome != 8) { if ((int)biome != 16) { break; } return WorldConfiguration.Biome.Plain; } return WorldConfiguration.Biome.BlackForest; case 0: return WorldConfiguration.Biome.Meadow; case 1: return WorldConfiguration.Biome.Swamp; case 3: return WorldConfiguration.Biome.Mountain; case 2: break; } } else if ((int)biome <= 64) { if ((int)biome == 32) { return WorldConfiguration.Biome.AshLand; } if ((int)biome == 64) { return WorldConfiguration.Biome.DeepNorth; } } else { if ((int)biome == 256) { return WorldConfiguration.Biome.Ocean; } if ((int)biome == 512) { return WorldConfiguration.Biome.Mistland; } } return WorldConfiguration.Biome.Undefined; } public static bool GetItemDrop(string name, out ItemDrop item) { item = null; if (!Utility.IsNullOrWhiteSpace(name)) { GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(name)); if ((Object)(object)itemPrefab == (Object)null) { itemPrefab = ObjectDB.instance.GetItemPrefab(name); } if ((Object)(object)itemPrefab != (Object)null) { item = itemPrefab.GetComponent<ItemDrop>(); if ((Object)(object)item != (Object)null) { return true; } } } return false; } public static Humanoid GetHumanoid(string name) { if (!Utility.IsNullOrWhiteSpace(name) && (Object)(object)ZNetScene.instance != (Object)null) { int stableHashCode = StringExtensionMethods.GetStableHashCode(name); if (ZNetScene.instance.m_namedPrefabs != null && ZNetScene.instance.m_namedPrefabs.ContainsKey(stableHashCode)) { return ZNetScene.instance.m_namedPrefabs[stableHashCode].GetComponent<Humanoid>(); } if (ZNetScene.instance.m_prefabs != null) { List<GameObject> prefabs = ZNetScene.instance.m_prefabs; for (int i = 0; i < prefabs.Count; i++) { if (((Object)prefabs[i]).name.Equals(name, StringComparison.OrdinalIgnoreCase)) { return prefabs[i].GetComponent<Humanoid>(); } } } } return null; } public static void GenerateData(bool overwrite = false) { //IL_02fd: Unknown result type (might be due to invalid IL or missing references) string text = string.Format("{0}{1}{2}", Paths.ConfigPath, Path.DirectorySeparatorChar, "ItemDropData"); if (!Directory.Exists(text) || overwrite) { Directory.CreateDirectory(text); foreach (GameObject item in ObjectDB.instance.m_items) { try { ItemDrop component = item.GetComponent<ItemDrop>(); File.WriteAllText($"{text}{Path.DirectorySeparatorChar}{((Object)component).name}.json", JsonUtility.ToJson((object)component, true)); } catch { ScalingPlugin.VentureScalingLogger.LogDebug((object)("Failed to write to file for GameObject: " + ((Object)item).name + ".")); } } } text = string.Format("{0}{1}{2}", Paths.ConfigPath, Path.DirectorySeparatorChar, "CreatureData"); if (Directory.Exists(text) && !overwrite) { return; } Directory.CreateDirectory(text); foreach (GameObject prefab in ZNetScene.instance.m_prefabs) { try { Humanoid component2 = prefab.GetComponent<Humanoid>(); if (!((Object)(object)component2 != (Object)null)) { continue; } File.WriteAllText($"{text}{Path.DirectorySeparatorChar}{((Object)component2).name}.json", JsonUtility.ToJson((object)component2, true)); Dictionary<string, GameObject> dictionary = new Dictionary<string, GameObject>(); if (component2.m_defaultItems != null) { GameObject[] defaultItems = component2.m_defaultItems; foreach (GameObject val in defaultItems) { if (!dictionary.ContainsKey(((Object)val).name)) { dictionary.Add(((Object)val).name, val); } } } if (component2.m_randomWeapon != null) { GameObject[] defaultItems = component2.m_randomWeapon; foreach (GameObject val2 in defaultItems) { if (!dictionary.ContainsKey(((Object)val2).name)) { dictionary.Add(((Object)val2).name, val2); } } } if (
