diff --git a/lang b/lang index f26fbe9da..cf9f2c21f 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit f26fbe9da8874b36881c9b1fe69f0e29ec768603 +Subproject commit cf9f2c21f53e6ad4ce180bdccf258ff7e717ce94 diff --git a/src/main/java/forestry/api/arboriculture/ITreeGenome.java b/src/main/java/forestry/api/arboriculture/ITreeGenome.java index a2b5f8612..6adf9bf35 100644 --- a/src/main/java/forestry/api/arboriculture/ITreeGenome.java +++ b/src/main/java/forestry/api/arboriculture/ITreeGenome.java @@ -5,9 +5,10 @@ ******************************************************************************/ package forestry.api.arboriculture; -import forestry.api.genetics.IGenome; import net.minecraft.item.ItemStack; +import forestry.api.genetics.IGenome; + public interface ITreeGenome extends IGenome { @Override @@ -37,6 +38,8 @@ public interface ITreeGenome extends IGenome { int getGirth(); + boolean getFireproof(); + IAlleleLeafEffect getEffect(); /** diff --git a/src/main/java/forestry/api/genetics/AlleleManager.java b/src/main/java/forestry/api/genetics/AlleleManager.java index f6d141bec..9cd03ab4b 100644 --- a/src/main/java/forestry/api/genetics/AlleleManager.java +++ b/src/main/java/forestry/api/genetics/AlleleManager.java @@ -23,4 +23,9 @@ public class AlleleManager { * Creates Forestry alleles. */ public static IAlleleFactory alleleFactory; + + /** + * @since 5.8 + */ + public static IFilterRegistry filterRegistry; } diff --git a/src/main/java/forestry/api/genetics/IBreedingTracker.java b/src/main/java/forestry/api/genetics/IBreedingTracker.java index 969307431..4fe138b29 100644 --- a/src/main/java/forestry/api/genetics/IBreedingTracker.java +++ b/src/main/java/forestry/api/genetics/IBreedingTracker.java @@ -5,10 +5,14 @@ ******************************************************************************/ package forestry.api.genetics; -import forestry.api.apiculture.IBeekeepingMode; +import java.util.Collection; +import java.util.Collections; + import net.minecraft.entity.player.EntityPlayer; import net.minecraft.nbt.NBTTagCompound; +import forestry.api.apiculture.IBeekeepingMode; + /** * Keeps track of who bred, discovered, and researched which species in a world. * @@ -67,6 +71,13 @@ public interface IBreedingTracker { */ boolean isDiscovered(IAlleleSpecies species); + /** + * @return A collection that contains the {@link IAllele#getUID()}s of all discovered species. + */ + default Collection getDiscoveredSpecies(){ + return Collections.emptyList(); + } + /** * Register a successfully researched mutation. * Mutations are normally researched in the Escritoire. diff --git a/src/main/java/forestry/api/genetics/IFilterData.java b/src/main/java/forestry/api/genetics/IFilterData.java new file mode 100644 index 000000000..4a23d18da --- /dev/null +++ b/src/main/java/forestry/api/genetics/IFilterData.java @@ -0,0 +1,27 @@ +package forestry.api.genetics; + +public interface IFilterData { + + /** + * If the root is present, returns the root, + * otherwise throws {@code NoSuchElementException}. + */ + ISpeciesRoot getRoot(); + + /** + * If the individual is present, returns the individual, + * otherwise throws {@code NoSuchElementException}. + */ + IIndividual getIndividual(); + + /** + * If the type is present, returns the type, + * otherwise throws {@code NoSuchElementException}. + */ + ISpeciesType getType(); + + /** + * @return True if this data contains a root, individual and type. + */ + boolean isPresent(); +} diff --git a/src/main/java/forestry/api/genetics/IFilterLogic.java b/src/main/java/forestry/api/genetics/IFilterLogic.java new file mode 100644 index 000000000..7a089ff42 --- /dev/null +++ b/src/main/java/forestry/api/genetics/IFilterLogic.java @@ -0,0 +1,17 @@ +package forestry.api.genetics; + +import javax.annotation.Nullable; + +import net.minecraft.item.ItemStack; + +public interface IFilterLogic { + boolean isValid(ItemStack itemStack, IFilterData data); + + /** + * If a root with this uid is registered, the filter will only get stack with individuals from this root. + */ + @Nullable + default String getRootUID() { + return null; + } +} diff --git a/src/main/java/forestry/api/genetics/IFilterRegistry.java b/src/main/java/forestry/api/genetics/IFilterRegistry.java new file mode 100644 index 000000000..8d27d7583 --- /dev/null +++ b/src/main/java/forestry/api/genetics/IFilterRegistry.java @@ -0,0 +1,36 @@ +package forestry.api.genetics; + +import javax.annotation.Nullable; +import java.util.Collection; + +/** + * @since 5.8 + */ +public interface IFilterRegistry { + /** + * Registers a filter rule. + */ + void registerFilter(IFilterRule rule); + + Collection getRules(); + + IFilterRule getDefaultRule(); + + @Nullable + IFilterRule getRule(String uid); + + @Nullable + IFilterRule getRule(int id); + + int getId(IFilterRule rule); + + default IFilterRule getRuleOrDefault(String uid){ + IFilterRule rule = getRule(uid); + return rule != null ? rule : getDefaultRule(); + } + + default IFilterRule getRuleOrDefault(int id){ + IFilterRule rule = getRule(id); + return rule != null ? rule : getDefaultRule(); + } +} diff --git a/src/main/java/forestry/api/genetics/IFilterRule.java b/src/main/java/forestry/api/genetics/IFilterRule.java new file mode 100644 index 000000000..c429db331 --- /dev/null +++ b/src/main/java/forestry/api/genetics/IFilterRule.java @@ -0,0 +1,25 @@ +package forestry.api.genetics; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.util.ResourceLocation; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +/** + * @since 5.8 + */ +public interface IFilterRule extends IFilterLogic { + void addLogic(IFilterLogic logic); + + /** + * @return A unique identifier for the rule. + */ + String getUID(); + + @SideOnly(Side.CLIENT) + TextureAtlasSprite getSprite(); + + @SideOnly(Side.CLIENT) + ResourceLocation getTextureMap(); +} diff --git a/src/main/java/forestry/apiculture/ApicultureFilterLogic.java b/src/main/java/forestry/apiculture/ApicultureFilterLogic.java new file mode 100644 index 000000000..ba3c81398 --- /dev/null +++ b/src/main/java/forestry/apiculture/ApicultureFilterLogic.java @@ -0,0 +1,86 @@ +package forestry.apiculture; + +import net.minecraft.item.ItemStack; + +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.apiculture.IBee; +import forestry.api.genetics.IFilterData; +import forestry.api.genetics.IFilterLogic; +import forestry.api.genetics.IFilterRule; +import forestry.api.genetics.IIndividual; +import forestry.sorting.DefaultFilterRule; + +public enum ApicultureFilterLogic implements IFilterLogic { + PURE_BREED(DefaultFilterRule.PURE_BREED){ + @Override + protected boolean isValid(IBee bee) { + return bee.isPureBred(EnumBeeChromosome.SPECIES); + } + }, + NOCTURNAL(DefaultFilterRule.NOCTURNAL){ + @Override + protected boolean isValid(IBee bee) { + return bee.getGenome().getNeverSleeps(); + } + }, + PURE_NOCTURNAL(DefaultFilterRule.PURE_NOCTURNAL){ + @Override + protected boolean isValid(IBee bee) { + return bee.getGenome().getNeverSleeps() && bee.isPureBred(EnumBeeChromosome.NEVER_SLEEPS); + } + }, + FLYER(DefaultFilterRule.FLYER){ + @Override + protected boolean isValid(IBee bee) { + return bee.getGenome().getToleratesRain(); + } + }, + PURE_FLYER((DefaultFilterRule.PURE_FLYER)){ + @Override + protected boolean isValid(IBee bee) { + return bee.getGenome().getToleratesRain() && bee.isPureBred(EnumBeeChromosome.TOLERATES_RAIN); + } + }, + CAVE(DefaultFilterRule.CAVE){ + @Override + protected boolean isValid(IBee bee) { + return bee.getGenome().getCaveDwelling(); + } + }, + PURE_CAVE(DefaultFilterRule.PURE_CAVE){ + @Override + protected boolean isValid(IBee bee) { + return bee.getGenome().getCaveDwelling() && bee.isPureBred(EnumBeeChromosome.CAVE_DWELLING); + } + }; + + ApicultureFilterLogic(IFilterRule rule) { + rule.addLogic(this); + } + + public static void init() { + } + + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + if(!data.isPresent()){ + return false; + } + IIndividual individual = data.getIndividual(); + if(!(individual instanceof IBee)){ + return false; + } + return isValid((IBee)individual); + } + + protected boolean isValid(IBee bee){ + return false; + } + + @Override + public String getRootUID() { + return BeeManager.beeRoot.getUID(); + } + +} diff --git a/src/main/java/forestry/apiculture/ApicultureFilterRule.java b/src/main/java/forestry/apiculture/ApicultureFilterRule.java new file mode 100644 index 000000000..ed1afa79f --- /dev/null +++ b/src/main/java/forestry/apiculture/ApicultureFilterRule.java @@ -0,0 +1,84 @@ +package forestry.apiculture; + +import java.util.Locale; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeType; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IFilterData; +import forestry.api.genetics.IFilterLogic; +import forestry.api.genetics.IFilterRule; +import forestry.core.render.TextureManagerForestry; + +public enum ApicultureFilterRule implements IFilterRule { + BEE{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent(); + } + }, + DRONE{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumBeeType.DRONE; + } + }, + PRINCESS{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumBeeType.PRINCESS; + } + }, + QUEEN{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumBeeType.QUEEN; + } + }; + + private final String uid; + + ApicultureFilterRule() { + this.uid = "forestry.apiculture." + name().toLowerCase(Locale.ENGLISH); + } + + public static void init() { + for (ApicultureFilterRule rule : values()) { + AlleleManager.filterRegistry.registerFilter(rule); + } + } + + @Override + public void addLogic(IFilterLogic logic) { + throw new IllegalStateException(); + } + + @SideOnly(Side.CLIENT) + @Override + public TextureAtlasSprite getSprite() { + return TextureManagerForestry.getInstance().getDefault("analyzer/" + name().toLowerCase(Locale.ENGLISH)); + } + + @SideOnly(Side.CLIENT) + @Override + public ResourceLocation getTextureMap() { + return TextureManagerForestry.LOCATION_FORESTRY_TEXTURE; + } + + @Override + public String getRootUID() { + return BeeManager.beeRoot.getUID(); + } + + @Override + public String getUID() { + return uid; + } +} diff --git a/src/main/java/forestry/apiculture/ModuleApiculture.java b/src/main/java/forestry/apiculture/ModuleApiculture.java index 61638091d..41e6564a6 100644 --- a/src/main/java/forestry/apiculture/ModuleApiculture.java +++ b/src/main/java/forestry/apiculture/ModuleApiculture.java @@ -133,6 +133,7 @@ import forestry.food.ModuleFood; import forestry.food.items.ItemRegistryFood; import forestry.modules.BlankForestryModule; import forestry.modules.ForestryModuleUids; +import forestry.modules.ModuleManager; @ForestryModule(containerID = Constants.MOD_ID, moduleID = ForestryModuleUids.APICULTURE, name = "Apiculture", author = "SirSengir", url = Constants.URL, unlocalizedDescription = "for.module.apiculture.description", lootTable = "apiculture") public class ModuleApiculture extends BlankForestryModule { @@ -231,6 +232,11 @@ public class ModuleApiculture extends BlankForestryModule { // Commands ModuleCore.rootCommand.addChildCommand(new CommandBee()); + + if(ModuleManager.getInstance().isModuleEnabled(Constants.MOD_ID, ForestryModuleUids.SORTING)){ + ApicultureFilterRule.init(); + ApicultureFilterLogic.init(); + } } // TODO: Buildcraft for 1.9 diff --git a/src/main/java/forestry/arboriculture/ArboricultureFilterRule.java b/src/main/java/forestry/arboriculture/ArboricultureFilterRule.java new file mode 100644 index 000000000..018f5f145 --- /dev/null +++ b/src/main/java/forestry/arboriculture/ArboricultureFilterRule.java @@ -0,0 +1,78 @@ +package forestry.arboriculture; + +import java.util.Locale; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.api.arboriculture.EnumGermlingType; +import forestry.api.arboriculture.TreeManager; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IFilterData; +import forestry.api.genetics.IFilterLogic; +import forestry.api.genetics.IFilterRule; +import forestry.core.render.TextureManagerForestry; + +public enum ArboricultureFilterRule implements IFilterRule { + TREE{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent(); + } + }, + SAPLING{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumGermlingType.SAPLING; + } + }, + POLLEN{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumGermlingType.POLLEN; + } + }; + + private final String uid; + + ArboricultureFilterRule() { + this.uid = "forestry.arboriculture." + name().toLowerCase(Locale.ENGLISH); + } + + public static void init() { + for (ArboricultureFilterRule rule : values()) { + AlleleManager.filterRegistry.registerFilter(rule); + } + } + + @Override + public void addLogic(IFilterLogic logic) { + throw new IllegalStateException(); + } + + @SideOnly(Side.CLIENT) + @Override + public TextureAtlasSprite getSprite() { + return TextureManagerForestry.getInstance().getDefault("analyzer/" + name().toLowerCase(Locale.ENGLISH)); + } + + @SideOnly(Side.CLIENT) + @Override + public ResourceLocation getTextureMap() { + return TextureManagerForestry.LOCATION_FORESTRY_TEXTURE; + } + + @Override + public String getRootUID() { + return TreeManager.treeRoot.getUID(); + } + + @Override + public String getUID() { + return uid; + } +} diff --git a/src/main/java/forestry/arboriculture/ModuleArboriculture.java b/src/main/java/forestry/arboriculture/ModuleArboriculture.java index c41962d17..015fb1508 100644 --- a/src/main/java/forestry/arboriculture/ModuleArboriculture.java +++ b/src/main/java/forestry/arboriculture/ModuleArboriculture.java @@ -110,6 +110,7 @@ import forestry.core.utils.ItemStackUtil; import forestry.core.utils.VillagerTradeLists; import forestry.modules.BlankForestryModule; import forestry.modules.ForestryModuleUids; +import forestry.modules.ModuleManager; @ForestryModule(containerID = Constants.MOD_ID, moduleID = ForestryModuleUids.ARBORICULTURE, name = "Arboriculture", author = "Binnie & SirSengir", url = Constants.URL, unlocalizedDescription = "for.module.arboriculture.description", lootTable = "arboriculture") public class ModuleArboriculture extends BlankForestryModule { @@ -213,6 +214,10 @@ public class ModuleArboriculture extends BlankForestryModule { // Commands ModuleCore.rootCommand.addChildCommand(new CommandTree()); + + if(ModuleManager.getInstance().isModuleEnabled(Constants.MOD_ID, ForestryModuleUids.SORTING)){ + ArboricultureFilterRule.init(); + } } @Override diff --git a/src/main/java/forestry/arboriculture/genetics/TreeAlyzerPlugin.java b/src/main/java/forestry/arboriculture/genetics/TreeAlyzerPlugin.java index 726454492..f1dfc6f80 100644 --- a/src/main/java/forestry/arboriculture/genetics/TreeAlyzerPlugin.java +++ b/src/main/java/forestry/arboriculture/genetics/TreeAlyzerPlugin.java @@ -39,10 +39,12 @@ import forestry.api.genetics.IFruitFamily; import forestry.arboriculture.ModuleArboriculture; import forestry.arboriculture.genetics.alleles.AlleleFruits; import forestry.core.config.Config; +import forestry.core.genetics.alleles.AlleleBoolean; import forestry.core.gui.GuiAlyzer; import forestry.core.gui.TextLayoutHelper; import forestry.core.gui.widgets.ItemStackWidget; import forestry.core.gui.widgets.WidgetManager; +import forestry.core.utils.StringUtil; import forestry.core.utils.Translator; public class TreeAlyzerPlugin implements IAlyzerPlugin { @@ -129,7 +131,7 @@ public class TreeAlyzerPlugin implements IAlyzerPlugin { TextLayoutHelper textLayout = guiAlyzer.getTextLayout(); - textLayout.startPage(); + textLayout.startPage(GuiAlyzer.COLUMN_0, GuiAlyzer.COLUMN_1, GuiAlyzer.COLUMN_2); int speciesDominance0 = guiAlyzer.getColorCoding(tree.getGenome().getPrimary().isDominant()); int speciesDominance1 = guiAlyzer.getColorCoding(tree.getGenome().getSecondary().isDominant()); @@ -140,14 +142,14 @@ public class TreeAlyzerPlugin implements IAlyzerPlugin { textLayout.newLine(); textLayout.newLine(); - IAlleleTreeSpecies activeSpecies = (IAlleleTreeSpecies) tree.getGenome().getActiveAllele(EnumTreeChromosome.SPECIES); - IAlleleTreeSpecies inActiveSpecies = (IAlleleTreeSpecies) tree.getGenome().getInactiveAllele(EnumTreeChromosome.SPECIES); + String yes = Translator.translateToLocal("for.yes"); + String no = Translator.translateToLocal("for.no"); + + String fireproofActive = StringUtil.readableBoolean(tree.getGenome().getFireproof(), yes, no); + String fireproofInactive = StringUtil.readableBoolean(((AlleleBoolean) tree.getGenome().getInactiveAllele(EnumTreeChromosome.FIREPROOF)).getValue(), yes, no); + + guiAlyzer.drawRow(Translator.translateToLocal("for.gui.fireproof"), fireproofActive, fireproofInactive, tree, EnumTreeChromosome.FIREPROOF); - int activeCarbonization = activeSpecies.getWoodProvider().getCarbonization(); - int inactiveCarbonization = inActiveSpecies.getWoodProvider().getCarbonization(); - textLayout.drawLine(Translator.translateToLocal("for.gui.carbonization"), GuiAlyzer.COLUMN_0); - guiAlyzer.drawLine(Integer.toString(activeCarbonization), GuiAlyzer.COLUMN_1, tree, EnumTreeChromosome.SPECIES, false); - guiAlyzer.drawLine(Integer.toString(inactiveCarbonization), GuiAlyzer.COLUMN_2, tree, EnumTreeChromosome.SPECIES, true); textLayout.newLine(); textLayout.drawLine(Translator.translateToLocal("for.gui.native"), GuiAlyzer.COLUMN_0); diff --git a/src/main/java/forestry/arboriculture/genetics/TreeGenome.java b/src/main/java/forestry/arboriculture/genetics/TreeGenome.java index 306b3a0d3..7abd16b34 100755 --- a/src/main/java/forestry/arboriculture/genetics/TreeGenome.java +++ b/src/main/java/forestry/arboriculture/genetics/TreeGenome.java @@ -25,6 +25,7 @@ import forestry.api.arboriculture.IFruitProvider; import forestry.api.arboriculture.ITreeGenome; import forestry.api.arboriculture.TreeManager; import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleBoolean; import forestry.api.genetics.IAlleleFloat; import forestry.api.genetics.IAlleleInteger; import forestry.api.genetics.IAlleleSpecies; @@ -102,6 +103,11 @@ public class TreeGenome extends Genome implements ITreeGenome { return ((IAlleleInteger) getActiveAllele(EnumTreeChromosome.GIRTH)).getValue(); } + @Override + public boolean getFireproof() { + return ((IAlleleBoolean) getActiveAllele(EnumTreeChromosome.FIREPROOF)).getValue(); + } + @Override public IAlleleLeafEffect getEffect() { return (IAlleleLeafEffect) getActiveAllele(EnumTreeChromosome.EFFECT); diff --git a/src/main/java/forestry/core/genetics/BreedingTracker.java b/src/main/java/forestry/core/genetics/BreedingTracker.java index b20bdba0a..3d0ec4f50 100755 --- a/src/main/java/forestry/core/genetics/BreedingTracker.java +++ b/src/main/java/forestry/core/genetics/BreedingTracker.java @@ -235,6 +235,11 @@ public abstract class BreedingTracker extends WorldSavedData implements IBreedin return discoveredSpecies.contains(species.getUID()); } + @Override + public Set getDiscoveredSpecies() { + return discoveredSpecies; + } + @Override public int getSpeciesBred() { return discoveredSpecies.size(); diff --git a/src/main/java/forestry/core/gui/GuiIdRegistry.java b/src/main/java/forestry/core/gui/GuiIdRegistry.java index ff87193c6..56d7e6872 100644 --- a/src/main/java/forestry/core/gui/GuiIdRegistry.java +++ b/src/main/java/forestry/core/gui/GuiIdRegistry.java @@ -54,6 +54,7 @@ import forestry.mail.items.ItemLetter; import forestry.mail.tiles.TileMailbox; import forestry.mail.tiles.TileStampCollector; import forestry.mail.tiles.TileTrader; +import forestry.sorting.tiles.TileGeneticFilter; import forestry.storage.items.ItemBackpack; import forestry.storage.items.ItemBackpackNaturalist; import forestry.worktable.tiles.TileWorktable; @@ -65,20 +66,25 @@ public class GuiIdRegistry { static { registerGuiHandlers(GuiType.Tile, Arrays.asList( + //Apiculture Module TileAlveary.class, TileAlvearyHygroregulator.class, TileAlvearySieve.class, TileApiary.class, TileBeeHouse.class, + //Core Module TileAnalyzer.class, TileEscritoire.class, TileNaturalistChest.class, - TileRaintank.class, + + //Worktable Module TileWorktable.class, + //Database Module TileDatabase.class, + //Factory Module TileBottler.class, TileCarpenter.class, TileCentrifuge.class, @@ -87,18 +93,26 @@ public class GuiIdRegistry { TileMoistener.class, TileSqueezer.class, TileStill.class, + TileRaintank.class, + //Farm Module TileFarm.class, + //Sorting Module + TileGeneticFilter.class, + + //Greenhouse Module TileGreenhouse.class, TileClimatiser.class, TileHygroregulator.class, + //Power Module TileEngineBiogas.class, TileEngineElectric.class, TileEnginePeat.class, TileEuGenerator.class, + //Mail Module TileMailbox.class, TileStampCollector.class, TileTrader.class diff --git a/src/main/java/forestry/core/gui/widgets/Widget.java b/src/main/java/forestry/core/gui/widgets/Widget.java index 0251e8f3f..2eb6b9677 100755 --- a/src/main/java/forestry/core/gui/widgets/Widget.java +++ b/src/main/java/forestry/core/gui/widgets/Widget.java @@ -11,7 +11,6 @@ package forestry.core.gui.widgets; import javax.annotation.Nullable; -import java.awt.Rectangle; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; @@ -44,8 +43,12 @@ public abstract class Widget implements IToolTipProvider { return height; } - public Rectangle getRectangle(int startX, int startY){ - return new Rectangle(startX + xPos, startY + yPos, width, height); + public int getX() { + return xPos; + } + + public int getY() { + return yPos; } public abstract void draw(int startX, int startY); diff --git a/src/main/java/forestry/core/inventory/AdjacentInventoryCache.java b/src/main/java/forestry/core/inventory/AdjacentInventoryCache.java index 16d64d7e6..8a6902957 100644 --- a/src/main/java/forestry/core/inventory/AdjacentInventoryCache.java +++ b/src/main/java/forestry/core/inventory/AdjacentInventoryCache.java @@ -17,12 +17,14 @@ import java.util.Comparator; import java.util.LinkedList; import java.util.List; -import forestry.core.tiles.AdjacentTileCache; -import forestry.core.tiles.TileUtil; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; + import net.minecraftforge.items.IItemHandler; +import forestry.core.tiles.AdjacentTileCache; +import forestry.core.tiles.TileUtil; + /** * @author CovertJaguar */ @@ -56,6 +58,7 @@ public final class AdjacentInventoryCache implements AdjacentTileCache.ICacheLis cache.addListener(this); } + @Nullable public IItemHandler getAdjacentInventory(EnumFacing side) { checkChanged(); return sides[side.ordinal()]; diff --git a/src/main/java/forestry/core/items/ItemRegistryCore.java b/src/main/java/forestry/core/items/ItemRegistryCore.java index e854ac51c..cfc4381f5 100644 --- a/src/main/java/forestry/core/items/ItemRegistryCore.java +++ b/src/main/java/forestry/core/items/ItemRegistryCore.java @@ -197,6 +197,7 @@ public class ItemRegistryCore extends ItemRegistry { for (ItemFruit.EnumFruit def : ItemFruit.EnumFruit.values()) { ItemStack fruit = new ItemStack(fruits, 1, def.ordinal()); OreDictionary.registerOre(def.getOreDict(), fruit); + OreDictionary.registerOre(OreDictUtil.FRUIT_FORESTRY, fruit); } } diff --git a/src/main/java/forestry/core/network/PacketIdServer.java b/src/main/java/forestry/core/network/PacketIdServer.java index 262934a8c..fa604b8e4 100644 --- a/src/main/java/forestry/core/network/PacketIdServer.java +++ b/src/main/java/forestry/core/network/PacketIdServer.java @@ -28,6 +28,10 @@ public enum PacketIdServer implements IPacketId { //Database INSERT_ITEM, EXTRACT_ITEM, + + // Sorting + FILTER_CHANGE_RULE, + FILTER_CHANGE_GENOME, // Greenhouse CAMOUFLAGE_SELECTION, diff --git a/src/main/java/forestry/core/render/TextureManagerForestry.java b/src/main/java/forestry/core/render/TextureManagerForestry.java index 7e286616a..8fec08b5f 100644 --- a/src/main/java/forestry/core/render/TextureManagerForestry.java +++ b/src/main/java/forestry/core/render/TextureManagerForestry.java @@ -53,16 +53,18 @@ public class TextureManagerForestry implements ITextureManager { } public static void initDefaultSprites() { - String[] defaultIconNames = new String[]{"habitats/desert", "habitats/end", "habitats/forest", "habitats/hills", "habitats/jungle", "habitats/mushroom", - "habitats/nether", "habitats/ocean", "habitats/plains", "habitats/snow", "habitats/swamp", "habitats/taiga", - "misc/access.shared", "misc/energy", "misc/hint", - "analyzer/anything", "analyzer/bee", "analyzer/cave", "analyzer/closed", "analyzer/drone", "analyzer/flyer", - "analyzer/item", "analyzer/nocturnal", "analyzer/princess", "analyzer/pure_breed", "analyzer/pure_cave", - "analyzer/pure_flyer", "analyzer/pure_nocturnal", "analyzer/queen", + String[] defaultIconNames = new String[]{"habitats/desert", "habitats/end", "habitats/forest", "habitats/hills", "habitats/jungle", + "habitats/mushroom", "habitats/nether", "habitats/ocean", "habitats/plains", "habitats/snow", "habitats/swamp", "habitats/taiga", + "misc/access.shared", "misc/energy", "misc/hint", + "analyzer/anything", "analyzer/bee", "analyzer/cave", "analyzer/closed", "analyzer/drone", "analyzer/flyer", "analyzer/item", + "analyzer/nocturnal", "analyzer/princess", "analyzer/pure_breed", "analyzer/pure_cave", "analyzer/pure_flyer", + "analyzer/pure_nocturnal", "analyzer/queen", "analyzer/tree", "analyzer/sapling", "analyzer/pollen", "analyzer/flutter", + "analyzer/butterfly", "analyzer/serum", "analyzer/caterpillar", "analyzer/cocoon", "errors/errored", "errors/unknown", - "slots/blocked", "slots/blocked_2", "slots/liquid", "slots/container", "slots/locked", "slots/cocoon", - "mail/carrier.player", "mail/carrier.trader", - "modifiers/rain"}; + "slots/blocked", "slots/blocked_2", "slots/liquid", "slots/container", "slots/locked", "slots/cocoon", "slots/bee", + "mail/carrier.player", "mail/carrier.trader", + "modifiers/rain" + }; for (String identifier : defaultIconNames) { ResourceLocation resourceLocation = getForestryGuiLocation(identifier); INSTANCE.registerGuiSprite(resourceLocation); diff --git a/src/main/java/forestry/core/utils/OreDictUtil.java b/src/main/java/forestry/core/utils/OreDictUtil.java index 4ab885cf3..bda0e0b6d 100644 --- a/src/main/java/forestry/core/utils/OreDictUtil.java +++ b/src/main/java/forestry/core/utils/OreDictUtil.java @@ -58,6 +58,8 @@ public class OreDictUtil { public static final String CROP_CARROT = "cropCarrot"; public static final String SUGARCANE = "sugarcane"; + public static final String FRUIT_FORESTRY = "fruitForestry"; + public static final String PANE_GLASS = "paneGlass"; public static final String SAND = "sand"; public static final String DUST_REDSTONE = "dustRedstone"; diff --git a/src/main/java/forestry/database/DatabaseHelper.java b/src/main/java/forestry/database/DatabaseHelper.java index 1daef2b36..a317e61be 100644 --- a/src/main/java/forestry/database/DatabaseHelper.java +++ b/src/main/java/forestry/database/DatabaseHelper.java @@ -1,7 +1,6 @@ package forestry.database; import java.util.ArrayList; -import java.util.Collections; import java.util.Comparator; import java.util.LinkedList; import java.util.List; @@ -44,7 +43,6 @@ public class DatabaseHelper { public static void update(String searchText, List items, ArrayList sorted){ sorted.clear(); - sorted.ensureCapacity(items.size()); Pattern pattern; @@ -84,7 +82,7 @@ public class DatabaseHelper { }*/ } - Collections.sort(sorted, SORT_BY_NAME); + sorted.sort(SORT_BY_NAME); } //TODO: Add more filter options diff --git a/src/main/java/forestry/database/gui/GuiDatabase.java b/src/main/java/forestry/database/gui/GuiDatabase.java index f17d3b56f..1d624f049 100644 --- a/src/main/java/forestry/database/gui/GuiDatabase.java +++ b/src/main/java/forestry/database/gui/GuiDatabase.java @@ -13,8 +13,6 @@ import net.minecraft.inventory.IInventory; import net.minecraft.inventory.Slot; import net.minecraft.util.ResourceLocation; -import org.lwjgl.input.Keyboard; - import forestry.core.config.Constants; import forestry.core.gui.Drawable; import forestry.core.gui.GuiForestry; @@ -36,6 +34,7 @@ import forestry.database.gui.widgets.WidgetDatabaseSelectedItem; import forestry.database.gui.widgets.WidgetDatabaseSlot; import forestry.database.gui.widgets.WidgetDatabaseTabs; import forestry.database.tiles.TileDatabase; +import org.lwjgl.input.Keyboard; public class GuiDatabase extends GuiForestry implements ISlotChangeWatcher, IScrollable { diff --git a/src/main/java/forestry/greenhouse/blocks/BlockClimatiser.java b/src/main/java/forestry/greenhouse/blocks/BlockClimatiser.java index 146139a52..90052844c 100644 --- a/src/main/java/forestry/greenhouse/blocks/BlockClimatiser.java +++ b/src/main/java/forestry/greenhouse/blocks/BlockClimatiser.java @@ -132,7 +132,6 @@ public class BlockClimatiser extends Block implements IBlockWithMeta, ISpriteReg if (tile != null) { if (TileUtil.isUsableByPlayer(player, tile)) { - ItemStack heldItem = player.getHeldItem(hand); if (!player.isSneaking()) { if (FluidUtil.interactWithFluidHandler(player, hand, world, pos, facing)) { return true; diff --git a/src/main/java/forestry/lepidopterology/LepidopterologyFilterLogic.java b/src/main/java/forestry/lepidopterology/LepidopterologyFilterLogic.java new file mode 100644 index 000000000..61dfea656 --- /dev/null +++ b/src/main/java/forestry/lepidopterology/LepidopterologyFilterLogic.java @@ -0,0 +1,74 @@ +package forestry.lepidopterology; + +import net.minecraft.item.ItemStack; + +import forestry.api.genetics.IFilterData; +import forestry.api.genetics.IFilterLogic; +import forestry.api.genetics.IFilterRule; +import forestry.api.genetics.IIndividual; +import forestry.api.lepidopterology.ButterflyManager; +import forestry.api.lepidopterology.EnumButterflyChromosome; +import forestry.api.lepidopterology.IButterfly; +import forestry.sorting.DefaultFilterRule; + +public enum LepidopterologyFilterLogic implements IFilterLogic { + PURE_BREED(DefaultFilterRule.PURE_BREED){ + @Override + protected boolean isValid(IButterfly butterfly) { + return butterfly.isPureBred(EnumButterflyChromosome.SPECIES); + } + }, + NOCTURNAL(DefaultFilterRule.NOCTURNAL){ + @Override + protected boolean isValid(IButterfly butterfly) { + return butterfly.getGenome().getNocturnal(); + } + }, + PURE_NOCTURNAL(DefaultFilterRule.PURE_NOCTURNAL){ + @Override + protected boolean isValid(IButterfly butterfly) { + return butterfly.getGenome().getNocturnal() && butterfly.isPureBred(EnumButterflyChromosome.NOCTURNAL); + } + }, + FLYER(DefaultFilterRule.FLYER){ + @Override + protected boolean isValid(IButterfly butterfly) { + return butterfly.getGenome().getTolerantFlyer(); + } + }, + PURE_FLYER(DefaultFilterRule.PURE_FLYER){ + @Override + protected boolean isValid(IButterfly butterfly) { + return butterfly.getGenome().getTolerantFlyer() && butterfly.isPureBred(EnumButterflyChromosome.TOLERANT_FLYER); + } + }; + + LepidopterologyFilterLogic(IFilterRule rule) { + rule.addLogic(this); + } + + public static void init() { + } + + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + if(!data.isPresent()){ + return false; + } + IIndividual individual = data.getIndividual(); + if(!(individual instanceof IButterfly)){ + return false; + } + return isValid((IButterfly) individual); + } + + protected boolean isValid(IButterfly butterfly){ + return false; + } + + @Override + public String getRootUID() { + return ButterflyManager.butterflyRoot.getUID(); + } + +} diff --git a/src/main/java/forestry/lepidopterology/LepidopterologyFilterRule.java b/src/main/java/forestry/lepidopterology/LepidopterologyFilterRule.java new file mode 100644 index 000000000..8c972f838 --- /dev/null +++ b/src/main/java/forestry/lepidopterology/LepidopterologyFilterRule.java @@ -0,0 +1,90 @@ +package forestry.lepidopterology; + +import java.util.Locale; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IFilterData; +import forestry.api.genetics.IFilterLogic; +import forestry.api.genetics.IFilterRule; +import forestry.api.lepidopterology.ButterflyManager; +import forestry.api.lepidopterology.EnumFlutterType; +import forestry.core.render.TextureManagerForestry; + +public enum LepidopterologyFilterRule implements IFilterRule { + FLUTTER{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent(); + } + }, + BUTTERFLY{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumFlutterType.BUTTERFLY; + } + }, + SERUM{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumFlutterType.SERUM; + } + }, + CATERPILLAR{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumFlutterType.CATERPILLAR; + } + }, + COCOON{ + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return data.isPresent() && data.getType() == EnumFlutterType.COCOON; + } + }; + + private final String uid; + + LepidopterologyFilterRule() { + this.uid = "forestry.lepidopterology." + name().toLowerCase(Locale.ENGLISH); + } + + public static void init() { + for (LepidopterologyFilterRule rule : values()) { + AlleleManager.filterRegistry.registerFilter(rule); + } + } + + @Override + public void addLogic(IFilterLogic logic) { + throw new IllegalStateException(); + } + + @SideOnly(Side.CLIENT) + @Override + public TextureAtlasSprite getSprite() { + return TextureManagerForestry.getInstance().getDefault("analyzer/" + name().toLowerCase(Locale.ENGLISH)); + } + + @SideOnly(Side.CLIENT) + @Override + public ResourceLocation getTextureMap() { + return TextureManagerForestry.LOCATION_FORESTRY_TEXTURE; + } + + @Override + public String getRootUID() { + return ButterflyManager.butterflyRoot.getUID(); + } + + @Override + public String getUID() { + return uid; + } +} diff --git a/src/main/java/forestry/lepidopterology/ModuleLepidopterology.java b/src/main/java/forestry/lepidopterology/ModuleLepidopterology.java index 5c1234ad5..20e8e929d 100644 --- a/src/main/java/forestry/lepidopterology/ModuleLepidopterology.java +++ b/src/main/java/forestry/lepidopterology/ModuleLepidopterology.java @@ -79,6 +79,7 @@ import forestry.lepidopterology.tiles.TileCocoon; import forestry.lepidopterology.worldgen.CocoonDecorator; import forestry.modules.BlankForestryModule; import forestry.modules.ForestryModuleUids; +import forestry.modules.ModuleManager; @ForestryModule(containerID = Constants.MOD_ID, moduleID = ForestryModuleUids.LEPIDOPTEROLOGY, name = "Lepidopterology", author = "SirSengir", url = Constants.URL, unlocalizedDescription = "for.module.lepidopterology.description") public class ModuleLepidopterology extends BlankForestryModule { @@ -137,10 +138,13 @@ public class ModuleLepidopterology extends BlankForestryModule { ButterflyDefinition.preInit(); MothDefinition.preInit(); MinecraftForge.EVENT_BUS.post(new AlleleSpeciesRegisterEvent<>(ButterflyManager.butterflyRoot, IAlleleButterflySpecies.class)); - - - GameRegistry.registerTileEntity(TileCocoon.class, "forestry.Cocoon"); + proxy.preInitializeRendering(); + + if(ModuleManager.getInstance().isModuleEnabled(Constants.MOD_ID, ForestryModuleUids.SORTING)){ + LepidopterologyFilterLogic.init(); + LepidopterologyFilterRule.init(); + } } @Override @@ -155,6 +159,8 @@ public class ModuleLepidopterology extends BlankForestryModule { public void doInit() { BlockRegistryLepidopterology blocks = getBlocks(); + GameRegistry.registerTileEntity(TileCocoon.class, "forestry.Cocoon"); + ModuleCore.rootCommand.addChildCommand(new CommandButterfly()); ResourceLocation butterflyResourceLocation = new ResourceLocation(Constants.MOD_ID, "butterflyGE"); diff --git a/src/main/java/forestry/modules/ForestryModuleUids.java b/src/main/java/forestry/modules/ForestryModuleUids.java index fe4f8c8c9..c9060f8b2 100644 --- a/src/main/java/forestry/modules/ForestryModuleUids.java +++ b/src/main/java/forestry/modules/ForestryModuleUids.java @@ -18,6 +18,7 @@ public class ForestryModuleUids { public static final String CRATE = "crates"; public static final String BACKPACKS = "backpacks"; public static final String DATABASE = "database"; + public static final String SORTING = "sorting"; //Mod Plugins public static final String BIOMES_O_PLENTY = "biomes.o.plenty"; diff --git a/src/main/java/forestry/sorting/AlleleFilter.java b/src/main/java/forestry/sorting/AlleleFilter.java new file mode 100644 index 000000000..5034fad0e --- /dev/null +++ b/src/main/java/forestry/sorting/AlleleFilter.java @@ -0,0 +1,22 @@ +package forestry.sorting; + +import javax.annotation.Nullable; + +import forestry.api.genetics.IAllele; + +public class AlleleFilter { + @Nullable + public IAllele activeAllele; + + @Nullable + public IAllele inactiveAllele; + + public boolean isValid(String activeUID, String inactiveUID) { + return (this.activeAllele == null || activeUID.equals(this.activeAllele.getUID())) + && (this.inactiveAllele == null || inactiveUID.equals(this.inactiveAllele.getUID())); + } + + public boolean isEmpty() { + return activeAllele == null && inactiveAllele == null; + } +} diff --git a/src/main/java/forestry/sorting/DefaultFilterRule.java b/src/main/java/forestry/sorting/DefaultFilterRule.java new file mode 100644 index 000000000..beebe290f --- /dev/null +++ b/src/main/java/forestry/sorting/DefaultFilterRule.java @@ -0,0 +1,98 @@ +package forestry.sorting; + +import java.util.HashSet; +import java.util.Locale; +import java.util.Set; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IFilterData; +import forestry.api.genetics.IFilterLogic; +import forestry.api.genetics.IFilterRule; +import forestry.core.render.TextureManagerForestry; + +public enum DefaultFilterRule implements IFilterRule { + CLOSED { + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return false; + } + }, + ANYTHING { + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return true; + } + }, + ITEM { + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + return !data.isPresent(); + } + }, + PURE_BREED, + NOCTURNAL, + PURE_NOCTURNAL, + FLYER, + PURE_FLYER, + CAVE, + PURE_CAVE, + /*FIREPROOF, + PURE_FIREPROOF*/; + + private final String uid; + private final Set logic; + + DefaultFilterRule() { + this.uid = "forestry.default." + name().toLowerCase(Locale.ENGLISH); + this.logic = new HashSet<>(); + } + + public static void init() { + for (DefaultFilterRule rule : values()) { + AlleleManager.filterRegistry.registerFilter(rule); + } + } + + @Override + public boolean isValid(ItemStack itemStack, IFilterData data) { + for (IFilterLogic logic : logic) { + if (logic.isValid(itemStack, data)) { + return true; + } + } + return false; + } + + @Override + public void addLogic(IFilterLogic logic) { + if (logic == this) { + throw new IllegalArgumentException(); + } + this.logic.add(logic); + } + + @SideOnly(Side.CLIENT) + @Override + public TextureAtlasSprite getSprite() { + return TextureManagerForestry.getInstance().getDefault("analyzer/" + name().toLowerCase(Locale.ENGLISH)); + } + + @SideOnly(Side.CLIENT) + @Override + public ResourceLocation getTextureMap() { + return TextureManagerForestry.LOCATION_FORESTRY_TEXTURE; + } + + @Override + public String getUID() { + return uid; + } + +} diff --git a/src/main/java/forestry/sorting/DummyFilterRegistry.java b/src/main/java/forestry/sorting/DummyFilterRegistry.java new file mode 100644 index 000000000..e310f6c04 --- /dev/null +++ b/src/main/java/forestry/sorting/DummyFilterRegistry.java @@ -0,0 +1,41 @@ +package forestry.sorting; + +import javax.annotation.Nullable; +import java.util.Collection; +import java.util.Collections; + +import forestry.api.genetics.IFilterRegistry; +import forestry.api.genetics.IFilterRule; + +public class DummyFilterRegistry implements IFilterRegistry { + @Override + public void registerFilter(IFilterRule rule) { + } + + @Override + public Collection getRules() { + return Collections.emptySet(); + } + + @Override + public IFilterRule getDefaultRule() { + return DefaultFilterRule.CLOSED; + } + + @Nullable + @Override + public IFilterRule getRule(String uid) { + return null; + } + + @Nullable + @Override + public IFilterRule getRule(int id) { + return null; + } + + @Override + public int getId(IFilterRule rule) { + return 0; + } +} diff --git a/src/main/java/forestry/sorting/FilterData.java b/src/main/java/forestry/sorting/FilterData.java new file mode 100644 index 000000000..648469ce8 --- /dev/null +++ b/src/main/java/forestry/sorting/FilterData.java @@ -0,0 +1,53 @@ +package forestry.sorting; + +import javax.annotation.Nullable; +import java.util.NoSuchElementException; + +import forestry.api.genetics.IFilterData; +import forestry.api.genetics.IIndividual; +import forestry.api.genetics.ISpeciesRoot; +import forestry.api.genetics.ISpeciesType; + +public class FilterData implements IFilterData { + @Nullable + private ISpeciesRoot root; + @Nullable + private IIndividual individual; + @Nullable + private ISpeciesType type; + + public FilterData(@Nullable ISpeciesRoot root, @Nullable IIndividual individual, @Nullable ISpeciesType type) { + this.root = root; + this.individual = individual; + this.type = type; + } + + @Override + public ISpeciesRoot getRoot() { + if (root == null) { + throw new NoSuchElementException("No root present"); + } + return root; + } + + @Override + public IIndividual getIndividual() { + if (individual == null) { + throw new NoSuchElementException("No individual present"); + } + return individual; + } + + @Override + public ISpeciesType getType() { + if (type == null) { + throw new NoSuchElementException("No type present"); + } + return type; + } + + @Override + public boolean isPresent() { + return root != null && individual != null && type != null; + } +} diff --git a/src/main/java/forestry/sorting/FilterRegistry.java b/src/main/java/forestry/sorting/FilterRegistry.java new file mode 100644 index 000000000..c1c9a087d --- /dev/null +++ b/src/main/java/forestry/sorting/FilterRegistry.java @@ -0,0 +1,50 @@ +package forestry.sorting; + +import javax.annotation.Nullable; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedHashMap; + +import forestry.api.genetics.IFilterRegistry; +import forestry.api.genetics.IFilterRule; + +public class FilterRegistry implements IFilterRegistry { + private final HashMap filterByName = new LinkedHashMap<>(); + private final HashMap filterIDByName = new LinkedHashMap<>(); + private final HashMap filterByID = new LinkedHashMap<>(); + private int ids; + + @Override + public void registerFilter(IFilterRule rule) { + filterByName.put(rule.getUID(), rule); + filterIDByName.put(rule.getUID(), ids++); + filterByID.put(ids - 1, rule); + } + + @Override + public Collection getRules() { + return filterByName.values(); + } + + @Override + public IFilterRule getDefaultRule() { + return DefaultFilterRule.ITEM; + } + + @Nullable + @Override + public IFilterRule getRule(String uid) { + return filterByName.get(uid); + } + + @Override + public int getId(IFilterRule rule) { + return filterIDByName.get(rule.getUID()); + } + + @Nullable + @Override + public IFilterRule getRule(int id) { + return filterByID.get(id); + } +} diff --git a/src/main/java/forestry/sorting/ModuleSorting.java b/src/main/java/forestry/sorting/ModuleSorting.java new file mode 100644 index 000000000..3f59484a2 --- /dev/null +++ b/src/main/java/forestry/sorting/ModuleSorting.java @@ -0,0 +1,103 @@ +package forestry.sorting; + +import com.google.common.base.Preconditions; + +import javax.annotation.Nullable; + +import net.minecraft.item.ItemStack; + +import net.minecraftforge.fml.common.registry.GameRegistry; + +import forestry.api.genetics.AlleleManager; +import forestry.api.modules.ForestryModule; +import forestry.apiculture.ModuleApiculture; +import forestry.core.ModuleCore; +import forestry.core.config.Constants; +import forestry.core.network.IPacketRegistry; +import forestry.core.recipes.RecipeUtil; +import forestry.core.utils.OreDictUtil; +import forestry.lepidopterology.ModuleLepidopterology; +import forestry.modules.BlankForestryModule; +import forestry.modules.ForestryModuleUids; +import forestry.modules.ModuleManager; +import forestry.sorting.blocks.BlockRegistrySorting; +import forestry.sorting.network.PacketRegistrySorting; +import forestry.sorting.tiles.TileGeneticFilter; + +@ForestryModule(containerID = Constants.MOD_ID, moduleID = ForestryModuleUids.SORTING, name = "Sorting", author = "Nedelosk", url = Constants.URL, unlocalizedDescription = "for.module.sorting.description") +public class ModuleSorting extends BlankForestryModule { + @Nullable + private static BlockRegistrySorting blocks; + + public static BlockRegistrySorting getBlocks() { + Preconditions.checkState(blocks != null); + return blocks; + } + + @Override + public IPacketRegistry getPacketRegistry() { + return new PacketRegistrySorting(); + } + + @Override + public void setupAPI() { + AlleleManager.filterRegistry = new FilterRegistry(); + } + + @Override + public void disabledSetupAPI() { + AlleleManager.filterRegistry = new DummyFilterRegistry(); + } + + @Override + public void registerItemsAndBlocks() { + blocks = new BlockRegistrySorting(); + } + + @Override + public void preInit() { + DefaultFilterRule.init(); + } + + @Override + public void registerRecipes() { + if(ModuleManager.getInstance().isModuleEnabled(Constants.MOD_ID, ForestryModuleUids.APICULTURE)) { + RecipeUtil.addRecipe("genetic_filter_api", new ItemStack(getBlocks().filter, 2), + "WDW", + "PGP", + "BDB", + 'D', OreDictUtil.GEM_DIAMOND, + 'W', OreDictUtil.PLANK_WOOD, + 'G', OreDictUtil.BLOCK_GLASS, + 'B', ModuleCore.getItems().gearBronze, + 'P', ModuleApiculture.getItems().propolis); + } + if(ModuleManager.getInstance().isModuleEnabled(Constants.MOD_ID, ForestryModuleUids.ARBORICULTURE)) { + RecipeUtil.addRecipe("genetic_filter_arb", new ItemStack(getBlocks().filter, 2), + "WDW", + "FGF", + "BDB", + 'D', OreDictUtil.GEM_DIAMOND, + 'W', OreDictUtil.PLANK_WOOD, + 'G', OreDictUtil.BLOCK_GLASS, + 'B', ModuleCore.getItems().gearBronze, + 'F', OreDictUtil.FRUIT_FORESTRY); + } + if(ModuleManager.getInstance().isModuleEnabled(Constants.MOD_ID, ForestryModuleUids.LEPIDOPTEROLOGY)) { + RecipeUtil.addRecipe("genetic_filter_lep", new ItemStack(getBlocks().filter, 2), + "WDW", + "FGF", + "BDB", + 'D', OreDictUtil.GEM_DIAMOND, + 'W', OreDictUtil.PLANK_WOOD, + 'G', OreDictUtil.BLOCK_GLASS, + 'B', ModuleCore.getItems().gearBronze, + 'F', ModuleLepidopterology.getItems().caterpillarGE); + } + } + + @Override + public void doInit() { + GameRegistry.registerTileEntity(TileGeneticFilter.class, "forestry.GeneticFilter"); + } +} diff --git a/src/main/java/forestry/sorting/blocks/BlockGeneticFilter.java b/src/main/java/forestry/sorting/blocks/BlockGeneticFilter.java new file mode 100644 index 000000000..35df1193d --- /dev/null +++ b/src/main/java/forestry/sorting/blocks/BlockGeneticFilter.java @@ -0,0 +1,116 @@ +package forestry.sorting.blocks; + +import net.minecraft.block.material.Material; +import net.minecraft.block.properties.PropertyBool; +import net.minecraft.block.state.BlockStateContainer; +import net.minecraft.block.state.IBlockState; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +import forestry.api.core.IItemModelRegister; +import forestry.api.core.IModelManager; +import forestry.core.CreativeTabForestry; +import forestry.core.blocks.BlockForestry; +import forestry.core.gui.GuiHandler; +import forestry.core.tiles.TileUtil; +import forestry.sorting.tiles.TileGeneticFilter; + +public class BlockGeneticFilter extends BlockForestry implements IItemModelRegister { + public static final PropertyBool NORTH = PropertyBool.create("north"); + public static final PropertyBool EAST = PropertyBool.create("east"); + public static final PropertyBool SOUTH = PropertyBool.create("south"); + public static final PropertyBool WEST = PropertyBool.create("west"); + public static final PropertyBool UP = PropertyBool.create("up"); + public static final PropertyBool DOWN = PropertyBool.create("down"); + + private static final AxisAlignedBB BOX_CENTER = new AxisAlignedBB(0.25, 0.25, 0.25, 0.75, 0.75, 0.75); + private static final AxisAlignedBB BOX_DOWN = new AxisAlignedBB(0.25, 0, 0.25, 0.75, 0.25, 0.75); + private static final AxisAlignedBB BOX_UP = new AxisAlignedBB(0.25, 0.75, 0.25, 0.75, 1, 0.75); + private static final AxisAlignedBB BOX_NORTH = new AxisAlignedBB(0.25, 0.25, 0, 0.75, 0.75, 0.25); + private static final AxisAlignedBB BOX_SOUTH = new AxisAlignedBB(0.25, 0.25, 0.75, 0.75, 0.75, 1); + private static final AxisAlignedBB BOX_WEST = new AxisAlignedBB(0, 0.25, 0.25, 0.25, 0.75, 0.75); + private static final AxisAlignedBB BOX_EAST = new AxisAlignedBB(0.75, 0.25, 0.25, 1, 0.75, 0.75); + private static final AxisAlignedBB[] BOX_FACES = {BOX_DOWN, BOX_UP, BOX_NORTH, BOX_SOUTH, BOX_WEST, BOX_EAST}; + + public BlockGeneticFilter() { + super(Material.WOOD); + setCreativeTab(CreativeTabForestry.tabForestry); + this.setDefaultState(this.blockState.getBaseState() + .withProperty(NORTH, false) + .withProperty(EAST, false) + .withProperty(SOUTH, false) + .withProperty(WEST, false) + .withProperty(UP, false) + .withProperty(DOWN, false)); + } + + @Override + public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) { + TileGeneticFilter geneticFilter = TileUtil.getTile(worldIn, pos, TileGeneticFilter.class); + if (geneticFilter == null) { + return getDefaultState(); + } + return state.withProperty(NORTH, geneticFilter.isConnected(EnumFacing.NORTH)) + .withProperty(EAST, geneticFilter.isConnected(EnumFacing.EAST)) + .withProperty(SOUTH, geneticFilter.isConnected(EnumFacing.SOUTH)) + .withProperty(WEST, geneticFilter.isConnected(EnumFacing.WEST)) + .withProperty(UP, geneticFilter.isConnected(EnumFacing.UP)) + .withProperty(DOWN, geneticFilter.isConnected(EnumFacing.DOWN)); + } + + @Override + public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) { + TileGeneticFilter tile = TileUtil.getTile(worldIn, pos, TileGeneticFilter.class); + if (tile != null) { + if (TileUtil.isUsableByPlayer(playerIn, tile)) { + if (!worldIn.isRemote) { + GuiHandler.openGui(playerIn, tile); + } + return true; + } + } + return false; + } + + @Override + public void registerModel(Item item, IModelManager manager) { + manager.registerItemModel(item, 0); + } + + @Override + protected BlockStateContainer createBlockState() { + return new BlockStateContainer(this, NORTH, EAST, SOUTH, WEST, UP, DOWN); + } + + @Override + public TileEntity createNewTileEntity(World worldIn, int meta) { + return new TileGeneticFilter(); + } + + @Override + public int getMetaFromState(IBlockState state) { + return 0; + } + + @Override + public boolean isFullCube(IBlockState state) { + return false; + } + + @Override + public boolean isFullBlock(IBlockState state) { + return false; + } + + @Override + public boolean isOpaqueCube(IBlockState state) { + return false; + } +} diff --git a/src/main/java/forestry/sorting/blocks/BlockRegistrySorting.java b/src/main/java/forestry/sorting/blocks/BlockRegistrySorting.java new file mode 100644 index 000000000..b0eefd14c --- /dev/null +++ b/src/main/java/forestry/sorting/blocks/BlockRegistrySorting.java @@ -0,0 +1,14 @@ +package forestry.sorting.blocks; + +import forestry.core.blocks.BlockRegistry; +import forestry.core.items.ItemBlockForestry; + +public class BlockRegistrySorting extends BlockRegistry { + + public final BlockGeneticFilter filter; + + public BlockRegistrySorting() { + filter = new BlockGeneticFilter(); + registerBlock(filter, new ItemBlockForestry<>(filter), "genetic_filter"); + } +} diff --git a/src/main/java/forestry/sorting/blocks/package-info.java b/src/main/java/forestry/sorting/blocks/package-info.java new file mode 100644 index 000000000..02486a0b8 --- /dev/null +++ b/src/main/java/forestry/sorting/blocks/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.sorting.blocks; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/sorting/gui/ContainerGeneticFilter.java b/src/main/java/forestry/sorting/gui/ContainerGeneticFilter.java new file mode 100644 index 000000000..9847746c6 --- /dev/null +++ b/src/main/java/forestry/sorting/gui/ContainerGeneticFilter.java @@ -0,0 +1,51 @@ +package forestry.sorting.gui; + +import net.minecraft.entity.player.InventoryPlayer; + +import forestry.core.gui.ContainerTile; +import forestry.core.network.packets.PacketGuiUpdate; +import forestry.sorting.tiles.TileGeneticFilter; + +public class ContainerGeneticFilter extends ContainerTile { + private boolean guiNeedsUpdate = true; + + public ContainerGeneticFilter(TileGeneticFilter tileForestry, InventoryPlayer playerInventory) { + super(tileForestry); + addInventory(playerInventory, 26, 140); + } + + protected void addInventory(InventoryPlayer playerInventory, int xInv, int yInv) { + // Player inventory + for (int row = 0; row < 3; row++) { + for (int column = 0; column < 9; column++) { + addSlotToContainer(new SlotGeneticFilter(playerInventory, column + row * 9 + 9, xInv + column * 18, yInv + row * 18)); + } + } + // Player hotbar + for (int column = 0; column < 9; column++) { + addSlotToContainer(new SlotGeneticFilter(playerInventory, column, xInv + column * 18, yInv + 58)); + } + + for (int x = 0; x < 6; x++) { + addSlotToContainer(new SlotFilterFacing(tile, x, 8, 18 + x * 18)); + } + } + + public void setGuiNeedsUpdate(boolean guiNeedsUpdate) { + this.guiNeedsUpdate = guiNeedsUpdate; + } + + @Override + public void detectAndSendChanges() { + super.detectAndSendChanges(); + if (guiNeedsUpdate) { + PacketGuiUpdate packet = new PacketGuiUpdate(tile); + sendPacketToListeners(packet); + guiNeedsUpdate = false; + } + } + + public boolean hasSameTile(ContainerGeneticFilter openContainer) { + return tile == openContainer.tile; + } +} diff --git a/src/main/java/forestry/sorting/gui/GuiGeneticFilter.java b/src/main/java/forestry/sorting/gui/GuiGeneticFilter.java new file mode 100644 index 000000000..2c6b64414 --- /dev/null +++ b/src/main/java/forestry/sorting/gui/GuiGeneticFilter.java @@ -0,0 +1,160 @@ +package forestry.sorting.gui; + +import javax.annotation.Nullable; +import java.io.IOException; + +import net.minecraft.client.gui.GuiTextField; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.ResourceLocation; + +import forestry.core.config.Constants; +import forestry.core.gui.Drawable; +import forestry.core.gui.GuiForestryTitled; +import forestry.core.gui.widgets.Widget; +import forestry.core.gui.widgets.WidgetScrollBar; +import forestry.sorting.gui.widgets.RuleWidget; +import forestry.sorting.gui.widgets.SelectionWidget; +import forestry.sorting.gui.widgets.SpeciesWidget; +import forestry.sorting.tiles.TileGeneticFilter; + +public class GuiGeneticFilter extends GuiForestryTitled { + + private final TileGeneticFilter tile; + private final WidgetScrollBar scrollBar; + public final SelectionWidget selection; + @Nullable + private GuiTextField searchField; + + public GuiGeneticFilter(TileGeneticFilter tile, InventoryPlayer inventory) { + super(Constants.TEXTURE_PATH_GUI + "/filter.png", new ContainerGeneticFilter(tile, inventory), tile); + ySize = 222; + xSize = 212; + this.tile = tile; + + for (int i = 0; i < 6; i++) { + EnumFacing facing = EnumFacing.getFront(i); + widgetManager.add(new RuleWidget(widgetManager, 8 + 36, 18 + i * 18, facing, this)); + } + + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + for (int k = 0; k < 2; k++) { + widgetManager.add(new SpeciesWidget(widgetManager, 44 + 36 + j * 45 + k * 18, 18 + i * 18, EnumFacing.getFront(i), j, k == 0, this)); + } + } + } + + this.scrollBar = new WidgetScrollBar(widgetManager, 157 + 36, 150, 12, 64, new Drawable(new ResourceLocation(Constants.TEXTURE_PATH_GUI + "/container/creative_inventory/tabs.png"), 232, 0, 12, 15)); + widgetManager.add(this.selection = new SelectionWidget(widgetManager, 0, 134, scrollBar, this)); + widgetManager.add(scrollBar); + scrollBar.setVisible(false); + } + + public void onModuleClick(ISelectableProvider provider) { + if (selection.isSame(provider)) { + deselectFilter(); + } else { + selectFilter(provider); + } + } + + private void selectFilter(ISelectableProvider provider) { + selection.setProvider(provider); + if (searchField != null) { + searchField.setEnabled(true); + searchField.setVisible(true); + } + selection.filterEntries(searchField != null ? searchField.getText() : ""); + for (Slot slot : inventorySlots.inventorySlots) { + if (slot instanceof SlotGeneticFilter) { + SlotGeneticFilter filter = (SlotGeneticFilter) slot; + filter.setEnabled(false); + } + } + } + + private void deselectFilter() { + this.selection.setProvider(null); + if (searchField != null) { + searchField.setEnabled(false); + searchField.setVisible(false); + } + scrollBar.setVisible(false); + for (Slot slot : inventorySlots.inventorySlots) { + if (slot instanceof SlotGeneticFilter) { + SlotGeneticFilter filter = (SlotGeneticFilter) slot; + filter.setEnabled(true); + } + } + } + + @Override + public void initGui() { + super.initGui(); + + String oldString = searchField != null ? searchField.getText() : ""; + + this.searchField = new GuiTextField(0, this.fontRenderer, this.guiLeft + selection.getX() + 89 + 36, selection.getY() + this.guiTop + 4, 80, this.fontRenderer.FONT_HEIGHT); + this.searchField.setMaxStringLength(50); + this.searchField.setEnableBackgroundDrawing(false); + this.searchField.setTextColor(16777215); + this.searchField.setText(oldString); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float f, int mouseX, int mouseY) { + super.drawGuiContainerBackgroundLayer(f, mouseX, mouseY); + + GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F); + GlStateManager.disableLighting(); + if (searchField != null) { + this.searchField.drawTextBox(); + } + } + + @Override + protected void keyTyped(char typedChar, int keyCode) throws IOException { + if (searchField != null && this.searchField.textboxKeyTyped(typedChar, keyCode)) { + scrollBar.setValue(0); + selection.filterEntries(searchField.getText()); + } else { + super.keyTyped(typedChar, keyCode); + } + } + + @Nullable + @Override + protected Slot getSlotAtPosition(int mouseX, int mouseY) { + Slot slot = super.getSlotAtPosition(mouseX, mouseY); + if (slot instanceof SlotGeneticFilter && selection.getLogic() != null) { + return null; + } + return slot; + } + + @Override + protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException { + super.mouseClicked(mouseX, mouseY, mouseButton); + + if (searchField != null) { + searchField.mouseClicked(mouseX, mouseY, mouseButton); + } + Widget widget = widgetManager.getAtPosition(mouseX - guiLeft, mouseY - guiTop); + if (widget == null) { + deselectFilter(); + } + } + + @Override + protected void addLedgers() { + addHintLedger("filter"); + } + + + public TileGeneticFilter getTile() { + return tile; + } +} diff --git a/src/main/java/forestry/sorting/gui/ISelectableProvider.java b/src/main/java/forestry/sorting/gui/ISelectableProvider.java new file mode 100644 index 000000000..00f72dbc4 --- /dev/null +++ b/src/main/java/forestry/sorting/gui/ISelectableProvider.java @@ -0,0 +1,15 @@ +package forestry.sorting.gui; + +import java.util.Collection; + +import forestry.core.gui.GuiForestry; + +public interface ISelectableProvider { + Collection getEntries(); + + void onSelect(S selectable); + + void draw(GuiForestry gui, S selectable, int x, int y); + + String getName(S selectable); +} diff --git a/src/main/java/forestry/sorting/gui/SlotFilterFacing.java b/src/main/java/forestry/sorting/gui/SlotFilterFacing.java new file mode 100644 index 000000000..0c252c6f6 --- /dev/null +++ b/src/main/java/forestry/sorting/gui/SlotFilterFacing.java @@ -0,0 +1,36 @@ +package forestry.sorting.gui; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.core.render.TextureManagerForestry; + +public class SlotFilterFacing extends Slot { + + public SlotFilterFacing(IInventory inventoryIn, int index, int xPosition, int yPosition) { + super(inventoryIn, index, xPosition, yPosition); + } + + @Override + public boolean isItemValid(ItemStack stack) { + return false; + } + + @SideOnly(Side.CLIENT) + @Override + public ResourceLocation getBackgroundLocation() { + return TextureManagerForestry.getInstance().getGuiTextureMap(); + } + + @SideOnly(Side.CLIENT) + @Override + public TextureAtlasSprite getBackgroundSprite() { + return TextureManagerForestry.getInstance().getDefault("slots/bee"); + } +} diff --git a/src/main/java/forestry/sorting/gui/SlotGeneticFilter.java b/src/main/java/forestry/sorting/gui/SlotGeneticFilter.java new file mode 100644 index 000000000..af57d099d --- /dev/null +++ b/src/main/java/forestry/sorting/gui/SlotGeneticFilter.java @@ -0,0 +1,21 @@ +package forestry.sorting.gui; + +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; + +public class SlotGeneticFilter extends Slot { + private boolean enabled = true; + + public SlotGeneticFilter(IInventory inventoryIn, int index, int xPosition, int yPosition) { + super(inventoryIn, index, xPosition, yPosition); + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + } + + @Override + public boolean isEnabled() { + return enabled; + } +} diff --git a/src/main/java/forestry/sorting/gui/package-info.java b/src/main/java/forestry/sorting/gui/package-info.java new file mode 100644 index 000000000..30d142f7d --- /dev/null +++ b/src/main/java/forestry/sorting/gui/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.sorting.gui; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/sorting/gui/widgets/RuleWidget.java b/src/main/java/forestry/sorting/gui/widgets/RuleWidget.java new file mode 100644 index 000000000..1b5597c7e --- /dev/null +++ b/src/main/java/forestry/sorting/gui/widgets/RuleWidget.java @@ -0,0 +1,107 @@ +package forestry.sorting.gui.widgets; + +import com.google.common.collect.ImmutableSet; + +import java.util.Collection; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.util.EnumFacing; + +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IFilterRule; +import forestry.core.gui.GuiForestry; +import forestry.core.gui.tooltips.ToolTip; +import forestry.core.gui.widgets.Widget; +import forestry.core.gui.widgets.WidgetManager; +import forestry.core.utils.NetworkUtil; +import forestry.core.utils.SoundUtil; +import forestry.core.utils.Translator; +import forestry.sorting.gui.GuiGeneticFilter; +import forestry.sorting.gui.ISelectableProvider; +import forestry.sorting.network.packets.PacketFilterChangeRule; +import forestry.sorting.tiles.TileGeneticFilter; + +public class RuleWidget extends Widget implements ISelectableProvider { + private static final ImmutableSet ENTRIES = createEntries(); + + private final EnumFacing facing; + private final GuiGeneticFilter gui; + + public RuleWidget(WidgetManager manager, int xPos, int yPos, EnumFacing facing, GuiGeneticFilter gui) { + super(manager, xPos, yPos); + this.facing = facing; + this.gui = gui; + } + + @Override + public void draw(int startX, int startY) { + int x = xPos + startX; + int y = yPos + startY; + IFilterRule rule = gui.getTile().getRule(facing); + draw(manager.gui, rule, x, y); + TextureManager textureManager = Minecraft.getMinecraft().getTextureManager(); + if (this.gui.selection.isSame(this)) { + textureManager.bindTexture(SelectionWidget.TEXTURE); + gui.drawTexturedModalRect(x - 1, y - 1, 212, 0, 18, 18); + } + } + + @Override + public Collection getEntries() { + return ENTRIES; + } + + @Override + public void draw(GuiForestry gui, IFilterRule selectable, int x, int y) { + TextureManager textureManager = Minecraft.getMinecraft().getTextureManager(); + textureManager.bindTexture(selectable.getTextureMap()); + + TextureAtlasSprite sprite = selectable.getSprite(); + gui.drawTexturedModalRect(x, y, sprite, 16, 16); + } + + @Override + public String getName(IFilterRule selectable) { + return Translator.translateToLocal("for.gui.filter." + selectable.getUID()); + } + + @Override + public void onSelect(IFilterRule selectable) { + TileGeneticFilter filter = gui.getTile(); + if (filter.setRule(facing, selectable)) { + NetworkUtil.sendToServer(new PacketFilterChangeRule(filter, facing, selectable)); + } + if (gui.selection.isSame(this)) { + gui.onModuleClick(this); + } + SoundUtil.playButtonClick(); + } + + @Override + public void handleMouseClick(int mouseX, int mouseY, int mouseButton) { + if (mouseButton == 1) { + onSelect(AlleleManager.filterRegistry.getDefaultRule()); + } else { + SoundUtil.playButtonClick(); + gui.onModuleClick(this); + } + } + + @Override + public ToolTip getToolTip(int mouseX, int mouseY) { + IFilterRule rule = gui.getTile().getRule(facing); + ToolTip tooltip = new ToolTip(); + tooltip.add(getName(rule)); + return tooltip; + } + + private static ImmutableSet createEntries() { + ImmutableSet.Builder entries = ImmutableSet.builder(); + for (IFilterRule rule : AlleleManager.filterRegistry.getRules()) { + entries.add(rule); + } + return entries.build(); + } +} diff --git a/src/main/java/forestry/sorting/gui/widgets/SelectionLogic.java b/src/main/java/forestry/sorting/gui/widgets/SelectionLogic.java new file mode 100644 index 000000000..13fb818c8 --- /dev/null +++ b/src/main/java/forestry/sorting/gui/widgets/SelectionLogic.java @@ -0,0 +1,148 @@ +package forestry.sorting.gui.widgets; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Comparator; +import java.util.HashSet; +import java.util.Set; +import java.util.regex.Pattern; + +import forestry.core.gui.GuiForestry; +import forestry.core.gui.tooltips.ToolTip; +import forestry.core.gui.widgets.IScrollable; +import forestry.sorting.gui.ISelectableProvider; + +public class SelectionLogic implements IScrollable { + private static final int SELECTABLE_PER_ROW = 11; + + private final ISelectableProvider provider; + private final Comparator comparator; + private final SelectionWidget widget; + private final Collection entries; + private ArrayList sorted = new ArrayList<>(); + private Set visible = new HashSet<>(); + + public SelectionLogic(SelectionWidget widget, ISelectableProvider provider) { + this.widget = widget; + this.provider = provider; + this.entries = provider.getEntries(); + this.comparator = (S f, S s) -> provider.getName(f).compareToIgnoreCase(provider.getName(s)); + + } + + public boolean isSame(ISelectableProvider provider) { + return this.provider == provider; + } + + @Override + public void onScroll(int value) { + visible.clear(); + int startIndex = value * SELECTABLE_PER_ROW; + Y: + for (int y = 0; y < 4; y++) { + for (int x = 0; x < SELECTABLE_PER_ROW; x++) { + int index = startIndex + y * SELECTABLE_PER_ROW + x; + if (index >= sorted.size()) { + break Y; + } + visible.add(new SelectableWidget(sorted.get(index), widget.getX() + 12 + x * 16, widget.getY() + 16 + y * 16)); + } + } + } + + public Set getVisible() { + return visible; + } + + public void filterEntries(String searchText) { + sorted.clear(); + sorted.ensureCapacity(entries.size()); + + Pattern pattern; + try { + pattern = Pattern.compile(searchText.toLowerCase(), Pattern.CASE_INSENSITIVE); + } catch (Throwable ignore) { + try { + pattern = Pattern.compile(Pattern.quote(searchText.toLowerCase()), Pattern.CASE_INSENSITIVE); + } catch (Throwable e) { + return; + } + } + + for (S entry : entries) { + String name = provider.getName(entry); + if (pattern.matcher(name.toLowerCase()).find()) { + sorted.add(entry); + } + } + sorted.sort(comparator); + + int elements = sorted.size() / SELECTABLE_PER_ROW - 4; + if (elements > 0) { + widget.scrollBar.setParameters(this, 0, elements, 1); + } else { + onScroll(0); + } + widget.scrollBar.setVisible(elements > 0); + + } + + @Override + public boolean isFocused(int mouseX, int mouseY) { + return widget.isMouseOver(mouseX, mouseY); + } + + public void draw() { + for (SelectableWidget selectable : visible) { + selectable.draw(widget.gui); + } + } + + @Nullable + public ToolTip getToolTip(int mouseX, int mouseY) { + for (SelectableWidget selectable : visible) { + if (selectable.isMouseOver(mouseX, mouseY)) { + return selectable.getToolTip(); + } + } + return null; + } + + public void select(int mouseX, int mouseY) { + mouseX -= widget.gui.getGuiLeft(); + mouseY -= widget.gui.getGuiTop(); + for (SelectableWidget selectable : visible) { + if (selectable.isMouseOver(mouseX, mouseY)) { + provider.onSelect(selectable.selectable); + break; + } + } + } + + private class SelectableWidget { + private final S selectable; + private final int xPos; + private final int yPos; + + public SelectableWidget(S entry, int xPos, int yPos) { + this.selectable = entry; + this.xPos = xPos; + this.yPos = yPos; + } + + public void draw(GuiForestry gui) { + provider.draw(gui, selectable, xPos, yPos); + } + + public boolean isMouseOver(int mouseX, int mouseY) { + return mouseX >= xPos && mouseX <= xPos + 16 && mouseY >= yPos && mouseY <= yPos + 16; + } + + public ToolTip getToolTip() { + ToolTip toolTip = new ToolTip(); + toolTip.add(provider.getName(selectable)); + return toolTip; + } + } +} diff --git a/src/main/java/forestry/sorting/gui/widgets/SelectionWidget.java b/src/main/java/forestry/sorting/gui/widgets/SelectionWidget.java new file mode 100644 index 000000000..a2fcea3b1 --- /dev/null +++ b/src/main/java/forestry/sorting/gui/widgets/SelectionWidget.java @@ -0,0 +1,91 @@ +package forestry.sorting.gui.widgets; + +import javax.annotation.Nullable; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.util.ResourceLocation; + +import forestry.core.config.Constants; +import forestry.core.gui.tooltips.ToolTip; +import forestry.core.gui.widgets.Widget; +import forestry.core.gui.widgets.WidgetManager; +import forestry.core.gui.widgets.WidgetScrollBar; +import forestry.core.utils.Translator; +import forestry.sorting.gui.GuiGeneticFilter; +import forestry.sorting.gui.ISelectableProvider; + +public class SelectionWidget extends Widget { + public static final ResourceLocation TEXTURE = new ResourceLocation(Constants.MOD_ID, Constants.TEXTURE_PATH_GUI + "/filter_selection.png"); + final WidgetScrollBar scrollBar; + @Nullable + private SelectionLogic logic; + final GuiGeneticFilter gui; + + public SelectionWidget(WidgetManager manager, int xPos, int yPos, WidgetScrollBar scrollBar, GuiGeneticFilter gui) { + super(manager, xPos, yPos); + this.width = 212; + this.height = 88; + this.scrollBar = scrollBar; + this.gui = gui; + } + + public void setProvider(@Nullable ISelectableProvider provider) { + if (provider == null) { + logic = null; + } else { + this.logic = new SelectionLogic<>(this, provider); + } + } + + public boolean isSame(ISelectableProvider provider) { + return logic != null && logic.isSame(provider); + } + + @Nullable + public SelectionLogic getLogic() { + return logic; + } + + @Override + public void draw(int startX, int startY) { + if (logic == null) { + return; + } + TextureManager textureManager = Minecraft.getMinecraft().getTextureManager(); + textureManager.bindTexture(TEXTURE); + manager.gui.drawTexturedModalRect(startX + xPos, startY + yPos, 0, 0, width, height); + logic.draw(); + + manager.minecraft.fontRenderer.drawString(Translator.translateToLocal("for.gui.filter.seletion"), startX + xPos + 12, startY + yPos + 4, manager.gui.getFontColor().get("gui.title")); + } + + @Override + public boolean isMouseOver(int mouseX, int mouseY) { + return logic != null && super.isMouseOver(mouseX, mouseY); + } + + @Nullable + @Override + public ToolTip getToolTip(int mouseX, int mouseY) { + if (logic == null) { + return null; + } + return logic.getToolTip(mouseX, mouseY); + } + + @Override + public void handleMouseClick(int mouseX, int mouseY, int mouseButton) { + if (logic == null) { + return; + } + logic.select(mouseX, mouseY); + } + + public void filterEntries(String filter) { + if (logic == null) { + return; + } + logic.filterEntries(filter); + } +} diff --git a/src/main/java/forestry/sorting/gui/widgets/SpeciesWidget.java b/src/main/java/forestry/sorting/gui/widgets/SpeciesWidget.java new file mode 100644 index 000000000..a20f900b4 --- /dev/null +++ b/src/main/java/forestry/sorting/gui/widgets/SpeciesWidget.java @@ -0,0 +1,151 @@ +package forestry.sorting.gui.widgets; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; + +import javax.annotation.Nullable; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; + +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleSpecies; +import forestry.api.genetics.IBreedingTracker; +import forestry.api.genetics.IGenome; +import forestry.api.genetics.IIndividual; +import forestry.api.genetics.ISpeciesRoot; +import forestry.core.gui.GuiForestry; +import forestry.core.gui.GuiUtil; +import forestry.core.gui.tooltips.ToolTip; +import forestry.core.gui.widgets.Widget; +import forestry.core.gui.widgets.WidgetManager; +import forestry.core.utils.NetworkUtil; +import forestry.core.utils.SoundUtil; +import forestry.sorting.AlleleFilter; +import forestry.sorting.gui.GuiGeneticFilter; +import forestry.sorting.gui.ISelectableProvider; +import forestry.sorting.network.packets.PacketFilterChangeGenome; +import forestry.sorting.tiles.TileGeneticFilter; + +public class SpeciesWidget extends Widget implements ISelectableProvider { + private final static ImmutableMap ITEMS = createEntries(); + private final ImmutableSet entries; + + private final EnumFacing facing; + private final int index; + private final boolean active; + private final GuiGeneticFilter gui; + + public SpeciesWidget(WidgetManager manager, int xPos, int yPos, EnumFacing facing, int index, boolean active, GuiGeneticFilter gui) { + super(manager, xPos, yPos); + this.facing = facing; + this.index = index; + this.active = active; + this.gui = gui; + ImmutableSet.Builder entries = ImmutableSet.builder(); + for (ISpeciesRoot root : AlleleManager.alleleRegistry.getSpeciesRoot().values()) { + IBreedingTracker tracker = root.getBreedingTracker(manager.minecraft.world, manager.minecraft.player.getGameProfile()); + for (String uid : tracker.getDiscoveredSpecies()) { + IAllele allele = AlleleManager.alleleRegistry.getAllele(uid); + if (allele instanceof IAlleleSpecies) { + IAlleleSpecies species = (IAlleleSpecies) allele; + entries.add(species); + } + } + } + this.entries = entries.build(); + } + + @Override + public void draw(int startX, int startY) { + int x = xPos + startX; + int y = yPos + startY; + AlleleFilter filter = gui.getTile().getGenomeFilter(facing, index); + if (filter != null) { + IAlleleSpecies allele = (IAlleleSpecies) (active ? filter.activeAllele : filter.inactiveAllele); + GuiUtil.drawItemStack(manager.gui, ITEMS.getOrDefault(allele, ItemStack.EMPTY), x, y); + } + TextureManager textureManager = Minecraft.getMinecraft().getTextureManager(); + if (this.gui.selection.isSame(this)) { + textureManager.bindTexture(SelectionWidget.TEXTURE); + gui.drawTexturedModalRect(x - 1, y - 1, 212, 0, 18, 18); + } + } + + @Override + public ImmutableSet getEntries() { + return entries; + } + + @Override + public void onSelect(@Nullable IAlleleSpecies selectable) { + TileGeneticFilter filter = gui.getTile(); + if (filter.setGenomeFilter(facing, index, active, selectable)) { + NetworkUtil.sendToServer(new PacketFilterChangeGenome(filter.getPos(), facing, (short) index, active, selectable)); + } + if (gui.selection.isSame(this)) { + gui.onModuleClick(this); + } + SoundUtil.playButtonClick(); + } + + @Override + public void draw(GuiForestry gui, IAlleleSpecies selectable, int x, int y) { + GuiUtil.drawItemStack(gui, ITEMS.getOrDefault(selectable, ItemStack.EMPTY), x, y); + } + + @Override + public String getName(IAlleleSpecies selectable) { + return selectable.getAlleleName(); + } + + @Nullable + @Override + public ToolTip getToolTip(int mouseX, int mouseY) { + AlleleFilter filter = gui.getTile().getGenomeFilter(facing, index); + if (filter == null) { + return null; + } + IAlleleSpecies allele = (IAlleleSpecies) (active ? filter.activeAllele : filter.inactiveAllele); + if (allele == null) { + return null; + } + ToolTip tooltip = new ToolTip(); + tooltip.add(getName(allele)); + return tooltip; + } + + @Override + public void handleMouseClick(int mouseX, int mouseY, int mouseButton) { + ItemStack stack = gui.mc.player.inventory.getItemStack(); + if (!stack.isEmpty()) { + IIndividual individual = AlleleManager.alleleRegistry.getIndividual(stack); + if (individual != null) { + IGenome genome = individual.getGenome(); + onSelect(mouseButton == 0 ? genome.getPrimary() : genome.getSecondary()); + return; + } + } + if (mouseButton == 1) { + onSelect(null); + } else { + SoundUtil.playButtonClick(); + gui.onModuleClick(this); + } + } + + private static ImmutableMap createEntries() { + ImmutableMap.Builder entries = ImmutableMap.builder(); + for (ISpeciesRoot root : AlleleManager.alleleRegistry.getSpeciesRoot().values()) { + for (IIndividual individual : root.getIndividualTemplates()) { + IAlleleSpecies species = individual.getGenome().getPrimary(); + ItemStack itemStack = root.getMemberStack(root.templateAsIndividual(root.getTemplate(species)), root.getIconType()); + entries.put(species, itemStack); + } + } + return entries.build(); + } +} diff --git a/src/main/java/forestry/sorting/gui/widgets/package-info.java b/src/main/java/forestry/sorting/gui/widgets/package-info.java new file mode 100644 index 000000000..0c7829915 --- /dev/null +++ b/src/main/java/forestry/sorting/gui/widgets/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.sorting.gui.widgets; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/sorting/inventory/InventoryFilter.java b/src/main/java/forestry/sorting/inventory/InventoryFilter.java new file mode 100644 index 000000000..256632db5 --- /dev/null +++ b/src/main/java/forestry/sorting/inventory/InventoryFilter.java @@ -0,0 +1,18 @@ +package forestry.sorting.inventory; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; + +import forestry.core.inventory.InventoryAdapterTile; +import forestry.sorting.tiles.TileGeneticFilter; + +public class InventoryFilter extends InventoryAdapterTile { + public InventoryFilter(TileGeneticFilter tile) { + super(tile, 6, "Items"); + } + + @Override + public boolean canExtractItem(int slotIndex, ItemStack stack, EnumFacing side) { + return false; + } +} diff --git a/src/main/java/forestry/sorting/inventory/ItemHandlerFilter.java b/src/main/java/forestry/sorting/inventory/ItemHandlerFilter.java new file mode 100644 index 000000000..a34378579 --- /dev/null +++ b/src/main/java/forestry/sorting/inventory/ItemHandlerFilter.java @@ -0,0 +1,53 @@ +package forestry.sorting.inventory; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; + +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.wrapper.InvWrapper; + +import forestry.sorting.tiles.TileGeneticFilter; + +public class ItemHandlerFilter implements IItemHandler { + private final TileGeneticFilter filter; + private final IItemHandler itemHandler; + private final EnumFacing facing; + + public ItemHandlerFilter(TileGeneticFilter filter, EnumFacing facing) { + this.filter = filter; + this.facing = facing; + this.itemHandler = new InvWrapper(filter); + } + + @Override + public int getSlots() { + return 1; + } + + @Override + public ItemStack getStackInSlot(int slot) { + return ItemStack.EMPTY; + } + + @Override + public ItemStack insertItem(int slot, ItemStack stack, boolean simulate) { + ItemStack remaining = stack; + for (EnumFacing facing : filter.getValidDirections(stack, facing)) { + remaining = itemHandler.insertItem(facing.getIndex(), stack, simulate); + if (remaining.isEmpty()) { + return ItemStack.EMPTY; + } + } + return remaining; + } + + @Override + public ItemStack extractItem(int slot, int amount, boolean simulate) { + return ItemStack.EMPTY; + } + + @Override + public int getSlotLimit(int slot) { + return 64; + } +} diff --git a/src/main/java/forestry/sorting/inventory/package-info.java b/src/main/java/forestry/sorting/inventory/package-info.java new file mode 100644 index 000000000..7506d7cd2 --- /dev/null +++ b/src/main/java/forestry/sorting/inventory/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.sorting.inventory; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/sorting/network/PacketRegistrySorting.java b/src/main/java/forestry/sorting/network/PacketRegistrySorting.java new file mode 100644 index 000000000..db4d7e0bc --- /dev/null +++ b/src/main/java/forestry/sorting/network/PacketRegistrySorting.java @@ -0,0 +1,23 @@ +package forestry.sorting.network; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.core.network.IPacketRegistry; +import forestry.core.network.PacketIdServer; +import forestry.sorting.network.packets.PacketFilterChangeGenome; +import forestry.sorting.network.packets.PacketFilterChangeRule; + +public class PacketRegistrySorting implements IPacketRegistry { + @Override + public void registerPacketsServer() { + PacketIdServer.FILTER_CHANGE_RULE.setPacketHandler(new PacketFilterChangeRule.Handler()); + PacketIdServer.FILTER_CHANGE_GENOME.setPacketHandler(new PacketFilterChangeGenome.Handler()); + } + + @SideOnly(Side.CLIENT) + @Override + public void registerPacketsClient() { + + } +} diff --git a/src/main/java/forestry/sorting/network/package-info.java b/src/main/java/forestry/sorting/network/package-info.java new file mode 100644 index 000000000..930a8b1b4 --- /dev/null +++ b/src/main/java/forestry/sorting/network/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.sorting.network; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/sorting/network/packets/PacketFilterChangeGenome.java b/src/main/java/forestry/sorting/network/packets/PacketFilterChangeGenome.java new file mode 100644 index 000000000..bddb43b7b --- /dev/null +++ b/src/main/java/forestry/sorting/network/packets/PacketFilterChangeGenome.java @@ -0,0 +1,75 @@ +package forestry.sorting.network.packets; + +import javax.annotation.Nullable; +import java.io.IOException; + +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; + +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.core.network.ForestryPacket; +import forestry.core.network.IForestryPacketHandlerServer; +import forestry.core.network.IForestryPacketServer; +import forestry.core.network.PacketBufferForestry; +import forestry.core.network.PacketIdServer; +import forestry.core.tiles.TileUtil; +import forestry.sorting.tiles.TileGeneticFilter; + +public class PacketFilterChangeGenome extends ForestryPacket implements IForestryPacketServer { + private final BlockPos pos; + private final EnumFacing facing; + private final short index; + private final boolean active; + @Nullable + private final IAllele allele; + + public PacketFilterChangeGenome(BlockPos pos, EnumFacing facing, short index, boolean active, @Nullable IAllele allele) { + this.pos = pos; + this.facing = facing; + this.index = index; + this.active = active; + this.allele = allele; + } + + @Override + protected void writeData(PacketBufferForestry data) throws IOException { + data.writeBlockPos(pos); + data.writeShort(facing.getIndex()); + data.writeShort(index); + data.writeBoolean(active); + if (allele != null) { + data.writeBoolean(true); + data.writeString(allele.getUID()); + } else { + data.writeBoolean(false); + } + } + + @Override + public PacketIdServer getPacketId() { + return PacketIdServer.FILTER_CHANGE_GENOME; + } + + public static class Handler implements IForestryPacketHandlerServer { + @Override + public void onPacketData(PacketBufferForestry data, EntityPlayerMP player) throws IOException { + BlockPos pos = data.readBlockPos(); + EnumFacing facing = EnumFacing.getFront(data.readShort()); + short index = data.readShort(); + boolean active = data.readBoolean(); + IAllele allele; + if (data.readBoolean()) { + allele = AlleleManager.alleleRegistry.getAllele(data.readString()); + } else { + allele = null; + } + TileUtil.actOnTile(player.world, pos, TileGeneticFilter.class, tile -> { + if (tile.setGenomeFilter(facing, index, active, allele)) { + tile.sendToPlayers(player.getServerWorld(), player); + } + }); + } + } +} diff --git a/src/main/java/forestry/sorting/network/packets/PacketFilterChangeRule.java b/src/main/java/forestry/sorting/network/packets/PacketFilterChangeRule.java new file mode 100644 index 000000000..212d6f567 --- /dev/null +++ b/src/main/java/forestry/sorting/network/packets/PacketFilterChangeRule.java @@ -0,0 +1,55 @@ +package forestry.sorting.network.packets; + +import java.io.IOException; + +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; + +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IFilterRule; +import forestry.core.network.ForestryPacket; +import forestry.core.network.IForestryPacketHandlerServer; +import forestry.core.network.IForestryPacketServer; +import forestry.core.network.PacketBufferForestry; +import forestry.core.network.PacketIdServer; +import forestry.core.tiles.TileUtil; +import forestry.sorting.tiles.TileGeneticFilter; + +public class PacketFilterChangeRule extends ForestryPacket implements IForestryPacketServer { + private final BlockPos pos; + private final EnumFacing facing; + private final IFilterRule rule; + + public PacketFilterChangeRule(TileGeneticFilter filter, EnumFacing facing, IFilterRule rule) { + this.pos = filter.getPos(); + this.facing = facing; + this.rule = rule; + } + + @Override + protected void writeData(PacketBufferForestry data) throws IOException { + data.writeBlockPos(pos); + data.writeShort(facing.getIndex()); + data.writeShort(AlleleManager.filterRegistry.getId(rule)); + } + + @Override + public PacketIdServer getPacketId() { + return PacketIdServer.FILTER_CHANGE_RULE; + } + + public static class Handler implements IForestryPacketHandlerServer { + @Override + public void onPacketData(PacketBufferForestry data, EntityPlayerMP player) throws IOException { + BlockPos pos = data.readBlockPos(); + EnumFacing facing = EnumFacing.getFront(data.readShort()); + IFilterRule rule = AlleleManager.filterRegistry.getRuleOrDefault(data.readShort()); + TileUtil.actOnTile(player.world, pos, TileGeneticFilter.class, tile -> { + if (tile.setRule(facing, rule)) { + tile.sendToPlayers(player.getServerWorld(), player); + } + }); + } + } +} diff --git a/src/main/java/forestry/sorting/network/packets/package-info.java b/src/main/java/forestry/sorting/network/packets/package-info.java new file mode 100644 index 000000000..35d068358 --- /dev/null +++ b/src/main/java/forestry/sorting/network/packets/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.sorting.network.packets; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/sorting/package-info.java b/src/main/java/forestry/sorting/package-info.java new file mode 100644 index 000000000..7ab3e2ee7 --- /dev/null +++ b/src/main/java/forestry/sorting/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.sorting; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/sorting/tiles/TileGeneticFilter.java b/src/main/java/forestry/sorting/tiles/TileGeneticFilter.java new file mode 100644 index 000000000..39f3fa91c --- /dev/null +++ b/src/main/java/forestry/sorting/tiles/TileGeneticFilter.java @@ -0,0 +1,346 @@ +package forestry.sorting.tiles; + +import javax.annotation.Nullable; +import java.io.IOException; +import java.util.Collection; +import java.util.LinkedList; +import java.util.List; + +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.WorldServer; + +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.items.CapabilityItemHandler; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.ItemHandlerHelper; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IFilterData; +import forestry.api.genetics.IFilterRule; +import forestry.api.genetics.IGenome; +import forestry.api.genetics.IIndividual; +import forestry.api.genetics.ISpeciesRoot; +import forestry.api.genetics.ISpeciesType; +import forestry.core.inventory.AdjacentInventoryCache; +import forestry.core.network.IStreamableGui; +import forestry.core.network.PacketBufferForestry; +import forestry.core.tiles.TileForestry; +import forestry.core.tiles.TileUtil; +import forestry.core.utils.ItemStackUtil; +import forestry.sorting.AlleleFilter; +import forestry.sorting.DefaultFilterRule; +import forestry.sorting.FilterData; +import forestry.sorting.gui.ContainerGeneticFilter; +import forestry.sorting.gui.GuiGeneticFilter; +import forestry.sorting.inventory.InventoryFilter; +import forestry.sorting.inventory.ItemHandlerFilter; + +public class TileGeneticFilter extends TileForestry implements IStreamableGui { + private static final int TRANSFER_DELAY = 5; + + private IFilterRule[] filterRules = new IFilterRule[6]; + private AlleleFilter[][] genomeFilter = new AlleleFilter[6][3]; + private final AdjacentInventoryCache inventoryCache; + + public TileGeneticFilter() { + for (int i = 0; i < filterRules.length; i++) { + filterRules[i] = AlleleManager.filterRegistry.getDefaultRule(); + } + this.inventoryCache = new AdjacentInventoryCache(this, getTileCache()); + setInternalInventory(new InventoryFilter(this)); + } + + @Override + public NBTTagCompound writeToNBT(NBTTagCompound data) { + super.writeToNBT(data); + + for (int i = 0; i < filterRules.length; i++) { + data.setString("TypeFilter" + i, filterRules[i].getUID()); + } + + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + AlleleFilter filter = genomeFilter[i][j]; + if (filter == null) { + continue; + } + if (filter.activeAllele != null) { + data.setString("GenomeFilterS" + i + "-" + j + "-" + 0, filter.activeAllele.getUID()); + } + if (filter.inactiveAllele != null) { + data.setString("GenomeFilterS" + i + "-" + j + "-" + 1, filter.inactiveAllele.getUID()); + } + } + } + return data; + } + + @Override + public void readFromNBT(NBTTagCompound data) { + super.readFromNBT(data); + for (int i = 0; i < filterRules.length; i++) { + filterRules[i] = AlleleManager.filterRegistry.getRuleOrDefault(data.getString("TypeFilter" + i)); + } + + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + AlleleFilter filter = new AlleleFilter(); + if (data.hasKey("GenomeFilterS" + i + "-" + j + "-" + 0)) { + filter.activeAllele = AlleleManager.alleleRegistry.getAllele(data.getString("GenomeFilterS" + i + "-" + j + "-" + 0)); + } + if (data.hasKey("GenomeFilterS" + i + "-" + j + "-" + 1)) { + filter.inactiveAllele = AlleleManager.alleleRegistry.getAllele(data.getString("GenomeFilterS" + i + "-" + j + "-" + 1)); + } + genomeFilter[i][j] = filter; + } + } + } + + @Override + public void writeGuiData(PacketBufferForestry data) { + for (int i = 0; i < filterRules.length; i++) { + data.writeShort(AlleleManager.filterRegistry.getId(filterRules[i])); + } + + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + AlleleFilter filter = genomeFilter[i][j]; + if (filter == null) { + data.writeBoolean(false); + data.writeBoolean(false); + continue; + } + if (filter.activeAllele != null) { + data.writeBoolean(true); + data.writeString(filter.activeAllele.getUID()); + } else { + data.writeBoolean(false); + } + if (filter.inactiveAllele != null) { + data.writeBoolean(true); + data.writeString(filter.inactiveAllele.getUID()); + } else { + data.writeBoolean(false); + } + } + } + } + + @SideOnly(Side.CLIENT) + @Override + public void readGuiData(PacketBufferForestry data) throws IOException { + for (int i = 0; i < filterRules.length; i++) { + filterRules[i] = AlleleManager.filterRegistry.getRule(data.readShort()); + } + + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + AlleleFilter filter = new AlleleFilter(); + if (data.readBoolean()) { + filter.activeAllele = AlleleManager.alleleRegistry.getAllele(data.readString()); + } + if (data.readBoolean()) { + filter.inactiveAllele = AlleleManager.alleleRegistry.getAllele(data.readString()); + } + genomeFilter[i][j] = filter; + } + } + } + + public void sendToPlayers(WorldServer server, EntityPlayer entityPlayer) { + for (EntityPlayer player : server.playerEntities) { + if (player != entityPlayer && player.openContainer instanceof ContainerGeneticFilter) { + if (((ContainerGeneticFilter) entityPlayer.openContainer).hasSameTile((ContainerGeneticFilter) player.openContainer)) { + ((ContainerGeneticFilter) player.openContainer).setGuiNeedsUpdate(true); + } + } + } + } + + @Override + protected void updateServerSide() { + if (updateOnInterval(TRANSFER_DELAY)) { + for (EnumFacing facing : EnumFacing.VALUES) { + ItemStack stack = getStackInSlot(facing.getIndex()); + if (stack.isEmpty()) { + continue; + } + ItemStack transferredStack = transferItem(stack, facing); + int remaining = stack.getCount() - transferredStack.getCount(); + if (remaining > 0) { + stack = stack.copy(); + stack.setCount(remaining); + ItemStackUtil.dropItemStackAsEntity(stack.copy(), world, pos.getX(), pos.getY() + 0.5F, pos.getZ()); + } + setInventorySlotContents(facing.getIndex(), ItemStack.EMPTY); + } + } + } + + public boolean isConnected(EnumFacing facing) { + if (inventoryCache.getAdjacentInventory(facing) != null) { + return true; + } + TileEntity tileEntity = world.getTileEntity(pos.offset(facing)); + return TileUtil.getInventoryFromTile(tileEntity, facing.getOpposite()) != null; + } + + private ItemStack transferItem(ItemStack itemStack, EnumFacing facing) { + IItemHandler itemHandler = inventoryCache.getAdjacentInventory(facing); + if (itemHandler == null) { + return ItemStack.EMPTY; + } + ItemStack transferredStack = ItemHandlerHelper.insertItemStacked(itemHandler, itemStack.copy(), true); + if (transferredStack.getCount() == itemStack.getCount()) { + return ItemStack.EMPTY; + } + transferredStack = ItemHandlerHelper.insertItemStacked(itemHandler, itemStack.copy(), false); + if (transferredStack.isEmpty()) { + return itemStack; + } + ItemStack copy = itemStack.copy(); + copy.setCount(itemStack.getCount() - transferredStack.getCount()); + return copy; + } + + public Collection getValidDirections(ItemStack itemStack, EnumFacing from) { + ISpeciesRoot root = AlleleManager.alleleRegistry.getSpeciesRoot(itemStack); + IIndividual individual = null; + ISpeciesType type = null; + if (root != null) { + individual = root.getMember(itemStack); + type = root.getType(itemStack); + } + IFilterData filterData = new FilterData(root, individual, type); + List validFacings = new LinkedList<>(); + for (EnumFacing facing : EnumFacing.VALUES) { + if (facing == from) { + continue; + } + if (isValidFacing(facing, itemStack, filterData)) { + validFacings.add(facing); + } + } + return validFacings; + } + + private boolean isValidFacing(EnumFacing facing, ItemStack itemStack, IFilterData filterData) { + if (inventoryCache.getAdjacentInventory(facing) == null) { + return false; + } + IFilterRule rule = getRule(facing); + if (rule == DefaultFilterRule.CLOSED) { + return false; + } + if (rule == DefaultFilterRule.ITEM && !filterData.isPresent()) { + return true; + } + String requiredRoot = rule.getRootUID(); + if (requiredRoot != null && (!filterData.isPresent() || !filterData.getRoot().getUID().equals(requiredRoot))) { + return false; + } + if (rule == DefaultFilterRule.ANYTHING || rule.isValid(itemStack, filterData)) { + if (filterData.isPresent()) { + IIndividual ind = filterData.getIndividual(); + IGenome genome = ind.getGenome(); + IAllele active = genome.getPrimary(); + IAllele inactive = genome.getSecondary(); + if (!isValidGenome(facing, active.getUID(), inactive.getUID())) { + return false; + } + } + return true; + } + return false; + } + + private boolean isValidGenome(EnumFacing orientation, String activeUID, String inactiveUID) { + AlleleFilter[] directionFilters = genomeFilter[orientation.ordinal()]; + + if (directionFilters == null) { + return true; + } + + boolean foundFilter = false; + for (int i = 0; i < 3; i++) { + AlleleFilter filter = directionFilters[i]; + if (filter != null && !filter.isEmpty()) { + foundFilter = true; + if (!filter.isEmpty() && filter.isValid(activeUID, inactiveUID)) { + return true; + } + } + } + return !foundFilter; + } + + public IFilterRule getRule(EnumFacing facing) { + return filterRules[facing.ordinal()]; + } + + public boolean setRule(EnumFacing facing, IFilterRule rule) { + if (filterRules[facing.ordinal()] != rule) { + filterRules[facing.ordinal()] = rule; + return true; + } + return false; + } + + @Nullable + public AlleleFilter getGenomeFilter(EnumFacing facing, int index) { + return genomeFilter[facing.ordinal()][index]; + } + + public boolean setGenomeFilter(EnumFacing facing, int index, boolean active, @Nullable IAllele allele) { + AlleleFilter filter = genomeFilter[facing.ordinal()][index]; + if (filter == null) { + filter = genomeFilter[facing.ordinal()][index] = new AlleleFilter(); + } + boolean set; + if (active) { + set = filter.activeAllele != allele; + filter.activeAllele = allele; + } else { + set = filter.inactiveAllele != allele; + filter.inactiveAllele = allele; + } + return set; + } + + @SideOnly(Side.CLIENT) + @Nullable + @Override + public GuiContainer getGui(EntityPlayer player, int data) { + return new GuiGeneticFilter(this, player.inventory); + } + + @Nullable + @Override + public Container getContainer(EntityPlayer player, int data) { + return new ContainerGeneticFilter(this, player.inventory); + } + + @Nullable + @Override + public T getCapability(Capability capability, @Nullable EnumFacing facing) { + if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY && facing != null) { + return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(new ItemHandlerFilter(this, facing)); + } + return super.getCapability(capability, facing); + } + + @Override + public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { + return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || super.hasCapability(capability, facing); + } +} diff --git a/src/main/java/forestry/sorting/tiles/package-info.java b/src/main/java/forestry/sorting/tiles/package-info.java new file mode 100644 index 000000000..13c877649 --- /dev/null +++ b/src/main/java/forestry/sorting/tiles/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.sorting.tiles; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/resources/assets/forestry/blockstates/genetic_filter.json b/src/main/resources/assets/forestry/blockstates/genetic_filter.json new file mode 100644 index 000000000..bb2146a69 --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/genetic_filter.json @@ -0,0 +1,23 @@ +{ + "multipart": [ + { "apply": { "model": "forestry:filter/filter_center" }}, + { "when": { "north": "true" }, + "apply": { "model": "forestry:filter/filter_north" } + }, + { "when": { "east": "true" }, + "apply": { "model": "forestry:filter/filter_east", "y": 90 } + }, + { "when": { "south": "true" }, + "apply": { "model": "forestry:filter/filter_south", "y": 180 } + }, + { "when": { "west": "true" }, + "apply": { "model": "forestry:filter/filter_west", "y": 270 } + }, + { "when": { "up": "true" }, + "apply": { "model": "forestry:filter/filter_up", "x": -90 } + }, + { "when": { "down": "true" }, + "apply": { "model": "forestry:filter/filter_down", "x": 90 } + } + ] +} diff --git a/src/main/resources/assets/forestry/models/block/filter/filter_center.json b/src/main/resources/assets/forestry/models/block/filter/filter_center.json new file mode 100644 index 000000000..49b062717 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/filter/filter_center.json @@ -0,0 +1,20 @@ +{ + "textures": { + "particle": "forestry:blocks/genetic_filter_particle", + "texture": "forestry:blocks/genetic_filter" + }, + "elements": [ + { + "from": [ 5, 5, 5 ], + "to": [ 11, 11, 11 ], + "faces": { + "down": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#texture", "rotation": 270 }, + "up": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#texture", "rotation": 270 }, + "north": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#texture", "rotation": 270 }, + "south": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#texture", "rotation": 270 }, + "west": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#texture", "rotation": 270 }, + "east": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#texture", "rotation": 270 } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/filter/filter_down.json b/src/main/resources/assets/forestry/models/block/filter/filter_down.json new file mode 100644 index 000000000..3c3e4bb5f --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/filter/filter_down.json @@ -0,0 +1,6 @@ +{ + "parent": "forestry:block/filter/filter_side", + "textures": { + "wool": "blocks/wool_colored_black" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/filter/filter_east.json b/src/main/resources/assets/forestry/models/block/filter/filter_east.json new file mode 100644 index 000000000..9ad0fbd8d --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/filter/filter_east.json @@ -0,0 +1,6 @@ +{ + "parent": "forestry:block/filter/filter_side", + "textures": { + "wool": "blocks/wool_colored_yellow" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/filter/filter_north.json b/src/main/resources/assets/forestry/models/block/filter/filter_north.json new file mode 100644 index 000000000..3cc0e8eb0 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/filter/filter_north.json @@ -0,0 +1,6 @@ +{ + "parent": "forestry:block/filter/filter_side", + "textures": { + "wool": "blocks/wool_colored_red" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/filter/filter_side.json b/src/main/resources/assets/forestry/models/block/filter/filter_side.json new file mode 100644 index 000000000..5689ce894 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/filter/filter_side.json @@ -0,0 +1,41 @@ +{ + "textures": { + "filter": "forestry:blocks/genetic_filter" + }, + "elements": [ + { + "from": [ 4, 4, 0 ], + "to": [ 12, 12, 1 ], + "faces": { + "down": { "uv": [ 2, 5.5, 6, 6 ], "texture": "#filter" }, + "up": { "uv": [ 2, 2, 6, 2.5 ], "texture": "#filter" }, + "north": { "uv": [ 2, 2, 6, 6 ], "texture": "#filter" }, + "south": { "uv": [ 2, 2, 6, 6 ], "texture": "#filter" }, + "west": { "uv": [ 2, 2, 2.5, 6 ], "texture": "#filter" }, + "east": { "uv": [ 5.5, 2, 6, 6 ], "texture": "#filter" } + } + }, + { + "from": [ 5, 5, 2 ], + "to": [ 11, 11, 5 ], + "faces": { + "down": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter", "rotation": 90 }, + "up": { "uv": [ 4, 15.5, 2.5, 13 ], "texture": "#filter", "rotation": 90 }, + "west": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter" }, + "east": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter" } + } + }, + { + "from": [ 4.5, 4.5, 1 ], + "to": [ 11.5, 11.5, 2 ], + "faces": { + "down": { "uv": [ 5, 12, 11, 13 ], "texture": "#wool" }, + "up": { "uv": [ 5, 3, 11, 4 ], "texture": "#wool" }, + "north": { "uv": [ 5, 5, 11, 11 ], "texture": "#wool" }, + "south": { "uv": [ 5, 5, 11, 11 ], "texture": "#wool" }, + "west": { "uv": [ 3, 5, 4, 11 ], "texture": "#wool" }, + "east": { "uv": [ 12, 5, 13, 11 ], "texture": "#wool" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/filter/filter_south.json b/src/main/resources/assets/forestry/models/block/filter/filter_south.json new file mode 100644 index 000000000..32d1159af --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/filter/filter_south.json @@ -0,0 +1,6 @@ +{ + "parent": "forestry:block/filter/filter_side", + "textures": { + "wool": "blocks/wool_colored_blue" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/filter/filter_up.json b/src/main/resources/assets/forestry/models/block/filter/filter_up.json new file mode 100644 index 000000000..b92cae26b --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/filter/filter_up.json @@ -0,0 +1,6 @@ +{ + "parent": "forestry:block/filter/filter_side", + "textures": { + "wool": "blocks/wool_colored_white" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/filter/filter_west.json b/src/main/resources/assets/forestry/models/block/filter/filter_west.json new file mode 100644 index 000000000..ec2a2dbee --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/filter/filter_west.json @@ -0,0 +1,6 @@ +{ + "parent": "forestry:block/filter/filter_side", + "textures": { + "wool": "blocks/wool_colored_green" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/item/e_particle.png b/src/main/resources/assets/forestry/models/item/e_particle.png new file mode 100644 index 000000000..e557878f9 Binary files /dev/null and b/src/main/resources/assets/forestry/models/item/e_particle.png differ diff --git a/src/main/resources/assets/forestry/models/item/genetic_filter.json b/src/main/resources/assets/forestry/models/item/genetic_filter.json new file mode 100644 index 000000000..409add3e8 --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/genetic_filter.json @@ -0,0 +1,121 @@ +{ + "textures": { + "filter": "forestry:blocks/genetic_filter", + "wool": "blocks/wool_colored_red", + "wool_blue": "blocks/wool_colored_blue" + }, + "elements": [ + { + "from": [ 4, 4, 0 ], + "to": [ 12, 12, 1 ], + "faces": { + "down": { "uv": [ 2, 5.5, 6, 6 ], "texture": "#filter" }, + "up": { "uv": [ 2, 2, 6, 2.5 ], "texture": "#filter" }, + "north": { "uv": [ 2, 2, 6, 6 ], "texture": "#filter" }, + "south": { "uv": [ 2, 2, 6, 6 ], "texture": "#filter" }, + "west": { "uv": [ 2, 2, 2.5, 6 ], "texture": "#filter" }, + "east": { "uv": [ 5.5, 2, 6, 6 ], "texture": "#filter" } + } + }, + { + "from": [ 5, 5, 2 ], + "to": [ 11, 11, 5 ], + "faces": { + "down": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter", "rotation": 90 }, + "up": { "uv": [ 4, 15.5, 2.5, 13 ], "texture": "#filter", "rotation": 90 }, + "west": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter" }, + "east": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter" } + } + }, + { + "from": [ 4.5, 4.5, 1 ], + "to": [ 11.5, 11.5, 2 ], + "faces": { + "down": { "uv": [ 5, 12, 11, 13 ], "texture": "#wool" }, + "up": { "uv": [ 5, 3, 11, 4 ], "texture": "#wool" }, + "north": { "uv": [ 5, 5, 11, 11 ], "texture": "#wool" }, + "south": { "uv": [ 5, 5, 11, 11 ], "texture": "#wool" }, + "west": { "uv": [ 3, 5, 4, 11 ], "texture": "#wool" }, + "east": { "uv": [ 12, 5, 13, 11 ], "texture": "#wool" } + } + }, + { + "from": [ 5, 5, 11 ], + "to": [ 11, 11, 14 ], + "faces": { + "down": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter", "rotation": 90 }, + "up": { "uv": [ 4, 15.5, 2.5, 13 ], "texture": "#filter", "rotation": 90 }, + "west": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter" }, + "east": { "uv": [ 2.5, 13, 4, 15.5 ], "texture": "#filter" } + } + }, + { + "from": [ 4.5, 4.5, 14 ], + "to": [ 11.5, 11.5, 15 ], + "faces": { + "down": { "uv": [ 5, 12, 11, 13 ], "texture": "#wool_blue" }, + "up": { "uv": [ 5, 3, 11, 4 ], "texture": "#wool_blue" }, + "north": { "uv": [ 5, 5, 11, 11 ], "texture": "#wool_blue" }, + "south": { "uv": [ 5, 5, 11, 11 ], "texture": "#wool_blue" }, + "west": { "uv": [ 3, 5, 4, 11 ], "texture": "#wool_blue" }, + "east": { "uv": [ 12, 5, 13, 11 ], "texture": "#wool_blue" } + } + }, + { + "from": [ 4, 4, 15 ], + "to": [ 12, 12, 16 ], + "faces": { + "down": { "uv": [ 2, 5.5, 6, 6 ], "texture": "#filter" }, + "up": { "uv": [ 2, 2, 6, 2.5 ], "texture": "#filter" }, + "north": { "uv": [ 2, 2, 6, 6 ], "texture": "#filter" }, + "south": { "uv": [ 2, 2, 6, 6 ], "texture": "#filter" }, + "west": { "uv": [ 2, 2, 2.5, 6 ], "texture": "#filter" }, + "east": { "uv": [ 5.5, 2, 6, 6 ], "texture": "#filter" } + } + }, + { + "from": [ 5, 5, 5 ], + "to": [ 11, 11, 11 ], + "faces": { + "down": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#filter" }, + "up": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#filter" }, + "north": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#filter" }, + "south": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#filter" }, + "west": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#filter" }, + "east": { "uv": [ 10.5, 13, 13, 15.5 ], "texture": "#filter" } + } + } + ], + "display": { + "thirdperson_righthand": { + "rotation": [ 75, 45, 0 ], + "translation": [ 0, 2.5, 0 ], + "scale": [ 0.375, 0.375, 0.375 ] + }, + "thirdperson_lefthand": { + "rotation": [ 75, 45, 0 ], + "translation": [ 0, 2.5, 0 ], + "scale": [ 0.375, 0.375, 0.375 ] + }, + "firstperson_righthand": { + "rotation": [ 0, 45, 0 ], + "scale": [ 0.4, 0.4, 0.4 ] + }, + "firstperson_lefthand": { + "rotation": [ 0, 45, 0 ], + "scale": [ 0.4, 0.4, 0.4 ] + }, + "gui": { + "rotation": [ 30, 135, 0 ], + "scale": [ 0.625, 0.625, 0.625 ] + }, + "ground": { + "translation": [ 0, 3, 0 ], + "scale": [ 0.25, 0.25, 0.25 ] + }, + "fixed": { + "rotation": [ 0, -90, 0 ], + "scale": [ 0.5, 0.5, 0.5 ] + } + } +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/textures/blocks/genetic_filter.png b/src/main/resources/assets/forestry/textures/blocks/genetic_filter.png new file mode 100644 index 000000000..2b07b0cff Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/genetic_filter.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/genetic_filter_particle.png b/src/main/resources/assets/forestry/textures/blocks/genetic_filter_particle.png new file mode 100644 index 000000000..a3254cc5d Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/genetic_filter_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/analyzer/butterfly.png b/src/main/resources/assets/forestry/textures/gui/analyzer/butterfly.png new file mode 100644 index 000000000..46bc22952 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/analyzer/butterfly.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/analyzer/caterpillar.png b/src/main/resources/assets/forestry/textures/gui/analyzer/caterpillar.png new file mode 100644 index 000000000..1423dcb33 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/analyzer/caterpillar.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/analyzer/cocoon.png b/src/main/resources/assets/forestry/textures/gui/analyzer/cocoon.png new file mode 100644 index 000000000..ca511d92b Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/analyzer/cocoon.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/analyzer/flutter.png b/src/main/resources/assets/forestry/textures/gui/analyzer/flutter.png new file mode 100644 index 000000000..292815f39 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/analyzer/flutter.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/analyzer/pollen.png b/src/main/resources/assets/forestry/textures/gui/analyzer/pollen.png new file mode 100644 index 000000000..ea469c257 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/analyzer/pollen.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/analyzer/sapling.png b/src/main/resources/assets/forestry/textures/gui/analyzer/sapling.png new file mode 100644 index 000000000..b58d7c9a9 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/analyzer/sapling.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/analyzer/serum.png b/src/main/resources/assets/forestry/textures/gui/analyzer/serum.png new file mode 100644 index 000000000..acafc2023 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/analyzer/serum.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/analyzer/tree.png b/src/main/resources/assets/forestry/textures/gui/analyzer/tree.png new file mode 100644 index 000000000..a917f9a92 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/analyzer/tree.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/filter.png b/src/main/resources/assets/forestry/textures/gui/filter.png new file mode 100644 index 000000000..fff698a8b Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/filter.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/filter_selection.png b/src/main/resources/assets/forestry/textures/gui/filter_selection.png new file mode 100644 index 000000000..8f7aa460c Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/filter_selection.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/slots/bee.png b/src/main/resources/assets/forestry/textures/gui/slots/bee.png new file mode 100644 index 000000000..91dad7cac Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/slots/bee.png differ