Java OreDictionary.WILDCARD_VALUE属性代码示例

@Override
public boolean matches(ItemStack subject) {
	List<ItemStack> inputs = getOres();
	boolean useOreStackMeta = (meta == null);
	Item subjectItem = subject.getItem();
	int subjectMeta = subject.getItemDamage();

	for (ItemStack oreStack : inputs) {
		Item oreItem = oreStack.getItem();
		if (oreItem == null) continue; // ignore invalid

		int metaRequired = useOreStackMeta ? oreStack.getItemDamage() : meta;

		if (subjectItem == oreItem &&
				(subjectMeta == metaRequired || metaRequired == OreDictionary.WILDCARD_VALUE)) {
			return true;
		}
	}

	return false;
}
 

/**
 * Used to create a list of stacks, from oreDictionary
 * @param oreDictName A list of OreDictionary value you want to use
 */
public HarshenStack(String... oreDictNames) {
	for(String oreDictName : oreDictNames)
	{
		NonNullList<ItemStack> stackList = OreDictionary.getOres(oreDictName);
		if(stackList.isEmpty())
			new IllegalArgumentException("Oredictionary vaule " + oreDictName + " doesnt exist").printStackTrace(System.out);
		else
			for(ItemStack stack : stackList)
				if(stack.getMetadata() == OreDictionary.WILDCARD_VALUE)
				{
			    		NonNullList<ItemStack> innerStacklist = NonNullList.create();
			    		stack.getItem().getSubItems(CreativeTabs.SEARCH, innerStacklist);
					for(ItemStack wildStack : innerStacklist)
						this.stackList.add(stack.copy());
				}
				else
					this.stackList.add(stack);
	}
}
 

public static boolean stackEqualsNonNBT(@Nonnull ItemStack stack, @Nonnull  ItemStack other) {
    if (stack.isEmpty() && other.isEmpty())
        return true;
    if (stack.isEmpty() || other.isEmpty())
        return false;
    Item sItem = stack.getItem();
    Item oItem = other.getItem();
    if (sItem.getHasSubtypes() || oItem.getHasSubtypes()) {
        return sItem.equals(other.getItem()) &&
                (stack.getItemDamage() == other.getItemDamage() ||
                        stack.getItemDamage() == OreDictionary.WILDCARD_VALUE ||
                        other.getItemDamage() == OreDictionary.WILDCARD_VALUE);
    } else {
        return sItem.equals(other.getItem());
    }
}
 

private Pair<String, Integer> parseItemPart(String input)
{
    int meta = 0;

    if (input.contains("@"))
    {
        String metaPart = input.substring(input.lastIndexOf('@') + 1);
        input = input.substring(0, input.lastIndexOf('@'));

        if (metaPart.equalsIgnoreCase(WILDCARD_STRING))
        {
            meta = OreDictionary.WILDCARD_VALUE;
        } else
        {
            meta = Integer.parseInt(metaPart);
        }
    }

    return Pair.of(input, meta);
}
 

public static float getBoostFromBooster(ItemStack stack)
{
	if (stack == null)
	{
		return Float.NaN;
	}

	for (Map.Entry<ItemStack, Float> entry : boosterRegistry.entrySet())
	{
		ItemStack tested = entry.getKey();
		if (tested.getMetadata() == OreDictionary.WILDCARD_VALUE)
		{
			if (tested.getItem() == stack.getItem())
			{
				return entry.getValue();
			}
		}
		else
		{
			if (tested.getItem() == stack.getItem() && tested.getMetadata() == stack.getMetadata())
			{
				return entry.getValue();
			}
		}
	}

	return Float.NaN;
}
 

public int getDamage()
{
	if (isWildcard)
	{
		return OreDictionary.WILDCARD_VALUE;
	}

	return damage;
}
 

protected boolean worksWith(final Block referenceBlock, final int referenceMetadata) {
    for (ItemStack stack : blocks) {
        if (stack != null && stack.getItem() instanceof ItemBlock) {
            final ItemBlock item = (ItemBlock) stack.getItem();
            final Block supportedBlock = item.getBlock();
            final int supportedMetadata = item.getMetadata(stack.getItemDamage());
            if (referenceBlock == supportedBlock && (referenceMetadata == supportedMetadata || stack.getItemDamage() == OreDictionary.WILDCARD_VALUE)) {
                return true;
            }
        }
    }
    return false;
}
 

@ZenMethod
public static void add(IItemStack output, ILiquidStack liquid, @NotNull IItemStack stamp, @Optional IItemStack input) {
    ItemStack stack = InputHelper.toStack(input);
    ItemStack stampStack = InputHelper.toStack(stamp); //This is pointless but also the easiest way.
    ItemStampingRecipe recipe = new ItemStampingRecipe(stack,InputHelper.toFluid(liquid), EnumStampType.getType(stampStack),InputHelper.toStack(output),stack.getMetadata() != OreDictionary.WILDCARD_VALUE,stack.hasTagCompound());
    CraftTweakerAPI.apply(new Add(recipe));
}
 

public static ArrayList<ItemStack> getStacksWithWildCard(ItemStack wildCardStack)
  {
  	if(wildCardStack.getMetadata() != OreDictionary.WILDCARD_VALUE)
  		return toArray();
  	ArrayList<ItemStack> stackList = new ArrayList<>();
  	NonNullList<ItemStack> innerStacklist = NonNullList.create();
  	wildCardStack.getItem().getSubItems(CreativeTabs.SEARCH, innerStacklist);
for(ItemStack stack : innerStacklist)
	stackList.add(stack.copy());
return stackList;
  }
 

/**
 * Can the input stack be used as an input item. Returns true if the stackList ({@link HarshenStack#getStackList})
 * contains the input item.
 * @param stack the stack to test with
 * @return true if the stack can be used, false if not
 */
public boolean containsItem(ItemStack stack)
{
	for(ItemStack innerStack :  getStackList())
		if(((innerStack.getMetadata() == OreDictionary.WILDCARD_VALUE ? innerStack.getItem() == stack.getItem() : innerStack.isItemEqual(stack)) && 
				(dependOnNBT ? ItemStack.areItemStackShareTagsEqual(innerStack, stack) : true)) || (innerStack.isEmpty() && stack.isEmpty()))
			return true;
	return false;
}
 

public static boolean isSameStackForFuel(ItemStack fuel, ItemStack stack)
{
    boolean itemEqual = stack.getMetadata() == OreDictionary.WILDCARD_VALUE
                        ? fuel.isItemEqualIgnoreDurability(stack)
                        : fuel.isItemEqual(stack);

    boolean nbtEqual = !stack.hasTagCompound() || ItemStack.areItemStackTagsEqual(stack, fuel);

    return itemEqual && nbtEqual;
}
 

private boolean isCorrectItem(ItemStack eventStack)
{
    boolean itemEqual = eventStack.getMetadata() == OreDictionary.WILDCARD_VALUE
                        ? stack.isItemEqualIgnoreDurability(eventStack)
                        : stack.isItemEqual(eventStack);

    boolean nbtEqual = !eventStack.hasTagCompound() || ItemStack.areItemStackTagsEqual(eventStack, stack);

    return itemEqual && nbtEqual;
}
 

public static final boolean matches(ItemStack template, ItemStack item) {
	boolean templatePresent = template!=null && !template.isEmpty();
	boolean itemPresent     = item!=null     && !item.isEmpty();
	if (!templatePresent &&  itemPresent) return false; // Empty    !=  NonEmpty
	if ( templatePresent && !itemPresent) return false; // NonEmpty !=  Empty
	if (!templatePresent && !itemPresent) return true;  // Empty    ==  Empty
	
	if (template.getItemDamage()==OreDictionary.WILDCARD_VALUE) {
		return ItemStack.areItemsEqualIgnoreDurability(template, item) &&
				ItemStack.areItemStackTagsEqual(template, item);
	} else {
		return ItemStack.areItemsEqual(template, item) &&
				ItemStack.areItemStackTagsEqual(template, item);
	}
}
 

@Override
public boolean matches(ItemStack subject) {
	return subject.getItem() == input.getItem() &&
			(subject.getItemDamage() == input.getItemDamage() || input.getItemDamage() == OreDictionary.WILDCARD_VALUE);
}
 

@ZenMethod
public static void add(ILiquidStack output, IItemStack input) {
    ItemStack stack = InputHelper.toStack(input);
    ItemMeltingRecipe recipe = new ItemMeltingRecipe(stack,InputHelper.toFluid(output),stack.getMetadata() != OreDictionary.WILDCARD_VALUE,stack.hasTagCompound());
    CraftTweakerAPI.apply(new Add(recipe));
}