Hide Tools in JEI - or not

src/main/java/gregtech/api/GregTechAPI.java

@@ -27,6 +27,8 @@ public class GregTechAPI {
         new BaseCreativeTab(GTValues.MODID + ".materials", () -> OreDictUnifier.get(OrePrefix.ingot, Materials.Aluminium), true);
     public static final BaseCreativeTab TAB_GREGTECH_ORES =
         new BaseCreativeTab(GTValues.MODID + ".ores", () -> MetaItems.JACKHAMMER.getStackForm(), true);
+    public static final BaseCreativeTab TAB_GREGTECH_TOOLS =
+        new BaseCreativeTab(GTValues.MODID + ".tools", () -> MetaItems.HARD_HAMMER.getStackForm(), true);
 
     public static final GTControlledRegistry<ResourceLocation, MetaTileEntity> META_TILE_ENTITY_REGISTRY = new GTControlledRegistry<>(Short.MAX_VALUE);
 

src/main/java/gregtech/api/items/toolitem/ToolMetaItem.java

@@ -5,6 +5,7 @@
 import com.google.common.collect.Multimap;
 import forestry.api.arboriculture.IToolGrafter;
 import gregtech.api.GTValues;
+import gregtech.api.GregTechAPI;
 import gregtech.api.capability.GregtechCapabilities;
 import gregtech.api.capability.IElectricItem;
 import gregtech.api.enchants.EnchantmentData;
@@ -24,6 +25,7 @@
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.enchantment.Enchantment;
 import net.minecraft.enchantment.EnchantmentDurability;
 import net.minecraft.enchantment.EnchantmentHelper;
@@ -34,9 +36,11 @@
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.init.Enchantments;
 import net.minecraft.inventory.EntityEquipmentSlot;
+import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EntityDamageSource;
+import net.minecraft.util.NonNullList;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.RayTraceResult;
@@ -52,6 +56,7 @@
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.util.*;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 /**
@@ -69,6 +74,14 @@
 @Interface(modid = GTValues.MODID_FR, iface = "forestry.api.arboriculture.IToolGrafter")
 public class ToolMetaItem<T extends ToolMetaItem<?>.MetaToolValueItem> extends MetaItem<T> implements IToolItem, IAOEItem, IToolGrafter {
 
+    public static boolean hasToolSubItems(final ItemStack itemStack) {
+        final Item item = itemStack.getItem();
+        if (item instanceof ToolMetaItem == false)
+            return false;
+        final ToolMetaItem<?>.MetaToolValueItem metaToolValueItem = (ToolMetaItem<?>.MetaToolValueItem)((ToolMetaItem) item).getItem(itemStack);
+        return metaToolValueItem.canGenerate != null;
+    }
+
     public ToolMetaItem() {
         super((short) 0);
     }
@@ -420,6 +433,40 @@ public String getItemStackDisplayName(ItemStack stack) {
         return super.getItemStackDisplayName(stack);
     }
 
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(CreativeTabs tab, NonNullList<ItemStack> subItems) {
+        super.getSubItems(tab, subItems);
+
+        // Not expanding tools
+        if (ConfigHolder.hideToolsInJEI) {
+            return;
+        }
+
+        if (tab != GregTechAPI.TAB_GREGTECH_TOOLS && tab != CreativeTabs.SEARCH) {
+            return;
+        }
+
+        for (short itemMetaKey : metaItems.keys()) {
+            ToolMetaItem<?>.MetaToolValueItem metaToolValueItem = metaItems.get(itemMetaKey);
+
+            // This tool knows how to do this
+            if (metaToolValueItem.canGenerate != null) {
+                for (Material material : Material.MATERIAL_REGISTRY) {
+                    if (material instanceof SolidMaterial == false) {
+                        continue;
+                    }
+
+                    // Matching tool
+                    SolidMaterial solidMaterial = (SolidMaterial) material;
+                    if (metaToolValueItem.canGenerate.test(solidMaterial)) {
+                        subItems.add(metaToolValueItem.getStackForm(solidMaterial));
+                    }
+                }
+            }
+        }
+    }
+
     @Override
     @SideOnly(Side.CLIENT)
     public void addInformation(ItemStack itemStack, @Nullable World worldIn, List<String> lines, ITooltipFlag tooltipFlag) {
@@ -609,6 +656,7 @@ public class MetaToolValueItem extends MetaValueItem {
 
         protected IToolStats toolStats = new DummyToolStats();
         protected double amountOfMaterialToRepair = 0;
+        protected Predicate<SolidMaterial> canGenerate;
 
         protected MetaToolValueItem(int metaValue, String unlocalizedName) {
             super(metaValue, unlocalizedName);
@@ -650,6 +698,11 @@ public MetaToolValueItem addOreDict(ToolDictNames... oreDictNames) {
             return this;
         }
 
+        public MetaToolValueItem canGenerate(Predicate<SolidMaterial> canGenerate) {
+            this.canGenerate = canGenerate;
+            return this;
+        }
+
         @Nonnull
         public IToolStats getToolStats() {
             return toolStats;

src/main/java/gregtech/common/ConfigHolder.java

@@ -24,6 +24,10 @@ public class ConfigHolder {
     @Config.RequiresMcRestart
     public static boolean hideFilledTanksInJEI = true;
 
+    @Config.Comment("Whether to hide tools in JEI and creative search menu showing only Darmstadtium. Default: true")
+    @Config.RequiresMcRestart
+    public static boolean hideToolsInJEI = true;
+
     @Config.Comment("Specifies min amount of veins in section. Default: 0")
     public static int minVeinsInSection = 0;
 

src/main/java/gregtech/common/items/MetaTool.java

@@ -19,11 +19,38 @@
 import net.minecraft.item.ItemStack;
 
 import java.util.function.Function;
+import java.util.function.Predicate;
 
+import static gregtech.api.unification.material.type.DustMaterial.MatFlags.GENERATE_PLATE;
+import static gregtech.api.unification.material.type.DustMaterial.MatFlags.NO_SMASHING;
+import static gregtech.api.unification.material.type.DustMaterial.MatFlags.NO_WORKING;
+import static gregtech.api.unification.material.type.IngotMaterial.MatFlags.GENERATE_BOLT_SCREW;
+import static gregtech.api.unification.material.type.SolidMaterial.MatFlags.GENERATE_ROD;
 import static gregtech.common.items.MetaItems.*;
 
 public class MetaTool extends ToolMetaItem<ToolMetaItem<?>.MetaToolValueItem> {
 
+    public static final Predicate<SolidMaterial> isToolMaterial = (material) -> material.toolDurability > 0;
+
+    public static final Predicate<SolidMaterial> isToolMaterialFlint = (material) -> material.toolDurability > 0 || material == Materials.Flint;
+
+    public static final Predicate<SolidMaterial> isSmashingMaterial = (material) -> material.toolDurability > 0 && !material.hasFlag(NO_SMASHING);
+
+    public static final Predicate<SolidMaterial> isWorkingMaterial = (material) -> material.toolDurability > 0 && !material.hasFlag(NO_WORKING);
+
+    public static final Predicate<SolidMaterial> isSmashingMaterialRod = (material) -> material.toolDurability > 0 && material.hasFlag(GENERATE_ROD);
+
+    public static final Predicate<SolidMaterial> isSmashingMaterialPlateFlint = (material) -> (material.toolDurability > 0 && material.hasFlag(GENERATE_PLATE))
+       || material == Materials.Flint;
+
+    public static final Predicate<SolidMaterial> isSmashingMaterialPlateRod = (material) ->
+        material.toolDurability > 0 && material.hasFlag(GENERATE_ROD) &&
+        material.hasFlag(GENERATE_PLATE);
+
+    public static final Predicate<SolidMaterial> isSmashingMaterialPlateRodBoltScrew = (material) ->
+        material.toolDurability > 0 && material.hasFlag(GENERATE_ROD) &&
+        material.hasFlag(GENERATE_PLATE) && material.hasFlag(GENERATE_BOLT_SCREW);
+
     public MetaTool() {
         super();
     }
@@ -32,151 +59,199 @@ public MetaTool() {
     public void registerSubItems() {
         SWORD = addItem(0, "tool.sword").setToolStats(new ToolSword())
             .setFullRepairCost(2)
+            .canGenerate(isToolMaterialFlint)
             .addOreDict(ToolDictNames.craftingToolSword);
 
         PICKAXE = addItem(1, "tool.pickaxe").setToolStats(new ToolPickaxe())
             .setFullRepairCost(3)
+            .canGenerate(isToolMaterialFlint)
             .addOreDict(ToolDictNames.craftingToolPickaxe);
 
         SHOVEL = addItem(2, "tool.shovel").setToolStats(new ToolShovel())
             .setFullRepairCost(1)
+            .canGenerate(isToolMaterialFlint)
             .addOreDict(ToolDictNames.craftingToolShovel);
 
         AXE = addItem(3, "tool.axe").setToolStats(new ToolAxe())
             .setFullRepairCost(3)
+            .canGenerate(isToolMaterialFlint)
             .addOreDict(ToolDictNames.craftingToolAxe);
 
         HOE = addItem(4, "tool.hoe").setToolStats(new ToolHoe())
             .setFullRepairCost(2)
+            .canGenerate(isToolMaterialFlint)
             .addOreDict(ToolDictNames.craftingToolHoe);
 
         SAW = addItem(5, "tool.saw").setToolStats(new ToolSaw())
             .setFullRepairCost(2)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolSaw);
 
         HARD_HAMMER = addItem(6, "tool.hard_hammer").setToolStats(new ToolHardHammer())
             .setFullRepairCost(6)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolHardHammer);
 
         SOFT_HAMMER = addItem(7, "tool.soft_hammer").setToolStats(new ToolSoftHammer())
             .setFullRepairCost(6)
+            .canGenerate((material) ->
+                material == Materials.Wood ||
+                material == Materials.Rubber ||
+                material == Materials.Plastic ||
+                material == Materials.Polytetrafluoroethylene
+            )
             .addOreDict(ToolDictNames.craftingToolSoftHammer)
             .addComponents(new SoftMalletItemStat());
 
         WRENCH = addItem(8, "tool.wrench").setToolStats(new ToolWrench())
             .setFullRepairCost(6)
+            .canGenerate(isSmashingMaterial)
             .addOreDict(ToolDictNames.craftingToolWrench)
             .addComponents(new WrenchItemStat());
 
         FILE = addItem(9, "tool.file").setToolStats(new ToolFile())
             .setFullRepairCost(2)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolFile);
 
         CROWBAR = addItem(10, "tool.crowbar").setToolStats(new ToolCrowbar())
             .setFullRepairCost(1.5)
+            .canGenerate(isSmashingMaterialRod)
             .addOreDict(ToolDictNames.craftingToolCrowbar);
 
         SCREWDRIVER = addItem(11, "tool.screwdriver").setToolStats(new ToolScrewdriver())
             .setFullRepairCost(1)
+            .canGenerate(isSmashingMaterialRod)
             .addOreDict(ToolDictNames.craftingToolScrewdriver)
             .addComponents(new ScrewdriverItemStat());
 
         MORTAR = addItem(12, "tool.mortar").setToolStats(new ToolMortar())
+            .canGenerate((material) ->
+                material == Materials.Flint ||
+                material == Materials.Bronze ||
+                material == Materials.Iron ||
+                material == Materials.Steel ||
+                material == Materials.DamascusSteel ||
+                material == Materials.WroughtIron ||
+                material == Materials.RedSteel ||
+                material == Materials.BlackSteel ||
+                material == Materials.BlueSteel
+            )
             .addOreDict(ToolDictNames.craftingToolMortar);
 
         WIRE_CUTTER = addItem(13, "tool.wire_cutter").setToolStats(new ToolWireCutter())
             .setFullRepairCost(4.125)
+            .canGenerate(isSmashingMaterialPlateRodBoltScrew)
             .addOreDict(ToolDictNames.craftingToolWireCutter);
 
         SCOOP = addItem(14, "tool.scoop").setToolStats(new ToolScoop())
             .setFullRepairCost(3)
+            .canGenerate(isSmashingMaterialRod)
             .addOreDict(ToolDictNames.craftingToolScoop);
 
         BRANCH_CUTTER = addItem(15, "tool.branch_cutter").setToolStats(new ToolBranchCutter())
             .setFullRepairCost(5.125)
+            .canGenerate(isSmashingMaterialPlateRodBoltScrew)
             .addOreDict(ToolDictNames.craftingToolBranchCutter);
 
         UNIVERSAL_SPADE = addItem(16, "tool.universal_spade").setToolStats(new ToolUniversalSpade())
             .setFullRepairCost(5)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolBlade, ToolDictNames.craftingToolShovel, ToolDictNames.craftingToolCrowbar, ToolDictNames.craftingToolSaw);
 
         KNIFE = addItem(17, "tool.knife").setToolStats(new ToolKnife())
             .setFullRepairCost(1.5)
+            .canGenerate(isSmashingMaterialPlateFlint)
             .addOreDict(ToolDictNames.craftingToolBlade, ToolDictNames.craftingToolKnife);
 
         BUTCHERY_KNIFE = addItem(18, "tool.butchery_knife").setToolStats(new ToolButcheryKnife())
             .setFullRepairCost(4.5)
+            .canGenerate(isSmashingMaterialPlateRod)
             .addOreDict(ToolDictNames.craftingToolBlade);
 
         SENSE = addItem(19, "tool.sense").setToolStats(new ToolSense())
             .setFullRepairCost(3)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolBlade);
 
         DRILL_LV = addItem(23, "tool.drill.lv").setToolStats(new ToolDrillLV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolMiningDrill)
             .addComponents(ElectricStats.createElectricItem(100000L, 1L));
 
         DRILL_MV = addItem(24, "tool.drill.mv").setToolStats(new ToolDrillMV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolMiningDrill)
             .addComponents(ElectricStats.createElectricItem(400000L, 2L));
 
         DRILL_HV = addItem(25, "tool.drill.hv").setToolStats(new ToolDrillHV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolMiningDrill)
             .addComponents(ElectricStats.createElectricItem(1600000L, 3L));
 
         CHAINSAW_LV = addItem(26, "tool.chainsaw.lv").setToolStats(new ToolChainsawLV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolSaw)
             .addComponents(ElectricStats.createElectricItem(100000L, 1L));
 
         CHAINSAW_MV = addItem(27, "tool.chainsaw.mv").setToolStats(new ToolChainsawMV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolSaw)
             .addComponents(ElectricStats.createElectricItem(400000L, 2L));
 
         CHAINSAW_HV = addItem(28, "tool.chainsaw.hv").setToolStats(new ToolChainsawHV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolSaw)
             .addComponents(ElectricStats.createElectricItem(1600000L, 3L));
 
         WRENCH_LV = addItem(29, "tool.wrench.lv").setToolStats(new ToolWrenchLV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolWrench)
             .addComponents(new WrenchItemStat())
             .addComponents(ElectricStats.createElectricItem(100000L, 1L));
 
         WRENCH_MV = addItem(30, "tool.wrench.mv").setToolStats(new ToolWrenchMV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolWrench)
             .addComponents(new WrenchItemStat())
             .addComponents(ElectricStats.createElectricItem(400000L, 2L));
 
         WRENCH_HV = addItem(31, "tool.wrench.hv").setToolStats(new ToolWrenchHV())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolWrench)
             .addComponents(new WrenchItemStat())
             .addComponents(ElectricStats.createElectricItem(1600000L, 3L));
 
         SCREWDRIVER_LV = addItem(34, "tool.screwdriver.lv").setToolStats(new ToolScrewdriverLV())
             .setFullRepairCost(1)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolScrewdriver)
             .addComponents(new ScrewdriverItemStat())
             .addComponents(ElectricStats.createElectricItem(100000L, 1L));
 
         JACKHAMMER = addItem(32, "tool.jackhammer").setToolStats(new ToolJackHammer())
             .setFullRepairCost(5)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolJackHammer)
             .addComponents(ElectricStats.createElectricItem(1600000L, GTValues.HV));
 
         BUZZSAW = addItem(33, "tool.buzzsaw").setToolStats(new ToolBuzzSaw())
             .setFullRepairCost(4)
+            .canGenerate(isToolMaterial)
             .addOreDict(ToolDictNames.craftingToolSaw)
             .addComponents(ElectricStats.createElectricItem(100000L, 1L));
 
         PLUNGER = addItem(37, "tool.plunger").setToolStats(new ToolPlunger())
+            .canGenerate(isSmashingMaterial)
             .addOreDict(ToolDictNames.craftingToolPlunger);
     }