2012-08-06 00:59:53 +00:00
|
|
|
package net.minecraftforge.oredict;
|
2012-08-01 23:35:35 +00:00
|
|
|
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.Map.Entry;
|
|
|
|
|
2013-12-23 02:25:26 +00:00
|
|
|
import cpw.mods.fml.common.FMLLog;
|
2013-12-17 01:18:48 +00:00
|
|
|
import cpw.mods.fml.common.eventhandler.Event;
|
2012-12-13 07:27:57 +00:00
|
|
|
import net.minecraft.block.Block;
|
2013-12-10 05:59:12 +00:00
|
|
|
import net.minecraft.init.Blocks;
|
|
|
|
import net.minecraft.init.Items;
|
2012-12-13 07:27:57 +00:00
|
|
|
import net.minecraft.item.Item;
|
|
|
|
import net.minecraft.item.ItemStack;
|
|
|
|
import net.minecraft.item.crafting.CraftingManager;
|
|
|
|
import net.minecraft.item.crafting.IRecipe;
|
|
|
|
import net.minecraft.item.crafting.ShapedRecipes;
|
|
|
|
import net.minecraft.item.crafting.ShapelessRecipes;
|
2012-08-06 00:59:53 +00:00
|
|
|
import net.minecraftforge.common.MinecraftForge;
|
2012-08-01 23:35:35 +00:00
|
|
|
|
|
|
|
public class OreDictionary
|
|
|
|
{
|
2012-11-13 01:07:33 +00:00
|
|
|
private static boolean hasInit = false;
|
2012-08-01 23:35:35 +00:00
|
|
|
private static int maxID = 0;
|
|
|
|
private static HashMap<String, Integer> oreIDs = new HashMap<String, Integer>();
|
|
|
|
private static HashMap<Integer, ArrayList<ItemStack>> oreStacks = new HashMap<Integer, ArrayList<ItemStack>>();
|
2013-03-11 21:43:23 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Minecraft changed from -1 to Short.MAX_VALUE in 1.5 release for the "block wildcard". Use this in case it
|
|
|
|
* changes again.
|
|
|
|
*/
|
|
|
|
public static final int WILDCARD_VALUE = Short.MAX_VALUE;
|
|
|
|
|
2012-10-28 14:24:01 +00:00
|
|
|
static {
|
|
|
|
initVanillaEntries();
|
|
|
|
}
|
|
|
|
|
2014-01-18 05:55:48 +00:00
|
|
|
@SuppressWarnings("unchecked")
|
2012-11-06 00:15:43 +00:00
|
|
|
public static void initVanillaEntries()
|
|
|
|
{
|
2012-11-13 01:07:33 +00:00
|
|
|
if (!hasInit)
|
|
|
|
{
|
2013-12-10 05:59:12 +00:00
|
|
|
registerOre("logWood", new ItemStack(Blocks.log, 1, WILDCARD_VALUE));
|
|
|
|
registerOre("logWood", new ItemStack(Blocks.log2, 1, WILDCARD_VALUE));
|
|
|
|
registerOre("plankWood", new ItemStack(Blocks.planks, 1, WILDCARD_VALUE));
|
|
|
|
registerOre("slabWood", new ItemStack(Blocks.wooden_slab, 1, WILDCARD_VALUE));
|
|
|
|
registerOre("stairWood", Blocks.oak_stairs);
|
|
|
|
registerOre("stairWood", Blocks.spruce_stairs);
|
|
|
|
registerOre("stairWood", Blocks.birch_stairs);
|
|
|
|
registerOre("stairWood", Blocks.jungle_stairs);
|
|
|
|
registerOre("stairWood", Blocks.acacia_stairs);
|
|
|
|
registerOre("stairWood", Blocks.dark_oak_stairs);
|
|
|
|
registerOre("stickWood", Items.stick);
|
|
|
|
registerOre("treeSapling", new ItemStack(Blocks.sapling, 1, WILDCARD_VALUE));
|
|
|
|
registerOre("treeLeaves", new ItemStack(Blocks.leaves, 1, WILDCARD_VALUE));
|
|
|
|
registerOre("treeLeaves", new ItemStack(Blocks.leaves2, 1, WILDCARD_VALUE));
|
|
|
|
registerOre("oreGold", Blocks.gold_ore);
|
|
|
|
registerOre("oreIron", Blocks.iron_ore);
|
|
|
|
registerOre("oreLapis", Blocks.lapis_ore);
|
|
|
|
registerOre("oreDiamond", Blocks.diamond_ore);
|
|
|
|
registerOre("oreRedstone", Blocks.redstone_ore);
|
|
|
|
registerOre("oreEmerald", Blocks.emerald_ore);
|
|
|
|
registerOre("oreQuartz", Blocks.quartz_ore);
|
|
|
|
registerOre("oreCoal", Blocks.coal_ore);
|
2014-05-24 20:01:35 +00:00
|
|
|
registerOre("blockGold", Blocks.gold_block);
|
|
|
|
registerOre("blockIron", Blocks.iron_block);
|
|
|
|
registerOre("blockLapis", Blocks.lapis_block);
|
|
|
|
registerOre("blockDiamond", Blocks.diamond_block);
|
|
|
|
registerOre("blockRedstone", Blocks.redstone_block);
|
|
|
|
registerOre("blockEmerald", Blocks.emerald_block);
|
|
|
|
registerOre("blockQuartz", Blocks.quartz_block);
|
|
|
|
registerOre("blockCoal", Blocks.coal_block);
|
|
|
|
registerOre("blockGlassColorless", Blocks.glass);
|
|
|
|
registerOre("blockGlass", Blocks.glass);
|
|
|
|
registerOre("blockGlass", new ItemStack(Blocks.stained_glass, 1, WILDCARD_VALUE));
|
|
|
|
//blockGlass{Color} is added below with dyes
|
|
|
|
registerOre("paneGlassColorless", Blocks.glass_pane);
|
|
|
|
registerOre("paneGlass", Blocks.glass_pane);
|
|
|
|
registerOre("paneGlass", new ItemStack(Blocks.stained_glass_pane, 1, WILDCARD_VALUE));
|
|
|
|
//paneGlass{Color} is added below with dyes
|
|
|
|
registerOre("ingotIron", Items.iron_ingot);
|
|
|
|
registerOre("ingotGold", Items.gold_ingot);
|
|
|
|
registerOre("ingotBrick", Items.brick);
|
|
|
|
registerOre("ingotBrickNether", Items.netherbrick);
|
|
|
|
registerOre("nuggetGold", Items.gold_nugget);
|
2014-02-28 03:48:33 +00:00
|
|
|
registerOre("gemDiamond", Items.diamond);
|
|
|
|
registerOre("gemEmerald", Items.emerald);
|
2014-05-24 20:01:35 +00:00
|
|
|
registerOre("gemQuartz", Items.quartz);
|
2014-02-28 03:48:33 +00:00
|
|
|
registerOre("dustRedstone", Items.redstone);
|
|
|
|
registerOre("dustGlowstone", Items.glowstone_dust);
|
2014-05-24 20:01:35 +00:00
|
|
|
registerOre("dustLapis", new ItemStack(Items.dye, 1, 4));
|
|
|
|
registerOre("slimeball", Items.slime_ball);
|
2014-02-28 03:48:33 +00:00
|
|
|
registerOre("glowstone", Blocks.glowstone);
|
|
|
|
registerOre("cropWheat", Items.wheat);
|
|
|
|
registerOre("cropPotato", Items.potato);
|
|
|
|
registerOre("cropCarrot", Items.carrot);
|
2013-12-10 05:59:12 +00:00
|
|
|
registerOre("stone", Blocks.stone);
|
|
|
|
registerOre("cobblestone", Blocks.cobblestone);
|
2014-05-24 20:01:35 +00:00
|
|
|
registerOre("sandstone", new ItemStack(Blocks.sandstone, 1, WILDCARD_VALUE));
|
|
|
|
registerOre("dye", new ItemStack(Items.dye, 1, WILDCARD_VALUE));
|
2013-12-10 05:59:12 +00:00
|
|
|
registerOre("record", Items.record_13);
|
|
|
|
registerOre("record", Items.record_cat);
|
|
|
|
registerOre("record", Items.record_blocks);
|
|
|
|
registerOre("record", Items.record_chirp);
|
|
|
|
registerOre("record", Items.record_far);
|
|
|
|
registerOre("record", Items.record_mall);
|
|
|
|
registerOre("record", Items.record_mellohi);
|
|
|
|
registerOre("record", Items.record_stal);
|
|
|
|
registerOre("record", Items.record_strad);
|
|
|
|
registerOre("record", Items.record_ward);
|
|
|
|
registerOre("record", Items.record_11);
|
|
|
|
registerOre("record", Items.record_wait);
|
2012-11-13 01:07:33 +00:00
|
|
|
}
|
2012-11-06 00:15:43 +00:00
|
|
|
|
|
|
|
// Build our list of items to replace with ore tags
|
|
|
|
Map<ItemStack, String> replacements = new HashMap<ItemStack, String>();
|
2013-12-10 05:59:12 +00:00
|
|
|
replacements.put(new ItemStack(Items.stick), "stickWood");
|
|
|
|
replacements.put(new ItemStack(Blocks.planks), "plankWood");
|
|
|
|
replacements.put(new ItemStack(Blocks.planks, 1, WILDCARD_VALUE), "plankWood");
|
|
|
|
replacements.put(new ItemStack(Blocks.stone), "stone");
|
|
|
|
replacements.put(new ItemStack(Blocks.stone, 1, WILDCARD_VALUE), "stone");
|
|
|
|
replacements.put(new ItemStack(Blocks.cobblestone), "cobblestone");
|
|
|
|
replacements.put(new ItemStack(Blocks.cobblestone, 1, WILDCARD_VALUE), "cobblestone");
|
2014-05-24 20:01:35 +00:00
|
|
|
replacements.put(new ItemStack(Items.gold_ingot), "ingotGold");
|
|
|
|
replacements.put(new ItemStack(Items.iron_ingot), "ingotIron");
|
2014-02-28 03:48:33 +00:00
|
|
|
replacements.put(new ItemStack(Items.diamond), "gemDiamond");
|
|
|
|
replacements.put(new ItemStack(Items.emerald), "gemEmerald");
|
|
|
|
replacements.put(new ItemStack(Items.redstone), "dustRedstone");
|
2014-02-28 07:54:50 +00:00
|
|
|
replacements.put(new ItemStack(Items.glowstone_dust), "dustGlowstone");
|
2014-02-28 03:48:33 +00:00
|
|
|
replacements.put(new ItemStack(Blocks.glowstone), "glowstone");
|
2014-05-24 20:01:35 +00:00
|
|
|
replacements.put(new ItemStack(Items.slime_ball), "slimeball");
|
|
|
|
replacements.put(new ItemStack(Blocks.glass), "blockGlassColorless");
|
2012-11-06 00:15:43 +00:00
|
|
|
|
|
|
|
// Register dyes
|
2013-03-11 21:43:23 +00:00
|
|
|
String[] dyes =
|
2012-11-06 00:15:43 +00:00
|
|
|
{
|
2014-05-24 20:01:35 +00:00
|
|
|
"Black",
|
|
|
|
"Red",
|
|
|
|
"Green",
|
|
|
|
"Brown",
|
|
|
|
"Blue",
|
|
|
|
"Purple",
|
|
|
|
"Cyan",
|
|
|
|
"LightGray",
|
|
|
|
"Gray",
|
|
|
|
"Pink",
|
|
|
|
"Lime",
|
|
|
|
"Yellow",
|
|
|
|
"LightBlue",
|
|
|
|
"Magenta",
|
|
|
|
"Orange",
|
|
|
|
"White"
|
2012-11-06 00:15:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
for(int i = 0; i < 16; i++)
|
|
|
|
{
|
2013-12-10 05:59:12 +00:00
|
|
|
ItemStack dye = new ItemStack(Items.dye, 1, i);
|
2014-05-24 20:01:35 +00:00
|
|
|
ItemStack block = new ItemStack(Blocks.stained_glass, 1, 15 - i);
|
|
|
|
ItemStack pane = new ItemStack(Blocks.stained_glass_pane, 1, 15 - i);
|
2012-11-13 01:07:33 +00:00
|
|
|
if (!hasInit)
|
|
|
|
{
|
2014-05-24 20:01:35 +00:00
|
|
|
registerOre("dye" + dyes[i], dye);
|
|
|
|
registerOre("blockGlass" + dyes[i], block);
|
|
|
|
registerOre("paneGlass" + dyes[i], pane);
|
2012-11-13 01:07:33 +00:00
|
|
|
}
|
2014-05-24 20:01:35 +00:00
|
|
|
replacements.put(dye, "dye" + dyes[i]);
|
|
|
|
replacements.put(block, "blockGlass" + dyes[i]);
|
|
|
|
replacements.put(pane, "paneGlass" + dyes[i]);
|
2012-11-06 00:15:43 +00:00
|
|
|
}
|
2012-11-13 01:07:33 +00:00
|
|
|
hasInit = true;
|
2012-11-06 00:15:43 +00:00
|
|
|
|
2013-01-02 04:57:45 +00:00
|
|
|
ItemStack[] replaceStacks = replacements.keySet().toArray(new ItemStack[replacements.keySet().size()]);
|
2012-11-06 00:15:43 +00:00
|
|
|
|
|
|
|
// Ignore recipes for the following items
|
|
|
|
ItemStack[] exclusions = new ItemStack[]
|
|
|
|
{
|
2013-12-10 05:59:12 +00:00
|
|
|
new ItemStack(Blocks.lapis_block),
|
|
|
|
new ItemStack(Items.cookie),
|
|
|
|
new ItemStack(Blocks.stonebrick),
|
2014-01-25 00:44:23 +00:00
|
|
|
new ItemStack(Blocks.stone_slab, 1, WILDCARD_VALUE),
|
2013-12-10 05:59:12 +00:00
|
|
|
new ItemStack(Blocks.stone_stairs),
|
2013-12-21 08:10:35 +00:00
|
|
|
new ItemStack(Blocks.cobblestone_wall),
|
|
|
|
new ItemStack(Blocks.oak_stairs),
|
|
|
|
new ItemStack(Blocks.spruce_stairs),
|
|
|
|
new ItemStack(Blocks.birch_stairs),
|
|
|
|
new ItemStack(Blocks.jungle_stairs),
|
|
|
|
new ItemStack(Blocks.acacia_stairs),
|
2014-05-24 20:01:35 +00:00
|
|
|
new ItemStack(Blocks.dark_oak_stairs),
|
|
|
|
new ItemStack(Blocks.glass_pane),
|
|
|
|
new ItemStack(Blocks.stained_glass)
|
2012-11-06 00:15:43 +00:00
|
|
|
};
|
|
|
|
|
2014-01-18 05:55:48 +00:00
|
|
|
List<IRecipe> recipes = CraftingManager.getInstance().getRecipeList();
|
2012-11-06 00:15:43 +00:00
|
|
|
List<IRecipe> recipesToRemove = new ArrayList<IRecipe>();
|
|
|
|
List<IRecipe> recipesToAdd = new ArrayList<IRecipe>();
|
|
|
|
|
|
|
|
// Search vanilla recipes for recipes to replace
|
|
|
|
for(Object obj : recipes)
|
|
|
|
{
|
|
|
|
if(obj instanceof ShapedRecipes)
|
|
|
|
{
|
|
|
|
ShapedRecipes recipe = (ShapedRecipes)obj;
|
|
|
|
ItemStack output = recipe.getRecipeOutput();
|
|
|
|
if (output != null && containsMatch(false, exclusions, output))
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(containsMatch(true, recipe.recipeItems, replaceStacks))
|
|
|
|
{
|
|
|
|
recipesToRemove.add(recipe);
|
|
|
|
recipesToAdd.add(new ShapedOreRecipe(recipe, replacements));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(obj instanceof ShapelessRecipes)
|
|
|
|
{
|
|
|
|
ShapelessRecipes recipe = (ShapelessRecipes)obj;
|
|
|
|
ItemStack output = recipe.getRecipeOutput();
|
|
|
|
if (output != null && containsMatch(false, exclusions, output))
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-01-02 04:57:45 +00:00
|
|
|
if(containsMatch(true, (ItemStack[])recipe.recipeItems.toArray(new ItemStack[recipe.recipeItems.size()]), replaceStacks))
|
2012-11-06 00:15:43 +00:00
|
|
|
{
|
|
|
|
recipesToRemove.add((IRecipe)obj);
|
|
|
|
IRecipe newRecipe = new ShapelessOreRecipe(recipe, replacements);
|
|
|
|
recipesToAdd.add(newRecipe);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
recipes.removeAll(recipesToRemove);
|
|
|
|
recipes.addAll(recipesToAdd);
|
2012-11-13 01:07:33 +00:00
|
|
|
if (recipesToRemove.size() > 0)
|
|
|
|
{
|
2013-12-23 02:25:26 +00:00
|
|
|
FMLLog.info("Replaced %d ore recipies", recipesToRemove.size());
|
2012-11-13 01:07:33 +00:00
|
|
|
}
|
2012-10-28 14:24:01 +00:00
|
|
|
}
|
|
|
|
|
2012-08-01 23:35:35 +00:00
|
|
|
/**
|
2013-03-11 21:43:23 +00:00
|
|
|
* Gets the integer ID for the specified ore name.
|
2012-08-01 23:35:35 +00:00
|
|
|
* If the name does not have a ID it assigns it a new one.
|
2013-03-11 21:43:23 +00:00
|
|
|
*
|
2012-08-01 23:35:35 +00:00
|
|
|
* @param name The unique name for this ore 'oreIron', 'ingotIron', etc..
|
|
|
|
* @return A number representing the ID for this ore type
|
|
|
|
*/
|
|
|
|
public static int getOreID(String name)
|
|
|
|
{
|
|
|
|
Integer val = oreIDs.get(name);
|
|
|
|
if (val == null)
|
|
|
|
{
|
|
|
|
val = maxID++;
|
|
|
|
oreIDs.put(name, val);
|
|
|
|
oreStacks.put(val, new ArrayList<ItemStack>());
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
2013-03-11 21:43:23 +00:00
|
|
|
|
2012-08-01 23:35:35 +00:00
|
|
|
/**
|
|
|
|
* Reverse of getOreID, will not create new entries.
|
2013-03-11 21:43:23 +00:00
|
|
|
*
|
2012-08-01 23:35:35 +00:00
|
|
|
* @param id The ID to translate to a string
|
|
|
|
* @return The String name, or "Unknown" if not found.
|
|
|
|
*/
|
|
|
|
public static String getOreName(int id)
|
|
|
|
{
|
|
|
|
for (Map.Entry<String, Integer> entry : oreIDs.entrySet())
|
|
|
|
{
|
|
|
|
if (id == entry.getValue())
|
|
|
|
{
|
|
|
|
return entry.getKey();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "Unknown";
|
|
|
|
}
|
2013-03-11 21:43:23 +00:00
|
|
|
|
2012-11-27 03:22:11 +00:00
|
|
|
/**
|
|
|
|
* Gets the integer ID for the specified item stack.
|
|
|
|
* If the item stack is not linked to any ore, this will return -1 and no new entry will be created.
|
|
|
|
*
|
|
|
|
* @param itemStack The item stack of the ore.
|
|
|
|
* @return A number representing the ID for this ore type, or -1 if couldn't find it.
|
|
|
|
*/
|
|
|
|
public static int getOreID(ItemStack itemStack)
|
|
|
|
{
|
2013-02-23 19:22:01 +00:00
|
|
|
if (itemStack == null)
|
|
|
|
{
|
2012-11-27 03:22:11 +00:00
|
|
|
return -1;
|
2013-02-23 19:22:01 +00:00
|
|
|
}
|
2012-11-27 03:22:11 +00:00
|
|
|
|
2013-02-23 19:22:01 +00:00
|
|
|
for(Entry<Integer, ArrayList<ItemStack>> ore : oreStacks.entrySet())
|
2012-11-27 03:22:11 +00:00
|
|
|
{
|
2013-02-23 19:22:01 +00:00
|
|
|
for(ItemStack target : ore.getValue())
|
2012-11-27 03:22:11 +00:00
|
|
|
{
|
2014-05-25 21:20:02 +00:00
|
|
|
if (itemMatches(itemStack, target, false))
|
2013-02-23 19:22:01 +00:00
|
|
|
{
|
|
|
|
return ore.getKey();
|
|
|
|
}
|
2012-11-27 03:22:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1; // didn't find it.
|
|
|
|
}
|
2013-03-11 21:43:23 +00:00
|
|
|
|
2014-05-25 21:20:02 +00:00
|
|
|
/**
|
|
|
|
* Gets all the integer ID for the ores that the specified item stakc is registered to.
|
|
|
|
* If the item stack is not linked to any ore, this will return an empty array and no new entry will be created.
|
|
|
|
*
|
|
|
|
* @param itemStack The item stack of the ore.
|
|
|
|
* @return An array of ids that this ore is registerd as.
|
|
|
|
*/
|
|
|
|
public static int[] getOreIDs(ItemStack itemStack)
|
|
|
|
{
|
|
|
|
if (itemStack == null) return new int[0];
|
|
|
|
|
|
|
|
List<Integer> ids = new ArrayList<Integer>();
|
|
|
|
for(Entry<Integer, ArrayList<ItemStack>> ore : oreStacks.entrySet())
|
|
|
|
{
|
|
|
|
for(ItemStack target : ore.getValue())
|
|
|
|
{
|
|
|
|
if (itemMatches(itemStack, target, false))
|
|
|
|
{
|
|
|
|
ids.add(ore.getKey());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int[] ret = new int[ids.size()];
|
|
|
|
for (int x = 0; x < ids.size(); x++)
|
|
|
|
ret[x] = ids.get(x);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-01 23:35:35 +00:00
|
|
|
/**
|
|
|
|
* Retrieves the ArrayList of items that are registered to this ore type.
|
|
|
|
* Creates the list as empty if it did not exist.
|
2013-03-11 21:43:23 +00:00
|
|
|
*
|
2012-09-11 20:11:17 +00:00
|
|
|
* @param name The ore name, directly calls getOreID
|
2012-08-01 23:35:35 +00:00
|
|
|
* @return An arrayList containing ItemStacks registered for this ore
|
|
|
|
*/
|
|
|
|
public static ArrayList<ItemStack> getOres(String name)
|
|
|
|
{
|
|
|
|
return getOres(getOreID(name));
|
|
|
|
}
|
2013-03-11 21:43:23 +00:00
|
|
|
|
2012-08-06 00:59:53 +00:00
|
|
|
/**
|
|
|
|
* Retrieves a list of all unique ore names that are already registered.
|
2013-03-11 21:43:23 +00:00
|
|
|
*
|
2012-08-06 00:59:53 +00:00
|
|
|
* @return All unique ore names that are currently registered.
|
|
|
|
*/
|
|
|
|
public static String[] getOreNames()
|
|
|
|
{
|
2013-01-02 04:57:45 +00:00
|
|
|
return oreIDs.keySet().toArray(new String[oreIDs.keySet().size()]);
|
2012-08-06 00:59:53 +00:00
|
|
|
}
|
2013-03-11 21:43:23 +00:00
|
|
|
|
2012-08-01 23:35:35 +00:00
|
|
|
/**
|
|
|
|
* Retrieves the ArrayList of items that are registered to this ore type.
|
|
|
|
* Creates the list as empty if it did not exist.
|
2013-03-11 21:43:23 +00:00
|
|
|
*
|
2012-08-01 23:35:35 +00:00
|
|
|
* @param id The ore ID, see getOreID
|
|
|
|
* @return An arrayList containing ItemStacks registered for this ore
|
|
|
|
*/
|
|
|
|
public static ArrayList<ItemStack> getOres(Integer id)
|
|
|
|
{
|
|
|
|
ArrayList<ItemStack> val = oreStacks.get(id);
|
|
|
|
if (val == null)
|
|
|
|
{
|
|
|
|
val = new ArrayList<ItemStack>();
|
|
|
|
oreStacks.put(id, val);
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
2012-11-06 00:15:43 +00:00
|
|
|
|
|
|
|
private static boolean containsMatch(boolean strict, ItemStack[] inputs, ItemStack... targets)
|
|
|
|
{
|
|
|
|
for (ItemStack input : inputs)
|
|
|
|
{
|
|
|
|
for (ItemStack target : targets)
|
|
|
|
{
|
|
|
|
if (itemMatches(target, input, strict))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-05-25 21:20:02 +00:00
|
|
|
private static boolean containsMatch(boolean strict, List<ItemStack> inputs, ItemStack... targets)
|
|
|
|
{
|
|
|
|
for (ItemStack input : inputs)
|
|
|
|
{
|
|
|
|
for (ItemStack target : targets)
|
|
|
|
{
|
|
|
|
if (itemMatches(target, input, strict))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-11-06 00:15:43 +00:00
|
|
|
public static boolean itemMatches(ItemStack target, ItemStack input, boolean strict)
|
|
|
|
{
|
|
|
|
if (input == null && target != null || input != null && target == null)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2013-12-10 05:59:12 +00:00
|
|
|
return (target.getItem() == input.getItem() && ((target.getItemDamage() == WILDCARD_VALUE && !strict) || target.getItemDamage() == input.getItemDamage()));
|
2012-11-06 00:15:43 +00:00
|
|
|
}
|
|
|
|
|
2012-08-01 23:35:35 +00:00
|
|
|
//Convenience functions that make for cleaner code mod side. They all drill down to registerOre(String, int, ItemStack)
|
|
|
|
public static void registerOre(String name, Item ore){ registerOre(name, new ItemStack(ore)); }
|
|
|
|
public static void registerOre(String name, Block ore){ registerOre(name, new ItemStack(ore)); }
|
|
|
|
public static void registerOre(String name, ItemStack ore){ registerOre(name, getOreID(name), ore); }
|
|
|
|
public static void registerOre(int id, Item ore){ registerOre(id, new ItemStack(ore)); }
|
|
|
|
public static void registerOre(int id, Block ore){ registerOre(id, new ItemStack(ore)); }
|
|
|
|
public static void registerOre(int id, ItemStack ore){ registerOre(getOreName(id), id, ore); }
|
2013-03-11 21:43:23 +00:00
|
|
|
|
2012-08-01 23:35:35 +00:00
|
|
|
/**
|
|
|
|
* Registers a ore item into the dictionary.
|
|
|
|
* Raises the registerOre function in all registered handlers.
|
2013-03-11 21:43:23 +00:00
|
|
|
*
|
2012-08-01 23:35:35 +00:00
|
|
|
* @param name The name of the ore
|
|
|
|
* @param id The ID of the ore
|
|
|
|
* @param ore The ore's ItemStack
|
|
|
|
*/
|
|
|
|
private static void registerOre(String name, int id, ItemStack ore)
|
|
|
|
{
|
|
|
|
ArrayList<ItemStack> ores = getOres(id);
|
2014-05-25 21:20:02 +00:00
|
|
|
if (containsMatch(false, ores, ore)) return; // Prevent duplicates.
|
2012-08-01 23:35:35 +00:00
|
|
|
ore = ore.copy();
|
|
|
|
ores.add(ore);
|
2012-08-06 02:14:02 +00:00
|
|
|
MinecraftForge.EVENT_BUS.post(new OreRegisterEvent(name, ore));
|
2012-08-06 00:59:53 +00:00
|
|
|
}
|
2013-03-11 21:43:23 +00:00
|
|
|
|
2012-08-06 00:59:53 +00:00
|
|
|
public static class OreRegisterEvent extends Event
|
|
|
|
{
|
|
|
|
public final String Name;
|
|
|
|
public final ItemStack Ore;
|
2013-03-11 21:43:23 +00:00
|
|
|
|
2012-08-06 00:59:53 +00:00
|
|
|
public OreRegisterEvent(String name, ItemStack ore)
|
2012-08-01 23:35:35 +00:00
|
|
|
{
|
2012-08-06 00:59:53 +00:00
|
|
|
this.Name = name;
|
|
|
|
this.Ore = ore;
|
2012-08-01 23:35:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|