minecraft-kajetans-mod/src/main/java/me/km/recipes/ModRecipes.java

package me.km.recipes;

import java.util.HashMap;
import me.km.blocks.EnumMetals;
import me.km.blocks.ModBlocks;
import me.km.items.ModItems;
import net.minecraft.block.Block;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.EnumDyeColor;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.FurnaceRecipes;
import net.minecraft.item.crafting.IRecipe;
import net.minecraft.item.crafting.Ingredient;
import net.minecraft.item.crafting.ShapedRecipes;
import net.minecraft.item.crafting.ShapelessRecipes;
import net.minecraft.util.NonNullList;
import net.minecraftforge.registries.IForgeRegistry;

public class ModRecipes 
{           
    // -----------------------------------------------------------------------------------
    // shaped recipe construction stuff
    // -----------------------------------------------------------------------------------
    
    private static ShapedRecipes newShapedRecipe(String group, String[] pattern, ItemStack result, char[] chars, ItemStack[][] stacks)
    {
        HashMap<Character, Ingredient> map = getPatternMap(chars, stacks);
        NonNullList<Ingredient> nonnulllist = getIngredientList(pattern, map);
        return new ShapedRecipes(group, pattern[0].length(), pattern.length, nonnulllist, result);
    }
    
    private static HashMap<Character, Ingredient> getPatternMap(char[] chars, ItemStack[][] stacks)
    {
        HashMap<Character, Ingredient> map = new HashMap<>();
        for(int i = 0; i < chars.length; i++)
        {
            map.put(chars[i], Ingredient.fromStacks(copyItemStack(stacks[i])));
        }
        map.put(' ', Ingredient.EMPTY);
        return map;
    }
    
    private static NonNullList<Ingredient> getIngredientList(String[] pattern, HashMap<Character, Ingredient> map)
    {
        int w = pattern[0].length();
        NonNullList<Ingredient> nonnulllist = NonNullList.<Ingredient>withSize(w * pattern.length, Ingredient.EMPTY);
        for(int i = 0; i < pattern.length; i++)
        {
            for (int j = 0; j < pattern[i].length(); j++)
            {
                nonnulllist.set(j + w * i, map.get(pattern[i].charAt(j)));
            }
        }
        return nonnulllist;
    }
    
    private static void registerShaped(IForgeRegistry<IRecipe> r, String group, String[] pattern, ItemStack result, char[] chars, ItemStack[][] stacks)
    {
        ShapedRecipes recipe = newShapedRecipe(group, pattern, result, chars, stacks);
        recipe.setRegistryName(buildRegistryName(result));
        r.register(recipe);
    }
    
    private static ShapelessRecipes newShapelessRecipe(String group, ItemStack result, ItemStack[][] stacks)
    {
        NonNullList<Ingredient> nonnulllist = NonNullList.<Ingredient>withSize(stacks.length, Ingredient.EMPTY);
        for(int i = 0; i < stacks.length; i++)
        {
            nonnulllist.set(i, Ingredient.fromStacks(copyItemStack(stacks[i])));
        }
        return new ShapelessRecipes(group, result, nonnulllist);
    }
    
    private static void registerShapeless(IForgeRegistry<IRecipe> r, String group, ItemStack result, ItemStack[][] stacks)
    {
        ShapelessRecipes recipe = newShapelessRecipe(group, result, stacks);
        recipe.setRegistryName(buildRegistryName(result));
        r.register(recipe);
    }
    
    private static void registerShapeless(IForgeRegistry<IRecipe> r, String group, ItemStack result, Item[] items)
    {
        ItemStack[][] stacks = new ItemStack[items.length][1];
        for(int i = 0; i < items.length; i++)
        {
            stacks[i][0] = new ItemStack(items[i]);
        }
        registerShapeless(r, group, result, stacks);
    }
    
    private static ItemStack[] copyItemStack(ItemStack[] stacks)
    {
        ItemStack[] copyStacks = new ItemStack[stacks.length];
        for(int i = 0; i < copyStacks.length; i++)
        {
            copyStacks[i] = stacks[i].copy();
        }
        return copyStacks;
    }
    
    private static String buildRegistryName(ItemStack stack)
    {
        id++;
        if(stack.getMetadata() != 0)
        {          
            return stack.getItem().getRegistryName().getResourcePath() + "_" + stack.getMetadata() + "_" + id;
        }
        return stack.getItem().getRegistryName().getResourcePath() + "_" + id;
    }
    
    // -----------------------------------------------------------------------------------
    // init recipes
    // -----------------------------------------------------------------------------------
    
    private static int id = 0;
    
    public static void init(IForgeRegistry<IRecipe> r) 
    {
        id = 0;
        FurnaceRecipes fr = FurnaceRecipes.instance();        
        
        // misc
        registerShapeless(r, "", new ItemStack(ModItems.bronzeIngot, 9), new Item[] 
        {
            ModItems.copperIngot, ModItems.copperIngot, ModItems.copperIngot,
            ModItems.copperIngot, ModItems.copperIngot, ModItems.copperIngot,
            ModItems.copperIngot, ModItems.copperIngot, ModItems.tinIngot
        });
        registerShapeless(r, "", new ItemStack(Items.STRING, 4), new ItemStack[][] 
        {
            {new ItemStack(Blocks.WOOL)}
        });
        registerShaped(r, "", new String[] {"XXX", "XSX", " I "}, new ItemStack(Items.SADDLE), 
                new char[] {'X', 'S', 'I'}, new ItemStack[][] 
                {
                    {new ItemStack(Items.LEATHER)},
                    {new ItemStack(Items.STRING)},
                    {new ItemStack(Items.IRON_INGOT)}
                });
        registerShaped(r, "", new String[] {"XXX", "XXX", "XXX"}, new ItemStack(ModItems.hayBundle, 9), 
                new char[] {'X'}, new ItemStack[][] {{new ItemStack(Blocks.TALLGRASS, 1, 1), new ItemStack(Blocks.TALLGRASS, 1, 2)}});
        registerShaped(r, "", new String[] {"XXX"}, new ItemStack(ModItems.realHayBed, 3), 
                new char[] {'X'}, new ItemStack[][] {{new ItemStack(ModBlocks.realHayBlock)}});
        registerShaped(r, "", new String[] {" X ", "XXX"}, new ItemStack(ModItems.strawHat), 
                new char[] {'X'}, new ItemStack[][] {{new ItemStack(Items.WHEAT)}});
        
        // traps
        addMetalRecipes(r, "", new String[] {" X ", "XXX"}, ModBlocks.spikes, 3);
        
        // furnace recipes
        fr.addSmeltingRecipeForBlock(ModBlocks.copperOre, new ItemStack(ModItems.copperIngot), 0.5f);
        fr.addSmeltingRecipeForBlock(ModBlocks.tinOre, new ItemStack(ModItems.tinIngot), 1);
        fr.addSmeltingRecipeForBlock(ModBlocks.silverOre, new ItemStack(ModItems.silverIngot), 1);
        
        // armor recipes
        Item[][] armorItems = new Item[][] 
        {
            {ModItems.copperIngot, ModItems.bronzeIngot}, 
            {ModItems.copperHelmet, ModItems.bronzeHelmet}, 
            {ModItems.copperChestplate, ModItems.bronzeChestplate}, 
            {ModItems.copperLeggings, ModItems.bronzeLeggings}, 
            {ModItems.copperBoots, ModItems.bronzeBoots}
        };
        addArmorRecipes(r, armorItems);
        
        // additionel old tool recipes
        String[][] toolPatterns = new String[][] 
        {
            {"XXX", " # ", " # "}, 
            {"X", "#", "#"}, 
            {"XX", "X#", " #"}, 
            {"XX", " #", " #"},
            {"X", "X", "#"}
        };
        Object[][] toolItems = new Object[][] 
        {
            {ModItems.copperIngot, ModItems.bronzeIngot}, 
            {ModItems.copperPickaxe, ModItems.bronzePickaxe}, 
            {ModItems.copperShovel, ModItems.bronzeShovel}, 
            {ModItems.copperAxe, ModItems.bronzeAxe}, 
            {ModItems.copperHoe, ModItems.bronzeHoe},
            {ModItems.copperSword, ModItems.bronzeSword}
        };
        addToolRecipes(r, toolPatterns, toolItems);
        
        // new tool / weapon recipes
        toolPatterns = new String[][] {{"X  ", " # ", "  X"}, {" X", "# "}, {"XXX", "X#X", " # "}};
        toolItems = new Object[][]
        {
            {Blocks.PLANKS, Blocks.COBBLESTONE, Items.IRON_INGOT, Items.DIAMOND, 
                Items.GOLD_INGOT, ModItems.copperIngot, ModItems.bronzeIngot}, 
            {ModItems.woodenStick, ModItems.stoneStick, ModItems.ironStick, ModItems.diamondStick, 
                ModItems.goldStick, ModItems.copperStick, ModItems.bronzeStick}, 
            {ModItems.woodenDagger, ModItems.stoneDagger, ModItems.ironDagger, ModItems.diamondDagger, 
                ModItems.goldDagger, ModItems.copperDagger, ModItems.bronzeDagger}, 
            {ModItems.woodenHammer, ModItems.stoneHammer, ModItems.ironHammer, ModItems.diamondHammer, 
                ModItems.goldHammer, ModItems.copperHammer, ModItems.bronzeHammer}, 
        };
        addToolRecipes(r, toolPatterns, toolItems);
        
        // wands
        toolPatterns = new String[][] {{" #X", " ##", "#  "}};
        toolItems = new Object[][] 
        {
            {Blocks.PLANKS, Blocks.COBBLESTONE, Items.IRON_INGOT, Items.DIAMOND, Items.GOLD_INGOT, 
                ModItems.copperIngot, ModItems.bronzeIngot, Items.EMERALD, Items.REDSTONE, 
                new ItemStack(Items.DYE, 1, EnumDyeColor.BLUE.getDyeDamage()), ModItems.silverIngot}, 
            {ModItems.woodenWand, ModItems.stoneWand, ModItems.ironWand, ModItems.diamondWand, ModItems.goldWand, 
                ModItems.copperWand, ModItems.bronzeWand, ModItems.emeraldWand, ModItems.redstoneWand,
                ModItems.lapisWand, ModItems.silverWand}, 
        };
        addToolRecipes(r, toolPatterns, toolItems);

        // block <-> parts <-> smaller parts recipes
        Object[][] ingotItems = new Object[][] 
        {
            {ModBlocks.copperBlock, new ItemStack(ModItems.copperIngot, 9)}, 
            {ModItems.copperIngot, new ItemStack(ModItems.copperNugget, 9)}, 
            {ModBlocks.tinBlock, new ItemStack(ModItems.tinIngot, 9)}, 
            {ModItems.tinIngot, new ItemStack(ModItems.tinNugget, 9)}, 
            {ModBlocks.bronzeBlock, new ItemStack(ModItems.bronzeIngot, 9)}, 
            {ModItems.bronzeIngot, new ItemStack(ModItems.bronzeNugget, 9)}, 
            {ModBlocks.silverBlock, new ItemStack(ModItems.silverIngot, 9)}, 
            {ModItems.silverIngot, new ItemStack(ModItems.silverNugget, 9)}, 
            {ModBlocks.realHayBlock, new ItemStack(ModItems.hayBundle, 9)}, 
        };
        addIngotRecipes(r, ingotItems);

        addNuggetRecipes(fr, toolItems, armorItems, ModItems.copperNugget, ModItems.bronzeNugget);
    }

    // -----------------------------------------------------------------------------------
    // recipe helper
    // -----------------------------------------------------------------------------------
    
    private static void addArmorRecipes(IForgeRegistry<IRecipe> r, Item[][] armorItems)
    {
        String[][] armorPatterns = new String[][] 
        {
            {"XXX", "X X"}, 
            {"X X", "XXX", "XXX"}, 
            {"XXX", "X X", "X X"}, 
            {"X X", "X X"}
        };
        char[] chars = new char[] {'X'};
        ItemStack[][] stacks = new ItemStack[][] {{ItemStack.EMPTY}};
        
        for (int i = 0; i < armorItems[0].length; ++i)
        {
            stacks[0][0] = new ItemStack(armorItems[0][i]);
            for (int j = 0; j < armorItems.length - 1; ++j)
            {
                registerShaped(r, "", armorPatterns[j], new ItemStack(armorItems[j + 1][i]), chars, stacks);
            }
        }
    }
    
    private static void addToolRecipes(IForgeRegistry<IRecipe> r, String[][] toolPatterns, Object[][] toolItems)
    {       
        char[] chars = new char[] {'#', 'X'};
        ItemStack[][] stacks = new ItemStack[][] {{new ItemStack(Items.STICK)} , {ItemStack.EMPTY}};
        
        for(int i = 0; i < toolItems[0].length; ++i)
        {
            Object object = toolItems[0][i];
            if(object instanceof Item)
            {
                stacks[1][0] = new ItemStack((Item) toolItems[0][i]);
            }
            else if(object instanceof Block)
            {
                Block b = (Block) toolItems[0][i];
                NonNullList<ItemStack> list = NonNullList.<ItemStack>create();               
                b.getSubBlocks(CreativeTabs.BUILDING_BLOCKS, list);
                stacks[1] = new ItemStack[list.size()];
                for(int k = 0; k < list.size(); k++)
                {
                    stacks[1][k] = list.get(k);
                }
            }
            else if(object instanceof ItemStack)
            {
                stacks[1][0] = (ItemStack) toolItems[0][i];
            }
            else
            {
                throw new IllegalArgumentException("only blocks or items are allowed");
            }
            for(int j = 0; j < toolItems.length - 1; ++j)
            {
                registerShaped(r, "", toolPatterns[j], new ItemStack((Item) toolItems[j + 1][i]), chars, stacks);
            }
        }
    }

    private static void addIngotRecipes(IForgeRegistry<IRecipe> r, Object[][] ingotItems)
    {
        String[] blockPattern = new String[] {"###", "###", "###"};
        String[] ingotPattern = new String[] {"#"};
        char[] chars = new char[] {'#'};
        ItemStack[][] stacks = new ItemStack[][] {{ItemStack.EMPTY}};
        
        for(Object[] aobject : ingotItems)
        {
            try
            {
                Item block = (Item) aobject[0];
                ItemStack parts = (ItemStack) aobject[1];
                ItemStack ingot = parts.copy();
                ingot.setCount(1);
                stacks[0][0] = ingot;
                registerShaped(r, "",  blockPattern, new ItemStack(block), chars, stacks);
                stacks[0][0] = new ItemStack(block);
                registerShaped(r, "", ingotPattern, parts, chars, stacks);
            }
            catch(ClassCastException ex)
            {
                Block block = (Block) aobject[0];
                ItemStack parts = (ItemStack) aobject[1];
                ItemStack ingot = parts.copy();
                ingot.setCount(1);
                stacks[0][0] = ingot;
                registerShaped(r, "", blockPattern, new ItemStack(block), chars, stacks);
                stacks[0][0] = new ItemStack(block);
                registerShaped(r, "", ingotPattern, parts, chars, stacks);
            }
        }
    }
    
    private static void addNuggetRecipes(FurnaceRecipes fr, Object[][] toolItems, Item[][] armorItems, Item... nuggets)
    {
        for(int i = 0; i < nuggets.length; i++)
        {
            for(int j = 1; j < toolItems.length; j++)
            {
                fr.addSmelting((Item) toolItems[j][i], new ItemStack(nuggets[i]), 0.1f);
            }
            for(int j = 1; j < armorItems.length; j++)
            {
                fr.addSmelting((Item) armorItems[j][i], new ItemStack(nuggets[i]), 0.1f);
            }
        }
    }
    
    private static void addMetalRecipes(IForgeRegistry<IRecipe> r, String group, String[] pattern, Item output, int amount)
    {
        char[] chars = new char[] {'X'};
        ItemStack[][] stacks = new ItemStack[][] {{ItemStack.EMPTY}};
        
        for(EnumMetals metal : EnumMetals.values())
        {
            stacks[0][0] = new ItemStack(metal.getMetalIngot());       
            registerShaped(r, group, pattern, new ItemStack(output, amount, metal.getMetadata()), chars, stacks);
        }
    }
    
    private static void addMetalRecipes(IForgeRegistry<IRecipe> r, String group, String[] patterns, Block output, int amount)
    {
        addMetalRecipes(r, group, patterns, Item.getItemFromBlock(output), amount);
    }
}