From 09798a74aa16316b66deddfdff5e1248be1ec14e Mon Sep 17 00:00:00 2001
From: Snogard <fulgiale@gmail.com>
Date: Sun, 9 Feb 2025 23:07:21 +0100
Subject: [PATCH] config: relics

---
 config/relics/relics/amphibian_boot.yaml      | 128 ++++++++++
 config/relics/relics/aqua_walker.yaml         |  40 ++++
 config/relics/relics/arrow_quiver.yaml        | 189 +++++++++++++++
 config/relics/relics/bastion_ring.yaml        |  48 ++++
 config/relics/relics/blazing_flask.yaml       |  77 ++++++
 config/relics/relics/chorus_inhibitor.yaml    |  57 +++++
 config/relics/relics/drowned_belt.yaml        | 136 +++++++++++
 config/relics/relics/elytra_booster.yaml      |  57 +++++
 config/relics/relics/enders_hand.yaml         |  48 ++++
 config/relics/relics/holy_locket.yaml         | 163 +++++++++++++
 config/relics/relics/horse_flute.yaml         |  51 ++++
 config/relics/relics/hunter_belt.yaml         |  65 +++++
 config/relics/relics/ice_breaker.yaml         |  85 +++++++
 config/relics/relics/ice_skates.yaml          |  85 +++++++
 config/relics/relics/infinity_ham.yaml        |  65 +++++
 config/relics/relics/jellyfish_necklace.yaml  |  75 ++++++
 config/relics/relics/leather_belt.yaml        |  39 +++
 config/relics/relics/magic_mirror.yaml        |  59 +++++
 config/relics/relics/magma_walker.yaml        |  50 ++++
 config/relics/relics/midnight_robe.yaml       | 103 ++++++++
 config/relics/relics/rage_glove.yaml          | 201 ++++++++++++++++
 config/relics/relics/reflection_necklace.yaml |  77 ++++++
 config/relics/relics/roller_skates.yaml       |  60 +++++
 config/relics/relics/shadow_glaive.yaml       | 140 +++++++++++
 config/relics/relics/space_dissector.yaml     |  59 +++++
 config/relics/relics/spatial_sign.yaml        |  41 ++++
 config/relics/relics/spore_sack.yaml          | 225 ++++++++++++++++++
 config/relics/relics/wool_mitten.yaml         |  95 ++++++++
 28 files changed, 2518 insertions(+)
 create mode 100644 config/relics/relics/amphibian_boot.yaml
 create mode 100644 config/relics/relics/aqua_walker.yaml
 create mode 100644 config/relics/relics/arrow_quiver.yaml
 create mode 100644 config/relics/relics/bastion_ring.yaml
 create mode 100644 config/relics/relics/blazing_flask.yaml
 create mode 100644 config/relics/relics/chorus_inhibitor.yaml
 create mode 100644 config/relics/relics/drowned_belt.yaml
 create mode 100644 config/relics/relics/elytra_booster.yaml
 create mode 100644 config/relics/relics/enders_hand.yaml
 create mode 100644 config/relics/relics/holy_locket.yaml
 create mode 100644 config/relics/relics/horse_flute.yaml
 create mode 100644 config/relics/relics/hunter_belt.yaml
 create mode 100644 config/relics/relics/ice_breaker.yaml
 create mode 100644 config/relics/relics/ice_skates.yaml
 create mode 100644 config/relics/relics/infinity_ham.yaml
 create mode 100644 config/relics/relics/jellyfish_necklace.yaml
 create mode 100644 config/relics/relics/leather_belt.yaml
 create mode 100644 config/relics/relics/magic_mirror.yaml
 create mode 100644 config/relics/relics/magma_walker.yaml
 create mode 100644 config/relics/relics/midnight_robe.yaml
 create mode 100644 config/relics/relics/rage_glove.yaml
 create mode 100644 config/relics/relics/reflection_necklace.yaml
 create mode 100644 config/relics/relics/roller_skates.yaml
 create mode 100644 config/relics/relics/shadow_glaive.yaml
 create mode 100644 config/relics/relics/space_dissector.yaml
 create mode 100644 config/relics/relics/spatial_sign.yaml
 create mode 100644 config/relics/relics/spore_sack.yaml
 create mode 100644 config/relics/relics/wool_mitten.yaml

diff --git a/config/relics/relics/amphibian_boot.yaml b/config/relics/relics/amphibian_boot.yaml
new file mode 100644
index 0000000..02df9c4
--- /dev/null
+++ b/config/relics/relics/amphibian_boot.yaml
@@ -0,0 +1,128 @@
+abilitiesData:
+    abilities:
+        swimming:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 35.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 15.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.01
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.005
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.25
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        slipping:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 25.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 15.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.01
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.005
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        gills:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                chance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.1
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.01
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.35
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(water|ocean|river|(?<!air)ship|aqua)[\w_\/]*': 0.025
+        minecraft:chests/buried_treasure: 0.025
diff --git a/config/relics/relics/aqua_walker.yaml b/config/relics/relics/aqua_walker.yaml
new file mode 100644
index 0000000..ddc2bec
--- /dev/null
+++ b/config/relics/relics/aqua_walker.yaml
@@ -0,0 +1,40 @@
+abilitiesData:
+    abilities:
+        walking:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                time:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 60.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 30.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(water|ocean|river|(?<!air)ship|aqua)[\w_\/]*': 0.025
+        minecraft:chests/buried_treasure: 0.025
diff --git a/config/relics/relics/arrow_quiver.yaml b/config/relics/relics/arrow_quiver.yaml
new file mode 100644
index 0000000..b677eeb
--- /dev/null
+++ b/config/relics/relics/arrow_quiver.yaml
@@ -0,0 +1,189 @@
+abilitiesData:
+    abilities:
+        receptacle:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                slots:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+        leap:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 6.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 4.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                multiplier:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.1
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+                cooldown:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 12.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 15.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+        agility:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 5
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 10
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 2
+            stats:
+                modifier:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 1.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+        rain:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 15
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 15.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 10.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.25
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                delay:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.75
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+                radius:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 3.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 20
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*village[\w_\/]*': 0.025
diff --git a/config/relics/relics/bastion_ring.yaml b/config/relics/relics/bastion_ring.yaml
new file mode 100644
index 0000000..c44afd9
--- /dev/null
+++ b/config/relics/relics/bastion_ring.yaml
@@ -0,0 +1,48 @@
+abilitiesData:
+    abilities:
+        compass:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 0
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats: {
+                }
+        trade:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 2
+            stats:
+                rolls:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 1.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(bastion|piglin)[\w_\/]*': 0.025
diff --git a/config/relics/relics/blazing_flask.yaml b/config/relics/relics/blazing_flask.yaml
new file mode 100644
index 0000000..099223b
--- /dev/null
+++ b/config/relics/relics/blazing_flask.yaml
@@ -0,0 +1,77 @@
+abilitiesData:
+    abilities:
+        bonfire:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                step:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.05
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.01
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.9
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                height:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 3.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        minecraft:chests/ruined_portal: 0.025
+        '[\w]+:chests\/[\w_\/]*(nether|hell|lava|magma|fire|burn|fortress)[\w_\/]*': 0.025
+        '[\w]+:chests\/[\w_\/]*(bastion|piglin)[\w_\/]*': 0.025
diff --git a/config/relics/relics/chorus_inhibitor.yaml b/config/relics/relics/chorus_inhibitor.yaml
new file mode 100644
index 0000000..a57d554
--- /dev/null
+++ b/config/relics/relics/chorus_inhibitor.yaml
@@ -0,0 +1,57 @@
+abilitiesData:
+    abilities:
+        blink:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                distance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 32.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 16.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                cooldown:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 10.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 5.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.5
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(end|warp)[\w_\/]*': 0.025
diff --git a/config/relics/relics/drowned_belt.yaml b/config/relics/relics/drowned_belt.yaml
new file mode 100644
index 0000000..2d3c560
--- /dev/null
+++ b/config/relics/relics/drowned_belt.yaml
@@ -0,0 +1,136 @@
+abilitiesData:
+    abilities:
+        slots:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 2
+            stats:
+                charm:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+        anchor:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                sinking:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 3.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 5.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+                slowness:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.25
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.5
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.05
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+        pressure:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.25
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        riptide:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                cooldown:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 10.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.5
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(water|ocean|river|(?<!air)ship|aqua)[\w_\/]*': 0.025
+        minecraft:chests/buried_treasure: 0.025
diff --git a/config/relics/relics/elytra_booster.yaml b/config/relics/relics/elytra_booster.yaml
new file mode 100644
index 0000000..643dfdd
--- /dev/null
+++ b/config/relics/relics/elytra_booster.yaml
@@ -0,0 +1,57 @@
+abilitiesData:
+    abilities:
+        boost:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 1.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.1
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                capacity:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 100.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 50.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.25
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(end|warp)[\w_\/]*': 0.025
diff --git a/config/relics/relics/enders_hand.yaml b/config/relics/relics/enders_hand.yaml
new file mode 100644
index 0000000..38d6ff7
--- /dev/null
+++ b/config/relics/relics/enders_hand.yaml
@@ -0,0 +1,48 @@
+abilitiesData:
+    abilities:
+        neutrality:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 0
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats: {
+                }
+        swap:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                distance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 32.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 16.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(end|warp)[\w_\/]*': 0.025
diff --git a/config/relics/relics/holy_locket.yaml b/config/relics/relics/holy_locket.yaml
new file mode 100644
index 0000000..ceb458f
--- /dev/null
+++ b/config/relics/relics/holy_locket.yaml
@@ -0,0 +1,163 @@
+abilitiesData:
+    abilities:
+        belief:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                amount:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.25
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.1
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                count:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 3.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                radius:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 6.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 3.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                capacity:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 12.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 8.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        repentance:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.2
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.1
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                radius:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 6.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        blessing:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 5
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 10
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 2
+            stats:
+                consumption:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 6.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 8.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 15
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(desert|sand|pyramid)[\w_\/]*': 0.025
diff --git a/config/relics/relics/horse_flute.yaml b/config/relics/relics/horse_flute.yaml
new file mode 100644
index 0000000..7439eea
--- /dev/null
+++ b/config/relics/relics/horse_flute.yaml
@@ -0,0 +1,51 @@
+abilitiesData:
+    abilities:
+        paddock:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 0
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats: {
+                }
+        heal:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                amount:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.1
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.01
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(mineshaft|city|stronghold)[\w_\/]*': 0.025
+        minecraft:chests/woodland_mansion: 0.025
+        '[\w]+:chests\/[\w_\/]*village[\w_\/]*': 0.025
+        '[\w]+:chests\/[\w_\/]*(pillag|outpost)[\w_\/]*': 0.025
diff --git a/config/relics/relics/hunter_belt.yaml b/config/relics/relics/hunter_belt.yaml
new file mode 100644
index 0000000..3722649
--- /dev/null
+++ b/config/relics/relics/hunter_belt.yaml
@@ -0,0 +1,65 @@
+abilitiesData:
+    abilities:
+        slots:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 2
+            stats:
+                charm:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+        training:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.25
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*village[\w_\/]*': 0.025
diff --git a/config/relics/relics/ice_breaker.yaml b/config/relics/relics/ice_breaker.yaml
new file mode 100644
index 0000000..634ebf8
--- /dev/null
+++ b/config/relics/relics/ice_breaker.yaml
@@ -0,0 +1,85 @@
+abilitiesData:
+    abilities:
+        sustainability:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                modifier:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.75
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.05
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+        impact:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.5
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.25
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                size:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.5
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.3
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(frosz?|taiga|cold|winter|snow|icey?|glac)[\w_\/]*': 0.025
+        minecraft:chests/village/village_fletcher: 0.025
+        minecraft:chests/igloo_chest: 0.025
diff --git a/config/relics/relics/ice_skates.yaml b/config/relics/relics/ice_skates.yaml
new file mode 100644
index 0000000..618ec66
--- /dev/null
+++ b/config/relics/relics/ice_skates.yaml
@@ -0,0 +1,85 @@
+abilitiesData:
+    abilities:
+        skating:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 50.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 25.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.035
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.01
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        ram:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.25
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.05
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(frosz?|taiga|cold|winter|snow|icey?|glac)[\w_\/]*': 0.025
+        minecraft:chests/village/village_fletcher: 0.025
+        minecraft:chests/igloo_chest: 0.025
diff --git a/config/relics/relics/infinity_ham.yaml b/config/relics/relics/infinity_ham.yaml
new file mode 100644
index 0000000..cb6b6a0
--- /dev/null
+++ b/config/relics/relics/infinity_ham.yaml
@@ -0,0 +1,65 @@
+abilitiesData:
+    abilities:
+        autophagy:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                feed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        infusion:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 3.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.5
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*village[\w_\/]*': 0.025
diff --git a/config/relics/relics/jellyfish_necklace.yaml b/config/relics/relics/jellyfish_necklace.yaml
new file mode 100644
index 0000000..cb80117
--- /dev/null
+++ b/config/relics/relics/jellyfish_necklace.yaml
@@ -0,0 +1,75 @@
+abilitiesData:
+    abilities:
+        unsinkable:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 0
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats: {
+                }
+        shock:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.5
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        paralysis:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 1.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.5
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(water|ocean|river|(?<!air)ship|aqua)[\w_\/]*': 0.025
+        minecraft:chests/buried_treasure: 0.025
diff --git a/config/relics/relics/leather_belt.yaml b/config/relics/relics/leather_belt.yaml
new file mode 100644
index 0000000..e31cdbb
--- /dev/null
+++ b/config/relics/relics/leather_belt.yaml
@@ -0,0 +1,39 @@
+abilitiesData:
+    abilities:
+        slots:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 2
+            stats:
+                charm:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 3.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*village[\w_\/]*': 0.025
diff --git a/config/relics/relics/magic_mirror.yaml b/config/relics/relics/magic_mirror.yaml
new file mode 100644
index 0000000..1b52a6a
--- /dev/null
+++ b/config/relics/relics/magic_mirror.yaml
@@ -0,0 +1,59 @@
+abilitiesData:
+    abilities:
+        teleport:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                distance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 1000.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 500.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.5
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                cooldown:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 120.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 60.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.05
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(mineshaft|city|stronghold)[\w_\/]*': 0.025
+        minecraft:chests/woodland_mansion: 0.025
+        '[\w]+:chests\/[\w_\/]*(pillag|outpost)[\w_\/]*': 0.025
diff --git a/config/relics/relics/magma_walker.yaml b/config/relics/relics/magma_walker.yaml
new file mode 100644
index 0000000..dc4a3c5
--- /dev/null
+++ b/config/relics/relics/magma_walker.yaml
@@ -0,0 +1,50 @@
+abilitiesData:
+    abilities:
+        heat_resistance:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 0
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats: {
+                }
+        pace:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                time:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 50.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 20.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        minecraft:chests/ruined_portal: 0.025
+        '[\w]+:chests\/[\w_\/]*(nether|hell|lava|magma|fire|burn|fortress)[\w_\/]*': 0.025
+        '[\w]+:chests\/[\w_\/]*(bastion|piglin)[\w_\/]*': 0.025
diff --git a/config/relics/relics/midnight_robe.yaml b/config/relics/relics/midnight_robe.yaml
new file mode 100644
index 0000000..bb5b00b
--- /dev/null
+++ b/config/relics/relics/midnight_robe.yaml
@@ -0,0 +1,103 @@
+abilitiesData:
+    abilities:
+        vanish:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 2
+            stats:
+                light:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+                speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.35
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.1
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.35
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        backstab:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 1.75
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.25
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                distance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 20.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 15.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.5
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(mineshaft|city|stronghold)[\w_\/]*': 0.025
+        minecraft:chests/woodland_mansion: 0.025
+        '[\w]+:chests\/[\w_\/]*(pillag|outpost)[\w_\/]*': 0.025
diff --git a/config/relics/relics/rage_glove.yaml b/config/relics/relics/rage_glove.yaml
new file mode 100644
index 0000000..0aba126
--- /dev/null
+++ b/config/relics/relics/rage_glove.yaml
@@ -0,0 +1,201 @@
+abilitiesData:
+    abilities:
+        rage:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 4.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                incoming_damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.025
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.05
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.05
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                dealt_damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.075
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.025
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        phlebotomy:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                heal:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.5E-4
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0E-4
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                attack_speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.01
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.005
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.05
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                movement_speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.025
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.01
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        spurt:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 10
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.25
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.1
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                distance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 8.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 3.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.3
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                cooldown:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 15.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 20.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.075
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 20
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        minecraft:chests/ruined_portal: 0.025
+        '[\w]+:chests\/[\w_\/]*(nether|hell|lava|magma|fire|burn|fortress)[\w_\/]*': 0.025
+        '[\w]+:chests\/[\w_\/]*(bastion|piglin)[\w_\/]*': 0.025
diff --git a/config/relics/relics/reflection_necklace.yaml b/config/relics/relics/reflection_necklace.yaml
new file mode 100644
index 0000000..2a3022b
--- /dev/null
+++ b/config/relics/relics/reflection_necklace.yaml
@@ -0,0 +1,77 @@
+abilitiesData:
+    abilities:
+        explode:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.25
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.5
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                stun:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.25
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.05
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.25
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                capacity:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 60.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 20.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.35
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        minecraft:chests/ruined_portal: 0.025
+        '[\w]+:chests\/[\w_\/]*(nether|hell|lava|magma|fire|burn|fortress)[\w_\/]*': 0.025
+        '[\w]+:chests\/[\w_\/]*(bastion|piglin)[\w_\/]*': 0.025
diff --git a/config/relics/relics/roller_skates.yaml b/config/relics/relics/roller_skates.yaml
new file mode 100644
index 0000000..65b3f86
--- /dev/null
+++ b/config/relics/relics/roller_skates.yaml
@@ -0,0 +1,60 @@
+abilitiesData:
+    abilities:
+        skating:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 35.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 15.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.005
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.001
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(mineshaft|city|stronghold)[\w_\/]*': 0.025
+        minecraft:chests/woodland_mansion: 0.025
+        '[\w]+:chests\/[\w_\/]*village[\w_\/]*': 0.025
+        '[\w]+:chests\/[\w_\/]*(pillag|outpost)[\w_\/]*': 0.025
diff --git a/config/relics/relics/shadow_glaive.yaml b/config/relics/relics/shadow_glaive.yaml
new file mode 100644
index 0000000..2809b49
--- /dev/null
+++ b/config/relics/relics/shadow_glaive.yaml
@@ -0,0 +1,140 @@
+abilitiesData:
+    abilities:
+        glaive:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                recharge:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 10.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 30.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.09
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                bounces:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 3.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+                radius:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.5
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.25
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+        saw:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 1.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.75
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                speed:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 15.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 20.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        minecraft:chests/ancient_city: 0.025
+        '[\w]+:chests\/[\w_\/]*(end|warp)[\w_\/]*': 0.025
+        minecraft:chests/ancient_city_ice_box: 0.025
+        '[\w]+:chests\/[\w_\/]*(warden|sculk|echo)[\w_\/]*': 0.025
diff --git a/config/relics/relics/space_dissector.yaml b/config/relics/relics/space_dissector.yaml
new file mode 100644
index 0000000..b6ddaf6
--- /dev/null
+++ b/config/relics/relics/space_dissector.yaml
@@ -0,0 +1,59 @@
+abilitiesData:
+    abilities:
+        dissection:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                distance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 32.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 16.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.25
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                time:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 10.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 5.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.5
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        minecraft:chests/ruined_portal: 0.025
+        '[\w]+:chests\/[\w_\/]*(nether|hell|lava|magma|fire|burn|fortress)[\w_\/]*': 0.025
+        '[\w]+:chests\/[\w_\/]*(bastion|piglin)[\w_\/]*': 0.025
diff --git a/config/relics/relics/spatial_sign.yaml b/config/relics/relics/spatial_sign.yaml
new file mode 100644
index 0000000..5f96c5d
--- /dev/null
+++ b/config/relics/relics/spatial_sign.yaml
@@ -0,0 +1,41 @@
+abilitiesData:
+    abilities:
+        seal:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                time:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 4.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.25
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 200
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(mineshaft|city|stronghold)[\w_\/]*': 0.025
+        minecraft:chests/woodland_mansion: 0.025
+        '[\w]+:chests\/[\w_\/]*(pillag|outpost)[\w_\/]*': 0.025
diff --git a/config/relics/relics/spore_sack.yaml b/config/relics/relics/spore_sack.yaml
new file mode 100644
index 0000000..9d6797b
--- /dev/null
+++ b/config/relics/relics/spore_sack.yaml
@@ -0,0 +1,225 @@
+abilitiesData:
+    abilities:
+        spore:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                duration:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 4.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.25
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+                size:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.5
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.1
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                cooldown:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 10.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 15.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: -0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+        buffer:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 5
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                chance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.075
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.025
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+                capacity:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 5.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 2.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 1.0
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: ADD
+        multiplying:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 10
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                amount:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.15
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.05
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.4
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                chance:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.15
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.05
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.128
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+                size:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.1
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.05
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1775
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_TOTAL
+        explosion:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 15
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                size:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.25
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.05
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 20
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(jungle|temple)[\w_\/]*': 0.025
diff --git a/config/relics/relics/wool_mitten.yaml b/config/relics/relics/wool_mitten.yaml
new file mode 100644
index 0000000..6fe2c37
--- /dev/null
+++ b/config/relics/relics/wool_mitten.yaml
@@ -0,0 +1,95 @@
+abilitiesData:
+    abilities:
+        mold:
+            # Highest level to which the ability can be upgraded
+            maxLevel: 10
+            # Relic level at which the ability becomes unlocked
+            requiredLevel: 0
+            # Number of leveling points needed to increase the ability level
+            requiredPoints: 1
+            stats:
+                damage:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.25
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.05
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.1
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                freeze:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 2.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 1.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.3
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                size:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 32.0
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 12.0
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.2
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+                stun:
+                    # Maximum base value of the stat. A random value within this range is assigned when the relic is first created
+                    maxInitialValue: 0.05
+                    # Maximum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    maxThresholdValue: 1.7976931348623157E308
+                    # Minimum base value of the stat. A random value within this range is assigned when the relic is first created
+                    minInitialValue: 0.025
+                    # Minimum threshold value for the stat, representing hard limits that cannot be surpassed through ability level upgrades or other methods
+                    minThresholdValue: 4.9E-324
+                    # Modifier applied to the base value of the stat, depending on the [upgradeOperation] parameter.
+                    upgradeModifier: 0.15
+                    # Type of mathematical operation used to calculate the stat's value based on the ability level. Supported operations include:
+                    # MULTIPLY_BASE: x + ((x * y) * z),
+                    # MULTIPLY_TOTAL: x * (y + 1)^z,
+                    # ADD: x + (y * z).
+                    # 
+                    # ...where x - Base stat value, y - Value of [upgradeModifier], z - Current relic level
+                    upgradeOperation: MULTIPLY_BASE
+levelingData:
+    # Amount of experience required to level up to relic level 1
+    initialCost: 100
+    # Maximum level of the relic
+    maxLevel: 10
+    # Increment in experience required for each subsequent level of the relic
+    step: 100
+lootData:
+    # List of key-value pairs where the key is a textual identifier for the loot table (supporting regular expressions) and the value represents the probability of generating the relic within the specified bounds
+    entries:
+        '[\w]+:chests\/[\w_\/]*(frosz?|taiga|cold|winter|snow|icey?|glac)[\w_\/]*': 0.025
+        minecraft:chests/village/village_fletcher: 0.025
+        minecraft:chests/igloo_chest: 0.025