diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 000000000..cab295f79
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,57 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+# Editor Guidelines VS/Rider extension: 180-col guide
+guidelines = 180
+
+[*.cs]
+indent_size = 4
+tab_width = 4
+
+# A BOM is what stops an editor from misreading a UTF-8 file as CP1252 and silently
+# round-tripping non-ASCII characters into mojibake (it happened to the tooltip pip
+# glyphs in EpicLoot.cs). Prefer \uXXXX escapes for glyphs in string literals anyway.
+charset = utf-8-bom
+
+# --- One True Brace Style (1TBS) ---
+csharp_new_line_before_open_brace = none
+csharp_new_line_before_else = false
+csharp_new_line_before_catch = false
+csharp_new_line_before_finally = false
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_between_query_expression_clauses = true
+
+# Always use braces (1TBS mandates them, even on single-line blocks)
+csharp_prefer_braces = true:suggestion
+
+# Block / switch indentation
+csharp_indent_case_contents = true
+csharp_indent_switch_labels = true
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+
+# Keep formatting deviations as hints, never warnings/errors
+dotnet_diagnostic.IDE0055.severity = suggestion
+
+# --- Reduce modernization nagging (merged from both old files) ---
+dotnet_diagnostic.IDE0003.severity = none # Remove qualification
+dotnet_diagnostic.IDE0031.severity = none # Use null propagation
+dotnet_diagnostic.IDE0051.severity = none # Remove unused private members
+dotnet_diagnostic.IDE0060.severity = none # Remove unused parameter
+dotnet_diagnostic.IDE0066.severity = none # Convert switch to expression
+dotnet_diagnostic.IDE0074.severity = none # Use compound assignment
+dotnet_diagnostic.IDE0090.severity = none # 'new' expression can be simplified
+dotnet_diagnostic.IDE0130.severity = none # Namespace doesn't match folder
+dotnet_diagnostic.IDE0270.severity = none # Use coalesce expression
+
+# Localization files are read with BOM detection but must never carry one for
+# other tooling; plain UTF-8 is the contract.
+[*.{json,md}]
+charset = utf-8
+
+# --- Generated / third-party Unity code: skip style analysis ---
+[ValheimUnity/**.cs]
+generated_code = true
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
old mode 100755
new mode 100644
index 21c7eba24..22320aacd
--- a/.gitignore
+++ b/.gitignore
@@ -15,6 +15,11 @@
/**/obj/
/packages/
+# Always ignore the valheim assembly metadata as it gets updated each time a build happens
+ValheimUnity/Assets/ExternalLibraries/**.meta
+ValheimUnity/Assets/Exports.meta
+EpicLoot/ValheimUnity/Assets/ExternalLibraries/EpicLoot.dll
+
# Never ignore Asset meta data
!/[Aa]ssets/**/*.meta
@@ -62,13 +67,15 @@ sysinfo.txt
*.apk
*.unitypackage
+# Releases
+EpicLoot/Releases/
+
# Crashlytics generated file
crashlytics-build.properties
*.swp
/valheim_Data/BepInEx-out/plugins/ExtendedItemDataFramework.dll
/valheim_Data/BepInEx-out/plugins/EpicLoot/translations.json
-/valheim_Data/BepInEx-out/plugins/EpicLoot/recipes.json
/valheim_Data/BepInEx-out/plugins/EpicLoot/magiceffects.json
/valheim_Data/BepInEx-out/plugins/EpicLoot/loottables.json
/valheim_Data/BepInEx-out/plugins/EpicLoot/legendaries.json
@@ -92,3 +99,9 @@ ValheimUnity/Packages/packages-lock.json
Common
ValheimMods.sln
*.env
+/EpicLoot/shardstone_testing_matrix.csv
+/.gitignore
+/Common/Common.projitems
+/EpicLoot/EpicLoot.csproj
+/EpicLoot/EpicLoot.sln
+/EpicLoot/shardstone_testing_matrix.csv
diff --git a/AdvancedPortals/AdvancedPortals.csproj b/AdvancedPortals/AdvancedPortals.csproj
index 3d8dc0b87..78b66c99b 100644
--- a/AdvancedPortals/AdvancedPortals.csproj
+++ b/AdvancedPortals/AdvancedPortals.csproj
@@ -51,7 +51,7 @@
-
+
+
\ No newline at end of file
diff --git a/AdvancedPortals/README.md b/AdvancedPortals/README.md
index 339288a68..d4c3fbd9b 100644
--- a/AdvancedPortals/README.md
+++ b/AdvancedPortals/README.md
@@ -1,7 +1,7 @@
# Advanced Portals
Author: [RandyKnapp](https://discord.gg/ZNhYeavv3C)
-Source: [Github](https://github.com/OrianaVenture/Randy_Vapok_ValheimMods/tree/main/AdvancedPortals)
+Source: [Github](https://github.com/RandyKnapp/ValheimMods/tree/main/AdvancedPortals)
Patreon: [patreon.com/randyknapp](https://www.patreon.com/randyknapp)
Discord: [RandyKnapp's Mod Community](https://discord.gg/ZNhYeavv3C)
diff --git a/BuildTasks.props b/BuildTasks.props
index 6eb505bb9..608a82f8d 100644
--- a/BuildTasks.props
+++ b/BuildTasks.props
@@ -8,6 +8,11 @@
Common
-
\ No newline at end of file
diff --git a/Common/src/Modding/AssetBundleLoader.cs b/Common/src/Modding/AssetBundleLoader.cs
new file mode 100644
index 000000000..db5521aac
--- /dev/null
+++ b/Common/src/Modding/AssetBundleLoader.cs
@@ -0,0 +1,46 @@
+using System;
+using System.IO;
+using System.Reflection;
+using UnityEngine;
+
+namespace Common {
+ ///
+ /// Loads an asset bundle embedded in a mod assembly as a manifest resource.
+ ///
+ /// Replaces the copy of this method that lived in EpicLoot, Jam, AdvancedPortals and
+ /// EquipmentAndQuickSlots. Those used Assembly.GetCallingAssembly(); that is unsafe here, because the
+ /// caller can be another type in this shared project rather than the mod, so the assembly is explicit.
+ ///
+ public static class AssetBundleLoader {
+ ///
+ /// Loads the bundle embedded as "<assembly name>.<filename>". Returns null (and logs) on failure.
+ ///
+ public static AssetBundle LoadFromResources(string filename, Assembly assembly) {
+ if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); }
+
+ string resourceName = $"{assembly.GetName().Name}.{filename}";
+ try {
+ using (Stream stream = assembly.GetManifestResourceStream(resourceName)) {
+ if (stream == null) {
+ ModLogger.LogError($"Embedded asset bundle '{resourceName}' not found in {assembly.GetName().Name}.");
+ return null;
+ }
+ return AssetBundle.LoadFromStream(stream);
+ }
+ } catch (Exception e) {
+ ModLogger.LogError($"Failed to load embedded asset bundle '{resourceName}': {e.Message}");
+ return null;
+ }
+ }
+
+ ///
+ /// Loads the bundle and assigns it to
+ public static AssetBundle LoadIntoContext(string filename, Assembly assembly) {
+ AssetBundle bundle = LoadFromResources(filename, assembly);
+ if (bundle != null) { ModContext.AssetBundle = bundle; }
+ return bundle;
+ }
+ }
+}
diff --git a/Common/src/Modding/ConfigBinder.cs b/Common/src/Modding/ConfigBinder.cs
new file mode 100644
index 000000000..655335f37
--- /dev/null
+++ b/Common/src/Modding/ConfigBinder.cs
@@ -0,0 +1,97 @@
+using BepInEx.Configuration;
+using Jotunn.Extensions;
+
+namespace Common {
+ ///
+ /// Binding helpers over
+ public static class ConfigBinder {
+ private static ConfigFile Cfg => ModContext.Cfg;
+
+ // -- Server synced (admin only) ------------------------------------------------------------
+
+ public static ConfigEntry BindServerConfig(string category, string key, bool value, string description,
+ AcceptableValueBase acceptableValues = null, bool advanced = false) {
+ return Cfg.Bind(category, key, value,
+ new ConfigDescription(description, acceptableValues,
+ new ConfigurationManagerAttributes { IsAdminOnly = true, IsAdvanced = advanced }));
+ }
+
+ public static ConfigEntry BindServerConfig(string category, string key, int value, string description,
+ bool advanced = false, int valMin = 0, int valMax = 150) {
+ return Cfg.Bind(category, key, value,
+ new ConfigDescription(description, new AcceptableValueRange(valMin, valMax),
+ new ConfigurationManagerAttributes { IsAdminOnly = true, IsAdvanced = advanced }));
+ }
+
+ public static ConfigEntry BindServerConfig(string category, string key, float value, string description,
+ bool advanced = false, float valMin = 0f, float valMax = 150f) {
+ return Cfg.Bind(category, key, value,
+ new ConfigDescription(description, new AcceptableValueRange(valMin, valMax),
+ new ConfigurationManagerAttributes { IsAdminOnly = true, IsAdvanced = advanced }));
+ }
+
+ public static ConfigEntry BindServerConfig(string category, string key, string value, string description,
+ AcceptableValueList acceptableValues = null, bool advanced = false) {
+ return Cfg.Bind(category, key, value,
+ new ConfigDescription(description, acceptableValues,
+ new ConfigurationManagerAttributes { IsAdminOnly = true, IsAdvanced = advanced }));
+ }
+
+ /// Generic escape hatch for types without a dedicated overload above.
+ public static ConfigEntry BindServerConfig(string category, string key, T value, string description,
+ AcceptableValueBase acceptableValues, bool advanced = false) {
+ return Cfg.Bind(category, key, value,
+ new ConfigDescription(description, acceptableValues,
+ new ConfigurationManagerAttributes { IsAdminOnly = true, IsAdvanced = advanced }));
+ }
+
+ // -- Client local --------------------------------------------------------------------------
+
+ public static ConfigEntry BindClientConfig(string category, string key, T value, string description,
+ AcceptableValueBase acceptableValues = null, bool advanced = false) {
+ return Cfg.Bind(category, key, value,
+ new ConfigDescription(description, acceptableValues,
+ new ConfigurationManagerAttributes { IsAdminOnly = false, IsAdvanced = advanced }));
+ }
+
+ // -- Ordered ---------------------------------------------------------------------------------
+
+ ///
+ /// Server-synced entry bound through Jotunn's ordered binder.
+ ///
+ ///
+ /// ConfigurationManager sorts sections alphabetically and, within a section, by the Order
+ /// attribute. Jotunn's BindConfigInOrder exploits both: it prefixes the section with the position
+ /// it was first bound in ("2 - Balance") and hands each entry a descending Order, so what the
+ /// player sees matches the grouping the code declares rather than an alphabetical jumble.
+ ///
+ /// Two consequences to plan for:
+ /// - Keep a config file to **nine sections or fewer**. The prefix is not zero padded, so a tenth
+ /// section sorts as "10 - ..." between "1 - ..." and "2 - ...".
+ /// - The prefix is part of the section name written to disk, so inserting a section renames every
+ /// section after it and orphans the player's saved values. Add new sections at the end, or
+ /// migrate the old names (EpicLoot's ELConfig does the latter).
+ ///
+ public static ConfigEntry BindServerConfigInOrder(string category, string key, T value, string description,
+ AcceptableValueBase acceptableValues = null, bool advanced = false) {
+ return Cfg.BindConfigInOrder(category, key, value, description, synced: true,
+ acceptableValues: acceptableValues,
+ configAttributes: new ConfigurationManagerAttributes { IsAdvanced = advanced });
+ }
+
+ /// Client-local counterpart of
+ public static ConfigEntry BindClientConfigInOrder(string category, string key, T value, string description,
+ AcceptableValueBase acceptableValues = null, bool advanced = false) {
+ return Cfg.BindConfigInOrder(category, key, value, description, synced: false,
+ acceptableValues: acceptableValues,
+ configAttributes: new ConfigurationManagerAttributes { IsAdvanced = advanced });
+ }
+ }
+}
diff --git a/Common/src/Modding/ConfigChangeDebouncer.cs b/Common/src/Modding/ConfigChangeDebouncer.cs
new file mode 100644
index 000000000..cd98cf17c
--- /dev/null
+++ b/Common/src/Modding/ConfigChangeDebouncer.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Common {
+ // Debounces config apply work so a burst of rapid SettingChanged events for one entry
+ // (a user typing into a field, a config file reload, or a server config sync) collapses
+ // into a single apply once the edits settle, instead of re-doing the heavy work (recipe
+ // rebuilds, world scans) on every intermediate value.
+ //
+ // Mirrors the EnqueueWorldUpdate/DrainWorldUpdates coroutine pattern (BepInEx ThreadingHelper,
+ // yielding null each frame - WaitForSeconds is not reliably honoured by that runner). No locking;
+ // like EnqueueWorldUpdate this assumes the config handlers run on the main thread.
+ public static class ConfigChangeDebouncer {
+ // Latest action to run per key (the changed ConfigEntry instance).
+ private static readonly Dictionary pendingActions = new Dictionary();
+ // Time (Time.realtimeSinceStartup) at which each key's action should fire.
+ private static readonly Dictionary fireAt = new Dictionary();
+ // Keys with a coroutine already waiting, so we don't start a second one.
+ private static readonly HashSet running = new HashSet();
+
+ // Schedules action to run after ModContext.ConfigApplyDelay seconds. Re-calling with the same
+ // key before it fires replaces the action and resets the timer (true debounce + coalesce).
+ // A delay <= 0 applies immediately (lets admins disable the delay).
+ public static void Schedule(object key, Action action) {
+ float delay = ModContext.ConfigApplyDelay != null ? ModContext.ConfigApplyDelay.Value : 0f;
+ if (delay <= 0f) {
+ action();
+ return;
+ }
+ // During game shutdown the ThreadingHelper's MonoBehaviour is destroyed while config entries can
+ // still fire SettingChanged (e.g. Jotunn reverting server-synced values on disconnect). Calling
+ // StartCoroutine on a destroyed behaviour throws ArgumentNullException, and there's nothing left
+ // to update anyway, so drop the change. The Unity '==' overload treats a destroyed object as null.
+ BepInEx.ThreadingHelper host = BepInEx.ThreadingHelper.Instance;
+ if (host == null) { return; }
+ pendingActions[key] = action;
+ fireAt[key] = Time.realtimeSinceStartup + delay;
+ if (running.Contains(key)) { return; }
+ running.Add(key);
+ host.StartCoroutine(Run(key));
+ }
+
+ private static IEnumerator Run(object key) {
+ // Wait until the entry has been idle for the full delay; re-scheduling pushes fireAt out.
+ while (fireAt.TryGetValue(key, out float at) && Time.realtimeSinceStartup < at) {
+ yield return null;
+ }
+ pendingActions.TryGetValue(key, out Action action);
+ pendingActions.Remove(key);
+ fireAt.Remove(key);
+ running.Remove(key);
+ action?.Invoke();
+ }
+ }
+}
diff --git a/Common/src/Modding/ConfigDrawers.cs b/Common/src/Modding/ConfigDrawers.cs
new file mode 100644
index 000000000..68180303e
--- /dev/null
+++ b/Common/src/Modding/ConfigDrawers.cs
@@ -0,0 +1,420 @@
+using BepInEx.Configuration;
+using Jotunn.Managers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Common {
+ // Shared IMGUI widgets used by the item/piece config drawers.
+ //
+ // Every entity (item or piece) collapses its many ConfigEntries into a single ConfigurationManager
+ // row backed by a CustomDrawer. The underlying ConfigEntries are untouched (same keys, same sync) -
+ // only their display is changed: all but one "anchor" entry get Browsable = false so the manager no
+ // longer lays each of them out every frame, which is what caused the lag.
+ internal static class ConfigDrawHelpers {
+ // Edit buffers so partial typing in text/number fields doesn't immediately overwrite the live value.
+ private static readonly Dictionary TextBuffer = new Dictionary();
+ // In-progress slider values; committed to the ConfigEntry only on mouse release to avoid a disk
+ // write (SaveOnConfigSet is true) on every frame of a drag.
+ private static readonly Dictionary SliderPending = new Dictionary();
+
+ private static GUIStyle _headerButton;
+ private static GUIStyle _groupLabel;
+ private static GUIStyle _dim;
+
+ internal static GUIStyle HeaderButton => _headerButton;
+ internal static GUIStyle Dim => _dim;
+
+ internal static void EnsureStyles() {
+ if (_headerButton != null) { return; }
+ _headerButton = new GUIStyle(GUI.skin.button) { alignment = TextAnchor.MiddleLeft, fontStyle = FontStyle.Bold };
+ _groupLabel = new GUIStyle(GUI.skin.label) { fontStyle = FontStyle.Bold };
+ _dim = new GUIStyle(GUI.skin.label) { fontStyle = FontStyle.Italic, fontSize = 11 };
+ }
+
+ // Fetches the Jotunn ConfigurationManagerAttributes already attached by ConfigBinder.
+ internal static ConfigurationManagerAttributes GetAttributes(ConfigEntryBase entry) =>
+ entry?.Description?.Tags?.OfType().FirstOrDefault();
+
+ // Hides an entry from the Configuration Manager window without affecting saving or server sync.
+ internal static void Hide(ConfigEntryBase entry) {
+ ConfigurationManagerAttributes attr = GetAttributes(entry);
+ if (attr != null) { attr.Browsable = false; }
+ }
+
+ internal static void GroupHeader(string text) {
+ GUILayout.Space(4f);
+ GUILayout.Label(text, _groupLabel);
+ }
+
+ private static bool EnterPressed() =>
+ Event.current.type == EventType.KeyDown &&
+ (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.KeypadEnter);
+
+ internal static void DrawBool(string label, ConfigEntry cfg) {
+ bool v = GUILayout.Toggle(cfg.Value, " " + label);
+ if (v != cfg.Value) { cfg.Value = v; }
+ }
+
+ // Free-text string field that commits on Enter or when focus leaves the field (never per keystroke,
+ // so handlers like "crafting station changed" don't fire/warn on every character).
+ internal static void DrawString(string label, ConfigEntry cfg) {
+ GUILayout.BeginHorizontal();
+ GUILayout.Label(label, GUILayout.Width(230f));
+ string ctrl = "str_" + cfg.GetHashCode();
+ GUI.SetNextControlName(ctrl);
+ bool focused = GUI.GetNameOfFocusedControl() == ctrl;
+ string shown = focused && TextBuffer.TryGetValue(cfg, out string buf) ? buf : cfg.Value;
+ string typed = GUILayout.TextField(shown, GUILayout.Width(230f));
+ if (focused) {
+ TextBuffer[cfg] = typed;
+ if (EnterPressed() && cfg.Value != typed) { cfg.Value = typed; }
+ } else if (TextBuffer.TryGetValue(cfg, out string pending)) {
+ if (cfg.Value != pending) { cfg.Value = pending; }
+ TextBuffer.Remove(cfg);
+ }
+ GUILayout.EndHorizontal();
+ }
+
+ // Cycler for string entries restricted to an AcceptableValueList (damage modifiers, piece category).
+ internal static void DrawChoice(string label, ConfigEntry cfg) {
+ GUILayout.BeginHorizontal();
+ GUILayout.Label(label, GUILayout.Width(230f));
+ if (cfg.Description.AcceptableValues is AcceptableValueList list && list.AcceptableValues.Length > 0) {
+ string[] vals = list.AcceptableValues;
+ int idx = Array.IndexOf(vals, cfg.Value);
+ if (idx < 0) { idx = 0; }
+ if (GUILayout.Button("◄", GUILayout.Width(26f))) { cfg.Value = vals[(idx - 1 + vals.Length) % vals.Length]; }
+ GUILayout.Label(cfg.Value, GUILayout.Width(160f));
+ if (GUILayout.Button("►", GUILayout.Width(26f))) { cfg.Value = vals[(idx + 1) % vals.Length]; }
+ } else {
+ GUILayout.Label(cfg.Value);
+ }
+ GUILayout.EndHorizontal();
+ }
+
+ internal static void DrawFloat(string label, ConfigEntry cfg) {
+ float min = 0f, max = Mathf.Max(100f, cfg.Value);
+ if (cfg.Description.AcceptableValues is AcceptableValueRange r) { min = r.MinValue; max = r.MaxValue; }
+ float v = DrawSliderRow(label, cfg, cfg.Value, min, max, false);
+ if (v != cfg.Value) { cfg.Value = Mathf.Clamp(v, min, max); }
+ }
+
+ internal static void DrawInt(string label, ConfigEntry cfg) {
+ float min = 0f, max = Mathf.Max(100f, cfg.Value);
+ if (cfg.Description.AcceptableValues is AcceptableValueRange r) { min = r.MinValue; max = r.MaxValue; }
+ float v = DrawSliderRow(label, cfg, cfg.Value, min, max, true);
+ int iv = Mathf.Clamp(Mathf.RoundToInt(v), (int)min, (int)max);
+ if (iv != cfg.Value) { cfg.Value = iv; }
+ }
+
+ // Slider (deferred-commit on mouse release) + a buffered numeric text box (commit on Enter/blur).
+ // Returns the value the caller should write; never writes the ConfigEntry itself.
+ private static float DrawSliderRow(string label, object key, float current, float min, float max, bool isInt) {
+ float result = current;
+ GUILayout.BeginHorizontal();
+ GUILayout.Label(label, GUILayout.Width(230f));
+
+ float shown = SliderPending.TryGetValue(key, out float pend) ? pend : current;
+ float slid = GUILayout.HorizontalSlider(shown, min, max, GUILayout.Width(150f));
+ if (Mathf.Abs(slid - shown) > Mathf.Epsilon) { SliderPending[key] = slid; }
+ if (SliderPending.TryGetValue(key, out float dragging)) {
+ result = dragging;
+ if (!Input.GetMouseButton(0)) { SliderPending.Remove(key); }
+ }
+
+ // Numeric text box for exact entry.
+ string ctrl = "num_" + key.GetHashCode();
+ GUI.SetNextControlName(ctrl);
+ bool focused = GUI.GetNameOfFocusedControl() == ctrl;
+ string live = isInt ? Mathf.RoundToInt(result).ToString() : result.ToString("0.###");
+ string shownText = focused && TextBuffer.TryGetValue(key, out string buf) ? buf : live;
+ string typed = GUILayout.TextField(shownText, GUILayout.Width(70f));
+ if (focused) {
+ TextBuffer[key] = typed;
+ if (EnterPressed() && float.TryParse(typed, out float parsed)) { result = parsed; }
+ } else if (TextBuffer.TryGetValue(key, out string pendingText)) {
+ if (float.TryParse(pendingText, out float p)) { result = p; }
+ TextBuffer.Remove(key);
+ }
+
+ GUILayout.Label($"[{(isInt ? min.ToString() : min.ToString("0.#"))} - {(isInt ? max.ToString() : max.ToString("0.#"))}]", _dim, GUILayout.Width(90f));
+ GUILayout.EndHorizontal();
+ return result;
+ }
+ }
+
+ // Collapses an ItemDefinition's ~10-20 ConfigEntries into a single expandable, grouped drawer.
+ internal static class ItemConfigDrawer {
+ private static readonly Dictionary Expanded = new Dictionary();
+ // CSV recipe rows being edited in-memory; only written back to the ConfigEntry on "Apply".
+ private static readonly Dictionary> RecipeRows = new Dictionary>();
+ private static int _order = 0;
+
+ private static readonly KeyValuePair[] StatGroups = new KeyValuePair[] {
+ new KeyValuePair("Damage", new[] {
+ ItemStat.slash, ItemStat.slash_per_level, ItemStat.blunt, ItemStat.blunt_per_level,
+ ItemStat.pierce, ItemStat.pierce_per_level, ItemStat.fire, ItemStat.fire_per_level,
+ ItemStat.lightning, ItemStat.lightning_per_level, ItemStat.frost, ItemStat.frost_per_level,
+ ItemStat.poison, ItemStat.poison_per_level, ItemStat.spirit, ItemStat.spirit_per_level,
+ ItemStat.pickaxe, ItemStat.pickaxe_per_level, ItemStat.chop, ItemStat.chop_per_level
+ }),
+ new KeyValuePair("Combat", new[] {
+ ItemStat.attack_force, ItemStat.primary_attack_force_multiply, ItemStat.secondary_attack_force_multiply,
+ ItemStat.primary_attack_stamina, ItemStat.primary_attack_eitr, ItemStat.primary_attack_flat_health_cost,
+ ItemStat.primary_attack_percent_health_cost, ItemStat.primary_attack_health_returned,
+ ItemStat.primary_attack_damage_bonus_per_missing_hp, ItemStat.primary_attack_projectile_count,
+ ItemStat.secondary_attack_stamina, ItemStat.secondary_attack_eitr, ItemStat.secondary_attack_flat_health_cost,
+ ItemStat.secondary_attack_percent_health_cost, ItemStat.projectile_velocity, ItemStat.projectile_accuracy_max,
+ ItemStat.bow_draw_speed, ItemStat.crossbow_reload_speed, ItemStat.crossbow_reload_stamina_drain,
+ ItemStat.draw_stamina_drain
+ }),
+ new KeyValuePair("Defense", new[] {
+ ItemStat.block_armor, ItemStat.block_armor_per_level, ItemStat.parry,
+ ItemStat.block_force, ItemStat.block_force_per_level
+ }),
+ new KeyValuePair("Item", new[] {
+ ItemStat.durability, ItemStat.durability_per_level, ItemStat.max_item_level,
+ ItemStat.tool_level, ItemStat.movement_speed, ItemStat.amount
+ }),
+ };
+
+ // Hides the item's sub-entries and turns CraftableCfg into the single visible drawer row.
+ internal static void Attach(ItemDefinition itemdef) {
+ ConfigDrawHelpers.Hide(itemdef.StationLVLCfg);
+ ConfigDrawHelpers.Hide(itemdef.CraftAmountCfg);
+ ConfigDrawHelpers.Hide(itemdef.CraftedAtCfg);
+ ConfigDrawHelpers.Hide(itemdef.Recipe.RecipeConfig);
+ if (itemdef.ModifableStats != null) {
+ foreach (ItemStatConfig stat in itemdef.ModifableStats.Values) {
+ if (stat.Cfg != null) { ConfigDrawHelpers.Hide(stat.Cfg); }
+ if (stat.CfgInt != null) { ConfigDrawHelpers.Hide(stat.CfgInt); }
+ }
+ }
+ if (itemdef.DamageMods != null) {
+ foreach (HitCustomDamageMod mod in itemdef.DamageMods.Values) {
+ if (mod.DmgModCfg != null) { ConfigDrawHelpers.Hide(mod.DmgModCfg); }
+ }
+ }
+
+ ConfigurationManagerAttributes anchor = ConfigDrawHelpers.GetAttributes(itemdef.CraftableCfg);
+ if (anchor != null) {
+ anchor.CustomDrawer = _ => Draw(itemdef);
+ anchor.HideSettingName = true;
+ anchor.HideDefaultButton = true;
+ anchor.Category = itemdef.Category.ToString();
+ anchor.Order = _order--;
+ }
+ }
+
+ private static void Draw(ItemDefinition itemdef) {
+ ConfigDrawHelpers.EnsureStyles();
+ GUILayout.BeginVertical(GUI.skin.box);
+
+ bool expanded = Expanded.TryGetValue(itemdef.DisplayName, out bool e) && e;
+ if (GUILayout.Button((expanded ? "▾ " : "▸ ") + itemdef.Name, ConfigDrawHelpers.HeaderButton)) {
+ expanded = !expanded;
+ Expanded[itemdef.DisplayName] = expanded;
+ }
+
+ if (expanded) {
+ bool admin = SynchronizationManager.Instance == null || SynchronizationManager.Instance.PlayerIsAdmin;
+ if (!admin) { GUILayout.Label("Server-controlled – admin only.", ConfigDrawHelpers.Dim); }
+ bool prevEnabled = GUI.enabled;
+ GUI.enabled = admin;
+
+ ConfigDrawHelpers.GroupHeader("Crafting");
+ ConfigDrawHelpers.DrawBool("Craftable", itemdef.CraftableCfg);
+ ConfigDrawHelpers.DrawString("Crafted at", itemdef.CraftedAtCfg);
+ ConfigDrawHelpers.DrawInt("Station level", itemdef.StationLVLCfg);
+ ConfigDrawHelpers.DrawInt("Craft amount", itemdef.CraftAmountCfg);
+
+ DrawRecipeEditor(itemdef);
+
+ HashSet drawn = new HashSet();
+ foreach (KeyValuePair group in StatGroups) {
+ List present = group.Value.Where(s => IsConfigurable(itemdef, s)).ToList();
+ bool damageMods = group.Key == "Damage" && itemdef.DamageMods != null && itemdef.DamageMods.Count > 0;
+ if (present.Count == 0 && !damageMods) { continue; }
+ ConfigDrawHelpers.GroupHeader(group.Key);
+ foreach (ItemStat s in present) { DrawStat(itemdef, s); drawn.Add(s); }
+ if (damageMods) {
+ foreach (KeyValuePair mod in itemdef.DamageMods) {
+ if (mod.Value.Configurable == false || mod.Value.DmgModCfg == null) { continue; }
+ ConfigDrawHelpers.DrawChoice(mod.Key + " resistance", mod.Value.DmgModCfg);
+ }
+ }
+ }
+
+ // Catch any configurable stat not covered by a group above.
+ if (itemdef.ModifableStats != null) {
+ List other = itemdef.ModifableStats.Keys.Where(s => !drawn.Contains(s) && IsConfigurable(itemdef, s)).ToList();
+ if (other.Count > 0) {
+ ConfigDrawHelpers.GroupHeader("Other");
+ foreach (ItemStat s in other) { DrawStat(itemdef, s); }
+ }
+ }
+
+ GUI.enabled = prevEnabled;
+ }
+
+ GUILayout.EndVertical();
+ }
+
+ private static bool IsConfigurable(ItemDefinition itemdef, ItemStat s) =>
+ itemdef.ModifableStats != null && itemdef.ModifableStats.TryGetValue(s, out ItemStatConfig sc) && sc.Configurable;
+
+ private static void DrawStat(ItemDefinition itemdef, ItemStat s) {
+ ItemStatConfig sc = itemdef.ModifableStats[s];
+ string label = s.ToString().Replace('_', ' ');
+ if (sc.IsInt) { ConfigDrawHelpers.DrawInt(label, sc.CfgInt); } else { ConfigDrawHelpers.DrawFloat(label, sc.Cfg); }
+ }
+
+ // Recipe shown as one row per resource: prefab (string) + amount (int) + per-level (int).
+ // Edits stay in-memory until "Apply", which re-serializes to the existing CSV format and writes it
+ // to the ConfigEntry, firing the existing SettingChanged -> ValidateRecipeConfig pipeline.
+ private static void DrawRecipeEditor(ItemDefinition itemdef) {
+ ConfigEntry cfg = itemdef.Recipe.RecipeConfig;
+ ConfigDrawHelpers.GroupHeader("Recipe");
+
+ if (!RecipeRows.TryGetValue(cfg, out List rows)) {
+ rows = ParseCsv(cfg.Value, 3);
+ RecipeRows[cfg] = rows;
+ }
+
+ GUILayout.BeginHorizontal();
+ GUILayout.Label("Resource (prefab)", GUILayout.Width(200f));
+ GUILayout.Label("Amount", GUILayout.Width(60f));
+ GUILayout.Label("Per level", GUILayout.Width(70f));
+ GUILayout.EndHorizontal();
+
+ for (int i = 0; i < rows.Count; i++) {
+ string[] row = rows[i];
+ GUILayout.BeginHorizontal();
+ row[0] = GUILayout.TextField(row[0] ?? "", GUILayout.Width(200f));
+ row[1] = DigitsOnly(GUILayout.TextField(row[1] ?? "", GUILayout.Width(60f)));
+ row[2] = DigitsOnly(GUILayout.TextField(row[2] ?? "", GUILayout.Width(70f)));
+ bool remove = GUILayout.Button("✕", GUILayout.Width(26f));
+ GUILayout.EndHorizontal();
+ if (remove) { rows.RemoveAt(i); i--; }
+ }
+
+ GUILayout.BeginHorizontal();
+ if (GUILayout.Button("Add resource", GUILayout.Width(120f))) { rows.Add(new[] { "", "1", "0" }); }
+ if (GUILayout.Button("Apply", GUILayout.Width(80f))) { cfg.Value = SerializeCsv(rows); }
+ if (GUILayout.Button("Reload", GUILayout.Width(80f))) { RecipeRows[cfg] = ParseCsv(cfg.Value, 3); }
+ GUILayout.EndHorizontal();
+ GUILayout.Label("Applied: " + cfg.Value, ConfigDrawHelpers.Dim);
+ }
+
+ internal static List ParseCsv(string csv, int cols) {
+ List rows = new List();
+ foreach (string part in (csv ?? "").Split('|')) {
+ if (string.IsNullOrEmpty(part) || part.Trim().Length == 0) { continue; }
+ string[] seg = part.Split(',');
+ string[] row = new string[cols];
+ for (int i = 0; i < cols; i++) { row[i] = i < seg.Length ? seg[i] : ""; }
+ rows.Add(row);
+ }
+ return rows;
+ }
+
+ internal static string SerializeCsv(List rows) =>
+ string.Join("|", rows.Where(r => !string.IsNullOrEmpty(r[0]) && r[0].Trim().Length > 0).Select(r => string.Join(",", r)).ToArray());
+
+ internal static string DigitsOnly(string s) =>
+ new string((s ?? "").Where(ch => char.IsDigit(ch) || ch == '-').ToArray());
+ }
+
+ // Collapses a building piece's ConfigEntries into a single expandable, grouped drawer.
+ internal static class PieceConfigDrawer {
+ private static readonly Dictionary Expanded = new Dictionary();
+ private static readonly Dictionary> CostRows = new Dictionary>();
+ private static int _order = 0;
+
+ // Hides the piece's sub-entries and turns Enabled into the single visible drawer row.
+ internal static void Attach(PieceLoader.BuildPiece jp) {
+ ConfigDrawHelpers.Hide(jp.Cfgs.RequiresWorkbench);
+ ConfigDrawHelpers.Hide(jp.Cfgs.Workbench);
+ ConfigDrawHelpers.Hide(jp.Cfgs.PieceCategory);
+ ConfigDrawHelpers.Hide(jp.Cfgs.PieceCost);
+
+ ConfigurationManagerAttributes anchor = ConfigDrawHelpers.GetAttributes(jp.Cfgs.Enabled);
+ if (anchor != null) {
+ anchor.CustomDrawer = _ => Draw(jp);
+ anchor.HideSettingName = true;
+ anchor.HideDefaultButton = true;
+ anchor.Category = "Building Pieces";
+ anchor.Order = _order--;
+ }
+ }
+
+ private static void Draw(PieceLoader.BuildPiece jp) {
+ ConfigDrawHelpers.EnsureStyles();
+ GUILayout.BeginVertical(GUI.skin.box);
+
+ bool expanded = Expanded.TryGetValue(jp.Name, out bool e) && e;
+ if (GUILayout.Button((expanded ? "▾ " : "▸ ") + jp.Name, ConfigDrawHelpers.HeaderButton)) {
+ expanded = !expanded;
+ Expanded[jp.Name] = expanded;
+ }
+
+ if (expanded) {
+ bool admin = SynchronizationManager.Instance == null || SynchronizationManager.Instance.PlayerIsAdmin;
+ if (!admin) { GUILayout.Label("Server-controlled – admin only.", ConfigDrawHelpers.Dim); }
+ bool prevEnabled = GUI.enabled;
+ GUI.enabled = admin;
+
+ ConfigDrawHelpers.GroupHeader("Settings");
+ ConfigDrawHelpers.DrawBool("Enabled", jp.Cfgs.Enabled);
+ ConfigDrawHelpers.DrawBool("Requires workbench", jp.Cfgs.RequiresWorkbench);
+ ConfigDrawHelpers.DrawString("Workbench", jp.Cfgs.Workbench);
+ ConfigDrawHelpers.DrawChoice("Piece category", jp.Cfgs.PieceCategory);
+
+ DrawCostEditor(jp);
+
+ GUI.enabled = prevEnabled;
+ }
+
+ GUILayout.EndVertical();
+ }
+
+ // Building cost shown as one row per resource: prefab (string) + amount (int) + refundable (bool).
+ private static void DrawCostEditor(PieceLoader.BuildPiece jp) {
+ ConfigEntry cfg = jp.Cfgs.PieceCost;
+ ConfigDrawHelpers.GroupHeader("Building Cost");
+
+ if (!CostRows.TryGetValue(cfg, out List rows)) {
+ rows = ItemConfigDrawer.ParseCsv(cfg.Value, 3);
+ CostRows[cfg] = rows;
+ }
+
+ GUILayout.BeginHorizontal();
+ GUILayout.Label("Resource (prefab)", GUILayout.Width(200f));
+ GUILayout.Label("Amount", GUILayout.Width(60f));
+ GUILayout.Label("Refund", GUILayout.Width(90f));
+ GUILayout.EndHorizontal();
+
+ for (int i = 0; i < rows.Count; i++) {
+ string[] row = rows[i];
+ GUILayout.BeginHorizontal();
+ row[0] = GUILayout.TextField(row[0] ?? "", GUILayout.Width(200f));
+ row[1] = ItemConfigDrawer.DigitsOnly(GUILayout.TextField(row[1] ?? "", GUILayout.Width(60f)));
+ bool refund = (row[2] ?? "").Trim().ToLower() != "false";
+ bool nr = GUILayout.Toggle(refund, refund ? " refundable" : " no refund", GUILayout.Width(110f));
+ row[2] = nr ? "true" : "false";
+ bool remove = GUILayout.Button("✕", GUILayout.Width(26f));
+ GUILayout.EndHorizontal();
+ if (remove) { rows.RemoveAt(i); i--; }
+ }
+
+ GUILayout.BeginHorizontal();
+ if (GUILayout.Button("Add resource", GUILayout.Width(120f))) { rows.Add(new[] { "", "1", "true" }); }
+ if (GUILayout.Button("Apply", GUILayout.Width(80f))) { cfg.Value = ItemConfigDrawer.SerializeCsv(rows); }
+ if (GUILayout.Button("Reload", GUILayout.Width(80f))) { CostRows[cfg] = ItemConfigDrawer.ParseCsv(cfg.Value, 3); }
+ GUILayout.EndHorizontal();
+ GUILayout.Label("Applied: " + cfg.Value, ConfigDrawHelpers.Dim);
+ }
+ }
+}
diff --git a/Common/src/Modding/ItemBatchLoader.cs b/Common/src/Modding/ItemBatchLoader.cs
new file mode 100644
index 000000000..5ac699bac
--- /dev/null
+++ b/Common/src/Modding/ItemBatchLoader.cs
@@ -0,0 +1,698 @@
+using BepInEx.Configuration;
+using Jotunn.Configs;
+using Jotunn.Entities;
+using Jotunn.Managers;
+using Jotunn.Utils;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Common {
+ ///
+ /// Batch-registers config-driven items from an asset bundle and keeps them reconciled to their config
+ /// entries for the rest of the session (recipe, station, station level, craft amount, per-stat values
+ /// and damage modifiers), including across server config syncs and ObjectDB rebuilds.
+ ///
+ /// Usage: add every
+ public class ItemBatchLoader {
+ internal static List resourceDefinitions = new List();
+ internal static AssetBundle Assets;
+ internal static Dictionary AddedItems = new Dictionary();
+ internal static List ArcheryAmmoToAdd = new List();
+
+ ///
+ /// Bundle path for an item prefab; {0} is the category, {1} the prefab name. Set to null to look the
+ /// prefab up by its bare name (flat bundles).
+ ///
+ public static string PrefabPathFormat = "Assets/Custom/Weapons/{0}/{1}.prefab";
+
+ /// Bundle path for an item icon; {0} is the icon name. Null looks it up by bare name.
+ public static string IconPathFormat = "Assets/Custom/Icons/{0}.png";
+
+ ///
+ /// Whether Jotunn should fix up JVLmock_ references on the registered prefabs. Set false for prefabs
+ /// authored directly against the real game assets, which have no mocks to resolve.
+ ///
+ public static bool FixReferences = true;
+
+ // Pending in-world item updates, drained once per frame so an entire burst of SettingChanged
+ // handlers (e.g. a full server config sync) costs a single Resources.FindObjectsOfTypeAll scan
+ // instead of one scan per changed setting.
+ private static readonly List>> pendingWorldUpdates = new List>>();
+ private static bool worldUpdateScheduled = false;
+
+ internal static readonly AcceptableValueList allowedModifiers = new AcceptableValueList(new string[] {
+ HitData.DamageModifier.Normal.ToString(),
+ HitData.DamageModifier.VeryWeak.ToString(),
+ HitData.DamageModifier.Weak.ToString(),
+ HitData.DamageModifier.Resistant.ToString(),
+ HitData.DamageModifier.VeryResistant.ToString(),
+ HitData.DamageModifier.Immune.ToString()
+ });
+
+ public bool AddDefinition(ItemDefinition itemdef) {
+ resourceDefinitions.Add(itemdef);
+ return true;
+ }
+
+ ///
+ /// Binds every definition's config entries, registers the items with Jotunn, and hooks up the
+ /// change/sync handlers that keep them reconciled.
+ ///
+ /// stat in itemdef.ModifableStats) {
+ if (stat.Value.Configurable == false) { continue; }
+ if (stat.Value.IsInt) {
+ stat.Value.CfgInt = ConfigBinder.BindServerConfig(section, $"{itemdef.DisplayName}-{stat.Key}", (int)stat.Value.Default_value, $"Value for {stat.Key} on {itemdef.Name}", true, (int)stat.Value.Min, (int)stat.Value.Max);
+ } else {
+ stat.Value.Cfg = ConfigBinder.BindServerConfig(section, $"{itemdef.DisplayName}-{stat.Key}", stat.Value.Default_value, $"Value for {stat.Key} on {itemdef.Name}", true, stat.Value.Min, stat.Value.Max);
+ }
+ }
+ // Set the damage modifiers for this item
+ if (itemdef.DamageMods != null) {
+ foreach (KeyValuePair dmgmod in itemdef.DamageMods) {
+ dmgmod.Value.DmgModCfg = ConfigBinder.BindServerConfig(section, $"{itemdef.DisplayName}-{dmgmod.Key}-DamageModifier", dmgmod.Value.DamageModifier.ToString(), $"Damage modifier for {dmgmod.Key} on {itemdef.Name}", allowedModifiers, true);
+ }
+ }
+
+ // Build the item recipe
+ itemdef.Recipe.RecipeConfig = ConfigBinder.BindServerConfig(section, $"{itemdef.DisplayName}-recipe", BuildStringRecipeFromItemDef(itemdef), $"Recipe for {itemdef.Name}. Should be in the format of Prefab,Amount,AmountPerLevel|Prefab,Amount,AmountPerLevel eg: Wood,12,2|Stone,2,0");
+ if (ValidateRecipeConfig(itemdef) == false) {
+ BuildRecipeReqsFromDefault(itemdef);
+ }
+
+ // Collapse this item's entries into a single grouped custom drawer to keep the in-game
+ // Configuration Manager responsive (one visible row per item instead of ~10-20).
+ ItemConfigDrawer.Attach(itemdef);
+ }
+ return true;
+ }
+
+ // TODO: Change batch onchange actions to pass to a queue and execute queue from a couroutine.
+ private bool SetupOnChange() {
+ foreach (ItemDefinition itemdef in resourceDefinitions) {
+ // Need to have config onchange settings available for items which are not enabled to ensure that we can enable them when joining a remote server with different items enabled
+ // Craftable config toggle
+ itemdef.CraftableCfg.SettingChanged += (_, __) => {
+ ConfigChangeDebouncer.Schedule(itemdef.CraftableCfg, () => EnableDisableItemInDB(itemdef, itemdef.CraftableCfg.Value));
+ };
+ // Station level config
+ itemdef.StationLVLCfg.SettingChanged += (_, __) => {
+ ConfigChangeDebouncer.Schedule(itemdef.StationLVLCfg, () => ModifyItemRecipeLevel(itemdef, itemdef.StationLVLCfg.Value));
+ };
+ // Modify where the item is crafted
+ itemdef.CraftedAtCfg.SettingChanged += (_, __) => {
+ ConfigChangeDebouncer.Schedule(itemdef.CraftedAtCfg, () => ModifyItemRecipeCraftedAt(itemdef));
+ };
+ // Modify how many of the item are crafted per recipe
+ itemdef.CraftAmountCfg.SettingChanged += (_, __) => {
+ ConfigChangeDebouncer.Schedule(itemdef.CraftAmountCfg, () => ModifyItemRecipeCraftAmount(itemdef, itemdef.CraftAmountCfg.Value));
+ };
+
+ // All of the configurable stat variables
+ foreach (KeyValuePair stat in itemdef.ModifableStats) {
+ if (stat.Value.Configurable == false) { continue; }
+ object statKey = stat.Value.IsInt ? (object)stat.Value.CfgInt : stat.Value.Cfg;
+ void UpdateFromConfig(object sender, EventArgs args) {
+ ConfigChangeDebouncer.Schedule(statKey, () => {
+ if (ZNet.instance == null || ZNet.instance.enabled == false) { return; }
+ stat.Value.Default_value = stat.Value.IsInt ? stat.Value.CfgInt.Value : stat.Value.Cfg.Value;
+ // Update player items
+ UpdateItemInPlayerInventory(itemdef.Prefab, (ItemDrop.ItemData item) => { ItemDataConfigModifier(stat.Key, stat.Value.Default_value, item); });
+ // Update in world items, batched into a single scan to prevent lag spikes (e.g. on server config sync).
+ EnqueueWorldUpdate(itemdef.Prefab, (ItemDrop.ItemData item) => { ItemDataConfigModifier(stat.Key, stat.Value.Default_value, item); });
+ });
+ }
+
+ if (stat.Value.IsInt) {
+ stat.Value.CfgInt.SettingChanged += UpdateFromConfig;
+ } else {
+ stat.Value.Cfg.SettingChanged += UpdateFromConfig;
+ }
+ }
+
+ // Modify the recipe in the object DB
+ itemdef.Recipe.RecipeConfig.SettingChanged += (sender, args) => {
+ ConfigChangeDebouncer.Schedule(itemdef.Recipe.RecipeConfig, () => {
+ if (ValidateRecipeConfig(itemdef)) {
+ ModifyItemRecipeInODB(itemdef);
+ }
+ });
+ };
+
+ //Modify the damage modifiers
+ if (itemdef.DamageMods == null) { continue; }
+ foreach (KeyValuePair dmgmod in itemdef.DamageMods) {
+ dmgmod.Value.DmgModCfg.SettingChanged += (_, __) => {
+ ConfigChangeDebouncer.Schedule(dmgmod.Value.DmgModCfg, () => {
+ if (ZNet.instance == null || ZNet.instance.enabled == false) { return; }
+ HitData.DamageModifier modifier = (HitData.DamageModifier)Enum.Parse(typeof(HitData.DamageModifier), dmgmod.Value.DmgModCfg.Value);
+ // Update player items
+ UpdateItemInPlayerInventory(itemdef.Prefab, (ItemDrop.ItemData item) => { SetItemDamageModifier(modifier, dmgmod.Key, item); });
+ // Update world items, batched into a single scan to prevent lag spikes (e.g. on server config sync).
+ EnqueueWorldUpdate(itemdef.Prefab, (ItemDrop.ItemData item) => { SetItemDamageModifier(modifier, dmgmod.Key, item); });
+ });
+ };
+ }
+ }
+ return true;
+ }
+
+ // Idempotently reconciles every item recipe in the live ObjectDB to the current config values.
+ // Safe to call repeatedly and from multiple lifecycle events; self guards when no ObjectDB exists.
+ private static void ReapplyAllRecipeConfig() {
+ if (ObjectDB.instance == null || ObjectDB.instance.m_recipes == null) { return; }
+ foreach (ItemDefinition itemdef in resourceDefinitions) {
+ // Make sure the recipe is present before we try to modify it. A prior ObjectDB.CopyOtherDB
+ // (server join) can drop our custom recipes, so re-add disabled items too - their config is
+ // applied here and EnableDisableItemInDB sets the disabled flag last.
+ EnsureRecipeInDB(itemdef);
+ if (ValidateRecipeConfig(itemdef)) { ModifyItemRecipeInODB(itemdef); }
+ ModifyItemRecipeLevel(itemdef, itemdef.StationLVLCfg.Value);
+ ModifyItemRecipeCraftedAt(itemdef);
+ ModifyItemRecipeCraftAmount(itemdef, itemdef.CraftAmountCfg.Value);
+ EnableDisableItemInDB(itemdef, itemdef.CraftableCfg.Value);
+ }
+ // Refresh an open crafting panel so changed recipes/amounts/enabled state are reflected immediately.
+ if (Player.m_localPlayer != null) { Player.m_localPlayer.UpdateKnownRecipesList(); }
+ }
+
+ // Fires when admin (server) config is synchronized to this client. Only re-apply when our plugin's
+ // config was part of the sync payload to avoid needless work when other mods sync.
+ private static void OnModConfigsChanged(object sender, ConfigurationSynchronizationEventArgs e) {
+ if (e.UpdatedPluginGUIDs != null && e.UpdatedPluginGUIDs.Count > 0 && !e.UpdatedPluginGUIDs.Contains(ModContext.PluginGuid)) {
+ return;
+ }
+ ReapplyAllRecipeConfig();
+ }
+
+ // Resolves a bundle asset, preferring the configured path convention and falling back to the bare
+ // name so flat bundles (Jam, AdvancedPortals, EpicLoot) work with the same loader.
+ private static T LoadBundleAsset(string pathFormat, string bareName, params object[] formatArgs) where T : UnityEngine.Object {
+ if (!string.IsNullOrEmpty(pathFormat)) {
+ T viaPath = Assets.LoadAsset(string.Format(pathFormat, formatArgs));
+ if (viaPath != null) { return viaPath; }
+ }
+ return Assets.LoadAsset(bareName);
+ }
+
+ private static bool BatchAddItems() {
+ foreach (ItemDefinition itemdef in resourceDefinitions) {
+ GameObject ItemPrefab = LoadBundleAsset(PrefabPathFormat, itemdef.Prefab, itemdef.Category, itemdef.Prefab);
+ if (ItemPrefab == null) {
+ ModLogger.LogError($"Could not find prefab '{itemdef.Prefab}' for {itemdef.Name} in the asset bundle; skipping.");
+ continue;
+ }
+ // Icon is optional: a prefab authored with its own icon leaves it unset and Jotunn keeps
+ // whatever the ItemDrop already carries.
+ Sprite ItemSprite = string.IsNullOrEmpty(itemdef.Icon)
+ ? null
+ : LoadBundleAsset(IconPathFormat, itemdef.Icon, itemdef.Icon);
+ ItemDrop ItemD = ItemPrefab.GetComponent();
+ // Modify this items stats
+ foreach (KeyValuePair modstat in itemdef.ModifableStats) {
+ if (modstat.Value.Configurable == false) {
+ ItemDataConfigModifier(modstat.Key, modstat.Value.Default_value, ItemD.m_itemData);
+ } else {
+ if (modstat.Value.IsInt) {
+ ItemDataConfigModifier(modstat.Key, modstat.Value.CfgInt.Value, ItemD.m_itemData);
+ } else {
+ ItemDataConfigModifier(modstat.Key, modstat.Value.Cfg.Value, ItemD.m_itemData);
+ }
+ }
+ }
+ // Modify this items resistances
+ if (itemdef.DamageMods != null) {
+ foreach (KeyValuePair dmgmod in itemdef.DamageMods) {
+ if (dmgmod.Value.Configurable == false || dmgmod.Value.DmgModCfg == null) { continue; }
+ HitData.DamageModifier modifier = (HitData.DamageModifier)Enum.Parse(typeof(HitData.DamageModifier), dmgmod.Value.DmgModCfg.Value);
+ SetItemDamageModifier(modifier, dmgmod.Key, ItemD.m_itemData);
+ }
+ }
+ ItemConfig itemcfg = new ItemConfig() {
+ Amount = itemdef.CraftAmountCfg.Value,
+ CraftingStation = $"{itemdef.CraftedAtCfg.Value}",
+ MinStationLevel = itemdef.StationLVLCfg.Value,
+ // Always register as enabled so the recipe is added to and retained in the ObjectDB (a
+ // recipe registered disabled never gets cached/retained). The real craftable state is
+ // applied immediately after by ReapplyAllRecipeConfig -> EnableDisableItemInDB, so a
+ // disabled item still lives in the DB (m_enabled=false), stays modifiable, and re-enables
+ // correctly - including after a server ObjectDB copy replaces the recipe list.
+ Enabled = true,
+ Icons = ItemSprite != null ? new[] { ItemSprite } : null,
+ Requirements = itemdef.Recipe.RecipeReqs.ToArray()
+ };
+ ItemManager.Instance.AddItem(new CustomItem(ItemPrefab, FixReferences, itemcfg));
+
+ // This item needs to be included as a returnable arrow/bolt
+ if (itemdef.Category == ItemCategory.Arrows) {
+ ArcheryAmmoToAdd.Add(itemdef.Prefab);
+ }
+ }
+ return true;
+ }
+
+ private static void ItemDataConfigModifier(ItemStat target_attribute, float updatedValue, ItemDrop.ItemData itemData) {
+ if (itemData == null) { return; }
+ switch (target_attribute) {
+ // Standard Dmg types
+ case ItemStat.slash:
+ itemData.m_shared.m_damages.m_slash = updatedValue;
+ break;
+ case ItemStat.slash_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_slash = updatedValue;
+ break;
+ case ItemStat.blunt:
+ itemData.m_shared.m_damages.m_blunt = updatedValue;
+ break;
+ case ItemStat.blunt_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_blunt = updatedValue;
+ break;
+ case ItemStat.pierce:
+ itemData.m_shared.m_damages.m_pierce = updatedValue;
+ break;
+ case ItemStat.pierce_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_pierce = updatedValue;
+ break;
+ // Special Damage Types
+ case ItemStat.pickaxe:
+ itemData.m_shared.m_damages.m_pickaxe = updatedValue;
+ break;
+ case ItemStat.pickaxe_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_pickaxe = updatedValue;
+ break;
+ case ItemStat.chop:
+ itemData.m_shared.m_damages.m_chop = updatedValue;
+ break;
+ case ItemStat.chop_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_chop = updatedValue;
+ break;
+ case ItemStat.attack_force:
+ itemData.m_shared.m_attackForce = updatedValue;
+ break;
+ case ItemStat.secondary_attack_force_multiply:
+ itemData.m_shared.m_secondaryAttack.m_forceMultiplier = updatedValue;
+ break;
+ case ItemStat.primary_attack_force_multiply:
+ itemData.m_shared.m_attack.m_forceMultiplier = updatedValue;
+ break;
+ // Elemental Damage Types
+ case ItemStat.fire:
+ itemData.m_shared.m_damages.m_fire = updatedValue;
+ break;
+ case ItemStat.fire_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_fire = updatedValue;
+ break;
+ case ItemStat.lightning:
+ itemData.m_shared.m_damages.m_lightning = updatedValue;
+ break;
+ case ItemStat.lightning_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_lightning = updatedValue;
+ break;
+ case ItemStat.frost:
+ itemData.m_shared.m_damages.m_frost = updatedValue;
+ break;
+ case ItemStat.frost_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_frost = updatedValue;
+ break;
+ case ItemStat.poison:
+ itemData.m_shared.m_damages.m_poison = updatedValue;
+ break;
+ case ItemStat.poison_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_poison = updatedValue;
+ break;
+ case ItemStat.spirit:
+ itemData.m_shared.m_damages.m_spirit = updatedValue;
+ break;
+ case ItemStat.spirit_per_level:
+ itemData.m_shared.m_damagesPerLevel.m_spirit = updatedValue;
+ break;
+ // Block and parry
+ case ItemStat.block_armor:
+ itemData.m_shared.m_blockPower = updatedValue;
+ break;
+ case ItemStat.block_armor_per_level:
+ itemData.m_shared.m_blockPowerPerLevel = updatedValue;
+ break;
+ case ItemStat.parry:
+ itemData.m_shared.m_timedBlockBonus = updatedValue;
+ break;
+ case ItemStat.block_force:
+ itemData.m_shared.m_deflectionForce = updatedValue;
+ break;
+ case ItemStat.block_force_per_level:
+ itemData.m_shared.m_deflectionForcePerLevel = updatedValue;
+ break;
+ // Costs for attack types
+ case ItemStat.primary_attack_stamina:
+ itemData.m_shared.m_attack.m_attackStamina = updatedValue;
+ break;
+ case ItemStat.primary_attack_eitr:
+ itemData.m_shared.m_attack.m_attackEitr = updatedValue;
+ break;
+ case ItemStat.primary_attack_flat_health_cost:
+ itemData.m_shared.m_attack.m_attackHealth = updatedValue;
+ break;
+ case ItemStat.primary_attack_percent_health_cost:
+ itemData.m_shared.m_attack.m_attackHealthPercentage = updatedValue;
+ break;
+ case ItemStat.primary_attack_health_returned:
+ itemData.m_shared.m_attack.m_attackHealthReturnHit = updatedValue;
+ break;
+ case ItemStat.primary_attack_damage_bonus_per_missing_hp:
+ itemData.m_shared.m_attack.m_damageMultiplierPerMissingHP = updatedValue;
+ break;
+ case ItemStat.primary_attack_projectile_count:
+ itemData.m_shared.m_attack.m_projectiles = (int)updatedValue;
+ break;
+ case ItemStat.secondary_attack_stamina:
+ itemData.m_shared.m_secondaryAttack.m_attackStamina = updatedValue;
+ break;
+ case ItemStat.secondary_attack_eitr:
+ itemData.m_shared.m_secondaryAttack.m_attackEitr = updatedValue;
+ break;
+ case ItemStat.secondary_attack_flat_health_cost:
+ itemData.m_shared.m_secondaryAttack.m_attackHealth = updatedValue;
+ break;
+ case ItemStat.secondary_attack_percent_health_cost:
+ itemData.m_shared.m_secondaryAttack.m_attackHealthPercentage = updatedValue;
+ break;
+ // Speed Modifiers
+ case ItemStat.movement_speed:
+ itemData.m_shared.m_movementModifier = updatedValue;
+ break;
+ case ItemStat.bow_draw_speed:
+ itemData.m_shared.m_attack.m_drawDurationMin = updatedValue;
+ break;
+ case ItemStat.crossbow_reload_speed:
+ itemData.m_shared.m_attack.m_reloadTime = updatedValue;
+ break;
+ case ItemStat.crossbow_reload_stamina_drain:
+ itemData.m_shared.m_attack.m_reloadStaminaDrain = updatedValue;
+ break;
+ case ItemStat.draw_stamina_drain:
+ itemData.m_shared.m_attack.m_drawStaminaDrain = updatedValue;
+ break;
+ case ItemStat.projectile_velocity:
+ itemData.m_shared.m_attack.m_projectileVel = updatedValue;
+ break;
+ case ItemStat.projectile_accuracy_max:
+ itemData.m_shared.m_attack.m_projectileAccuracy = (100f - updatedValue);
+ break;
+ // Item Modifiers
+ case ItemStat.durability:
+ itemData.m_shared.m_maxDurability = updatedValue;
+ break;
+ case ItemStat.durability_per_level:
+ itemData.m_shared.m_durabilityPerLevel = updatedValue;
+ break;
+ case ItemStat.max_item_level:
+ itemData.m_shared.m_maxQuality = (int)updatedValue;
+ break;
+ // 'amount' is the inventory stack size; it is grouped with the other item modifiers in the
+ // config drawer and previously fell through to the "unknown stat" warning below.
+ case ItemStat.amount:
+ itemData.m_shared.m_maxStackSize = (int)updatedValue;
+ break;
+ case ItemStat.tool_level:
+ itemData.m_shared.m_toolTier = (int)updatedValue;
+ break;
+ default:
+ ModLogger.LogWarning($"Unknown item stat {target_attribute} for {itemData.m_shared.m_name}");
+ break;
+ }
+ }
+
+ private static bool ValidateRecipeConfig(ItemDefinition itemdef) {
+ List requirements = new List();
+ try {
+ string[] recipeConfig = itemdef.Recipe.RecipeConfig.Value.Split('|');
+ foreach (string ingredient in recipeConfig) {
+ string[] ingredientConfig = ingredient.Split(',');
+ if (ingredientConfig.Length == 1) {
+ // This is the first run or deleted config entry scenario
+ return false;
+ }
+ if (ingredientConfig.Length != 3) {
+ ModLogger.LogWarning($"Invalid ({itemdef.Name}) recipe config detected: {ingredient}. Needs three entries eg: Wood,1,1");
+ return false;
+ }
+ requirements.Add(new RequirementConfig { Item = ingredientConfig[0], Amount = int.Parse(ingredientConfig[1]), AmountPerLevel = int.Parse(ingredientConfig[2]) });
+ }
+ // Only happens if the recipe is valid
+ itemdef.Recipe.RecipeReqs = requirements;
+ return true;
+ } catch {
+ ModLogger.LogWarning($"Recipe is Invalid. Should have the format of Wood,1,1|Stone,2,0 - Prefab,cost,upgrade.");
+ return false;
+ }
+ }
+
+ private static void BuildRecipeReqsFromDefault(ItemDefinition itemdef) {
+ List requirements = new List();
+ foreach (RecipeIngredient recipeIng in itemdef.Recipe.RecipeItems) {
+ requirements.Add(new RequirementConfig { Item = recipeIng.Prefab, Amount = recipeIng.Amount, AmountPerLevel = recipeIng.UpgradeCost });
+ }
+ itemdef.Recipe.RecipeReqs = requirements;
+ }
+
+ private static string BuildStringRecipeFromItemDef(ItemDefinition itemdef) {
+ List recipe = new List();
+ foreach (RecipeIngredient req in itemdef.Recipe.RecipeItems) {
+ recipe.Add($"{req.Prefab},{req.Amount},{req.UpgradeCost}");
+ }
+ return string.Join("|", recipe.ToArray());
+ }
+
+ private static bool ModifyItemRecipeCraftedAt(ItemDefinition itemdef) {
+ if (ObjectDB.instance == null || ObjectDB.instance.m_recipes == null) { return false; }
+
+ int index = GetRecipeIndexByPrefab(itemdef.Prefab);
+ if (index == -1) {
+ ModLogger.LogWarning($"Recipe of {itemdef.Prefab} not found in ObjectDB, recipe will not be modified.");
+ return false;
+ }
+ CraftingStation craftable_at = PrefabManager.Instance.GetPrefab(itemdef.CraftedAtCfg.Value)?.GetComponent();
+ if (craftable_at == null) {
+ ModLogger.LogWarning($"Crafting Station {itemdef.CraftedAtCfg.Value} prefab not found, or does not have a crafting station componet.");
+ return false;
+ }
+ ObjectDB.instance.m_recipes[index].m_craftingStation = craftable_at;
+ // repair station should likely be split out into a seperate config
+ ObjectDB.instance.m_recipes[index].m_repairStation = craftable_at;
+ return true;
+ }
+
+ private static void ModifyItemRecipeInODB(ItemDefinition itemdef) {
+ if (ObjectDB.instance == null || ObjectDB.instance.m_recipes == null) { return; }
+
+ int recipe_index = GetRecipeIndexByPrefab(itemdef.Prefab);
+ if (recipe_index == -1) {
+ ModLogger.LogWarning($"Recipe of {itemdef.Prefab} not found in ObjectDB, Recipe will not be modified.");
+ return;
+ }
+ Recipe current_recipe = ObjectDB.instance.m_recipes[recipe_index];
+ Recipe newRecipe = current_recipe;
+ List newRequirements = new List();
+ foreach (RequirementConfig req in itemdef.Recipe.RecipeReqs) {
+ GameObject resgo = ObjectDB.instance.GetItemPrefab(req.Item);
+ if (resgo == null) {
+ ModLogger.LogWarning($"Recipe for {itemdef.Prefab} has an invalid requirement {req.Item}.");
+ return;
+ }
+ newRequirements.Add(new Piece.Requirement { m_resItem = resgo.GetComponent(), m_amount = req.Amount, m_amountPerLevel = req.AmountPerLevel });
+ }
+ newRecipe.m_resources = newRequirements.ToArray();
+
+ int index = ObjectDB.instance.m_recipes.IndexOf(current_recipe);
+ if (index > -1) {
+ ObjectDB.instance.m_recipes[index] = newRecipe;
+ itemdef.Recipe.ResolvedRecipe = newRecipe;
+ } else {
+ ModLogger.LogWarning($"Recipe {current_recipe.name} not found in ObjectDB.");
+ }
+ }
+
+ // Re-add itemdef's cached recipe to the live ObjectDB if a prior ObjectDB.CopyOtherDB (server join)
+ // replaced m_recipes and dropped it. Keeps even disabled items present so their recipe can still be
+ // modified and correctly re-enabled later.
+ private static void EnsureRecipeInDB(ItemDefinition itemdef) {
+ if (ObjectDB.instance == null || ObjectDB.instance.m_recipes == null) { return; }
+ if (GetRecipeIndexByPrefab(itemdef.Prefab) != -1) { return; }
+ if (itemdef.Recipe.ResolvedRecipe != null) {
+ ObjectDB.instance.m_recipes.Add(itemdef.Recipe.ResolvedRecipe);
+ }
+ }
+
+ private static void EnableDisableItemInDB(ItemDefinition itemdef, bool enable) {
+ if (ObjectDB.instance == null || ObjectDB.instance.m_recipes == null) { return; }
+
+ int index = GetRecipeIndexByPrefab(itemdef.Prefab);
+ if (index == -1) {
+ // Recipe was dropped (e.g. server ObjectDB copy). Re-add our cached recipe so a disabled
+ // item still lives in the DB and can be modified / re-enabled later.
+ if (itemdef.Recipe.ResolvedRecipe != null) {
+ itemdef.Recipe.ResolvedRecipe.m_enabled = enable;
+ ObjectDB.instance.m_recipes.Add(itemdef.Recipe.ResolvedRecipe);
+ } else {
+ ModLogger.LogWarning($"Recipe of {itemdef.Prefab} not found in ObjectDB and no cached recipe to re-add.");
+ }
+ return;
+ }
+ // recipe exists in the ODB
+ ObjectDB.instance.m_recipes[index].m_enabled = enable;
+ itemdef.Recipe.ResolvedRecipe = ObjectDB.instance.m_recipes[index];
+ }
+
+ private static void ModifyItemRecipeLevel(ItemDefinition itemdef, int level) {
+ if (ObjectDB.instance == null || ObjectDB.instance.m_recipes == null) { return; }
+ int index = GetRecipeIndexByPrefab(itemdef.Prefab);
+ if (index == -1) {
+ ModLogger.LogWarning($"Recipe of {itemdef.Prefab} not found in ObjectDB, required level will not be modified.");
+ return;
+ }
+ ObjectDB.instance.m_recipes[index].m_minStationLevel = level;
+ // Update the stored recipe so if we use it to target things again it will still be accurate
+ itemdef.Recipe.ResolvedRecipe = ObjectDB.instance.m_recipes[index];
+ }
+
+ private static void ModifyItemRecipeCraftAmount(ItemDefinition itemdef, int amount) {
+ if (ObjectDB.instance == null || ObjectDB.instance.m_recipes == null) { return; }
+ int index = GetRecipeIndexByPrefab(itemdef.Prefab);
+ if (index == -1) {
+ ModLogger.LogWarning($"Recipe of {itemdef.Prefab} not found in ObjectDB, craft amount will not be modified.");
+ return;
+ }
+ ObjectDB.instance.m_recipes[index].m_amount = amount;
+ // Update the stored recipe so if we use it to target things again it will still be accurate
+ itemdef.Recipe.ResolvedRecipe = ObjectDB.instance.m_recipes[index];
+ }
+
+ private static int GetRecipeIndexByPrefab(string prefab) {
+ return ObjectDB.instance.m_recipes.FindIndex(m => m.m_item != null && m.m_item.name == prefab);
+ }
+
+ private static void SetItemDamageModifier(HitData.DamageModifier modifier, HitData.DamageType type, ItemDrop.ItemData itemData) {
+ List temp = itemData.m_shared.m_damageModifiers.Where(entry => entry.m_type != type).ToList();
+ if (temp.Count == 0) {
+ itemData.m_shared.m_damageModifiers.Clear();
+ itemData.m_shared.m_damageModifiers.Add(new HitData.DamageModPair() { m_modifier = modifier, m_type = type });
+ } else {
+ temp.Add(new HitData.DamageModPair() { m_modifier = modifier, m_type = type });
+ itemData.m_shared.m_damageModifiers = temp;
+ }
+ }
+
+ private static void UpdateItemInPlayerInventory(string prefab, Action callback) {
+ if (Player.m_localPlayer == null) { return; }
+ foreach (ItemDrop.ItemData user_item in Player.m_localPlayer.m_inventory.GetAllItems()) {
+ if (user_item == null || user_item.m_dropPrefab == null) { continue; }
+ if (user_item.m_dropPrefab.name != prefab) { continue; }
+ callback(user_item);
+ }
+ }
+
+ // Queues an in-world item update. All updates enqueued within a frame are applied together in a single
+ // scan (see DrainWorldUpdates), collapsing N Resources.FindObjectsOfTypeAll scans - one per changed
+ // setting during a config sync - into one.
+ private static void EnqueueWorldUpdate(string prefab, Action callback) {
+ // Skip during game shutdown: the ThreadingHelper's MonoBehaviour is destroyed (StartCoroutine
+ // would throw) and there are no in-world items left to update. Unity's '==' treats it as null.
+ BepInEx.ThreadingHelper host = BepInEx.ThreadingHelper.Instance;
+ if (host == null) { return; }
+ pendingWorldUpdates.Add(new KeyValuePair>(prefab, callback));
+ if (worldUpdateScheduled) { return; }
+ worldUpdateScheduled = true;
+ host.StartCoroutine(DrainWorldUpdates());
+ }
+
+ // Applies all queued in-world item updates using a single Resources.FindObjectsOfTypeAll scan.
+ private static IEnumerator DrainWorldUpdates() {
+ // Wait a frame so the full burst of SettingChanged handlers (e.g. an entire config sync) enqueues first.
+ yield return null;
+ try {
+ if (pendingWorldUpdates.Count > 0) {
+ foreach (GameObject go in Resources.FindObjectsOfTypeAll()) {
+ if (go == null) { continue; }
+ if (!go.TryGetComponent(out ItemDrop id)) { continue; }
+ foreach (KeyValuePair> update in pendingWorldUpdates) {
+ if (go.name.StartsWith(update.Key)) {
+ update.Value(id.m_itemData);
+ }
+ }
+ }
+ }
+ } finally {
+ pendingWorldUpdates.Clear();
+ worldUpdateScheduled = false;
+ }
+ }
+
+ private static void AddAmmoItemsToArcheryTarget() {
+ if (ArcheryAmmoToAdd.Count == 0) { return; }
+ GameObject archerTarget = PrefabManager.Instance.GetPrefab("piece_ArcheryTarget");
+ if (archerTarget == null) { return; }
+ ArcheryTarget ArcherAmmoManger = archerTarget.GetComponentInChildren(true);
+ if (ArcherAmmoManger == null) { return; }
+
+ foreach (string ammoPrefab in ArcheryAmmoToAdd) {
+ ModLogger.LogDebug($"Adding {ammoPrefab} to Archery Target Ammo Return.");
+ ItemDrop ammoID = PrefabManager.Instance.GetPrefab(ammoPrefab)?.GetComponent();
+ if (ammoID != null && ArcherAmmoManger.m_returnAmmo.Contains(ammoID) == false) {
+ ArcherAmmoManger.m_returnAmmo.Add(ammoID);
+ }
+ }
+ }
+ }
+}
diff --git a/Common/src/Modding/ItemDefinition.cs b/Common/src/Modding/ItemDefinition.cs
new file mode 100644
index 000000000..ac954c2a6
--- /dev/null
+++ b/Common/src/Modding/ItemDefinition.cs
@@ -0,0 +1,141 @@
+using BepInEx.Configuration;
+using Jotunn.Configs;
+using System.Collections.Generic;
+
+namespace Common {
+ /// Item fields that
+ public enum ItemStat {
+ slash,
+ slash_per_level,
+ blunt,
+ blunt_per_level,
+ pierce,
+ pierce_per_level,
+ pickaxe,
+ pickaxe_per_level,
+ chop,
+ chop_per_level,
+ attack_force,
+ fire,
+ fire_per_level,
+ lightning,
+ lightning_per_level,
+ frost,
+ frost_per_level,
+ poison,
+ poison_per_level,
+ spirit,
+ spirit_per_level,
+ block_armor,
+ block_armor_per_level,
+ parry,
+ block_force,
+ block_force_per_level,
+ primary_attack_stamina,
+ primary_attack_eitr,
+ primary_attack_flat_health_cost,
+ primary_attack_percent_health_cost,
+ primary_attack_health_returned,
+ primary_attack_damage_bonus_per_missing_hp,
+ primary_attack_projectile_count,
+ primary_attack_force_multiply,
+ secondary_attack_stamina,
+ secondary_attack_eitr,
+ secondary_attack_force_multiply,
+ secondary_attack_flat_health_cost,
+ secondary_attack_percent_health_cost,
+ movement_speed,
+ bow_draw_speed,
+ crossbow_reload_speed,
+ crossbow_reload_stamina_drain,
+ draw_stamina_drain,
+ projectile_velocity,
+ projectile_accuracy_max,
+ durability,
+ durability_per_level,
+ max_item_level,
+ amount,
+ tool_level
+ }
+
+ ///
+ /// Groups items in the config file and, by default, in the asset-bundle prefab path.
+ ///
+ public enum ItemCategory {
+ Arrows,
+ Atgeirs,
+ Axes,
+ Hammers,
+ Shields,
+ Swords,
+ Bows,
+ Spears,
+ Knives,
+ Maces,
+ Fists,
+ Pickaxes,
+ Magics,
+ /// Catch-all for non-weapon craftables (jewellery, belts, trinkets).
+ Misc
+ }
+
+ ///
+ /// Authored definition of one config-driven item. Everything above the "Populated at runtime" line is
+ /// what a mod fills in; the ConfigEntry handles are wired up by
+ public class ItemDefinition {
+ // Metadata
+ public string Name { get; set; }
+ public string DisplayName { get; set; }
+ public ItemCategory Category { get; set; }
+ public string Prefab { get; set; }
+ public string Icon { get; set; }
+
+ // Authored defaults, each exposed as a config entry
+ public string CraftedAt { get; set; }
+ public bool Craftable { get; set; } = true;
+ public int ReqStationlevel { get; set; }
+ public int CraftAmount { get; set; }
+ public Dictionary ModifableStats { get; set; } = new Dictionary();
+ public Dictionary DamageMods { get; set; }
+ public RecipeDefinition Recipe { get; set; }
+
+ // -- Populated at runtime by ItemBatchLoader ------------------------------------------------
+ public ConfigEntry CraftedAtCfg { get; set; }
+ public ConfigEntry CraftableCfg { get; set; }
+ public ConfigEntry StationLVLCfg { get; set; }
+ public ConfigEntry CraftAmountCfg { get; set; }
+ }
+
+ public class HitCustomDamageMod {
+ public bool Configurable { get; set; } = true;
+ public HitData.DamageModifier DamageModifier { get; set; }
+ public ConfigEntry DmgModCfg { get; set; }
+ }
+
+ public class ItemStatConfig {
+ public bool Configurable { get; set; } = true;
+ public bool IsInt { get; set; } = false;
+ public float Default_value { get; set; }
+ public float Min { get; set; } = 0f;
+ public float Max { get; set; } = 400f;
+
+ // Only one of these is bound, selected by IsInt.
+ public ConfigEntry Cfg { get; set; }
+ public ConfigEntry CfgInt { get; set; }
+ }
+
+ public class RecipeDefinition {
+ /// Raw CSV form: Prefab,Amount,AmountPerLevel|Prefab,Amount,AmountPerLevel .
+ public ConfigEntry RecipeConfig { get; set; }
+ public List RecipeItems { get; set; }
+ public List RecipeReqs { get; set; }
+ public Recipe ResolvedRecipe { get; set; }
+ }
+
+ public class RecipeIngredient {
+ public string Prefab { get; set; }
+ public int Amount { get; set; }
+ public int UpgradeCost { get; set; } = 0;
+ }
+}
diff --git a/Common/src/Modding/ModContext.cs b/Common/src/Modding/ModContext.cs
new file mode 100644
index 000000000..2d39fb0d1
--- /dev/null
+++ b/Common/src/Modding/ModContext.cs
@@ -0,0 +1,106 @@
+using BepInEx;
+using BepInEx.Configuration;
+using BepInEx.Logging;
+using Jotunn.Entities;
+using UnityEngine;
+
+namespace Common {
+ ///
+ /// Per-mod ambient state that the shared loaders in this folder read from.
+ ///
+ /// Common is a *shared project*: its source is compiled into each consuming mod assembly, so these
+ /// statics are per-mod and never shared between plugins. Each plugin calls
+ public static class ModContext {
+ /// The owning plugin's log source. Prefer
+ public static ManualLogSource Log { get; private set; }
+
+ /// The owning plugin's config file.
+ public static ConfigFile Cfg { get; private set; }
+
+ /// The owning plugin's BepInPlugin GUID, used to namespace Jotunn registrations.
+ public static string PluginGuid { get; private set; }
+
+ /// Subfolder under BepInEx/config that this mod owns (localizations, patch files, ...).
+ public static string ConfigFolder { get; private set; }
+
+ /// The mod's asset bundle. Set here or passed explicitly to the loaders that need one.
+ public static AssetBundle AssetBundle { get; set; }
+
+ /// The mod's Jotunn localization instance.
+ public static CustomLocalization Localization { get; set; }
+
+ /// Gates the verbose logging in the shared loaders. Never null after
+ public static ConfigEntry EnableDebugMode { get; private set; }
+
+ /// Seconds
+ public static ConfigEntry ConfigApplyDelay { get; private set; }
+
+ public static bool Initialized { get; private set; }
+
+ /// True when debug logging is on. Safe to call before Initialize.
+ public static bool DebugEnabled => EnableDebugMode != null && EnableDebugMode.Value;
+
+ ///
+ /// Wires the shared Common code to this plugin. Call once from Awake, before binding any other
+ /// config or invoking
+ /// Logger .
+ ///
+ /// Points the shared debug-logging gate at a config entry the mod already owns, instead of the
+ /// baseline entry bound by
+ public static void UseDebugEntry(ConfigEntry entry) {
+ if (entry == null) { return; }
+ if (EnableDebugMode != null) { EnableDebugMode.SettingChanged -= ModLogger.OnDebugModeChanged; }
+ EnableDebugMode = entry;
+ EnableDebugMode.SettingChanged += ModLogger.OnDebugModeChanged;
+ ModLogger.RefreshLevel();
+ }
+
+ ///
+ /// Toggles write-through saving and flushes. The loaders turn this off while binding a batch of
+ /// entries and back on afterwards so startup doesn't write the config file once per entry.
+ ///
+ public static void SaveOnSet(bool enabled) {
+ if (Cfg == null) { return; }
+ Cfg.SaveOnConfigSet = enabled;
+ Cfg.Save();
+ }
+ }
+}
diff --git a/Common/src/Modding/ModLocalization.cs b/Common/src/Modding/ModLocalization.cs
new file mode 100644
index 000000000..8a360250f
--- /dev/null
+++ b/Common/src/Modding/ModLocalization.cs
@@ -0,0 +1,96 @@
+using Jotunn.Entities;
+using Jotunn.Managers;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace Common {
+ ///
+ /// Loads every localization JSON embedded in the mod assembly, mirrors it to
+ /// BepInEx/config/<ConfigFolder>/Localizations/<Language>.json so players can edit it, and
+ /// registers the merged result with Jotunn.
+ ///
+ /// The on-disk copy wins for keys it already has; keys the mod newly ships are added, and keys the mod
+ /// no longer ships are pruned. Files should be plain JSON objects named for a language from
+ /// https://valheim-modding.github.io/Jotunn/data/localization/language-list.html
+ ///
+ public static class ModLocalization {
+ /// Resource-name fragment identifying localization files, and the config subfolder name.
+ public static string LocalizationFolder = "Localizations";
+
+ public static void AddLocalizations(Assembly assembly = null) {
+ if (assembly == null) { assembly = Assembly.GetExecutingAssembly(); }
+
+ CustomLocalization localization = ModContext.Localization ?? LocalizationManager.Instance.GetLocalization();
+ ModContext.Localization = localization;
+
+ string translationFolder = Path.Combine(BepInEx.Paths.ConfigPath, ModContext.ConfigFolder ?? assembly.GetName().Name, LocalizationFolder);
+ Directory.CreateDirectory(translationFolder);
+
+ foreach (string embeddedResource in assembly.GetManifestResourceNames()) {
+ if (embeddedResource.IndexOf(LocalizationFolder, StringComparison.OrdinalIgnoreCase) < 0) { continue; }
+ if (!embeddedResource.EndsWith(".json", StringComparison.OrdinalIgnoreCase)) { continue; }
+
+ string language = LanguageFromResourceName(embeddedResource);
+ if (string.IsNullOrEmpty(language)) {
+ ModLogger.LogWarning($"Could not derive a language name from '{embeddedResource}', skipping.");
+ continue;
+ }
+
+ // Comments are used in the shipped files but are not valid JSON, so strip them first.
+ string shipped = Regex.Replace(ReadEmbeddedResourceFile(embeddedResource, assembly), @"\/\/.*", "");
+ string onDiskPath = Path.Combine(translationFolder, $"{language}.json");
+
+ string merged = shipped;
+ if (File.Exists(onDiskPath)) {
+ try {
+ Dictionary shippedKeys = SimpleJson.SimpleJson.DeserializeObject>(shipped);
+ Dictionary onDiskKeys = SimpleJson.SimpleJson.DeserializeObject>(File.ReadAllText(onDiskPath));
+ ReconcileKeys(shippedKeys, onDiskKeys);
+ merged = SimpleJson.SimpleJson.SerializeObject(onDiskKeys);
+ } catch (Exception e) {
+ // A hand-edited file that no longer parses gets replaced with the shipped copy rather
+ // than silently leaving the player with a broken (or missing) translation.
+ ModLogger.LogWarning($"Could not merge '{onDiskPath}' ({e.Message}); replacing it with the shipped localization.");
+ merged = shipped;
+ }
+ }
+
+ File.WriteAllText(onDiskPath, merged);
+ localization.AddJsonFile(language, merged);
+ ModLogger.LogDebug($"Added localization '{language}' from {embeddedResource}");
+ }
+ }
+
+ // Resource names look like "...json" but the folder nesting varies by
+ // mod, so take the segment before the .json extension rather than a fixed index.
+ private static string LanguageFromResourceName(string embeddedResource) {
+ string withoutExtension = embeddedResource.Substring(0, embeddedResource.Length - ".json".Length);
+ return withoutExtension.Split('.').LastOrDefault();
+ }
+
+ // Adds keys the mod newly ships and drops keys it no longer ships, leaving player edits intact.
+ private static void ReconcileKeys(Dictionary shipped, Dictionary onDisk) {
+ List staleKeys = onDisk.Keys.Where(key => !shipped.ContainsKey(key)).ToList();
+ foreach (KeyValuePair entry in shipped) {
+ if (onDisk.ContainsKey(entry.Key)) { continue; }
+ ModLogger.LogDebug($"Adding missing localization key {entry.Key}");
+ onDisk.Add(entry.Key, entry.Value);
+ }
+ if (staleKeys.Count > 0) {
+ ModLogger.LogDebug($"Removing extra keys {string.Join(",", staleKeys.ToArray())}.");
+ foreach (string key in staleKeys) { onDisk.Remove(key); }
+ }
+ }
+
+ private static string ReadEmbeddedResourceFile(string filename, Assembly assembly) {
+ using (Stream stream = assembly.GetManifestResourceStream(filename))
+ using (StreamReader reader = new StreamReader(stream)) {
+ return reader.ReadToEnd();
+ }
+ }
+ }
+}
diff --git a/Common/src/Modding/ModLogger.cs b/Common/src/Modding/ModLogger.cs
new file mode 100644
index 000000000..306a1c18d
--- /dev/null
+++ b/Common/src/Modding/ModLogger.cs
@@ -0,0 +1,54 @@
+using BepInEx.Logging;
+using System;
+
+namespace Common {
+ ///
+ /// Level-gated logging for the shared Common code, forwarding to the owning plugin's log source.
+ ///
+ /// Named ModLogger rather than Logger on purpose: Common.Logger would be ambiguous with
+ /// using Common; .
+ ///
+ public static class ModLogger {
+ public static LogLevel Level = LogLevel.Info;
+
+ internal static void OnDebugModeChanged(object sender, EventArgs e) {
+ RefreshLevel();
+ }
+
+ /// Re-reads
+ public static void RefreshLevel() {
+ Level = ModContext.DebugEnabled ? LogLevel.Debug : LogLevel.Info;
+ }
+
+ public static void SetDebugLogging(bool state) {
+ Level = state ? LogLevel.Debug : LogLevel.Info;
+ }
+
+ public static void LogDebug(string message) {
+ if (Level >= LogLevel.Debug) { Write(LogLevel.Info, "[DEBUG]" + message); }
+ }
+
+ public static void LogInfo(string message) {
+ if (Level >= LogLevel.Info) { Write(LogLevel.Info, message); }
+ }
+
+ public static void LogWarning(string message) {
+ if (Level >= LogLevel.Warning) { Write(LogLevel.Warning, message); }
+ }
+
+ public static void LogError(string message) {
+ if (Level >= LogLevel.Error) { Write(LogLevel.Error, message); }
+ }
+
+ // ModContext.Log is null until Initialize runs (and after the plugin is torn down). Falling back to
+ // the Unity log keeps early/late diagnostics visible instead of throwing an NRE inside a config handler.
+ private static void Write(LogLevel level, string message) {
+ ManualLogSource log = ModContext.Log;
+ if (log == null) {
+ UnityEngine.Debug.Log($"[Common][{level}] {message}");
+ return;
+ }
+ log.Log(level, message);
+ }
+ }
+}
diff --git a/Common/src/Modding/PieceLoader.cs b/Common/src/Modding/PieceLoader.cs
new file mode 100644
index 000000000..8f62b06d1
--- /dev/null
+++ b/Common/src/Modding/PieceLoader.cs
@@ -0,0 +1,338 @@
+using BepInEx.Configuration;
+using Jotunn.Configs;
+using Jotunn.Entities;
+using Jotunn.Managers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Common {
+ ///
+ /// Registers a build piece with Jotunn and exposes its workbench requirement, build category and
+ /// build cost as server-synced config entries that apply live, without a restart.
+ ///
+ /// Call
+ public static class PieceLoader {
+ public class LoadedGameObjects {
+ public GameObject Prefab { get; set; }
+ public Sprite Sprite { get; set; }
+ public GameObject ScenePrefab { get; set; }
+ /// The resolved prefab's Piece component. Everything applied at runtime goes through this.
+ public Piece ScenePiece { get; set; }
+ }
+
+ public class PieceCost {
+ public string Prefab { get; set; }
+ public int Amount { get; set; }
+ public bool Refundable { get; set; } = true;
+ }
+
+ public class PieceConfigs {
+ public ConfigEntry Enabled { get; set; }
+ public ConfigEntry RequiresWorkbench { get; set; }
+ public ConfigEntry Workbench { get; set; }
+ public ConfigEntry PieceCategory { get; set; }
+ public ConfigEntry PieceCost { get; set; }
+ public List UpdatedCost { get; set; } = new List();
+ }
+
+ /// Authored definition of one build piece.
+ public class BuildPiece {
+ /// Config section name for this piece.
+ public string Name { get; set; }
+ public bool Enabled { get; set; } = true;
+ /// Prefab name in the asset bundle (with or without a .prefab suffix).
+ public string Prefab { get; set; }
+ /// Optional icon name in the asset bundle. Null uses the prefab's own icon.
+ public string Sprite { get; set; }
+ public string Category { get; set; } = PieceCategories.Misc;
+ public string PieceTable { get; set; } = PieceTables.Hammer;
+ /// Crafting station prefab required to build. Ignored when RequiresWorkbench is false.
+ public string Workbench { get; set; } = "piece_workbench";
+ public bool RequiresWorkbench { get; set; } = true;
+ public bool AllowedInDungeons { get; set; } = false;
+ public List PieceCost { get; set; } = new List();
+
+ // Populated by in-game related runtime objects
+ public LoadedGameObjects Objs { get; set; }
+ public PieceConfigs Cfgs { get; set; }
+ }
+
+ private static readonly List BuildPieces = new List();
+ private static bool PiecesReady = false;
+
+ public static void Register(BuildPiece jbuildpiece, AssetBundle assetBundle = null) {
+ AssetBundle bundle = assetBundle ?? ModContext.AssetBundle;
+ if (bundle == null) {
+ ModLogger.LogError($"No asset bundle available; piece '{jbuildpiece.Name}' will not be registered.");
+ return;
+ }
+
+ LoadedGameObjects LGos = new LoadedGameObjects();
+ LGos.Prefab = LoadBundleAsset(bundle, jbuildpiece.Prefab, ".prefab");
+ if (LGos.Prefab == null) {
+ ModLogger.LogError($"Could not find prefab '{jbuildpiece.Prefab}' in the asset bundle; piece '{jbuildpiece.Name}' will not be registered.");
+ return;
+ }
+ if (!string.IsNullOrEmpty(jbuildpiece.Sprite)) {
+ LGos.Sprite = LoadBundleAsset(bundle, jbuildpiece.Sprite, ".png");
+ }
+ jbuildpiece.Objs = LGos;
+ jbuildpiece.Cfgs = new PieceConfigs();
+
+ InitialPieceSetup(jbuildpiece);
+
+ BuildPieces.Add(jbuildpiece);
+
+ void ResolveAndApplyScenePrefab() {
+ GameObject scenePrefab = ResolveScenePrefab(jbuildpiece.Prefab);
+ if (scenePrefab == null) {
+ ModLogger.LogWarning($"Could not find a scene prefab named '{jbuildpiece.Prefab}' with a Piece component after prefab registration; skipping in-place setup for {jbuildpiece.Name}.");
+ return;
+ }
+ jbuildpiece.Objs.ScenePrefab = scenePrefab;
+ jbuildpiece.Objs.ScenePiece = scenePrefab.GetComponent();
+ PiecesReady = true;
+ // Bring the current config (default or server-synced) into effect a single time now that
+ // every mod prefab is resolvable. This also covers values that arrived early via config sync.
+ ApplyWorkbench(jbuildpiece);
+ ApplyCategory(jbuildpiece);
+ ApplyRecipe(jbuildpiece);
+ }
+ PrefabManager.OnPrefabsRegistered += ResolveAndApplyScenePrefab;
+ }
+
+ // Finds the registered prefab to apply config to. Jotunn's PrefabManager is authoritative, so ask it
+ // first; the Resources scan is only a fallback for prefabs injected into ZNetScene by other means.
+ //
+ // The scan must filter on the Piece component: several loaded GameObjects can share a prefab's name
+ // (the bundle asset, Jotunn's registered clone, child objects), Resources.FindObjectsOfTypeAll returns
+ // them in no defined order, and picking one without a Piece made every Apply* below throw an NRE.
+ private static GameObject ResolveScenePrefab(string prefabName) {
+ GameObject registered = PrefabManager.Instance.GetPrefab(prefabName);
+ if (registered != null && registered.GetComponent() != null) {
+ return registered;
+ }
+
+ List candidates = Resources.FindObjectsOfTypeAll()
+ .Where(obj => obj.name == prefabName && obj.GetComponent() != null)
+ .ToList();
+ if (ModContext.DebugEnabled) {
+ ModLogger.LogInfo($"Found {candidates.Count} scene object(s) named '{prefabName}' with a Piece component.");
+ }
+ return candidates.FirstOrDefault();
+ }
+
+ // Bundles differ by mod: the template authors assets under Assets/Custom/... with a file extension,
+ // while EpicLoot/Jam/AdvancedPortals bundles use bare names. Try the bare name first, then suffixed.
+ private static T LoadBundleAsset(AssetBundle bundle, string name, string suffix) where T : UnityEngine.Object {
+ T asset = bundle.LoadAsset(name);
+ if (asset != null) { return asset; }
+ return name.EndsWith(suffix, StringComparison.OrdinalIgnoreCase) ? null : bundle.LoadAsset(name + suffix);
+ }
+
+ private static void InitialPieceSetup(BuildPiece jbuildpiece) {
+ // Set where the recipe can be crafted. Gated on PiecesReady so an early config sync / file
+ // reload (both fire before ZNetScene.Awake) can't run before the scene prefab is resolved.
+ void RequiredBench_SettingChanged(object sender, EventArgs e) {
+ if (!PiecesReady || jbuildpiece.Objs.ScenePiece == null) { return; }
+ ConfigChangeDebouncer.Schedule(jbuildpiece.Cfgs.Workbench, () => ApplyWorkbench(jbuildpiece));
+ }
+ jbuildpiece.Cfgs.RequiresWorkbench = ConfigBinder.BindServerConfig(jbuildpiece.Name, "Requires Workbench", jbuildpiece.RequiresWorkbench, $"Whether {jbuildpiece.Name} requires a crafting station to be built at all.");
+ jbuildpiece.Cfgs.RequiresWorkbench.SettingChanged += RequiredBench_SettingChanged;
+ jbuildpiece.Cfgs.Workbench = ConfigBinder.BindServerConfig(jbuildpiece.Name, "Workbench", jbuildpiece.Workbench, "The table required to allow building this piece, eg: 'forge', 'piece_workbench', 'blackforge', 'piece_artisanstation'.");
+ jbuildpiece.Cfgs.Workbench.SettingChanged += RequiredBench_SettingChanged;
+
+ // Crafting cost change
+ void BuildRecipeChanged_SettingChanged(object sender, EventArgs e) {
+ if (!PiecesReady || jbuildpiece.Objs.ScenePiece == null) { return; }
+ ConfigChangeDebouncer.Schedule(sender, () => {
+ if (sender is ConfigEntry sendEntry) {
+ if (ModContext.DebugEnabled) { ModLogger.LogInfo($"Recieved new piece config {sendEntry.Value}"); }
+ // return if its an invalid change
+ if (PieceRecipeConfigUpdater(jbuildpiece, sendEntry.Value) == false) { return; }
+ }
+ ApplyRecipe(jbuildpiece);
+ });
+ }
+
+ // Setup enable/disable
+ jbuildpiece.Cfgs.Enabled = ConfigBinder.BindServerConfig(jbuildpiece.Name, "Enabled", jbuildpiece.Enabled, $"Enable/Disable the {jbuildpiece.Name}.");
+ jbuildpiece.Cfgs.Enabled.SettingChanged += BuildRecipeChanged_SettingChanged;
+ // Setup piece category
+ jbuildpiece.Cfgs.PieceCategory = ConfigBinder.BindServerConfig(jbuildpiece.Name, "Piece Category", jbuildpiece.Category, "Piece category for building.", PieceCategories.GetAcceptableValueList());
+ void CraftingCategory_SettingChanged(object sender, EventArgs e) {
+ if (!PiecesReady || jbuildpiece.Objs.ScenePiece == null) { return; }
+ ConfigChangeDebouncer.Schedule(jbuildpiece.Cfgs.PieceCategory, () => ApplyCategory(jbuildpiece));
+ }
+ jbuildpiece.Cfgs.PieceCategory.SettingChanged += CraftingCategory_SettingChanged;
+
+ // Build out the internal default recipe
+ List raw_recipe_default = new List();
+ foreach (PieceCost entry in jbuildpiece.PieceCost) { raw_recipe_default.Add($"{entry.Prefab},{entry.Amount},{entry.Refundable}"); }
+ string recipe_cfg_default = string.Join("|", raw_recipe_default.ToArray());
+ // Wire up the config and on-change for piece costs
+ jbuildpiece.Cfgs.PieceCost = ConfigBinder.BindServerConfig(jbuildpiece.Name, "Building Cost", recipe_cfg_default, "Cost to build. Find item ids: https://valheim.fandom.com/wiki/Item_IDs Format: resouce_id,amount,refund eg: Wood,8,true|LeatherScraps,4,false", advanced: true);
+ if (PieceRecipeConfigUpdater(jbuildpiece, jbuildpiece.Cfgs.PieceCost.Value, false) == false) {
+ ModLogger.LogWarning($"{jbuildpiece.Name} has an invalid piece cost. The default will be used instead.");
+ PieceRecipeConfigUpdater(jbuildpiece, recipe_cfg_default, false);
+ }
+
+ jbuildpiece.Cfgs.PieceCost.SettingChanged += BuildRecipeChanged_SettingChanged;
+
+ // Collapse this piece's entries into a single grouped custom drawer to keep the in-game
+ // Configuration Manager responsive (one visible row per piece under "Building Pieces").
+ PieceConfigDrawer.Attach(jbuildpiece);
+
+ List recipe = new List();
+ foreach (PieceCost entry in jbuildpiece.Cfgs.UpdatedCost) {
+ recipe.Add(new RequirementConfig { Item = entry.Prefab, Amount = entry.Amount, Recover = entry.Refundable });
+ }
+
+ // Build the jotunn piece definition
+ PieceConfig piececfg = new PieceConfig() {
+ CraftingStation = ResolveWorkbenchName(jbuildpiece),
+ PieceTable = jbuildpiece.PieceTable,
+ Category = jbuildpiece.Cfgs.PieceCategory.Value,
+ AllowedInDungeons = jbuildpiece.AllowedInDungeons,
+ Icon = jbuildpiece.Objs.Sprite,
+ Requirements = recipe.ToArray()
+ };
+ // Add the updated piece to the piece manager
+ PieceManager.Instance.AddPiece(new CustomPiece(jbuildpiece.Objs.Prefab, fixReference: true, piececfg));
+ }
+
+ // Empty string / "none" / RequiresWorkbench=false all mean "buildable anywhere"; Jotunn wants null.
+ private static string ResolveWorkbenchName(BuildPiece jbuildpiece) {
+ bool requiresWorkbench = jbuildpiece.Cfgs.RequiresWorkbench?.Value ?? true;
+ string workbench = jbuildpiece.Cfgs.Workbench.Value;
+ if (!requiresWorkbench || string.IsNullOrEmpty(workbench) || workbench.ToLower() == "none") { return null; }
+ return workbench;
+ }
+
+ // Applies the configured crafting station to the in-scene piece. Callers must ensure the scene
+ // prefab is resolved (PiecesReady) before invoking this.
+ private static void ApplyWorkbench(BuildPiece jbuildpiece) {
+ Piece piece = jbuildpiece.Objs.ScenePiece;
+ if (piece == null) { return; }
+
+ string workbench = ResolveWorkbenchName(jbuildpiece);
+ if (workbench == null) {
+ if (ModContext.DebugEnabled) { ModLogger.LogInfo($"Setting required crafting station for {jbuildpiece.Name} to none."); }
+ piece.m_craftingStation = null;
+ return;
+ }
+
+ CraftingStation craftable_at = PrefabManager.Instance.GetPrefab(workbench)?.GetComponent();
+ if (craftable_at == null) {
+ ModLogger.LogWarning($"Required crafting station does not exist or does not have a crafting station component, check your prefab name ({workbench}).");
+ return;
+ }
+
+ if (ModContext.DebugEnabled) { ModLogger.LogInfo($"Setting crafting station to {workbench}."); }
+ piece.m_craftingStation = craftable_at;
+ }
+
+ // Applies the configured build category to the in-scene piece.
+ private static void ApplyCategory(BuildPiece jbuildpiece) {
+ Piece piece = jbuildpiece.Objs.ScenePiece;
+ if (piece == null) { return; }
+
+ Piece.PieceCategory? category = PieceManager.Instance.GetPieceCategory(jbuildpiece.Cfgs.PieceCategory.Value);
+ if (category == null) {
+ category = PieceManager.Instance.AddPieceCategory(jbuildpiece.Cfgs.PieceCategory.Value);
+ }
+ piece.m_category = (Piece.PieceCategory)category;
+ }
+
+ // Resolves the recipe in UpdatedCost against the live prefab database and applies it to the
+ // in-scene piece. Bails out (leaving the existing recipe intact) if any requirement prefab is not
+ // yet resolvable, so it is safe even if a dependency mod registered its items late.
+ private static void ApplyRecipe(BuildPiece jbuildpiece) {
+ Piece piece = jbuildpiece.Objs.ScenePiece;
+ if (piece == null) { return; }
+
+ if (jbuildpiece.Cfgs.Enabled.Value == false) {
+ // Set this piece not craftable
+ piece.m_enabled = false;
+ return;
+ }
+
+ List recipe = new List();
+ if (ModContext.DebugEnabled) { ModLogger.LogInfo("Validating and building requirementsConfig"); }
+ foreach (PieceCost entry in jbuildpiece.Cfgs.UpdatedCost) {
+ if (PrefabManager.Instance.GetPrefab(entry.Prefab) == null) {
+ if (ModContext.DebugEnabled) { ModLogger.LogInfo($"{entry.Prefab} is not a valid prefab, skipping recipe update."); }
+ return;
+ }
+ if (ModContext.DebugEnabled) { ModLogger.LogInfo($"Checking entry {entry.Prefab} amount:{entry.Amount} refund?:{entry.Refundable}"); }
+ recipe.Add(new RequirementConfig { Item = entry.Prefab, Amount = entry.Amount, Recover = entry.Refundable });
+ }
+
+ if (ModContext.DebugEnabled) { ModLogger.LogInfo("Updating Piece."); }
+ List newRequirements = new List();
+ foreach (RequirementConfig recipe_entry in recipe) {
+ Piece.Requirement piece_req = new Piece.Requirement();
+ piece_req.m_resItem = PrefabManager.Instance.GetPrefab(recipe_entry.Item.Replace("JVLmock_", ""))?.GetComponent();
+ piece_req.m_amount = recipe_entry.Amount;
+ piece_req.m_recover = recipe_entry.Recover;
+ newRequirements.Add(piece_req);
+ }
+ if (ModContext.DebugEnabled) { ModLogger.LogInfo($"Fixed mock requirements {newRequirements.Count}."); }
+ piece.m_resources = newRequirements.ToArray();
+ // Re-enable as well as disable, so toggling Enabled back on takes effect without a restart.
+ piece.m_enabled = true;
+ }
+
+ private static bool PieceRecipeConfigUpdater(BuildPiece jBuildPiece, string rawRecipe, bool during_runtime = true) {
+ string[] RawRecipeEntries = rawRecipe.Split('|');
+ List updated_pieceRecipe = new List();
+ foreach (string recipe_entry in RawRecipeEntries) {
+ string[] recipe_segments = recipe_entry.Split(',');
+ if (recipe_segments.Length != 3) {
+ ModLogger.LogWarning($"{recipe_entry} is invalid, it does not have enough segments. Proper format is: PREFABNAME,COST,REFUND_BOOL eg: Wood,8,false");
+ return false;
+ }
+ // Add a sanity check to ensure the prefab we are trying to use exists
+ // This can only happen during runtime after pieces are available otherwise it will cause errors
+ if (during_runtime) {
+ if (PrefabManager.Instance.GetPrefab(recipe_segments[0]) == null) {
+ ModLogger.LogWarning($"{recipe_segments[0]} is an invalid prefab and does not exist.");
+ return false;
+ }
+ }
+ if (recipe_segments[0].Length == 0 || recipe_segments[1].Length == 0 || recipe_segments[2].Length == 0) {
+ ModLogger.LogWarning($"{recipe_entry} is invalid, one segment does not have enough data. Proper format is: PREFABNAME,CRAFT_COST,REFUND_BOOL eg: Wood,8,false");
+ return false;
+ }
+ if (bool.TryParse(recipe_segments[2], out bool refund_flag_parse) == false) {
+ ModLogger.LogWarning($"{recipe_entry} is invalid, the REFUND_BOOL could not be parsed to (true/false). Proper format is: PREFABNAME,CRAFT_COST,REFUND_BOOL eg: Wood,8,false");
+ return false;
+ }
+ if (int.TryParse(recipe_segments[1], out int amount_parse) == false) {
+ ModLogger.LogWarning($"{recipe_entry} is invalid, the CRAFT_COST could not be parsed to a whole number. Proper format is: PREFABNAME,CRAFT_COST,REFUND_BOOL eg: Wood,8,false");
+ return false;
+ }
+
+ if (ModContext.DebugEnabled) {
+ ModLogger.LogInfo($"prefab: {recipe_segments[0]} c:{recipe_segments[1]} u:{recipe_segments[2]}");
+ }
+ updated_pieceRecipe.Add(new PieceCost() { Prefab = recipe_segments[0], Amount = amount_parse, Refundable = refund_flag_parse });
+ }
+
+ jBuildPiece.Cfgs.UpdatedCost.Clear();
+ foreach (PieceCost entry in updated_pieceRecipe) { jBuildPiece.Cfgs.UpdatedCost.Add(entry); }
+ if (ModContext.DebugEnabled) {
+ string recipe_string = "";
+ foreach (PieceCost entry in updated_pieceRecipe) {
+ recipe_string += $" {entry.Prefab} c:{entry.Amount} r:{entry.Refundable}";
+ }
+ ModLogger.LogInfo($"Updated recipe:{recipe_string}");
+ }
+ return true;
+ }
+ }
+}
diff --git a/EpicLoot-UnityLib/EpicLoot-UnityLib.csproj b/EpicLoot-UnityLib/EpicLoot-UnityLib.csproj
deleted file mode 100644
index 6c1d698b4..000000000
--- a/EpicLoot-UnityLib/EpicLoot-UnityLib.csproj
+++ /dev/null
@@ -1,63 +0,0 @@
-
-
-
- Debug
- AnyCPU
- {8DABA031-AEA4-472F-A9AA-DE8B1AA69DE5}
- Library
- Properties
- EpicLoot_UnityLib
- EpicLoot-UnityLib
- v4.8
- 10.0
- 512
- true
-
-
-
-
- true
- full
- false
- bin\Debug\
- DEBUG;TRACE
- prompt
- 4
- true
- latest
-
-
- pdbonly
- true
- bin\Release\
- TRACE
- prompt
- 4
- latest
-
-
-
-
-
-
-
-
-
- This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.
-
-
-
-
-
\ No newline at end of file
diff --git a/EpicLoot-UnityLib/Properties/AssemblyInfo.cs b/EpicLoot-UnityLib/Properties/AssemblyInfo.cs
deleted file mode 100644
index e97ec1d7b..000000000
--- a/EpicLoot-UnityLib/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("EpicLoot-UnityLib")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("Randy Knapp Mods")]
-[assembly: AssemblyProduct("EpicLoot-UnityLib")]
-[assembly: AssemblyCopyright("Copyright © 2021")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components. If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("fb508e8d-0c64-4ec6-b746-f668f510296f")]
-
-// Version information for an assembly consists of the following four values:
-//
-// Major Version
-// Minor Version
-// Build Number
-// Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0")]
-[assembly: AssemblyFileVersion("1.0.0")]
diff --git a/EpicLoot-UnityLib/packages.config b/EpicLoot-UnityLib/packages.config
deleted file mode 100644
index 1063f24dc..000000000
--- a/EpicLoot-UnityLib/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-
-
-
\ No newline at end of file
diff --git a/EpicLoot/.editorconfig b/EpicLoot/.editorconfig
deleted file mode 100644
index ccedc8e85..000000000
--- a/EpicLoot/.editorconfig
+++ /dev/null
@@ -1,40 +0,0 @@
-[*]
-
-# https://marketplace.visualstudio.com/items?itemName=PaulHarrington.EditorGuidelinesPreview
-guidelines = 120
-
-[*.cs]
-
-# IDE0003: Remove qualification
-dotnet_diagnostic.IDE0003.severity = none
-
-# IDE0051: Remove unused private members
-dotnet_diagnostic.IDE0051.severity = none
-
-# IDE0060: Remove unused parameter
-dotnet_diagnostic.IDE0060.severity = none
-
-# IDE0066: Convert switch statement to expression
-dotnet_diagnostic.IDE0066.severity = none
-
-# IDE0090: 'new' expression can be simplified
-dotnet_diagnostic.IDE0090.severity = none
-
-# IDE0130: Namespace does not match folder structure
-dotnet_diagnostic.IDE0130.severity = none
-
-[*.cs]
-
-# Indentation and spacing
-indent_size = 4
-indent_style = space
-tab_width = 4
-
-# New line preferences
-csharp_new_line_before_catch = false
-csharp_new_line_before_else = true
-csharp_new_line_before_finally = false
-csharp_new_line_before_members_in_anonymous_types = true
-csharp_new_line_before_members_in_object_initializers = true
-csharp_new_line_before_open_brace = all
-csharp_new_line_between_query_expression_clauses = true
diff --git a/EpicLoot/API/API.cs b/EpicLoot/API/API.cs
index 1da5b536e..9b0fcedba 100644
--- a/EpicLoot/API/API.cs
+++ b/EpicLoot/API/API.cs
@@ -4,7 +4,7 @@
using EpicLoot.Crafting;
using EpicLoot.CraftingV2;
using EpicLoot.LegendarySystem;
-using EpicLoot.MagicItemEffects;
+using EpicLoot.src.Magic.MagicItemEffects.Helpers;
using JetBrains.Annotations;
using Newtonsoft.Json;
using System;
@@ -37,6 +37,7 @@ public static partial class API
///
static API()
{
+ LootRoller.OnSetupLootTables += ReloadExternalLootTables;
MagicItemEffectDefinitions.OnSetupMagicItemEffectDefinitions += ReloadExternalMagicEffects;
UniqueLegendaryHelper.OnSetupLegendaryItemConfig += ReloadExternalLegendary;
AbilityDefinitions.OnSetupAbilityDefinitions += ReloadExternalAbilities;
diff --git a/EpicLoot/API/Events.cs b/EpicLoot/API/Events.cs
new file mode 100644
index 000000000..08c4cd8cf
--- /dev/null
+++ b/EpicLoot/API/Events.cs
@@ -0,0 +1,247 @@
+using JetBrains.Annotations;
+using System;
+
+namespace EpicLoot;
+
+///
+/// Lifecycle notifications. Exposed as explicit Add/Remove listener calls rather than public
+/// event fields so a reflection-only consumer can subscribe with a plain method call.
+///
+/// Listeners run inside a try/catch; one that throws is logged with the exception and does not stop the
+/// remaining listeners or the game action that raised it.
+///
+public static partial class API
+{
+ ///
+ /// Reason tokens passed to a magic-item-changed listener. String constants rather than an enum, so
+ /// they cross the API boundary without a shared type.
+ ///
+ public static class ChangeReason
+ {
+ public const string Enchant = "Enchant";
+ public const string Augment = "Augment";
+ public const string Disenchant = "Disenchant";
+ public const string Rune = "Rune";
+ public const string Temper = "Temper";
+ public const string Socket = "Socket";
+ public const string Unsocket = "Unsocket";
+ public const string LootRoll = "LootRoll";
+ public const string Transfer = "Transfer";
+
+ ///
+ /// A write that has no dedicated call site. Every magic-data write funnels through
+ /// MagicItemComponent.SetMagicItem , so this is the catch-all that guarantees coverage.
+ ///
+ public const string Unspecified = "Unspecified";
+ }
+
+ private static event Action MagicItemChanged;
+ private static event Action LootGenerated;
+ private static event Action BountyCompleted;
+
+ // Set while a semantic raise is in flight. SetMagicItem sits underneath every crafting operation, so
+ // without this a single enchant would report both "Enchant" and "Unspecified".
+ private static string _activeChangeReason;
+
+ // Item load is not a change: MagicItemComponent.Load/FirstLoad call SetMagicItem to normalize data
+ // on every item that enters the world, which would otherwise flood listeners at world load.
+ internal static bool SuppressChangeEvents;
+
+ private static void LogListenerFailure(string family, Exception ex)
+ {
+ // Force-logged: a listener that throws belongs to another plugin, and swallowing it silently
+ // makes the resulting missed-notification report impossible to diagnose.
+ EpicLoot.LogErrorForce($"[EpicLoot.API] {family} listener threw: {ex}");
+ }
+
+ ///
+ /// Fires whenever an item's magic data is written -- enchant, augment, disenchant, rune extract,
+ /// temper, socket, unsocket, loot roll, or any other write.
+ ///
+ /// true if subscribed
+ [PublicAPI]
+ public static bool AddMagicItemChangedListener(Action listener)
+ {
+ if (listener == null)
+ {
+ return false;
+ }
+
+ MagicItemChanged += listener;
+ return true;
+ }
+
+ /// true if the listener was non-null; unsubscribing something never subscribed is a no-op
+ [PublicAPI]
+ public static bool RemoveMagicItemChangedListener(Action listener)
+ {
+ if (listener == null)
+ {
+ return false;
+ }
+
+ MagicItemChanged -= listener;
+ return true;
+ }
+
+ ///
+ /// Fires for each magic item Epic Loot rolls as loot, after its magic data is applied and before it
+ /// is handed to the world.
+ ///
+ [PublicAPI]
+ public static bool AddLootGeneratedListener(Action listener)
+ {
+ if (listener == null)
+ {
+ return false;
+ }
+
+ LootGenerated += listener;
+ return true;
+ }
+
+ /// true if the listener was non-null
+ [PublicAPI]
+ public static bool RemoveLootGeneratedListener(Action listener)
+ {
+ if (listener == null)
+ {
+ return false;
+ }
+
+ LootGenerated -= listener;
+ return true;
+ }
+
+ ///
+ /// Fires on the claiming player's client when an adventure-mode bounty reward is collected.
+ ///
+ /// listener)
+ {
+ if (listener == null)
+ {
+ return false;
+ }
+
+ BountyCompleted += listener;
+ return true;
+ }
+
+ /// true if the listener was non-null
+ [PublicAPI]
+ public static bool RemoveBountyCompletedListener(Action listener)
+ {
+ if (listener == null)
+ {
+ return false;
+ }
+
+ BountyCompleted -= listener;
+ return true;
+ }
+
+ ///
+ /// Labels the write performed by SetMagicItem raises
+ /// carries a real reason token instead of
+ ///
+ /// Nested calls keep the outermost reason: socketing re-hosts effects through several writes, and
+ /// the caller's intent is the interesting one.
+ ///
+ internal static void WithChangeReason(string reason, Action write)
+ {
+ if (_activeChangeReason != null)
+ {
+ write();
+ return;
+ }
+
+ _activeChangeReason = reason;
+ try
+ {
+ write();
+ }
+ finally
+ {
+ _activeChangeReason = null;
+ }
+ }
+
+ ///
+ /// Called from MagicItemComponent.SetMagicItem , the single funnel every magic-data write
+ /// passes through. Picks up the reason from an enclosing
+ internal static void RaiseMagicItemChanged(ItemDrop.ItemData item)
+ {
+ RaiseMagicItemChanged(item, _activeChangeReason ?? ChangeReason.Unspecified);
+ }
+
+ ///
+ /// Direct raise for operations that do not write through SetMagicItem -- disenchanting and a
+ /// fully-extracted rune both drop the component outright rather than writing to it.
+ ///
+ internal static void RaiseMagicItemChanged(ItemDrop.ItemData item, string reason)
+ {
+ if (SuppressChangeEvents || item == null || MagicItemChanged == null)
+ {
+ return;
+ }
+
+ foreach (Delegate handler in MagicItemChanged.GetInvocationList())
+ {
+ try
+ {
+ ((Action)handler)(item, reason);
+ }
+ catch (Exception ex)
+ {
+ LogListenerFailure("MagicItemChanged", ex);
+ }
+ }
+ }
+
+ internal static void RaiseLootGenerated(ItemDrop.ItemData item)
+ {
+ if (item == null || LootGenerated == null)
+ {
+ return;
+ }
+
+ foreach (Delegate handler in LootGenerated.GetInvocationList())
+ {
+ try
+ {
+ ((Action)handler)(item);
+ }
+ catch (Exception ex)
+ {
+ LogListenerFailure("LootGenerated", ex);
+ }
+ }
+ }
+
+ internal static void RaiseBountyCompleted(Player player, string targetId)
+ {
+ if (BountyCompleted == null)
+ {
+ return;
+ }
+
+ foreach (Delegate handler in BountyCompleted.GetInvocationList())
+ {
+ try
+ {
+ ((Action)handler)(player, targetId);
+ }
+ catch (Exception ex)
+ {
+ LogListenerFailure("BountyCompleted", ex);
+ }
+ }
+ }
+}
diff --git a/EpicLoot/API/Helpers.cs b/EpicLoot/API/Helpers.cs
index dc828948d..b307e8018 100644
--- a/EpicLoot/API/Helpers.cs
+++ b/EpicLoot/API/Helpers.cs
@@ -2,6 +2,7 @@
using EpicLoot.Crafting;
using JetBrains.Annotations;
using Newtonsoft.Json;
+using System;
using System.Collections.Generic;
using System.Reflection;
@@ -9,7 +10,15 @@ namespace EpicLoot;
public static partial class API
{
+ ///
+ /// Message shared by the deprecated recipe endpoints below.
+ ///
+ private const string RecipeApiObsolete = "Epic Loot's recipes.json was removed in 0.13.0 and it no longer ships the recipes.json file. ";
+
+ /// unique key if successfully added
[PublicAPI]
+ [Obsolete(RecipeApiObsolete)]
public static string AddRecipe(string json)
{
try
@@ -34,6 +43,7 @@ public static string AddRecipe(string json)
/// unique key if successfully added
[PublicAPI]
+ [Obsolete(RecipeApiObsolete)]
public static string AddRecipes(string json)
{
// TODO: Figure out why it looks like recipes are added twice
@@ -61,9 +71,10 @@ public static string AddRecipes(string json)
}
/// True if updated
[PublicAPI]
+ [Obsolete(RecipeApiObsolete)]
public static bool UpdateRecipes(string key, string json)
{
if (!RuntimeRegistry.TryGetValue(key, out List list))
diff --git a/EpicLoot/API/Loot.cs b/EpicLoot/API/Loot.cs
new file mode 100644
index 000000000..6f1786717
--- /dev/null
+++ b/EpicLoot/API/Loot.cs
@@ -0,0 +1,311 @@
+using EpicLoot.LegendarySystem;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace EpicLoot;
+
+///
+/// Generating magic items and extending the loot tables from another plugin. This is the supported
+/// replacement for compiling against a publicized EpicLoot.dll and calling LootRoller
+/// directly, which breaks on every internal refactor.
+///
+public static partial class API
+{
+ ///
+ /// Rolls a magic item of the given rarity and stamps it onto
+ /// true if the item is now magic
+ [PublicAPI]
+ public static bool TryMakeMagicItem(ItemDrop.ItemData item, int rarity, float luck, string legendaryID)
+ {
+ if (!EpicLoot.CanBeMagicItem(item) || !TryToRarity(rarity, out ItemRarity value))
+ {
+ return false;
+ }
+
+ try
+ {
+ MagicItem magicItem = LootRoller.RollMagicItem(value, item, luck);
+ if (magicItem == null)
+ {
+ return false;
+ }
+
+ if (!string.IsNullOrEmpty(legendaryID))
+ {
+ if (!UniqueLegendaryHelper.TryGetLegendaryInfo(legendaryID, out LegendaryInfo info)
+ || !info.Requirements.CheckRequirements(item, magicItem))
+ {
+ OnError?.Invoke($"TryMakeMagicItem: legendary '{legendaryID}' is unknown or does not fit {item.m_shared.m_name}");
+ return false;
+ }
+
+ magicItem.LegendaryID = legendaryID;
+ magicItem.DisplayName = info.Name;
+ magicItem.SetID = UniqueLegendaryHelper.GetSetForLegendaryItem(info);
+ }
+
+ WithChangeReason(ChangeReason.LootRoll, () => item.SaveMagicItem(magicItem));
+ LootRoller.InitializeMagicItem(item);
+ RaiseLootGenerated(item);
+ return true;
+ }
+ catch (Exception ex)
+ {
+ EpicLoot.LogErrorForce($"[EpicLoot.API] TryMakeMagicItem failed for {item.m_shared?.m_name}: {ex}");
+ return false;
+ }
+ }
+
+ ///
+ /// Rolls a magic item without applying it, for callers that want to inspect or adjust it first.
+ ///
+ /// JSON serialized MagicItem, or "" if the roll was not possible
+ [PublicAPI]
+ public static string RollMagicItemJson(int rarity, ItemDrop.ItemData item, float luck)
+ {
+ if (item == null || !TryToRarity(rarity, out ItemRarity value))
+ {
+ return "";
+ }
+
+ try
+ {
+ MagicItem magicItem = LootRoller.RollMagicItem(value, item, luck);
+ return magicItem == null ? "" : JsonConvert.SerializeObject(magicItem);
+ }
+ catch (Exception ex)
+ {
+ EpicLoot.LogErrorForce($"[EpicLoot.API] RollMagicItemJson failed: {ex}");
+ return "";
+ }
+ }
+
+ ///
+ /// Applies previously rolled or hand-authored magic data to an item.
+ ///
+ /// true if applied
+ [PublicAPI]
+ public static bool ApplyMagicItemJson(ItemDrop.ItemData item, string magicItemJson)
+ {
+ if (item == null || string.IsNullOrEmpty(magicItemJson))
+ {
+ return false;
+ }
+
+ try
+ {
+ MagicItem magicItem = JsonConvert.DeserializeObject(magicItemJson);
+ if (magicItem == null)
+ {
+ return false;
+ }
+
+ item.SaveMagicItem(magicItem);
+ return true;
+ }
+ catch (Exception ex)
+ {
+ OnError?.Invoke($"ApplyMagicItemJson: could not parse magic item json: {ex.Message}");
+ return false;
+ }
+ }
+
+ /// The luck factor in effect there, from the world luck setting and nearby players' Luck
+ /// magic effects.
+ [PublicAPI]
+ public static float GetLuckFactor(Vector3 position)
+ {
+ return LootRoller.GetLuckFactor(position);
+ }
+
+ /// How many effects a fresh roll of this rarity would get; 0 for an unknown rarity.
+ [PublicAPI]
+ public static int RollEffectCountForRarity(int rarity)
+ {
+ return TryToRarity(rarity, out ItemRarity value) ? LootRoller.RollEffectCountPerRarity(value) : 0;
+ }
+
+ /// Every registered legendary/mythic id at that rarity, including API-registered ones.
+ [PublicAPI]
+ public static List GetLegendaryIDs(int rarity)
+ {
+ if (!TryToRarity(rarity, out ItemRarity value))
+ {
+ return new List();
+ }
+
+ switch (value)
+ {
+ case ItemRarity.Legendary:
+ return UniqueLegendaryHelper.LegendaryInfo.Keys.ToList();
+ case ItemRarity.Mythic:
+ return UniqueLegendaryHelper.MythicInfo.Keys.ToList();
+ default:
+ return new List();
+ }
+ }
+
+ /// JSON serialized LegendaryInfo, or "" if unknown
+ [PublicAPI]
+ public static string GetLegendaryInfoJson(string legendaryID)
+ {
+ if (string.IsNullOrEmpty(legendaryID)
+ || !UniqueLegendaryHelper.TryGetLegendaryInfo(legendaryID, out LegendaryInfo info))
+ {
+ return "";
+ }
+
+ return JsonConvert.SerializeObject(info);
+ }
+
+ ///
+ /// The effect types that could legally be rolled onto this item, honoring rarity, item type, skill,
+ /// exclusivity and any requirement registered via
+ /// The available effect type ids
+ [PublicAPI]
+ public static List GetAvailableEffectTypes(ItemDrop.ItemData item, string magicItemJson, int rarity)
+ {
+ if (item == null)
+ {
+ return new List();
+ }
+
+ try
+ {
+ MagicItem magicItem = string.IsNullOrEmpty(magicItemJson)
+ ? null
+ : JsonConvert.DeserializeObject(magicItemJson);
+
+ if (magicItem == null)
+ {
+ if (!TryToRarity(rarity, out ItemRarity value))
+ {
+ return new List();
+ }
+
+ magicItem = new MagicItem { Rarity = value };
+ }
+
+ return MagicItemEffectDefinitions.GetAvailableEffects(item, magicItem)
+ .Select(x => x.Type)
+ .ToList();
+ }
+ catch (Exception ex)
+ {
+ OnError?.Invoke($"GetAvailableEffectTypes failed: {ex.Message}");
+ return new List();
+ }
+ }
+
+ ///
+ /// Adds a loot table at runtime. Registrations are cached and re-applied whenever loottables.json
+ /// reloads or a dedicated server pushes its copy, so they survive both.
+ ///
+ /// unique key if added, else null
+ [PublicAPI]
+ public static string AddLootTables(string json)
+ {
+ if (string.IsNullOrEmpty(json))
+ {
+ return null;
+ }
+
+ try
+ {
+ List tables = json.TrimStart().StartsWith("[")
+ ? JsonConvert.DeserializeObject>(json)
+ : new List { JsonConvert.DeserializeObject(json) };
+
+ tables?.RemoveAll(x => x == null);
+ if (tables == null || tables.Count == 0)
+ {
+ return null;
+ }
+
+ ExternalLootTables.AddRange(tables);
+ LootRoller.AddLootTables(tables);
+ return RuntimeRegistry.Register(tables);
+ }
+ catch (Exception ex)
+ {
+ OnError?.Invoke($"Failed to parse loot table passed in through external plugin: {ex.Message}");
+ return null;
+ }
+ }
+
+ /// True if updated
+ [PublicAPI]
+ public static bool UpdateLootTables(string key, string json)
+ {
+ if (!RuntimeRegistry.TryGetValue(key, out List existing))
+ {
+ return false;
+ }
+
+ List tables = JsonConvert.DeserializeObject>(json);
+ if (tables == null)
+ {
+ return false;
+ }
+
+ // AddLootTable appends, so the previous instances have to be dropped by reference first or both
+ // versions would roll.
+ LootRoller.RemoveLootTables(existing);
+ ExternalLootTables.RemoveAll(existing);
+
+ ExternalLootTables.AddRange(tables);
+ existing.Clear();
+ existing.AddRange(tables);
+
+ LootRoller.AddLootTables(tables);
+ return true;
+ }
+
+ private static readonly List ExternalLootTables = new();
+
+ ///
+ /// Re-applies cached external loot tables into
+ private static void ReloadExternalLootTables()
+ {
+ if (ExternalLootTables.Count == 0)
+ {
+ return;
+ }
+
+ LootRoller.AddLootTables(ExternalLootTables);
+ OnReload?.Invoke("Reloaded external loot tables");
+ }
+}
diff --git a/EpicLoot/API/MagicEffectRequirement.cs b/EpicLoot/API/MagicEffectRequirement.cs
new file mode 100644
index 000000000..e99660e45
--- /dev/null
+++ b/EpicLoot/API/MagicEffectRequirement.cs
@@ -0,0 +1,89 @@
+using JetBrains.Annotations;
+using System;
+using System.Collections.Generic;
+
+namespace EpicLoot;
+
+public static partial class API
+{
+ private static readonly Dictionary> ExternalMagicEffectRequirements = new();
+
+ ///
+ /// Registers a magic effect requirement predicate for a Requirements.ExternalRequirements value.
+ ///
+ /// true if the requirement was registered
+ [PublicAPI]
+ public static bool RegisterMagicEffectRequirement(string externalRequirement, Func requirement)
+ {
+ if (string.IsNullOrWhiteSpace(externalRequirement))
+ {
+ OnError?.Invoke("Failed to register magic effect requirement: external requirement is empty");
+ return false;
+ }
+
+ if (requirement == null)
+ {
+ OnError?.Invoke($"Failed to register magic effect requirement '{externalRequirement}': requirement is null");
+ return false;
+ }
+
+ if (ExternalMagicEffectRequirements.ContainsKey(externalRequirement))
+ {
+ OnError?.Invoke($"Duplicate magic effect requirement: {externalRequirement}");
+ return false;
+ }
+
+ ExternalMagicEffectRequirements[externalRequirement] = requirement;
+ OnReload?.Invoke($"Registered magic effect requirement: {externalRequirement}");
+ return true;
+ }
+
+ internal static bool CheckMagicEffectExternalRequirements(
+ List externalRequirements,
+ ItemDrop.ItemData itemData,
+ MagicItem magicItem,
+ string magicEffectType,
+ bool checklootroll,
+ bool checkaugmentroll,
+ bool checkruneroll)
+ {
+ if (externalRequirements == null || externalRequirements.Count == 0)
+ {
+ return true;
+ }
+
+ foreach (string externalRequirement in externalRequirements)
+ {
+ if (string.IsNullOrWhiteSpace(externalRequirement))
+ {
+ OnError?.Invoke($"Magic effect '{magicEffectType}' has an empty external requirement");
+ return false;
+ }
+
+ if (!ExternalMagicEffectRequirements.TryGetValue(externalRequirement, out Func requirement))
+ {
+ OnError?.Invoke($"Magic effect '{magicEffectType}' requires unregistered external requirement '{externalRequirement}'");
+ return false;
+ }
+
+ try
+ {
+ if (!requirement(itemData, magicItem, magicEffectType, checklootroll, checkaugmentroll, checkruneroll))
+ {
+ return false;
+ }
+ }
+ catch (Exception ex)
+ {
+ OnError?.Invoke($"Magic effect requirement '{externalRequirement}' failed for '{magicEffectType}': {ex.Message}");
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/EpicLoot/API/Providers.cs b/EpicLoot/API/Providers.cs
new file mode 100644
index 000000000..43f233110
--- /dev/null
+++ b/EpicLoot/API/Providers.cs
@@ -0,0 +1,449 @@
+using JetBrains.Annotations;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EpicLoot;
+
+///
+/// Extension points that let another plugin widen what Epic Loot considers "available" without patching
+/// it. Each family replaces a set of Harmony patches integrating mods write today -- see the migration
+/// table in docs/API.md.
+///
+/// Every registered delegate is invoked inside a try/catch. A provider that throws is logged with its id
+/// (unconditionally, since it is another plugin's bug) and treated as contributing nothing, so a broken
+/// integration degrades to vanilla behavior rather than breaking the enchanting table.
+///
+public static partial class API
+{
+ private class InventoryProvider
+ {
+ public string Id;
+ public Func> GetItems;
+ public Func CountItem;
+ public Func RemoveItem;
+ public Func RemoveExactItem;
+ }
+
+ private static readonly List InventoryProviders = new();
+ private static readonly Dictionary>> EquipmentProviders = new();
+ private static readonly Dictionary> SacrificeFilters = new();
+
+ // Checked before every provider dispatch. Registration is rare and dispatch is not, so the common
+ // case must cost one bool read.
+ internal static bool AnyInventoryProviders;
+ internal static bool AnyEquipmentProviders;
+ internal static bool AnySacrificeFilters;
+
+ private static void LogProviderFailure(string family, string id, Exception ex)
+ {
+ // Force-logged: this is a fault in the registering plugin, and silently swallowing it would make
+ // the resulting "my items don't count" report impossible to diagnose.
+ EpicLoot.LogErrorForce($"[EpicLoot.API] {family} provider '{id}' threw and was skipped: {ex}");
+ }
+
+ #region Inventory providers
+
+ ///
+ /// Contributes additional items to the enchanting table's view of the player's inventory -- nearby
+ /// containers, a backpack, a remote stash. Epic Loot always draws from the player's own inventory
+ /// first and only falls through to providers for the shortfall.
+ ///
+ /// m_shared.m_name , returns how many you can supply. May be null.
+ /// m_shared.m_name and a requested amount, consumes up to that
+ /// amount and returns how many were actually removed. May be null.
+ /// true if registered; false if
+ [PublicAPI]
+ public static bool RegisterInventoryProvider(
+ string id,
+ Func> getItems,
+ Func countItem,
+ Func removeItem,
+ Func removeExactItem)
+ {
+ if (string.IsNullOrWhiteSpace(id))
+ {
+ OnError?.Invoke("Failed to register inventory provider: id is empty");
+ return false;
+ }
+
+ if (InventoryProviders.Exists(x => x.Id == id))
+ {
+ OnError?.Invoke($"Duplicate inventory provider: {id}");
+ return false;
+ }
+
+ InventoryProviders.Add(new InventoryProvider
+ {
+ Id = id,
+ GetItems = getItems,
+ CountItem = countItem,
+ RemoveItem = removeItem,
+ RemoveExactItem = removeExactItem
+ });
+ AnyInventoryProviders = true;
+ OnReload?.Invoke($"Registered inventory provider: {id}");
+ return true;
+ }
+
+ /// true if a registration was removed
+ [PublicAPI]
+ public static bool UnregisterInventoryProvider(string id)
+ {
+ bool removed = InventoryProviders.RemoveAll(x => x.Id == id) > 0;
+ AnyInventoryProviders = InventoryProviders.Count > 0;
+ return removed;
+ }
+
+ ///
+ /// Appends every provider-supplied item to Inventory.m_inventory .
+ ///
+ internal static void AppendProviderItems(List into)
+ {
+ if (!AnyInventoryProviders || into == null)
+ {
+ return;
+ }
+
+ foreach (InventoryProvider provider in InventoryProviders)
+ {
+ if (provider.GetItems == null)
+ {
+ continue;
+ }
+
+ try
+ {
+ List items = provider.GetItems();
+ if (items == null)
+ {
+ continue;
+ }
+
+ foreach (ItemDrop.ItemData item in items)
+ {
+ // Guard against a provider handing back something the player already holds; the
+ // table would otherwise count it twice.
+ if (item != null && !into.Contains(item))
+ {
+ into.Add(item);
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ LogProviderFailure("Inventory", provider.Id, ex);
+ }
+ }
+ }
+
+ /// m_shared.m_name
+ /// How many of
+ internal static int CountProviderItems(string itemName)
+ {
+ if (!AnyInventoryProviders)
+ {
+ return 0;
+ }
+
+ int total = 0;
+ foreach (InventoryProvider provider in InventoryProviders)
+ {
+ if (provider.CountItem == null)
+ {
+ continue;
+ }
+
+ try
+ {
+ total += Math.Max(0, provider.CountItem(itemName));
+ }
+ catch (Exception ex)
+ {
+ LogProviderFailure("Inventory", provider.Id, ex);
+ }
+ }
+
+ return total;
+ }
+
+ /// Drains
+ /// How many were actually removed, which may be less than requested.
+ internal static int RemoveProviderItems(string itemName, int amount)
+ {
+ if (!AnyInventoryProviders || amount <= 0)
+ {
+ return 0;
+ }
+
+ int remaining = amount;
+ foreach (InventoryProvider provider in InventoryProviders)
+ {
+ if (remaining <= 0)
+ {
+ break;
+ }
+
+ if (provider.RemoveItem == null)
+ {
+ continue;
+ }
+
+ try
+ {
+ // Clamp: a provider that over-reports would otherwise make the caller believe it
+ // consumed more than it asked for.
+ int removed = Mathf.Clamp(provider.RemoveItem(itemName, remaining), 0, remaining);
+ remaining -= removed;
+ }
+ catch (Exception ex)
+ {
+ LogProviderFailure("Inventory", provider.Id, ex);
+ }
+ }
+
+ return amount - remaining;
+ }
+
+ /// Drains a specific item instance across providers.
+ /// How many were actually removed.
+ internal static int RemoveExactProviderItem(ItemDrop.ItemData item, int amount)
+ {
+ if (!AnyInventoryProviders || item == null || amount <= 0)
+ {
+ return 0;
+ }
+
+ int remaining = amount;
+ foreach (InventoryProvider provider in InventoryProviders)
+ {
+ if (remaining <= 0)
+ {
+ break;
+ }
+
+ if (provider.RemoveExactItem == null)
+ {
+ continue;
+ }
+
+ try
+ {
+ int removed = Mathf.Clamp(provider.RemoveExactItem(item, remaining), 0, remaining);
+ remaining -= removed;
+ }
+ catch (Exception ex)
+ {
+ LogProviderFailure("Inventory", provider.Id, ex);
+ }
+ }
+
+ return amount - remaining;
+ }
+
+ #endregion
+
+ #region Equipment providers
+
+ ///
+ /// Contributes additional equipped items for magic effect resolution -- extra equipment slots, quick
+ /// slots, an equipped backpack. Feeds PlayerExtensions.GetMagicEquipment , so contributed items
+ /// count toward effect totals, legendary set bonuses, tooltips, and shard socketing alike.
+ ///
+ ///
+ /// Results are memoized per player in Humanoid.EquipItem /UnequipItem . If your slots change outside those methods,
+ /// call
+ /// true if registered
+ [PublicAPI]
+ public static bool RegisterEquipmentProvider(string id, Func> getExtraEquipped)
+ {
+ if (string.IsNullOrWhiteSpace(id))
+ {
+ OnError?.Invoke("Failed to register equipment provider: id is empty");
+ return false;
+ }
+
+ if (getExtraEquipped == null)
+ {
+ OnError?.Invoke($"Failed to register equipment provider '{id}': callback is null");
+ return false;
+ }
+
+ if (EquipmentProviders.ContainsKey(id))
+ {
+ OnError?.Invoke($"Duplicate equipment provider: {id}");
+ return false;
+ }
+
+ EquipmentProviders[id] = getExtraEquipped;
+ AnyEquipmentProviders = true;
+ OnReload?.Invoke($"Registered equipment provider: {id}");
+ return true;
+ }
+
+ /// true if a registration was removed
+ [PublicAPI]
+ public static bool UnregisterEquipmentProvider(string id)
+ {
+ bool removed = id != null && EquipmentProviders.Remove(id);
+ AnyEquipmentProviders = EquipmentProviders.Count > 0;
+ return removed;
+ }
+
+ ///
+ /// Discards the memoized magic effect totals for a player, forcing the next read to recompute, and
+ /// refreshes the equip effect visuals worn on the player. Call after changing the contents of slots
+ /// you provide.
+ ///
+ ///
+ /// Appends provider-supplied equipped items to
+ internal static void AppendProviderEquipment(Player player, List into)
+ {
+ if (!AnyEquipmentProviders || player == null || into == null)
+ {
+ return;
+ }
+
+ foreach (KeyValuePair>> entry in EquipmentProviders)
+ {
+ try
+ {
+ List items = entry.Value(player);
+ if (items == null)
+ {
+ continue;
+ }
+
+ foreach (ItemDrop.ItemData item in items)
+ {
+ if (item != null && item.IsMagic() && !into.Contains(item))
+ {
+ into.Add(item);
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ LogProviderFailure("Equipment", entry.Key, ex);
+ }
+ }
+ }
+
+ #endregion
+
+ #region Sacrifice filters
+
+ ///
+ /// Vetoes sacrificing (disenchanting) specific items -- for instance to stop an item equipped in a
+ /// slot Epic Loot cannot see from being destroyed. A filter returning false makes the item yield no
+ /// sacrifice products, which hides it from the Sacrifice tab.
+ ///
+ /// true if registered
+ [PublicAPI]
+ public static bool RegisterSacrificeFilter(string id, Func canSacrifice)
+ {
+ if (string.IsNullOrWhiteSpace(id))
+ {
+ OnError?.Invoke("Failed to register sacrifice filter: id is empty");
+ return false;
+ }
+
+ if (canSacrifice == null)
+ {
+ OnError?.Invoke($"Failed to register sacrifice filter '{id}': callback is null");
+ return false;
+ }
+
+ if (SacrificeFilters.ContainsKey(id))
+ {
+ OnError?.Invoke($"Duplicate sacrifice filter: {id}");
+ return false;
+ }
+
+ SacrificeFilters[id] = canSacrifice;
+ AnySacrificeFilters = true;
+ OnReload?.Invoke($"Registered sacrifice filter: {id}");
+ return true;
+ }
+
+ /// true if a registration was removed
+ [PublicAPI]
+ public static bool UnregisterSacrificeFilter(string id)
+ {
+ bool removed = id != null && SacrificeFilters.Remove(id);
+ AnySacrificeFilters = SacrificeFilters.Count > 0;
+ return removed;
+ }
+
+ /// false if any filter vetoes sacrificing this item. A filter that throws does not veto.
+ internal static bool SacrificeAllowed(ItemDrop.ItemData item)
+ {
+ if (!AnySacrificeFilters || item == null)
+ {
+ return true;
+ }
+
+ foreach (KeyValuePair> entry in SacrificeFilters)
+ {
+ try
+ {
+ if (!entry.Value(item))
+ {
+ return false;
+ }
+ }
+ catch (Exception ex)
+ {
+ LogProviderFailure("Sacrifice", entry.Key, ex);
+ }
+ }
+
+ return true;
+ }
+
+ #endregion
+
+ /// The ids of every registered provider, grouped by family, for diagnostics.
+ [PublicAPI]
+ public static Dictionary> GetRegisteredProviders()
+ {
+ return new Dictionary>
+ {
+ ["Inventory"] = InventoryProviders.ConvertAll(x => x.Id),
+ ["Equipment"] = new List(EquipmentProviders.Keys),
+ ["Sacrifice"] = new List(SacrificeFilters.Keys)
+ };
+ }
+}
diff --git a/EpicLoot/API/Query.cs b/EpicLoot/API/Query.cs
new file mode 100644
index 000000000..6461462c6
--- /dev/null
+++ b/EpicLoot/API/Query.cs
@@ -0,0 +1,251 @@
+using EpicLoot.Crafting;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace EpicLoot;
+
+///
+/// Read-only questions an external plugin can ask about an item. Everything here is non-throwing and
+/// null-safe: the underlying extension methods are not (
+public static partial class API
+{
+ private static readonly int RarityCount = Enum.GetValues(typeof(ItemRarity)).Length;
+
+ ///
+ /// Converts a boundary int to an
+ /// false if the value names no rarity, in which case nothing should be assumed about
+ ///
+ private static bool TryToRarity(int rarity, out ItemRarity result)
+ {
+ result = default;
+ if (rarity < 0 || rarity >= RarityCount)
+ {
+ return false;
+ }
+
+ result = (ItemRarity)rarity;
+ return true;
+ }
+
+ /// true if the item carries Epic Loot magic data
+ [PublicAPI]
+ public static bool IsMagicItem(ItemDrop.ItemData item)
+ {
+ return item != null && item.IsMagic();
+ }
+
+ ///
+ /// The rarity of a magic item, magic crafting material, or runestone.
+ ///
+ /// true if the item has a rarity at all
+ [PublicAPI]
+ public static bool TryGetRarity(ItemDrop.ItemData item, ref int rarity)
+ {
+ if (item == null || !item.HasRarity())
+ {
+ return false;
+ }
+
+ rarity = (int)item.GetRarity();
+ return true;
+ }
+
+ ///
+ /// The name Epic Loot shows for an item -- the generated magic name ("Sturdy Rag Trousers of the
+ /// Bear") where it has one, the vanilla m_shared.m_name otherwise. Any parenthesised suffix
+ /// on the vanilla name, such as a variant's stat text, is carried over.
+ ///
+ /// The unlocalized display name, or "" for a null item
+ [PublicAPI]
+ public static string GetItemDisplayName(ItemDrop.ItemData item)
+ {
+ return item == null ? "" : item.GetDisplayName();
+ }
+
+ ///
+ ///
+ /// The decorated display name, or "" for a null item
+ [PublicAPI]
+ public static string GetItemDecoratedName(ItemDrop.ItemData item, string colorOverride = null)
+ {
+ return item == null ? "" : item.GetDecoratedName(colorOverride);
+ }
+
+ /// The number of rarity tiers, so a consumer can enumerate 0..n-1 without hard-coding 5.
+ [PublicAPI]
+ public static int GetRarityCount()
+ {
+ return RarityCount;
+ }
+
+ /// The configured hex color, e.g. "#AA55FF". White for an unknown rarity.
+ [PublicAPI]
+ public static string GetRarityColorByIndex(int rarity)
+ {
+ return TryToRarity(rarity, out ItemRarity value) ? EpicLoot.GetRarityColor(value) : "#FFFFFF";
+ }
+
+ /// The unlocalized display token, e.g. "$mod_epicloot_Epic".
+ [PublicAPI]
+ public static string GetRarityDisplayNameByIndex(int rarity)
+ {
+ return TryToRarity(rarity, out ItemRarity value) ? EpicLoot.GetRarityDisplayName(value) : "";
+ }
+
+ ///
+ /// The color Epic Loot draws this specific item's name in -- magic rarity, crafting material rarity,
+ /// or runestone rarity, whichever applies.
+ ///
+ /// hex color, "#FFFFFF" when the item has no rarity
+ [PublicAPI]
+ public static string GetItemRarityColor(ItemDrop.ItemData item)
+ {
+ if (item == null || !item.HasRarity())
+ {
+ return "#FFFFFF";
+ }
+
+ return GetRarityColorByIndex((int)item.GetRarity());
+ }
+
+ ///
+ /// Whether this item was added by Epic Loot (shard stone, runestone, crafting material, bounty token,
+ /// and so on). Supported replacement for testing m_shared.m_name.StartsWith("$mod_epicloot") .
+ ///
+ ///
+ /// An unidentified item is magic data that has not been revealed yet; it reports true from
+ ///
+ ///
+ /// Whether Epic Loot would ever allow this item to become magic (player item, non-stackable, not on
+ /// the restricted list, an allowed item type). Check this before calling
+ ///
+ /// Every registered magic effect type id, including any added through the API.
+ [PublicAPI]
+ public static List GetAllMagicEffectTypes()
+ {
+ return MagicItemEffectDefinitions.AllDefinitions.Keys.ToList();
+ }
+
+ ///
+ /// The material cost of enchanting this item to the given rarity. Supported replacement for
+ /// reflecting the long-removed EnchantTabController.GetEnchantCosts .
+ ///
+ /// JSON list of
+ [PublicAPI]
+ public static string GetEnchantCostsJson(ItemDrop.ItemData item, int rarity)
+ {
+ if (item == null || !TryToRarity(rarity, out ItemRarity value))
+ {
+ return "[]";
+ }
+
+ List costs = EnchantCostsHelper.GetEnchantCost(item, value);
+ return JsonConvert.SerializeObject(costs ?? new List());
+ }
+
+ ///
+ /// What sacrificing (disenchanting) this item yields. Honors any filter registered through
+ ///
+ /// JSON list of
+ [PublicAPI]
+ public static string GetSacrificeProductsJson(ItemDrop.ItemData item)
+ {
+ if (item == null)
+ {
+ return "[]";
+ }
+
+ List products = EnchantCostsHelper.GetSacrificeProducts(item);
+ return JsonConvert.SerializeObject(products ?? new List());
+ }
+}
diff --git a/EpicLoot/API/Version.cs b/EpicLoot/API/Version.cs
new file mode 100644
index 000000000..101f34f94
--- /dev/null
+++ b/EpicLoot/API/Version.cs
@@ -0,0 +1,81 @@
+using JetBrains.Annotations;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace EpicLoot;
+
+public static partial class API
+{
+ ///
+ /// The version of the public API contract, independent of
+ ///
+ /// 1 - Queries, providers (inventory / equipment / sacrifice), lifecycle events, loot generation,
+ /// item slot and icon decoration.
+ ///
+ [PublicAPI]
+ public const int ApiVersion = 1;
+
+ /// The running Epic Loot plugin version, e.g. "0.13.0".
+ [PublicAPI]
+ public static string GetPluginVersion()
+ {
+ return EpicLoot.Version;
+ }
+
+ /// The Epic Loot plugin GUID, for BepInEx soft-dependency checks.
+ [PublicAPI]
+ public static string GetPluginId()
+ {
+ return EpicLoot.PluginId;
+ }
+
+ ///
+ /// Feature probe. Lets a plugin built against a newer API degrade gracefully on an older Epic Loot
+ /// instead of throwing when a method it expects is missing.
+ ///
+ /// true if at least one overload by that name exists
+ [PublicAPI]
+ public static bool HasEndpoint(string name)
+ {
+ if (string.IsNullOrEmpty(name))
+ {
+ return false;
+ }
+
+ return EndpointNames.Contains(name);
+ }
+
+ /// Every public endpoint name on this class, for diagnostics.
+ [PublicAPI]
+ public static List GetEndpointNames()
+ {
+ return EndpointNames.ToList();
+ }
+
+ private static readonly HashSet EndpointNames = typeof(API)
+ .GetMethods(BindingFlags.Public | BindingFlags.Static)
+ .Select(m => m.Name)
+ .ToHashSet();
+
+ ///
+ /// Turns on the API's internal registration/reload chatter. Off by default because a healthy
+ /// registration is not interesting; failures are logged unconditionally regardless of this flag.
+ ///
+ [PublicAPI]
+ public static void SetVerboseLogging(bool enabled)
+ {
+ ShowLogs = enabled;
+ }
+}
diff --git a/EpicLoot/API/Visuals.cs b/EpicLoot/API/Visuals.cs
new file mode 100644
index 000000000..ebd8f205e
--- /dev/null
+++ b/EpicLoot/API/Visuals.cs
@@ -0,0 +1,148 @@
+using JetBrains.Annotations;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace EpicLoot;
+
+///
+/// Hooks for plugins that draw their own item slots -- custom hotbars, extra equipment rows, quick
+/// slots. Epic Loot decorates the vanilla inventory grid and hotkey bar with transpilers, so a plugin
+/// that reimplements InventoryGrid.UpdateGui or HotkeyBar.UpdateIcons (a prefix returning
+/// false, say) necessarily skips that decoration. This is the supported way to put it back.
+///
+public static partial class API
+{
+ ///
+ /// Applies Epic Loot's rarity background to a single item slot, creating the child images the first
+ /// time one is actually needed. Safe to call every frame: after the first call only the sprite,
+ /// colour and enabled state are touched.
+ ///
+ /// true if the slot was handled
+ [PublicAPI]
+ public static bool ApplyMagicItemBackground(GameObject slotRoot, GameObject equippedOverlay,
+ ItemDrop.ItemData item, bool inventoryGrid)
+ {
+ if (slotRoot == null || equippedOverlay == null)
+ {
+ return false;
+ }
+
+ bool showBackground = item != null && item.UseMagicBackground();
+ bool showSetMarker = inventoryGrid && item != null && item.IsSetItem();
+
+ // An empty slot has nothing to show and, until something has been shown in it, nothing to hide
+ // either -- so do not build images for every empty cell of every grid.
+ if (!showBackground && !showSetMarker && slotRoot.transform.Find("magicItem") == null)
+ {
+ return true;
+ }
+
+ Image magicItem = ItemBackgroundHelper.CreateAndGetMagicItemBackgroundImage(slotRoot, equippedOverlay, inventoryGrid);
+ if (magicItem == null)
+ {
+ return false;
+ }
+
+ magicItem.enabled = showBackground;
+ if (showBackground)
+ {
+ magicItem.sprite = EpicLoot.GetMagicItemBgSprite();
+ magicItem.color = item.GetRarityColor();
+ }
+
+ if (!inventoryGrid)
+ {
+ return true;
+ }
+
+ Transform setItemTransform = slotRoot.transform.Find("setItem");
+ if (setItemTransform != null)
+ {
+ Image setItem = setItemTransform.GetComponent();
+ if (setItem != null)
+ {
+ setItem.enabled = showSetMarker;
+ }
+ }
+
+ return true;
+ }
+
+ ///
+ /// Applies Epic Loot's rarity background behind an arbitrary item icon, for UI that is not a 64x64
+ /// inventory cell -- crafting recipe rows, the crafting detail panel, custom lists.
+ ///
+ ///
+ /// The background is a clone of the icon, so it inherits the icon's anchors, pivot, size and
+ /// position and lines up whatever the layout. Safe to call every frame: after the first call only
+ /// the sprite, colour and enabled state are touched.
+ ///
+ /// Image . Must have a parent --
+ /// the background is created as its sibling.
+ /// true if the icon was handled
+ [PublicAPI]
+ public static bool ApplyMagicItemBackgroundToIcon(GameObject iconObject, ItemDrop.ItemData item)
+ {
+ if (iconObject == null || iconObject.transform.parent == null)
+ {
+ return false;
+ }
+
+ Transform parent = iconObject.transform.parent;
+ Transform existing = parent.Find(IconBackgroundName);
+ bool showBackground = item != null && item.UseMagicBackground();
+
+ // Nothing to show and nothing built yet -- do not create an image per row of every list.
+ if (!showBackground && existing == null)
+ {
+ return true;
+ }
+
+ Image background;
+ if (existing == null)
+ {
+ GameObject backgroundObject = UnityEngine.Object.Instantiate(iconObject, parent);
+ backgroundObject.name = IconBackgroundName;
+ backgroundObject.SetActive(true);
+ // Taking the icon's own index leaves the background drawn behind it.
+ backgroundObject.transform.SetSiblingIndex(iconObject.transform.GetSiblingIndex());
+
+ background = backgroundObject.GetComponent();
+ if (background == null)
+ {
+ UnityEngine.Object.Destroy(backgroundObject);
+ return false;
+ }
+
+ background.raycastTarget = false;
+ }
+ else
+ {
+ background = existing.GetComponent();
+ if (background == null)
+ {
+ return false;
+ }
+ }
+
+ background.enabled = showBackground;
+ if (showBackground)
+ {
+ background.sprite = EpicLoot.GetMagicItemBgSprite();
+ background.color = item.GetRarityColor();
+ }
+
+ return true;
+ }
+
+ private const string IconBackgroundName = "magicItemIconBG";
+}
diff --git a/EpicLoot/CHANGELOG.md b/EpicLoot/CHANGELOG.md
index 56dc0ad85..56e1af92f 100644
--- a/EpicLoot/CHANGELOG.md
+++ b/EpicLoot/CHANGELOG.md
@@ -1,3 +1,101 @@
+## Version 0.13.0
+
+New Content:
+* Shardstones Added! Shardstones are a new item that can be attached to weapons with available shardsockets
+ * Thanks Leslie, Warp and Rusty for contributing effects
+ * Interacting with an enchanted item that has a shard socket will pull up a small storage UI, allowing you to socket or remove shards.
+ * Shardstones can be found in the world as loot, different shards in each biome
+ * Every boss drops a shardstone of its own (Eikthyr, The Elder, Bonemass, Moder, Yagluth, The Queen and Fader), and two unique shardstones drop rarely from elite creatures and treasure chests
+ * 90+ new magic effects have been added and are primarily available through shardstones
+ * The enchanting table's probability panel now lists shard slot odds alongside effect count odds
+ * `Shard Stack Mode` option controls whether several shards of the same color may be socketed into the same item
+ * `Shard Removal Mode` option controls whether a socketed shard can be freely removed, must be broken out (destroying it), or is permanent
+ * `Shard Stone Drop Ratio` balance option weighs shardstone drops against normal item, unidentified and material drops
+* Tempering (Thanks Rusty!)
+ * Tempering allows you to pay to increase the value of an existing enchantment (service provided by Hildir)
+ * Tempering can be configured to allow upgrading past a tiers normal maximum.
+ * Careful! Tempering can downgrade enchantments too if you critically fail (its configurable don't worry).
+* Runestone Balance options
+ * Runestone extraction can now be configured with new options: KeepItem / ReduceEnchants / ReduceEnchantsAndRarity / DestroyItem
+ * Runestones can also be socketed into shardsockets
+* Improved Tooltips!
+ * User-side configuration allows you to expand vertical or horizontally (or shrink) tooltips (scrollbar automatically used, as needed)
+ * SHIFT when moused over an item will now show extended tooltip information, this includes more detailed descriptions, configurable effects and precise values for multiple parts of the effects
+* Terminal Commands upgraded (Thanks Rusty!)
+ * Terminal commands now have better completion and more options
+ * Color based formatting for rarity loot table rolls!
+* Config option to show computed roll chance for all effects when enchanting an item (disabled by default)
+* Client side config options to personalize how large item tooltips are
+* Base configs now keep themselves up to date
+ * Epic Loot now tracks config file versions and will prompt you to update configs which have been customized
+ * Configs you *have* edited are never overwritten on their own. If an update changes one of them, a prompt at the main menu offers to replace it, copying your version to `BepInEx\config\EpicLoot\baseconfig-backup` first. Declining is remembered per file, and you are only asked again if that config changes in a future update
+ * Configs targeted by a patch file are unaffected, as they are already rebuilt from the current defaults every launch
+ * Dedicated servers log the affected files instead of prompting.
+ * Enabling `Always Refresh Core Configs` activates the patch system and prevents config file prompts (configs are rebuilt every restart, and only changes defined in patches will be applied)
+
+Changes:
+* Enchanting shards (Shard Magic, Shard Rare, and so on -- not the new Shardstones) are now crafted at the enchanting table instead of the forge
+* The Leather Belt, Silver Ring and Gold Ruby Ring are now configurable
+* Enchanting table building resources are now easily configurable
+ * Resources to build the enchanting table has been changed to 10 wood, 2 greydwarf eyes
+* The Epic Loot config file has been regrouped and now reads in a deliberate order instead of alphabetically, in both the file and the configuration manager
+ * Sections are numbered in the order they are meant to be read (`1 - General`, `2 - Balance`, `3 - Shardstones & Runes`, `4 - Enchanting Table`, `5 - Adventure`, `6 - Interface`, `7 - Item Colors`, `8 - Abilities`, `9 - Debug`) and the settings inside each one keep the order they were written in
+ * The bounty and adventure settings gathered into Adventure, the crafting UI / tooltip / panel position settings into Interface, `Rune Extract Mode` into Shardstones & Runes, and logging into Debug
+ * Every setting you had customized is carried over to its new home automatically; nothing resets to defaults
+ * Each setting's description now states whether it is synced from the server
+* New cheat commands `magicshards` and `cheatsockets`
+
+Bugfixes:
+* Fixes tooltip display for enchanted items health use percentage
+* Fixes a bug with Ragnar's ice wave which would cause a player to swim upwards in the air (upon exit) if the effect was used in a dungeon
+* Attack speed compatibility: when another mod already provides AnimationSpeedManager (embedded as a binary), Epic Loot now routes its attack-speed changes into that shared instance instead of running its own copy, so the two mods' attack-speed modifiers stack correctly instead of overwriting each other
+* Merchant panels are now draggable, and save their position client side
+* Config patches now honor the `Priority` field reliably and equal-priority patches are now applied in a deterministic order instead of depending on the filesystem's file listing order
+ * When any config patches are active, Epic Loot now always logs a one-line summary of how many patches were applied (regardless of your logging settings) to make patched setups obvious in bug reports
+* Adventure data (Treasure hunts, bounties etc) is now compressed and cleaned resulting in massive reductions in stored custom data
+* Transfer Enchantments through crafting now works properly
+* Chest loot is now rolled when it is opened, not when it is spawned, so that the loot is always appropriate for the player opening it. This primarily fixes mountain & swamp loot which would be loaded very early, but actually opened later.
+* Filtering an enchanting table list no longer hides items from you while still acting on them. Previously, typing in the Sacrifice tab's filter and pressing Select All would sacrifice every sacrificeable item in your inventory, not just the filtered ones
+ * Select All, the products preview and the action itself now only ever cover the rows the filter is showing
+ * Items you selected before filtering keep their selection, so you can filter and select several times over and then clear the filter to act on everything you picked
+ * The filter is also reapplied after each action and when switching between Sacrifice and Identify, so the list no longer shows a stale set of rows
+* Equip effect visuals (auras such as `Glowing`) are now reconciled against your equipped magic gear after every equipment change, instead of being attached from the model-building path and removed from the unequip path
+ * Items worn in slots added by other mods now get their aura, which previously never appeared at all
+ * The spurious `Unequipped item (...) from player that had fx, but could not find fx (...)!` error is gone — a missing effect is now simply nothing to remove
+ * An aura shared by two worn items survives unequipping either one, and is removed when the last one comes off
+* Fixed the reset for helmet attachment never running, which let the helmet's texture overrides and item effects be applied to a beard, hair or back-slung weapon model instead
+* Fixed legendary texture overrides on armor being resolved by item type rather than by the item actually being attached, which picked the wrong item when two worn items shared a type
+ * This also makes legendary armor texture overrides render for other players, which previously never happened
+
+API:
+* The API now covers integration, not just content registration. Full reference and a migration table in `EpicLoot/docs/API.md`
+ * `API.ApiVersion` / `GetApiVersion()` / `HasEndpoint(name)` let a mod check what the installed Epic Loot supports and degrade gracefully instead of throwing
+ * The `EpicLootAPI` shim provides typed wrappers for everything below and can be bundled into your plugin with ILRepack
+* Inventory providers — `API.RegisterInventoryProvider` lets container, backpack and stash mods feed the enchanting table
+ * Epic Loot spends the player's own inventory first and only charges the shortfall to providers
+ * Removal by item instance matches on reference, so magic data on the consumed item is preserved
+* Equipment providers — `API.RegisterEquipmentProvider` lets extra-slot mods contribute equipped items
+ * Contributed items count toward effect totals, legendary set bonuses, tooltips and shard socketing, and receive their equip effect visuals
+ * `API.InvalidatePlayerEffectCache(player)` discards memoized effect totals and refreshes worn equip effect visuals when your slot contents change outside vanilla equip/unequip
+* Sacrifice filters — `API.RegisterSacrificeFilter` lets a mod veto sacrificing an item, so gear equipped in slots Epic Loot cannot see is not destroyed by accident
+* Custom item slots — `API.ApplyMagicItemBackground` draws the rarity background, set marker and equipped overlay on a slot your own mod renders
+ * Epic Loot decorates the vanilla grid and hotkey bar with transpilers, so a mod that reimplements `InventoryGrid.UpdateGui` or `HotkeyBar.UpdateIcons` previously lost the background entirely; this is the supported way to put it back
+* Lifecycle events — `API.AddMagicItemChangedListener`, `AddLootGeneratedListener` and `AddBountyCompletedListener`
+ * The change event fires on every magic-data write with a reason token: `Enchant`, `Augment`, `Disenchant`, `Rune`, `Temper`, `Socket`, `Unsocket`, `LootRoll`, `Transfer`, or `Unspecified`. Item loading does not raise it
+* Queries — `IsMagicItem`, `TryGetRarity` (non-throwing), rarity colors and display names, `IsEpicLootItem`, `IsShardStone`, `IsRunestone`, `IsMagicCraftingMaterial`, `IsUnidentified`, `CanBeMagicItem`, `ItemHasMagicEffect`, `GetAllMagicEffectTypes`, `GetEnchantCostsJson`, `GetSacrificeProductsJson`
+* Loot generation — `TryMakeMagicItem` rolls and applies a magic item exactly the way a drop does, plus `RollMagicItemJson` / `ApplyMagicItemJson` to inspect before applying, `GetLuckFactor`, `RollEffectCountForRarity`, `GetLegendaryIDs` and `GetLegendaryInfoJson`
+ * `API.AddLootTables` / `UpdateLootTables` register loot tables at runtime, and they are re-applied on config reload and on a dedicated server's config push
+* New `magicapi` console command (`version`, `query`, `providers`, `events`, `roll`) for testing an integration in game
+* Mod authors patching `PlayerExtensions.GetEquipment` should switch to an equipment provider: that method is a deprecated alias and nothing inside Epic Loot calls it
+* `EpicLootAPI`'s `MagicItem` was updated to account for tempering, shardstones and unidentified items
+* New magic effect requirement flags: `ItemGivesAdrenaline` (item's attack grants above-default adrenaline) and `ItemHasAdrenaline` (item provides a max adrenaline pool)
+ * Note: `ItemGivesAdrenaline` requires that the item gives more than 1 adrenaline. This is due to all items by default adding 1 adrenaline.
+* New magic effect requirements allowed from the API
+ * API magic effect requirements when defined for an effect will be evaluated for all items, allowing only items which fit the filter (Thanks Warp!)
+* `recipes.json` has been removed (its contained recipes are now handled and directly exposed in the Bepinex config file [Randyknapp.epicloot.cfg])
+ * Mod authors: `API.AddRecipe`, `API.AddRecipes`, `API.UpdateRecipes` and the shim's `CustomRecipe` are now deprecated.
+
+
## Version 0.12.15
* Fixed an issue with bounties not spawning correctly if not using the Star Level System mod.
diff --git a/EpicLoot/EpicLoot-Header.psd b/EpicLoot/EpicLoot-Header.psd
new file mode 100644
index 000000000..3035b71e7
Binary files /dev/null and b/EpicLoot/EpicLoot-Header.psd differ
diff --git a/EpicLoot/EpicLoot-Tile.psd b/EpicLoot/EpicLoot-Tile.psd
new file mode 100644
index 000000000..baa6f5185
Binary files /dev/null and b/EpicLoot/EpicLoot-Tile.psd differ
diff --git a/EpicLoot/EpicLoot.cs b/EpicLoot/EpicLoot.cs
index 3f69a2a8d..216aa5163 100644
--- a/EpicLoot/EpicLoot.cs
+++ b/EpicLoot/EpicLoot.cs
@@ -1,4 +1,4 @@
-using BepInEx;
+using BepInEx;
using Common;
using EpicLoot.Adventure;
using EpicLoot.Config;
@@ -8,6 +8,7 @@
using EpicLoot.GatedItemType;
using EpicLoot.General;
using EpicLoot.Magic;
+using EpicLoot.Magic.MagicItemEffects.Helpers;
using EpicLoot.MagicItemEffects;
using HarmonyLib;
using JetBrains.Annotations;
@@ -33,11 +34,10 @@ namespace EpicLoot;
[BepInDependency("vapok.mods.adventurebackpacks", BepInDependency.DependencyFlags.SoftDependency)]
[BepInDependency("kg.ValheimEnchantmentSystem", BepInDependency.DependencyFlags.SoftDependency)]
[BepInDependency("org.bepinex.plugins.steadyregeneration", BepInDependency.DependencyFlags.SoftDependency)]
-public sealed class EpicLoot : BaseUnityPlugin
-{
+public sealed class EpicLoot : BaseUnityPlugin {
public const string PluginId = "randyknapp.mods.epicloot";
public const string DisplayName = "Epic Loot";
- public const string Version = "0.12.15";
+ public const string Version = "0.13.0";
private static string ConfigFileName = PluginId + ".cfg";
private static string ConfigFileFullPath = BepInEx.Paths.ConfigPath + Path.DirectorySeparatorChar + ConfigFileName;
@@ -66,19 +66,20 @@ public sealed class EpicLoot : BaseUnityPlugin
"Essence"
};
+ ///
+ /// Plain, non-craftable items registered straight from the bundle. Craftable items are declared in
+ ///
public static string[] ItemNames = new string[]
{
- "LeatherBelt",
- "SilverRing",
- "GoldRubyRing",
"ForestToken",
"IronBountyToken",
"GoldBountyToken"
};
public static bool AlwaysDropCheat = false;
- public const Minimap.PinType BountyPinType = (Minimap.PinType) 800;
- public const Minimap.PinType TreasureMapPinType = (Minimap.PinType) 801;
+ public const Minimap.PinType BountyPinType = (Minimap.PinType)800;
+ public const Minimap.PinType TreasureMapPinType = (Minimap.PinType)801;
public static bool HasAuga;
public static bool AugaTooltipNoTextBoxes;
@@ -91,13 +92,12 @@ public sealed class EpicLoot : BaseUnityPlugin
internal ELConfig cfg;
[UsedImplicitly]
- void Awake()
- {
+ void Awake() {
_instance = this;
- Assembly assembly = Assembly.GetExecutingAssembly();
-
- LoadEmbeddedAssembly(assembly, "EpicLoot-UnityLib.dll");
+ // Wire the shared Common support layer (config binder, piece loader, drawers) to this plugin before
+ // any config is bound, so ConfigBinder and ModLogger have a config file and log source to use.
+ ModContext.Initialize(this, Logger, "EpicLoot");
cfg = new ELConfig(Config);
@@ -106,40 +106,68 @@ void Awake()
InitializeAbilities();
AddLocalizations();
LoadAssets();
- EnchantingUIController.Initialize();
_harmony = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), PluginId);
LootTableLoaded?.Invoke();
RegisterMagicEffectEvents();
- TerminalCommands.AddTerminalCommands();
+ // Scheduled (non-per-frame) effect drivers, on their own DontDestroyOnLoad objects.
+ MagicItemEffects.Shards.PoisonAdrenalinePulse.Create();
+ MagicItemEffects.Shards.StormFuryPulse.Create();
+
// Main file config watcher
SetupWatcher();
}
- private static void RegisterMagicEffectEvents()
- {
+ private static void RegisterMagicEffectEvents() {
+ // Register per-effect tooltip display-value providers (effects that show more than one number).
+ // These are keyed by effect-type constant and don't depend on config load, so register once here.
+ MagicItemEffects.BulkupEffect.RegisterDisplayValues();
+ MagicItemEffects.Shards.HealthGainPerXDamageDone.RegisterDisplayValues();
+ MagicItemEffects.Shards.HealthOnEitrUse.RegisterDisplayValues();
+ MagicItemEffects.Shards.Mercenary.RegisterDisplayValues();
+ MagicItemEffects.Shards.Coinplated.RegisterDisplayValues();
+ MagicItemEffects.Shards.Wager.RegisterDisplayValues();
+ MagicItemEffects.Shards.ChanceToCritOnHit.RegisterDisplayValues();
+ MagicItemEffects.Shards.BloodDrinker.RegisterDisplayValues();
+ MagicItemEffects.Shards.TravelLight.RegisterDisplayValues();
+ MagicItemEffects.Shards.PerfectDodge.RegisterDisplayValues();
+ MagicItemEffects.Shards.AdrenalineFrostWave.RegisterDisplayValues();
+ MagicItemEffects.Shards.AdrenalineIncreasesHealthRegen.RegisterDisplayValues();
+ MagicItemEffects.Shards.GainAdrenalineWhenApplyingPoison.RegisterDisplayValues();
+ MagicItemEffects.Shards.StormFury.RegisterDisplayValues();
+ MagicItemEffects.Shards.LuckWhileFishing.RegisterDisplayValues();
+ MagicItemEffects.Shards.Kindling.RegisterDisplayValues();
+ MagicItemEffects.Shards.Conduit.RegisterDisplayValues();
+ MagicItemEffects.Shards.Inspiration.RegisterDisplayValues();
+ MagicItemEffects.Shards.LuckyLoot.RegisterDisplayValues();
+ MagicItemEffects.Shards.Bloodrage.RegisterDisplayValues();
+ MagicItemEffects.Shards.MeteorSummoner.RegisterDisplayValues();
+ MagicItemEffects.Shards.BlockAsDodgeAsBlock.RegisterDisplayValues();
+ MagicItemEffects.Shards.BlockAsWoodCuttingAndPickaxes.RegisterDisplayValues();
+
// This needs to not run until after the game is loaded, otherwise it will not be able to find the ObjectDB
MagicItemEffectDefinitions.OnSetupMagicItemEffectDefinitions += Riches_CharacterDrop_GenerateDropList_Patch.UpdateRichesOnEffectSetup;
- }
- private static void LoadEmbeddedAssembly(Assembly assembly, string assemblyName)
- {
- var stream = assembly.GetManifestResourceStream($"{assembly.GetName().Name}.{assemblyName}");
- if (stream == null)
- {
- LogErrorForce($"Could not load embedded assembly ({assemblyName})!");
- return;
+ // Register definitions for the Shardstone-only effect types (blank tooltips + warnings otherwise).
+ // Re-runs on every config (re)load; the defensive call covers the case where the effect config was
+ // already loaded (during ELConfig construction) before this subscription was added.
+ MagicItemEffectDefinitions.OnSetupMagicItemEffectDefinitions += ShardEffectDefinitions.RegisterShardEffectDefinitions;
+ if (MagicItemEffectDefinitions.AllDefinitions.Count > 0) {
+ ShardEffectDefinitions.RegisterShardEffectDefinitions();
}
- using (stream)
- {
- var data = new byte[stream.Length];
- stream.Read(data, 0, data.Length);
- Assembly.Load(data);
+ // Fold the ShardStone recipes into the material conversions (enchanting "Convert Materials" tab).
+ // Same event/defensive pattern as the shard effect definitions above: re-runs on every
+ // material-conversions (re)load, with a defensive call if that config was already loaded before
+ // this subscription was added.
+ CraftingV2.MaterialConversions.OnSetupMaterialConversions += ShardStones.ShardStoneConversions.Merge;
+ if (CraftingV2.MaterialConversions.Config != null) {
+ ShardStones.ShardStoneConversions.Merge();
}
}
+
//sealed void Start()
//{
// //HasAuga = Auga.API.IsLoaded();
@@ -236,10 +264,10 @@ private static void LoadEmbeddedAssembly(Assembly assembly, string assemblyName)
// {
// //Auga.API.ComplexTooltip_SetSubtitle(complexTooltip, localizedSubtitle);
// }
-
+
// if (AugaTooltipNoTextBoxes)
// return;
-
+
// //Don't need to process the InventoryTooltip Information.
// if (complexTooltip.name.Contains("InventoryTooltip"))
// return;
@@ -251,13 +279,13 @@ private static void LoadEmbeddedAssembly(Assembly assembly, string assemblyName)
// var textBox = Auga.API.ComplexTooltip_AddTwoColumnTextBox(complexTooltip);
// magicItemText = magicItemText.Replace("\n\n", "");
// Auga.API.TooltipTextBox_AddLine(textBox, magicItemText);
-
+
// if (magicItem.IsLegendarySetItem())
// {
// var textBox2 = Auga.API.ComplexTooltip_AddTwoColumnTextBox(complexTooltip);
// Auga.API.TooltipTextBox_AddLine(textBox2, item.GetSetTooltip());
// }
-
+
// try
// {
// Auga.API.ComplexTooltip_SetDescription(complexTooltip,
@@ -270,13 +298,11 @@ private static void LoadEmbeddedAssembly(Assembly assembly, string assemblyName)
// }
//}
- private void AddLocalizations()
- {
+ private void AddLocalizations() {
CustomLocalization Localization = LocalizationManager.Instance.GetLocalization();
// load all localization files within the localizations directory
Log("Loading Localizations.");
- foreach (string embeddedResouce in typeof(EpicLoot).Assembly.GetManifestResourceNames())
- {
+ foreach (string embeddedResouce in typeof(EpicLoot).Assembly.GetManifestResourceNames()) {
if (!embeddedResouce.Contains("localizations")) { continue; }
string localization = ReadEmbeddedResourceFile(embeddedResouce);
// This will clean comments out of the localization files
@@ -290,57 +316,77 @@ private void AddLocalizations()
ELConfig.StartupProcessModifiedLocalizations();
}
- private static void InitializeAbilities()
- {
+ private static void InitializeAbilities() {
MagicEffectType.Initialize();
AbilitiesInitialized?.Invoke();
}
- public static void Log(string message)
- {
- if (ELConfig._loggingEnabled.Value && ELConfig._logLevel.Value <= LogLevel.Info)
- {
- _instance.Logger.LogInfo(message);
+ private static BepInEx.Logging.ManualLogSource _fallbackLogSink;
+
+ ///
+ /// Where every Log* below writes. Falls back to a standalone log source when
+ private static BepInEx.Logging.ManualLogSource LogSink =>
+ _instance != null
+ ? _instance.Logger
+ : _fallbackLogSink ??= BepInEx.Logging.Logger.CreateLogSource(DisplayName);
+
+ ///
+ /// Gate for the level-filtered Log* helpers. Both config entries are bound in
+ /// ELConfig.CreateConfigValues, but these helpers run from Harmony prefixes on hot vanilla methods
+ /// (Inventory.AddItem among them), so an unguarded deref here does not merely lose a log line - it
+ /// throws out of the vanilla method that was running. An unbound config logs rather than staying
+ /// silent, since that state is itself worth seeing.
+ ///
+ private static bool ShouldLog(LogLevel level) {
+ BepInEx.Configuration.ConfigEntry enabled = ELConfig._loggingEnabled;
+ BepInEx.Configuration.ConfigEntry threshold = ELConfig._logLevel;
+ return enabled == null || threshold == null || (enabled.Value && threshold.Value <= level);
+ }
+
+ public static void Log(string message) {
+ if (ShouldLog(LogLevel.Info)) {
+ LogSink.LogInfo(message);
}
}
- public static void LogWarning(string message)
- {
- if (ELConfig._loggingEnabled.Value && ELConfig._logLevel.Value <= LogLevel.Warning)
- {
- _instance.Logger.LogWarning(message);
+ public static void LogWarning(string message) {
+ if (ShouldLog(LogLevel.Warning)) {
+ LogSink.LogWarning(message);
}
}
- public static void LogError(string message)
- {
- if (ELConfig._loggingEnabled.Value && ELConfig._logLevel.Value <= LogLevel.Error)
- {
- _instance.Logger.LogError(message);
+ public static void LogError(string message) {
+ if (ShouldLog(LogLevel.Error)) {
+ LogSink.LogError(message);
}
}
- public static void LogWarningForce(string message)
- {
- _instance.Logger.LogWarning(message);
+ public static void LogForce(string message) {
+ // Intentionally NOT gated by _loggingEnabled/_logLevel: some diagnostics must always be visible.
+ LogSink.LogInfo(message);
}
- public static void LogErrorForce(string message)
- {
- _instance.Logger.LogError(message);
+ public static void LogWarningForce(string message) {
+ LogSink.LogWarning(message);
}
- private static void LoadAssets()
- {
+ public static void LogErrorForce(string message) {
+ LogSink.LogError(message);
+ }
+
+ private static void LoadAssets() {
var assetBundle = LoadAssetBundle("epicloot");
- if (assetBundle == null)
- {
+ if (assetBundle == null) {
LogErrorForce("Unable to load asset bundle! This mod will not behave as expected!");
return;
}
EpicAssets.AssetBundle = assetBundle;
+ // Shared Common loaders (PieceLoader) resolve their prefabs through here.
+ ModContext.AssetBundle = assetBundle;
EpicAssets.EquippedSprite = assetBundle.LoadAsset("Equipped");
EpicAssets.AugaEquippedSprite = assetBundle.LoadAsset("AugaEquipped");
EpicAssets.GenericSetItemSprite = assetBundle.LoadAsset("GenericSetItemMarker");
@@ -364,6 +410,8 @@ private static void LoadAssets()
EpicAssets.AugmentItemSFX = assetBundle.LoadAsset("AugmentItem");
EpicAssets.MerchantPanel = assetBundle.LoadAsset("MerchantPanel");
+ EpicAssets.TemperPanel = assetBundle.LoadAsset("TemperPanel");
+
EpicAssets.MapIconTreasureMap = assetBundle.LoadAsset("TreasureMapIcon");
EpicAssets.MapIconBounty = assetBundle.LoadAsset("MapIconBounty");
EpicAssets.AbandonBountySFX = assetBundle.LoadAsset("AbandonBounty");
@@ -372,6 +420,13 @@ private static void LoadAssets()
EpicAssets.DebugTextPrefab = assetBundle.LoadAsset("DebugText");
EpicAssets.AbilityBar = assetBundle.LoadAsset("AbilityBar");
EpicAssets.WelcomMessagePrefab = assetBundle.LoadAsset("WelcomeMessage");
+ EpicAssets.ConfigMessagePrefab = assetBundle.LoadAsset("ConfigMessage");
+ EpicAssets.SocketMessagePrefab = assetBundle.LoadAsset("SocketMessage");
+
+ // Register the frost-cone AOE effect (Ragnar set / FrostDamageAOE) so its ZNetView networks
+ // properly, and route its ripped SFX through the volume mixer once AudioMan exists (below).
+ EpicAssets.IceSpikesVFX = assetBundle.LoadAsset(FrostAOE.Attack_DoMeleeAttack_Transpiler.FxPrefabName);
+ PrefabManager.Instance.AddPrefab(new CustomPrefab(EpicAssets.IceSpikesVFX, false));
EpicAssets.BulwarkStatusEffect = assetBundle.LoadAsset(EpicAssets.Bulwark_SE_Name);
EpicAssets.BulwarkMagicShieldVFX = assetBundle.LoadAsset("MagicShield");
@@ -383,7 +438,7 @@ private static void LoadAssets()
EpicAssets.BerserkerStatusEffect = assetBundle.LoadAsset(EpicAssets.Berserker_SE_Name);
EpicAssets.BerserkerVFX = assetBundle.LoadAsset("Berserker");
- EpicAssets.BerserkerSFX = assetBundle.LoadAsset("sfx_berserker");
+ EpicAssets.BerserkerSFX = assetBundle.LoadAsset