🌸 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
• 18 Status Effects: Burn, Wetness, Stun, Freeze, Shock, Break, Rupture, Bloom, Overload, Windswept, Corruption, Taunt, Dispersion, Eclipse, Critical Gain, Prism, Fluorescence, Suppression
• 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()
    );
}

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.

Priority in Element Resolution Chain

1. Enchantment override (highest priority) — checked first
2. Elemental projectile element
3. Multi-stage weapon element
4. ElementalWeaponComponent (item component)
5. ElementalWeaponRegistry lookup
6. Vanilla damage type msgId matching
7. ElementType.fromVanillaDamageType() fallback

Built-in Mappings

Registering Custom Enchantments (For Other Mods)

Other mods can register their custom enchantments to map to Abloom elements by adding entries to the enchantment-element mapping. Currently, this requires using reflection or waiting for a public API, as the mapping is stored in a private static map in ElementDamageHandler.

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;

import java.lang.reflect.Field;
import java.util.concurrent.ConcurrentHashMap;

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.
     * Uses reflection to access Abloom's private ENCHANTMENT_ELEMENT_MAP.
     */
    public static void registerEnchantmentMappings() {
        try {
            Field mapField = ElementDamageHandler.class.getDeclaredField("ENCHANTMENT_ELEMENT_MAP");
            mapField.setAccessible(true);
            @SuppressWarnings("unchecked")
            ConcurrentHashMap<ResourceLocation, com.auranite.abloom.util.ElementType> map =
                (ConcurrentHashMap<ResourceLocation, com.auranite.abloom.util.ElementType>) mapField.get(null);

            // Map custom enchantments to element types
            ResourceLocation iceAspectId = ResourceLocation.fromNamespaceAndPath("mymod", "ice_aspect");
            map.put(iceAspectId, com.auranite.abloom.util.ElementType.ICE);

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

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

        } catch (NoSuchFieldException | IllegalAccessException e) {
            System.err.println("[MyMod] Failed to register enchantment-element mappings: " + e.getMessage());
        }
    }
}

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
}

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)

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

Single-Element Weapon Example (No Stages)

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

{
  "item": "abloom:water_blade",
  "basic_element": "WATER",
  "accumulation_multiplier": 12.0,
  "crit_chance": 0.3,
  "crit_damage": 0.8
}

Fields for Single-Element Weapons:

• item: Item ID (namespace:item_id)
• 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)

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