Improve backpack API and add backpack config blacklists

This commit is contained in:
mezz committed 2016-07-20 02:25:32 -07:00
1 parent f6feca096f
commit 94f751d78a
18 files changed
+627 -376

No files matched your search

@@ -5,43 +5,41 @@
******************************************************************************/
package forestry.api.storage;
import java.util.List;
import java.util.function.Predicate;
import javax.annotation.Nonnull;
import net.minecraft.item.ItemStack;
public interface IBackpackDefinition extends Predicate<ItemStack> {
/**
* To make your own backpack, create a backpack definition and register it with
* {@link IBackpackInterface#registerBackpackDefinition(String, IBackpackDefinition)}.
*/
public interface IBackpackDefinition {
/**
* @return Human-readable name of the backpack.
*/
@Nonnull
String getName(ItemStack backpack);
/**
* @return Primary colour for the backpack icon.
* @return Primary color for the backpack icon.
*/
int getPrimaryColour();
/**
* @return Secondary colour for backpack icon.
* @return Secondary color for backpack icon, normally white.
*/
int getSecondaryColour();
/**
* Adds an item as valid for this backpack.
* Filters items that can be put into a backpack.
*
* @param validItem
* For Backpack Implementers: you can create a new filter with
* {@link IBackpackInterface#createBackpackFilter()} or
* {@link IBackpackInterface#createNaturalistBackpackFilter(String)}
* or implement your own.
*
* @return the backpack's item filter.
*/
void addValidItem(ItemStack validItem);
void addValidItems(List<ItemStack> validItems);
void addValidOreDictName(String oreDictName);
/**
* Returns true if the ItemStack is a valid item for this backpack type.
*/
@Override
boolean test(ItemStack itemstack);
@Nonnull
IBackpackFilter getFilter();
}
@@ -0,0 +1,21 @@
package forestry.api.storage;
import java.util.function.Predicate;
import net.minecraft.item.ItemStack;
/**
* Filters items that can be put into a backpack.
* You can get a specific backpack's filter with {@link IBackpackDefinition#getFilter()}.
* <p>
* For Backpack Implementers: you can create a new filter with {@link IBackpackInterface#createBackpackFilter()} or implement your own.
*
* @see IBackpackFilterConfigurable
*/
public interface IBackpackFilter extends Predicate<ItemStack> {
/**
* Returns true if the ItemStack is a valid item for this backpack filter.
*/
@Override
boolean test(ItemStack itemstack);
}
@@ -0,0 +1,43 @@
package forestry.api.storage;
import net.minecraft.item.ItemStack;
import net.minecraftforge.oredict.OreDictionary;
/**
* A configurable backpack filter. Useful for implementers of {@link IBackpackDefinition}.
* Get a new instance from {@link IBackpackInterface#createBackpackFilter()}.
*/
public interface IBackpackFilterConfigurable extends IBackpackFilter {
/**
* Adds an item as valid for this backpack to pick up.
*/
void acceptItem(ItemStack validItem);
/**
* Adds an item as invalid for this backpack, used to make exceptions to oreDictionary matches.
*
* @see #acceptOreDictName(String)
*/
void rejectItem(ItemStack invalidItem);
/**
* Adds an ore dictionary name as valid for this backpack.
* The backpack will pick up any item that has this oreDictName.
*
* @see OreDictionary
*/
void acceptOreDictName(String oreDictName);
/**
* Removes an ore dictionary name as valid for this backpack.
* The backpack will not pick up any item that has this oreDictName.
*
* @see OreDictionary
*/
void rejectOreDictName(String oreDictName);
/**
* Clear all the rules from this filter.
*/
void clear();
}
@@ -8,31 +8,81 @@ package forestry.api.storage;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import forestry.api.genetics.ISpeciesRoot;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.common.registry.IForgeRegistryEntry;
import net.minecraftforge.oredict.OreDictionary;
/**
* The Backpack Interface allows you to add items to Forestry backpacks or create your own backpacks.
* <p>
* To create your own backpack, create an {@link IBackpackDefinition}.
* Backpack definitions have a filter, which you can create here with
* {@link #createBackpackFilter()}
* or {@link #createNaturalistBackpackFilter(String)}
* or create your own.
* <p>
* After you've registered your backpack definition, create the item with
* {@link #createBackpack(String, EnumBackpackType)}
* or {@link #createNaturalistBackpack(String, ISpeciesRoot)}
* and then register the returned item with {@link GameRegistry#register(IForgeRegistryEntry)} like any other item.
*/
public interface IBackpackInterface {
/**
* Get a backpack with a given uid so you can add items to it or get information about it.
* returns null if there is no backpack for the given uid.
* Add an accepted item to a Forestry backpack.
*
* @param backpackUid The unique ID of the Forestry backpack. See {@link BackpackManager} for valid UIDs.
* @param itemStack The itemStack that the backpack should accept.
* {@link OreDictionary#WILDCARD_VALUE} can be used for meta value.
*/
void addItemToForestryBackpack(@Nonnull String backpackUid, @Nonnull ItemStack itemStack);
/**
* Register a backpack definition with a given uid.
*/
void registerBackpackDefinition(@Nonnull String backpackUid, @Nonnull IBackpackDefinition definition);
/**
* Get a backpack definition with a given uid.
*/
@Nullable
IBackpackDefinition getBackpack(@Nonnull String uid);
IBackpackDefinition getBackpackDefinition(@Nonnull String backpackUid);
/**
* Register a backpack with a given uid
*/
void registerBackpack(@Nonnull String uid, @Nonnull IBackpackDefinition definition);
/**
* Adds a backpack with the given definition and type, returning the item.
* Creates a backpack with the given UID and type, returning the item.
* The backpack's definition must first be registered with {@link #registerBackpackDefinition(String, IBackpackDefinition)}.
*
* @param definition
* Definition of backpack behaviour.
* @param type
* Type of backpack.
* @param backpackUid The unique ID of the backpack.
* @param type Type of backpack.
* @return Created backpack item.
*/
@Nonnull
Item createBackpack(@Nonnull IBackpackDefinition definition, @Nonnull EnumBackpackType type);
Item createBackpack(@Nonnull String backpackUid, @Nonnull EnumBackpackType type);
/**
* Create a backpack that can hold items from a specific {@link ISpeciesRoot}.
* The backpack's definition must first be registered with {@link #registerBackpackDefinition(String, IBackpackDefinition)}.
*
* @param backpackUid The unique ID of the backpack.
* @param speciesRoot The species root.
* @return Created backpack item.
*/
Item createNaturalistBackpack(@Nonnull String backpackUid, @Nonnull ISpeciesRoot speciesRoot);
/**
* Makes a new configurable backpack filter. Useful for implementing {@link IBackpackDefinition}.
*/
IBackpackFilterConfigurable createBackpackFilter();
/**
* Makes a new naturalist backpack filter. Only accepts items from a specific {@link ISpeciesRoot}.
* Useful for implementing {@link IBackpackDefinition} for naturalist's backpacks.
*
* @param speciesRootUid The species root's unique ID. See {@link ISpeciesRoot#getUID()}.
* @return a new backpack filter for the specified species root
* @see #createNaturalistBackpack(String, ISpeciesRoot)
*/
IBackpackFilter createNaturalistBackpackFilter(String speciesRootUid);
}
@@ -3,7 +3,7 @@
*
* This work (the API) is licensed under the "MIT" License, see LICENSE.txt for details.
******************************************************************************/
@API(apiVersion = "3.0.0", owner = "ForestryAPI|core", provides = "ForestryAPI|storage")
@API(apiVersion = "4.0.0", owner = "ForestryAPI|core", provides = "ForestryAPI|storage")
package forestry.api.storage;
import net.minecraftforge.fml.common.API;