Ariel Xbox

Angelic ore Drops = Angelic residue 1-3 (depends on fortune) Crafting recipe: Get iron ingot and gold ingot. Smelt both ingots AGAIN in a BLAST FURNACE causing the ingots to turn into liquid iron and liquid gold. Mix both of the liquids to get the get "Pyrite". Then your going to smelt the angel residue to get Pure angelic residue. Combine the pure angelic residue with the pyrite to get "Divine alloy" Finally smelt this alloy in a blast furnace for 2 minutes to get a divine ingot

[Viewing 1 image]

Kodari AI
KodariMon at 12:31 am 2
DivineAlloyForge
DivineAlloyForge is a Minecraft plugin that introduces a multi-step divine ingot crafting system. Players mine angelic ore to obtain angelic residue, with drops scaling based on the Fortune enchantment. The plugin adds a unique smelting mechanic: iron and gold ingots are re-smelted in a blast furnace to produce liquid iron and liquid gold, which are then combined to create pyrite. Angelic residue is separately smelted into pure angelic residue. Players combine pure angelic residue with pyrite to form divine alloy, which undergoes a final two-minute blast furnace smelting process to yield the powerful divine ingot. The plugin includes custom recipes, liquid material handling, and progression-based crafting.
  • Add placeable Angelic Ore that drops 1–3 residue, with Fortune improving the chance of higher drops.

  • Register the refining and crafting recipes, including the two-minute blast-furnace step.

  • Add a command to obtain the ore and recipe materials for testing. The items will use vanilla appearances; matching the reference artwork would require custom assets.

Created the Angelic Ore refining chain. Use /angelic give ore to obtain placeable ore; it doesn’t generate naturally.

The items use vanilla appearances. To create custom textures or models, enable Kodari Studio under this project’s Settings → Generation, or for all projects at https://kodari.ai/settings?tab=features.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
settings.gradle
Code
4 214
src/main/java/com/kodari/angelicores/AngelicOres.java
package com.kodari.angelicores;

import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.block.Block;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockExplodeEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.inventory.BlastingRecipe;
import org.bukkit.inventory.FurnaceRecipe;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.RecipeChoice;
import org.bukkit.inventory.ShapelessRecipe;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataType;
import org.bukkit.plugin.java.JavaPlugin;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;

public final class AngelicOres extends JavaPlugin implements Listener {
    private NamespacedKey itemKey;
    private final Set<String> ores = new HashSet<>();

    @Override
    public void onEnable() {
        itemKey = new NamespacedKey(this, "item");
        ores.addAll(getConfig().getStringList("ores"));
        registerRecipes();
        Bukkit.getPluginManager().registerEvents(this, this);
    }

    @Override
    public void onDisable() {
        saveOres();
    }

    private void saveOres() {
        getConfig().set("ores", new ArrayList<>(ores));
        saveConfig();
    }

    private String locationKey(Block block) {
        return block.getWorld().getUID() + ":" + block.getX() + ":" + block.getY() + ":" + block.getZ();
    }

    private ItemStack item(String id) {
        Material material;
        String name;
        switch (id) {
            case "ore" -> { material = Material.GOLD_ORE; name = "Angelic Ore"; }
            case "residue" -> { material = Material.GLOWSTONE_DUST; name = "Angelic Residue"; }
            case "liquid_iron" -> { material = Material.IRON_NUGGET; name = "Liquid Iron"; }
            case "liquid_gold" -> { material = Material.GOLD_NUGGET; name = "Liquid Gold"; }
            case "pyrite" -> { material = Material.RAW_GOLD; name = "Pyrite"; }
            case "pure_residue" -> { material = Material.QUARTZ; name = "Pure Angelic Residue"; }
            case "alloy" -> { material = Material.RAW_IRON; name = "Divine Alloy"; }
            case "ingot" -> { material = Material.GOLD_INGOT; name = "Divine Ingot"; }
            default -> { return null; }
        }
        ItemStack stack = new ItemStack(material);
        ItemMeta meta = stack.getItemMeta();
        meta.setDisplayName("§e" + name);
        meta.getPersistentDataContainer().set(itemKey, PersistentDataType.STRING, id);
        stack.setItemMeta(meta);
        return stack;
    }

    private boolean isItem(ItemStack stack, String id) {
        return stack != null && stack.hasItemMeta()
                && id.equals(stack.getItemMeta().getPersistentDataContainer().get(itemKey, PersistentDataType.STRING));
    }

    private NamespacedKey key(String id) {
        return new NamespacedKey(this, id);
    }

    private void registerRecipes() {
        Bukkit.addRecipe(new BlastingRecipe(key("liquid_iron"), item("liquid_iron"),
                new RecipeChoice.ExactChoice(new ItemStack(Material.IRON_INGOT)), 0.0f, 100));
        Bukkit.addRecipe(new BlastingRecipe(key("liquid_gold"), item("liquid_gold"),
                new RecipeChoice.ExactChoice(new ItemStack(Material.GOLD_INGOT)), 0.0f, 100));

        ShapelessRecipe pyrite = new ShapelessRecipe(key("pyrite"), item("pyrite"));
        pyrite.addIngredient(new RecipeChoice.ExactChoice(item("liquid_iron")));
        pyrite.addIngredient(new RecipeChoice.ExactChoice(item("liquid_gold")));
        Bukkit.addRecipe(pyrite);

        Bukkit.addRecipe(new FurnaceRecipe(key("pure_residue"), item("pure_residue"),
                new RecipeChoice.ExactChoice(item("residue")), 0.0f, 200));

        ShapelessRecipe alloy = new ShapelessRecipe(key("alloy"), item("alloy"));
        alloy.addIngredient(new RecipeChoice.ExactChoice(item("pure_residue")));
        alloy.addIngredient(new RecipeChoice.ExactChoice(item("pyrite")));
        Bukkit.addRecipe(alloy);

        Bukkit.addRecipe(new BlastingRecipe(key("divine_ingot"), item("ingot"),
                new RecipeChoice.ExactChoice(item("alloy")), 0.0f, 2400));
    }

    @EventHandler(ignoreCancelled = true)
    public void onPlace(BlockPlaceEvent event) {
        if (isItem(event.getItemInHand(), "ore")) {
            ores.add(locationKey(event.getBlockPlaced()));
            saveOres();
        }
    }

    @EventHandler(ignoreCancelled = true)
    public void onBreak(BlockBreakEvent event) {
        Block block = event.getBlock();
        if (!ores.remove(locationKey(block))) return;
        saveOres();
        event.setDropItems(false);
        ItemStack tool = event.getPlayer().getInventory().getItemInMainHand();
        if (tool.getEnchantmentLevel(Enchantment.SILK_TOUCH) > 0) {
            block.getWorld().dropItemNaturally(block.getLocation(), item("ore"));
            return;
        }
        int fortune = tool.getEnchantmentLevel(Enchantment.FORTUNE);
        int amount = Math.min(3, 1 + ThreadLocalRandom.current().nextInt(fortune + 1));
        ItemStack drop = item("residue");
        drop.setAmount(amount);
        block.getWorld().dropItemNaturally(block.getLocation(), drop);
    }

    private void forgetExplodedOres(List<Block> blocks) {
        boolean changed = false;
        for (Block block : blocks) changed |= ores.remove(locationKey(block));
        if (changed) saveOres();
    }

    @EventHandler(ignoreCancelled = true)
    public void onBlockExplode(BlockExplodeEvent event) {
        forgetExplodedOres(event.blockList());
    }

    @EventHandler(ignoreCancelled = true)
    public void onEntityExplode(EntityExplodeEvent event) {
        forgetExplodedOres(event.blockList());
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (!(sender instanceof Player player)) {
            sender.sendMessage("Only players can receive items.");
            return true;
        }
        if (args.length < 2 || args.length > 3 || !args[0].equalsIgnoreCase("give")) return false;
        ItemStack stack = item(args[1].toLowerCase(Locale.ROOT));
        if (stack == null) return false;
        int amount = 1;
        if (args.length == 3) {
            try {
                amount = Integer.parseInt(args[2]);
            } catch (NumberFormatException ex) {
                sender.sendMessage("Amount must be a number from 1 to 64.");
                return true;
            }
        }
        if (amount < 1 || amount > 64) {
            sender.sendMessage("Amount must be a number from 1 to 64.");
            return true;
        }
        stack.setAmount(amount);
        player.getInventory().addItem(stack).values().forEach(leftover ->
                player.getWorld().dropItemNaturally(player.getLocation(), leftover));
        return true;
    }
}