net.minecraftforge.event.AnvilUpdateEvent Java Examples

@SubscribeEvent
public void onAnvilUpdate(AnvilUpdateEvent event)
{
    ItemStack left = event.getLeft();
    ItemStack right = event.getRight();

    if (left.getItem() instanceof IAnvilRepairable)
    {
        IAnvilRepairable repairable = (IAnvilRepairable) left.getItem();

        // Advanced Ender Alloy
        if (repairable.isRepairItem(left, right))
        {
            this.fullyRepairItem(event, repairable, 1, 15);
        }
        else if (right.getItem() == Items.ENCHANTED_BOOK)
        {
            this.enchantItem(event, repairable, (ItemEnchantedBook) right.getItem());
        }
        else
        {
            // Cancel vanilla behaviour, otherwise it would allow repairing tools with another tool (and lose the modules)
            event.setCanceled(true);
        }
    }
}
 

private void fullyRepairItem(AnvilUpdateEvent event, IAnvilRepairable repairable, int materialCost, int xpCost)
{
    ItemStack repaired = event.getLeft().copy();

    if (repairable.repairItem(repaired, -1))
    {
        event.setMaterialCost(materialCost);
        event.setCost(xpCost);
        event.setOutput(repaired);

        this.updateItemName(event, repaired);
    }
    else
    {
        event.setCanceled(true);
    }
}
 

private void updateItemName(AnvilUpdateEvent event, ItemStack outputStack)
{
    String name = event.getName();

    if (StringUtils.isBlank(name) == false)
    {
        outputStack.setStackDisplayName(name);
        event.setCost(event.getCost() + 1);
    }
    else if (outputStack.hasDisplayName())
    {
        // Remove the custom name
        outputStack.clearCustomName();
        event.setCost(event.getCost() + 1);
    }
}
 

@SubscribeEvent
public static void onAnvilChange(AnvilUpdateEvent event) {
    ItemStack firstStack = event.getLeft();
    ItemStack secondStack = event.getRight();
    if (!firstStack.isEmpty() && !secondStack.isEmpty() && firstStack.getItem() instanceof ToolMetaItem) {
        ToolMetaItem<?> toolMetaItem = (ToolMetaItem<?>) firstStack.getItem();
        MetaToolValueItem toolValueItem = toolMetaItem.getItem(firstStack);
        if (toolValueItem == null) {
            return;
        }
        SolidMaterial toolMaterial = ToolMetaItem.getToolMaterial(firstStack);
        OrePrefix solidPrefix = getSolidPrefix(toolMaterial);
        UnificationEntry unificationEntry = OreDictUnifier.getUnificationEntry(secondStack);
        double toolDamage = toolMetaItem.getItemDamage(firstStack) / (toolMetaItem.getMaxItemDamage(firstStack) * 1.0);
        double materialForFullRepair = toolValueItem.getAmountOfMaterialToRepair(firstStack);
        int durabilityPerUnit = (int) Math.ceil(toolMetaItem.getMaxItemDamage(firstStack) / materialForFullRepair);
        int materialUnitsRequired = Math.min(secondStack.getCount(), (int) Math.ceil(toolDamage * materialForFullRepair));
        int repairCost = (MathHelper.clamp(toolMaterial.harvestLevel, 2, 3) - 1) * materialUnitsRequired;

        if (toolDamage > 0.0 && materialUnitsRequired > 0 && unificationEntry != null &&
            unificationEntry.material == toolMaterial && unificationEntry.orePrefix == solidPrefix) {
            int durabilityToRegain = durabilityPerUnit * materialUnitsRequired;
            ItemStack resultStack = firstStack.copy();
            toolMetaItem.regainItemDurability(resultStack, durabilityToRegain);
            event.setMaterialCost(materialUnitsRequired);
            event.setCost(repairCost);
            event.setOutput(resultStack);
        }
    }
}
 

private boolean onAnvilChange(@Nonnull ItemStack inputItem, @Nonnull ItemStack modifierItem, String itemName, int baseCost) {
	AnvilUpdateEvent e = new AnvilUpdateEvent(inputItem, modifierItem, itemName, baseCost);
	if (MinecraftForge.EVENT_BUS.post(e)) return false;
	if (!e.getOutput().isEmpty()) {
		this.outputStack = e.getOutput();
		this.maximumCost = e.getCost();
		this.materialCost = e.getMaterialCost();
		return false;
	}
	return true;
}
 

private void enchantItem(AnvilUpdateEvent event, IAnvilRepairable repairable, ItemEnchantedBook book)
{
    ItemStack toolStack = event.getLeft().copy();
    ItemStack bookStack = event.getRight().copy();
    NBTTagList bookEnchantmentList = ItemEnchantedBook.getEnchantments(bookStack);

    if (bookEnchantmentList.tagCount() <= 0 || toolStack.getItem().isBookEnchantable(toolStack, bookStack) == false)
    {
        return;
    }

    Map<Enchantment, Integer> oldEnchantments = EnchantmentHelper.getEnchantments(toolStack);
    Map<Enchantment, Integer> bookEnchantments = EnchantmentHelper.getEnchantments(bookStack);
    Iterator<Map.Entry<Enchantment, Integer>> iterBookEnchantments = bookEnchantments.entrySet().iterator();
    int cost = oldEnchantments.size() * 2;
    boolean levelIncreased = false;

    while (iterBookEnchantments.hasNext())
    {
        Map.Entry<Enchantment, Integer> enchantmentEntry = iterBookEnchantments.next();
        Enchantment enchBook = enchantmentEntry.getKey();

        if (enchBook != null)
        {
            int oldEnchLvl = oldEnchantments.containsKey(enchBook) ? oldEnchantments.get(enchBook).intValue() : 0;
            int bookEnchLvl = enchantmentEntry.getValue();
            int newLvl = bookEnchLvl == oldEnchLvl ? oldEnchLvl + 1 : Math.max(oldEnchLvl, bookEnchLvl);
            newLvl = Math.min(newLvl, enchBook.getMaxLevel());

            if (repairable.canApplyEnchantment(toolStack, enchBook) == false)
            {
                event.setCanceled(true);
                return;
            }

            if (newLvl > oldEnchLvl)
            {
                levelIncreased = true;
            }

            Iterator<Map.Entry<Enchantment, Integer>> iterOldEnchantments = oldEnchantments.entrySet().iterator();

            // Check that the new enchantment doesn't conflict with any of the existing enchantments
            while (iterOldEnchantments.hasNext())
            {
                Enchantment enchOld = iterOldEnchantments.next().getKey();

                if (enchOld.equals(enchBook) == false && enchOld.isCompatibleWith(enchBook) == false)
                {
                    event.setCanceled(true);
                    return;
                }
            }

            oldEnchantments.put(enchBook, newLvl);
            cost += newLvl * 2;
        }
    }

    // Check that at least some new enchantments would be added, or some of the existing levels increased
    if (levelIncreased == false)
    {
        event.setCanceled(true);
        return;
    }

    EnchantmentHelper.setEnchantments(oldEnchantments, toolStack);
    event.setOutput(toolStack);
    event.setCost(cost);
    this.updateItemName(event, toolStack);
    event.setCost(Math.min(event.getCost(), 39));
}