🌸 Abloom API Mod

Overview

Abloom is a comprehensive combat modification that introduces an elemental resonance system with 14 unique elements. Each element has its own accumulation mechanics, special status effects, and strategic applications.

Key Features:

• 14 Element Types: FIRE, PHYSICAL, WIND, WATER, EARTH, ICE, ELECTRIC, ENERGY, NATURAL, QUANTUM, ETHER, LIGHT, SHADOW, PRISMATIC
• Resonance System: Accumulate elemental points through attacks to trigger powerful resonance explosions at 100 points
• 20 Status Effects: Burn, Wetness, Stun, Freeze, Shock, Break, Rupture, Bloom, Overload, Windswept, Corruption, Taunt, Dispersion, Eclipse, Critical Gain, Prism, Fluorescence, Suppression, Bleeding, Reinforcement
• Multi-Stage Weapons: Weapons can have up to 4 attack stages with different elements and accumulation multipliers
• Critical Hit System: Custom CRIT_CHANCE and CRIT_DMG attributes with weapon-specific bonuses
• Armor Resistances: Armor pieces can provide resistance or weakness to specific elements (-0.99 to 0.99)
• Elemental Projectiles: Arrows and projectiles can inherit element from shooter's weapon or be forced to specific element
• Damage Priority System: Resolve conflicts with other mods using priority-based damage modification (HIGHEST=300, HIGH=200, NORMAL=0, LOW=-100, LOWEST=-300)
• Damage Number Display: Visual feedback with configurable damage numbers and status texts
• Datapack Support: Configure weapons, armor, and mob properties without code
• Developer API: Comprehensive Java API for mod integration

Mechanics

Element Types & Resonance Effects

Damage Priority System

The damage priority system resolves conflicts when multiple mods modify damage simultaneously. Modifiers are sorted by priority (highest to lowest) and called in registration order (FIFO) for equal priorities.

Status Effects

Abloom adds 16 custom status effects that can be applied through elemental resonance or other means:

Weapon System

Weapons Registration

Weapons can be registered with elemental properties. Multi-stage weapons can have up to 4 attack stages, each with its own element type and accumulation multiplier. Stages reset after cooldown based on attack speed.

Multi-Stage Registration Example:

// Register a 2-stage weapon
ResourceLocation swordId = ResourceLocation.fromNamespaceAndPath("mymod", "dragon_sword");

// Stage 1: Fire element with 2x accumulation
ElementalWeaponRegistry.registerBuiltinWeaponWithStage(
    swordId,
    1,                              // stage number (1-4)
    ElementType.FIRE,
    2.0f,                           // accumulation multiplier
    0.15f,                          // crit chance (shared)
    0.5f                            // crit damage (shared)
);

// Stage 2: Physical element with 3x accumulation
ElementalWeaponRegistry.registerBuiltinWeaponWithStage(
    swordId,
    2,
    ElementType.PHYSICAL,
    3.0f,
    0.15f,
    0.5f
);

Single-Stage Registration Example:

For weapons that don't require multiple stages, use the simplified registration method:

// Register a simple fire staff with single-stage behavior
ResourceLocation staffId = ResourceLocation.fromNamespaceAndPath("mymod", "fire_staff");

ElementalWeaponRegistry.registerBuiltinWeapon(
    staffId,                        // weapon ID
    ElementType.FIRE,               // element type
    1.5f,                           // accumulation multiplier
    0.2f,                           // crit chance
    0.75f                           // crit damage
);

Critical Hit System

Abloom adds two custom attributes for critical hits:

Multi-Crit System

Abloom supports multi-critical hits, which deal double critical damage. The total crit chance (entity attributes + weapon values, summed additively) is clamped to a maximum of 2.0 (200%). When total crit chance exceeds 100% (1.0), any excess above 1.0 gives a chance to trigger a multi-crit, which multiplies the resulting critical damage by 2x.

Weapon Crit Values

// Get crit chance from weapon stack
float critChance = ElementalWeaponUtils.getCritChance(stack);

// Get crit damage from weapon stack
float critDamage = ElementalWeaponUtils.getCritDamage(stack);

// Register weapon with crit values
ElementalWeaponRegistry.registerWeapon(
    myItem,
    ElementType.FIRE,
    2.0f,       // accumulation
    0.25f,      // 25% crit chance
    0.75f       // 75% crit damage
);

// Get effective element type (checks enchantment override first)
ElementType element = ElementDamageHandler.getEffectiveElementType(stack);
if (element == ElementType.FIRE) {
    // Weapon has fire_aspect or flame enchantment
}

Resonance Accumulation Buildup Attribute

Abloom introduces a third custom attribute that controls how quickly elemental resonance accumulates:

How It Works

The attribute value is applied as a multiplier to the effective accumulation multiplier during damage processing. The formula is:

effectiveAccumMultiplier *= (1.0f + buildupAttributeValue);

Examples

Setting the Attribute

import net.minecraft.world.entity.ai.attributes.AttributeInstance;
import net.minecraft.world.entity.ai.attributes.Attributes;
import com.auranite.abloom.init.AbloomModAttributes;

// On entity creation or modification
Entity entity = ...;
AttributeInstance buildupAttr = entity.getAttribute(
    AbloomModAttributes.RESONANCE_ACCUMULATION_BUILDUP
);
if (buildupAttr != null) {
    // Set absolute value
    buildupAttr.setBaseValue(0.5);  // +50% accumulation

    // Or add a modifier
    buildupAttr.addPermanentModifier(
        new java.util.UUID(123456, 789012),
        "mymod.buff.resonance_boost",
        0.3,
        java.util.UUID.randomUUID()
    );
}

Resonance Frequency (Weapon Property)

Weapons can have a resonance_frequency property that increases the damage multiplier when a resonance explosion is triggered. This property is configured in the weapon's datapack JSON.

Base Multipliers by Element

Resonance Frequency Bonus Attribute

Abloom introduces the RESONANCE_FREQUENCY_BONUS attribute that modifies the resonance frequency on the entity. This allows buffs, debuffs, or equipment to increase or decrease the resonance explosion damage.

Setting the Attribute

import com.auranite.abloom.init.AbloomModAttributes;

// Add +50 resonance frequency bonus to attacker
Entity attacker = ...;
AttributeInstance rfBonus = attacker.getAttribute(
    AbloomModAttributes.RESONANCE_FREQUENCY_BONUS
);
if (rfBonus != null) {
    rfBonus.setBaseValue(50);  // +50 resonance frequency
}

// Remove resonance frequency bonus
if (rfBonus != null) {
    rfBonus.setBaseValue(0);
}

Elemental Damage Bonus Attributes

Abloom adds 14 new attributes that directly modify damage for each element type. Each attribute has a range of -1.0 to 1.0, representing -100% to +100% damage modifier.

How It Works

Each attribute value is applied as a multiplier to the final damage for that specific element. The formula is:

finalDamage *= (1.0f + elementDmgBonusValue);
// Example: fire_dmg_bonus = 0.3 → finalDamage *= 1.3 (+30% fire damage)
// Example: ice_dmg_bonus = -0.5 → finalDamage *= 0.5 (-50% ice damage)

Setting the Attribute

import com.auranite.abloom.init.AbloomModAttributes;

// Set fire damage bonus on an entity
Entity entity = ...;
AttributeInstance fireBonus = entity.getAttribute(
    AbloomModAttributes.FIRE_DMG_BONUS
);
if (fireBonus != null) {
    fireBonus.setBaseValue(0.5);  // +50% fire damage
}

// Set multiple element bonuses
AttributeInstance iceBonus = entity.getAttribute(
    AbloomModAttributes.ICE_DMG_BONUS
);
if (iceBonus != null) {
    iceBonus.setBaseValue(-0.3);  // -30% ice damage (vulnerability)
}

Elemental Resistance Modifier Attributes

Abloom adds 14 new attributes that directly modify elemental resistance for each element type. Each attribute has a range of -1.0 to 1.0, representing ±100% resistance modifier.

How It Works

Each attribute value is added to the base resistance value from the target's elemental tags. The formula is:

effectiveResist = baseResist + resistModValue;
damageMultiplier = 1.0 - effectiveResist;
// Example: baseResist = 0.5 (50% resist), resistMod = -0.3 → effectiveResist = 0.2 → multiplier = 0.8 (+60% damage taken)
// Example: baseResist = 0.0, resistMod = 0.4 → effectiveResist = 0.4 → multiplier = 0.6 (+40% resistance)

Setting the Attribute

import com.auranite.abloom.init.AbloomModAttributes;

// Set fire resistance modifier on an entity
Entity entity = ...;
AttributeInstance fireResist = entity.getAttribute(
    AbloomModAttributes.FIRE_RESIST_MOD
);
if (fireResist != null) {
    fireResist.setBaseValue(0.3);  // +30% fire resistance
}

// Reduce ice resistance (make entity more vulnerable)
AttributeInstance iceResist = entity.getAttribute(
    AbloomModAttributes.ICE_RESIST_MOD
);
if (iceResist != null) {
    iceResist.setBaseValue(-0.2);  // -20% ice resistance
}

Elemental Resistance Shred Attributes

Abloom adds 14 new attributes that shred (reduce) the target's effective resistance. Each attribute has a range of 0 to 1, representing 0% to 100% resistance shred.

How It Works

Each attribute value is subtracted from the effective resistance, reducing it directly. The formula is:

effectiveResist = (R_resist + R_mod + R_armor) − resShredValue;
// Example: effectiveResist = 0.5 − 0.3 = 0.2 (20% resist instead of 50% → 80% damage taken)

Setting the Attribute

import com.auranite.abloom.init.AbloomModAttributes;

// Set fire resistance shred on an attacker
Entity attacker = ...;
AttributeInstance fireShred = attacker.getAttribute(
    AbloomModAttributes.FIRE_RES_SHRED
);
if (fireShred != null) {
    fireShred.setBaseValue(0.3);  // 30% fire resistance shred
}

// Reduce target's ice resistance by 50%
AttributeInstance iceShred = attacker.getAttribute(
    AbloomModAttributes.ICE_RES_SHRED
);
if (iceShred != null) {
    iceShred.setBaseValue(0.5);  // 50% ice resistance shred
}

Enchantment-Based Damage Type Override

Abloom supports overriding a weapon's elemental damage type through enchantments. This allows weapons to deal different elements based on enchantments like fire_aspect or flame, without requiring custom enchantment classes.

How It Works

The damage handler checks all enchantments on the attacker's main hand and offhand weapons before checking weapon registration or datapack configs. If a matching enchantment is found, its mapped ElementType overrides the weapon's default element. The mapping is stored in a public static final ConcurrentHashMap in ElementDamageHandler, making it directly accessible for other mods to extend.

Built-in Mappings

Registering Custom Enchantments (For Other Mods)

Other mods can register their custom enchantments to map to Abloom elements by directly adding entries to the public ENCHANTMENT_ELEMENT_MAP in ElementDamageHandler. Since the map is a public static final ConcurrentHashMap, no reflection is needed.

package com.example.mymod;

import com.auranite.abloom.handler.ElementDamageHandler;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.item.enchantment.Enchantment;
import net.minecraftforge.registries.DeferredRegister;
import net.minecraftforge.registries.ForgeRegistries;
import net.minecraftforge.registries.RegistryObject;

public class MyModEnchantments {

    // Register your custom enchantment normally
    public static final DeferredRegister ENCHANTMENTS =
        DeferredRegister.create(ForgeRegistries.ENCHANTMENTS, "mymod");

    public static final RegistryObject ICE_ASPECT =
        ENCHANTMENTS.register("ice_aspect", () -> new IceAspectEnchantment());

    public static final RegistryObject ELECTRIC_ASPECT =
        ENCHANTMENTS.register("electric_aspect", () -> new ElectricAspectEnchantment());

    /**
     * Called during mod initialization to register enchantment-to-element mappings.
     * Directly accesses Abloom's public ENCHANTMENT_ELEMENT_MAP (ConcurrentHashMap).
     */
    public static void registerEnchantmentMappings() {
        // Map custom enchantments to element types
        ResourceLocation iceAspectId = ResourceLocation.fromNamespaceAndPath("mymod", "ice_aspect");
        ElementDamageHandler.ENCHANTMENT_ELEMENT_MAP.put(
            iceAspectId,
            com.auranite.abloom.util.ElementType.ICE
        );

        ResourceLocation electricAspectId = ResourceLocation.fromNamespaceAndPath("mymod", "electric_aspect");
        ElementDamageHandler.ENCHANTMENT_ELEMENT_MAP.put(
            electricAspectId,
            com.auranite.abloom.util.ElementType.ELECTRIC
        );

        // Example: Map a thunder enchantment to ELECTRIC
        ResourceLocation thunderId = ResourceLocation.fromNamespaceAndPath("mymod", "thunder_strike");
        ElementDamageHandler.ENCHANTMENT_ELEMENT_MAP.put(
            thunderId,
            com.auranite.abloom.util.ElementType.ELECTRIC
        );
    }
}

Combat API

Dealing Elemental Damage

// Deal elemental damage
ElementDamageHandler.dealElementDamage(target, ElementType.FIRE, 10.0f);

// Deal with custom accumulation multiplier
ElementDamageHandler.dealElementDamage(target, ElementType.FIRE, 10.0f, 2.0f, attacker);

// Deal with specific accumulation points
ElementDamageHandler.dealElementDamage(target, ElementType.FIRE, 10.0f, 50);

// Instant damage (bypasses some modifiers)
ElementDamageHandler.applyElementalDamageInstant(target, source, ElementType.FIRE, 10.0f, 1.0f);

Managing Accumulation Points

// Add accumulation points
ElementDamageHandler.addElementPoints(entity, ElementType.FIRE, 25);

// Get current points
int points = ElementDamageHandler.getElementPoints(entity, ElementType.FIRE);

// Reset specific element
ElementDamageHandler.resetElementPoints(entity, ElementType.FIRE);

// Reset all elements
ElementDamageHandler.resetAllElementPoints(entity);

// Get progress (0-100%)
int progress = ElementDamageHandler.getAccumulationProgress(entity, ElementType.FIRE);

Elemental Projectiles

// Register projectile by entity type
ElementalProjectileRegistry.registerProjectile(EntityType.ARROW, ElementType.FIRE, 1.5f);

// Register by class
ElementalProjectileRegistry.registerProjectileByClass(
    MyCustomProjectile.class,
    ElementType.ICE,
    2.0f
);

// Check if elemental
boolean isElemental = ElementalProjectileRegistry.isElementalProjectile(projectile);

// Get element from projectile
Optional<ElementType> element = ElementalProjectileRegistry.getElementForEntity(projectile);

// Create and launch elemental projectile
Arrow projectile = ElementalProjectileRegistry.createAndLaunchElementalProjectile(
    level,
    shooter,
    EntityType.ARROW,
    1.5f,   // velocity
    0.1f    // inaccuracy
);

// Force specific element (overrides shooter's weapon)
Arrow projectile = ElementalProjectileRegistry.createElementalProjectileWithOverride(
    level,
    shooter,
    EntityType.ARROW,
    ElementType.FIRE,  // forced element
    1.5f,
    0.1f
);

// Enable/disable inheriting element from shooter (default: true)
ElementalProjectileRegistry.setInheritElementFromShooter(true);

Armor Resistances

// Register armor with single resistance
ArmorResistanceRegistry.registerArmor(myArmor, ElementType.FIRE, 0.3f);

// Register with multiple resistances
Map<ElementType, Float> resistances = Map.of(
    ElementType.FIRE, 0.3f,
    ElementType.WATER, 0.2f,
    ElementType.ICE, 0.4f
);
ArmorResistanceRegistry.registerArmor(myArmor, resistances);

// Low-level component API
ItemStack resistantStack = ElementalResistanceComponent.withResistance(
    stack,
    ElementType.FIRE,
    0.3f
);

// Get resistance value
float fireRes = ElementalResistanceComponent.getResistance(stack, ElementType.FIRE);

// Get all resistances
Map<ElementType, Float> allResistances = ElementalResistanceComponent.getAllResistances(stack);

Checking Resistances

// Get entity resistance
ElementResistanceManager.Resistance resistance =
    ElementResistanceManager.getResistance(entity, ElementType.FIRE);

// Check if has resistance
boolean hasResistance = ElementResistanceManager.hasResistanceFor(entity, ElementType.FIRE);

// Check if weak to element
boolean isWeak = ElementResistanceManager.isWeakness(entity, ElementType.FIRE);

// Check if immune
boolean isImmune = ElementResistanceManager.isImmune(entity, ElementType.FIRE);

// Calculate reduced damage
float reducedDamage = ElementResistanceManager.calculateReducedDamage(
    entity,
    ElementType.FIRE,
    10.0f
);

// Calculate accumulation points (takes resistance into account)
int points = ElementResistanceManager.calculateAccumulationPoints(
    entity,
    ElementType.FIRE,
    10
);

Damage Display

// Check if damage numbers enabled
boolean enabled = AbloomConfig.areDamageNumbersEnabled();

// Check if status texts enabled
boolean statusEnabled = AbloomConfig.areStatusTextsEnabled();

// Spawn damage number
ElementDamageDisplayManager displayManager = new ElementDamageDisplayManager();
displayManager.spawnDamageNumber(entity, 10.5f, ElementType.FIRE);

// Spawn status text
displayManager.spawnStatusText(
    entity,
    Component.translatable("elemental.tooltip.overheating"),
    0xFF5500
);

Mod Integration

Damage Modification System

Register damage modifiers with priorities to integrate with Abloom's damage pipeline:

// Register modifier with explicit priority
DamageModificationManager.registerModifier(myModifier, 200);  // HIGH - before Abloom
DamageModificationManager.registerModifier(myModifier, -100); // LOW - after Abloom

// Register with default priority (0 = NORMAL)
DamageModificationManager.registerModifier(myModifier);

// Process damage manually
float highPriorityDamage = DamageModificationManager.processHighPriorityDamage(
    target,
    source,
    baseDamage
);

float lowPriorityDamage = DamageModificationManager.processLowPriorityDamage(
    target,
    source,
    currentDamage
);

// Debug: get registered modifier count
int count = DamageModificationManager.getRegisteredModifierCount();

Entity Resistance Tags

Use predefined tags to register mob resistances in datapacks:

// Available tag keys
Tags.FIRE_RESISTANCE      Tags.FIRE_WEAKNESS
Tags.WATER_RESISTANCE     Tags.WATER_WEAKNESS
Tags.EARTH_RESISTANCE     Tags.EARTH_WEAKNESS
Tags.WIND_RESISTANCE      Tags.WIND_WEAKNESS
Tags.ICE_RESISTANCE       Tags.ICE_WEAKNESS
Tags.ELECTRIC_RESISTANCE  Tags.ELECTRIC_WEAKNESS
Tags.PHYSICAL_RESISTANCE  Tags.PHYSICAL_WEAKNESS
Tags.NATURAL_RESISTANCE   Tags.NATURAL_WEAKNESS
Tags.QUANTUM_RESISTANCE   Tags.QUANTUM_WEAKNESS
Tags.ETHER_RESISTANCE     Tags.ETHER_WEAKNESS
Tags.LIGHT_RESISTANCE     Tags.LIGHT_WEAKNESS
Tags.SHADOW_RESISTANCE    Tags.SHADOW_WEAKNESS

Complete Integration Example

package com.example.mymod;

import com.auranite.abloom.*;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.Rarity;

public class MyModElements {

    public static final Item DRAGON_SWORD = new Item(new Item.Properties().rarity(Rarity.RARE));
    public static final Item ICE_BOW = new Item(new Item.Properties().rarity(Rarity.RARE));
    public static final Item IRON_CHESTPLATE = new Item(new Item.Properties().rarity(Rarity.COMMON));

    public static void init() {
        // Register elemental weapons
        registerElementalWeapons();

        // Register armor resistances
        registerArmorResistances();

        // Register projectiles
        registerProjectiles();
    }

    private static void registerElementalWeapons() {
        // Dragon sword: fire damage with 3x accumulation, 20% crit chance, 60% crit damage
        ElementalWeaponRegistry.registerBuiltinWeapon(
            DRAGON_SWORD,
            ElementType.FIRE,
            3.0f,
            0.2f,
            0.6f
        );

        // Ice bow: ice damage with 2x accumulation
        ElementalWeaponRegistry.registerBuiltinWeapon(
            ICE_BOW,
            ElementType.ICE,
            2.0f,
            0.05f,
            0.5f
        );
    }

    private static void registerArmorResistances() {
        // Iron chestplate: 30% fire resistance
        ArmorResistanceRegistry.registerArmor(
            IRON_CHESTPLATE,
            ElementType.FIRE,
            0.3f
        );
    }

    private static void registerProjectiles() {
        // Fireball projectiles: fire-elemental
        ElementalProjectileRegistry.registerProjectile(
            EntityType.FIREBALL,
            ElementType.FIRE,
            1.5f
        );

        // Arrows inherit element from shooter's weapon
        ElementalProjectileRegistry.setInheritElementFromShooter(true);
    }
}

Datapack Configuration

Directory Structure

your_datapack.zip
└── data
    └── abloom
        ├── damage_type/           # Custom damage types (optional)
        ├── elemental_weapons/     # Elemental weapon configurations
        ├── armor_resistances/     # Armor resistance configurations
        └── tags
            └── entity_type
                └── element_resistance/  # Mob elemental properties
                    ├── fire/
                    │   ├── resistance.json
                    │   └── weakness.json
                    └── [other elements]/

Elemental Weapons Configuration

Weapons can be configured with or without attack stages. Multi-stage weapons deal different element types and accumulation values per hit, while single-element weapons maintain consistent behavior.

Multi-Stage Weapon Example

Weapons can have multiple attack stages with different elements and accumulation multipliers:

{
  "item": "abloom:fire_stick",
  "stages": {
    "1": {
      "element": "PHYSICAL",
      "accumulation_multiplier": 10.0
    },
    "2": {
      "element": "PHYSICAL",
      "accumulation_multiplier": 10.0
    },
    "3": {
      "element": "FIRE",
      "accumulation_multiplier": 15.0
    },
    "4": {
      "element": "FIRE",
      "accumulation_multiplier": 35.0
    }
  },
  "base_element": "FIRE",
  "crit_chance": 0.5,
  "crit_damage": 1.0,
  "resonance_frequency": 125
}

Fields:

• item: Item ID (namespace:item_id)
• stages: Attack stages with element type and accumulation multiplier
  • Stage numbers must be sequential (1, 2, 3, 4...)
  • element: Element type for this stage (FIRE, WATER, ICE, etc.)
  • accumulation_multiplier: How much resonance points this stage adds
• base_element: Default element type of the weapon
• crit_chance: Critical hit chance (0.0 to 1.0)
• crit_damage: Critical hit damage multiplier (1.0 = 100% extra damage)
• resonance_frequency: Resonance frequency that increases resonance explosion damage multiplier (1 unit = 0.01 multiplier, e.g. 125 → +125% resonance explosion damage)

Example Breakdown: The fire_stick example shows a 4-stage weapon:

• Stages 1-2: PHYSICAL damage with low accumulation (10.0 each)
• Stage 3: FIRE damage with medium accumulation (15.0)
• Stage 4: FIRE damage with high accumulation (35.0)
• 50% crit chance with 100% extra crit damage
• Base element is FIRE for resistance calculations
• resonance_frequency: 125 (adds +125% to FIRE resonance explosion damage multiplier, FIRE: 2.0 + 1.25 = 3.25 = 325%)

Single-Element Weapon Example (No Stages)

For simpler weapons that always deal the same element type without stage progression:

{
  "item": "abloom:water_blade",
  "base_element": "WATER",
  "accumulation_multiplier": 12.0,
  "crit_chance": 0.3,
  "crit_damage": 0.8,
  "resonance_frequency": 150
}

Fields for Single-Element Weapons:

• item: Item ID (namespace:item_id)
• base_element: Element type for all attacks (required)
• accumulation_multiplier: Resonance points added per hit (required when no stages)
• crit_chance: Critical hit chance (optional, defaults to 0.0)
• crit_damage: Critical hit damage multiplier (optional, defaults to 0.0)
• resonance_frequency: Resonance frequency that increases resonance explosion damage multiplier (1 unit = 0.01 multiplier, e.g. 150 → +150% resonance explosion damage)

Armor Resistances Configuration

{
  "item": "minecraft:leather_helmet",
  "resistances": {
    "ELECTRIC": 0.02,
    "ICE": 0.01
  }
}

Mob Elemental Properties

// data/abloom/tags/entity_type/element_resistance/fire/resistance.json
{
  "replace": false,
  "values": [
    "minecraft:blaze",
    "minecraft:magma_cube",
    "minecraft:wither",
    "minecraft:ender_dragon"
  ]
}

// data/abloom/tags/entity_type/element_resistance/fire/weakness.json
{
  "replace": false,
  "values": [
    "minecraft:snow_golem",
    "minecraft:dolphin",
    "minecraft:zombie",
    "minecraft:zombie_villager"
  ]
}

Loading Datapacks

1. Place your datapack in .minecraft/saves/[worldname]/datapacks/
2. Reload with /reload command
3. Check logs for confirmation messages:
   • Loaded X elemental weapon configurations from datapacks
   • Loaded X armor resistance configurations from datapacks

Custom Elemental Types

Abloom supports loading custom elemental types from datapacks. Custom elements extend the elemental system beyond the 14 built-in types, allowing mod developers and players to create new elements with unique properties, resonance effects, and visual representations.

Directory Structure

your_mod_or_datapack/
└── data
    └── your_mod_id
        └── elemental_types/     # Custom element definitions
            └── your_element.json

JSON Format

Each custom element is defined in a JSON file with the following structure:

{
  "element_id": "yourmod:custom_element",
  "override_damage_types": ["yourmod:custom_element_damage", "minecraft:generic"],
  "color": "0x2B004C",
  "element_translation_key": "element.yourmod.custom",
  "resonance_translation_key": "resonance.yourmod.custom",
  "base_element": "FIRE",
  "can_resonance_accumulation": true,
  "resonance_dmg_multiplier": 2.0,
  "dispersion_bonus": 0.25,
  "resonance_effect": {
    "effect": "yourmod:custom_resonance_effect",
    "config": {
      "duration": 100,
      "amplifier": 0
    }
  },
  "resonance_display_effect": "yourmod:custom_effect"
}

Fields Reference

Resonance Effect Configuration

The resonance_effect field defines the MobEffect applied when the element reaches 100 accumulation points:

"resonance_effect": {
  "effect": "yourmod:custom_resonance_effect",
  "config": {
    "duration": 100,
    "amplifier": 0
  }
}

Translation Keys

Custom elements support translation keys for localization. Add entries to your mod's language file:

# en_us.json
"element.yourmod.custom": "Custom Element"
"resonance.yourmod.custom": "Custom Resonance Explosion!"

# ru_ru.json
"element.yourmod.custom": "Специальный Элемент"
"resonance.yourmod.custom": "Взрыв Резонанса!"

Using Custom Elements in Code

Custom elements can be used through the IElementalType interface, which is implemented by both built-in ElementType enum values and custom CustomElementType records.

Lookup by Name

import com.auranite.abloom.util.IElementalType;
import com.auranite.abloom.util.ElementType;

// Lookup any elemental type (built-in or custom)
Optional<? extends IElementalType> customType = IElementalType.byName("VOID");
if (customType.isPresent()) {
    IElementalType type = customType.get();
    // Use with elemental damage API
    ElementDamageHandler.dealElementDamage(target, type, 10.0f);
}

Lookup by Damage Type ID

// Lookup by damage type ID (e.g., "void_dmg")
Optional<? extends IElementalType> type = IElementalType.byDamageTypeId("void_dmg");
if (type.isPresent()) {
    // Use with elemental API
}

Checking Element Type

IElementalType type = ...;

// Check if custom
if (type.isCustom()) {
    // Access custom element data
    Optional<CustomElementData> data = CustomElementRegistry.getData(type);
    if (data.isPresent()) {
        CustomElementData elementData = data.get();
        int color = elementData.color();
        double multiplier = elementData.resonanceDmgMultiplier();
        
        // Access resonance effect config
        if (elementData.resonanceEffect() != null) {
            CustomElementData.ResonanceEffectConfig resonance = elementData.resonanceEffect();
            ResourceLocation effectId = resonance.effect();
            int duration = resonance.duration();
        }
    }
}

// Get display name (works for both built-in and custom)
String displayName = type.getDisplayName();

// Get damage type ID
String damageTypeId = type.damageTypeId();

Dealing Custom Elemental Damage

import com.auranite.abloom.handler.ElementDamageHandler;
import com.auranite.abloom.util.IElementalType;

// Method 1: By name
Optional<? extends IElementalType> voidType = IElementalType.byName("VOID");
voidType.ifPresent(type -> {
    ElementDamageHandler.dealElementDamage(target, type, 15.0f, 2.0f, attacker);
});

// Method 2: From CustomElementRegistry
Optional<CustomElementData> data = CustomElementRegistry.byElementId(ResourceLocation.tryParse("yourmod:void"));
data.ifPresent(elementData -> {
    IElementalType type = ElementType.getCustomTypeByName(elementData.getElementName()).orElse(null);
    if (type != null) {
        ElementDamageHandler.dealElementDamage(target, type, 15.0f);
    }
});

Checking Custom Element Properties

import com.auranite.abloom.registries.CustomElementRegistry;
import com.auranite.abloom.datapack.CustomElementData;

// Get custom element data
Optional<CustomElementData> data = CustomElementRegistry.getData(type);
if (data.isPresent()) {
    CustomElementData elementData = data.get();
    
    // Check if can accumulate resonance
    if (elementData.canResonanceAccumulation()) {
        // Element supports resonance
    }
    
    // Get resonance multiplier
    float multiplier = CustomElementRegistry.getResonanceMultiplier(type);
    
    // Get base element (if set)
    String baseElement = CustomElementRegistry.getBaseElement(type);
    if (baseElement != null) {
        // This element uses base element's attributes and threshold multiplier
        // e.g., "FIRE" → uses fire_dmg_bonus, fire_resist_mod, FIRE threshold (2.0)
    }
    
    // Get resonance effect config
    Optional<CustomElementData.ResonanceEffectConfig> resonanceEffect = 
        CustomElementRegistry.getResonanceEffectConfig(type);
    if (resonanceEffect.isPresent()) {
        CustomElementData.ResonanceEffectConfig config = resonanceEffect.get();
        // Apply resonance effect to target
        target.addEffect(new MobEffectInstance(
            BuiltInRegistries.MOB_EFFECT.getOptional(config.effect()).orElse(null),
            config.duration(),
            config.amplifier(),
            false,
            true
        ));
    }
}

Color Format

Colors support both decimal and hex format:

// Decimal format
"color": 2891628

// Hex format (recommended for readability)
"color": "0x2B004C"

Important Notes

Example: Void Element (without base_element)

Complete example of a void element definition:

{
  "element_id": "yourmod:void",
  "override_damage_types": ["yourmod:void_damage", "minecraft:generic"],
  "color": "0x2B004C",
  "element_translation_key": "element.yourmod.void",
  "resonance_translation_key": "resonance.yourmod.void",
  "can_resonance_accumulation": true,
  "resonance_dmg_multiplier": 2.5,
  "dispersion_bonus": 0.30,
  "resonance_effect": {
    "effect": "yourmod:void_resonance",
    "config": {
      "duration": 200,
      "amplifier": 1
    }
  },
  "resonance_display_effect": "yourmod:void_resonance"
}

With corresponding translation entries:

// en_us.json
{
  "element.yourmod.void": "Void",
  "resonance.yourmod.void": "Void Resonance Explosion!",
  "effect.yourmod.void_resonance": "Void Resonance"
}

// ru_ru.json
{
  "element.yourmod.void": "Пустота",
  "resonance.yourmod.void": "Взрыв Пустоты!",
  "effect.yourmod.void_resonance": "Резонанс Пустоты"
}

Example: Blue Fire Element (with base_element)

A themed "Blue Fire" element that uses FIRE's attributes, but has its own custom resonance effect:

{
  "element_id": "yourmod:blue_fire",
  "color": "0x4488FF",
  "element_translation_key": "element.yourmod.blue_fire",
  "base_element": "FIRE",
  "resonance_dmg_multiplier": 1.5,
  "resonance_effect": {
    "effect": "yourmod:blue_burn",
    "config": {
      "duration": 240,
      "amplifier": 0
    }
  },
  "resonance_display_effect": "yourmod:blue_burn"
}

What this does:

• Damage bonus: Uses fire_dmg_bonus attribute (not blue_fire_dmg_bonus)
• Resistance: Uses fire_resist_mod and fire_res_shred attributes
• Threshold multiplier: resonance_dmg_multiplier = 1.5 (custom, overrides FIRE's default 2.0)
• Custom properties: Own resonance_dmg_multiplier (1.5) and resonance_effect (blue_burn)
• Result: Resonance explosion damage = 1.5 (blue_fire) + frequencyBonus

Example: Blue Fire Element (without resonance_dmg_multiplier)

If resonance_dmg_multiplier is omitted, it defaults to the base element's threshold multiplier:

{
  "element_id": "yourmod:blue_fire",
  "color": "0x4488FF",
  "element_translation_key": "element.yourmod.blue_fire",
  "base_element": "FIRE",
  "resonance_effect": {
    "effect": "yourmod:blue_burn",
    "config": {
      "duration": 240,
      "amplifier": 0
    }
  }
}

What this does:

• Damage bonus: Uses fire_dmg_bonus attribute
• Resistance: Uses fire_resist_mod and fire_res_shred attributes
• Threshold multiplier: resonance_dmg_multiplier defaults to 2.0 (FIRE's threshold multiplier)
• Custom properties: Own resonance_effect (blue_burn)
• Result: Resonance explosion damage = 2.0 (FIRE default) + frequencyBonus