Add dual-tool mining support for GT + TiC cross-hand combinations

CHANGELOG.md

@@ -1,3 +1,12 @@
+# v1.2.3
+## Tinkers' Construct Integration
+- GT tool in main-hand + TiC tool in off-hand (and vice versa) now mines blocks using the off-hand tool
+  - Mining speed is taken from the off-hand tool
+  - Blocks drop items even when the main-hand tool has insufficient harvest level, using the off-hand tool
+  - HUD mods (e.g. HWYLA) now show the correct can-harvest indicator (✓/×) based on the off-hand tool
+
+* * *
+
 # v1.2.2
 ## Tinkers' Construct Integration
 - GT material fluids are now registered as TiC Smeltery melting recipes (ingot, nugget, block, dust, gem families always; ore/crushed variants behind `smelteryOreMelting` config). Raw ore doubling is disabled by default (`smelteryOreDoubling=false`) to preserve GT ore-processing progression.

src/main/java/com/github/gtexpert/gtmt/integration/tic/DualToolHandler.java

@@ -0,0 +1,118 @@
+package com.github.gtexpert.gtmt.integration.tic;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Enchantments;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraftforge.common.ForgeHooks;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+import gregtech.api.items.toolitem.IGTTool;
+
+import slimeknights.tconstruct.library.tools.TinkerToolCore;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+/**
+ * Extends TiC's off-hand mining to work with GT tools.
+ *
+ * <ul>
+ * <li>GT main-hand + TiC off-hand: uses TiC dig speed and generates drops when GT cannot harvest.</li>
+ * <li>TiC main-hand + GT off-hand: uses GT dig speed when TiC cannot harvest.</li>
+ * </ul>
+ *
+ * Runs at {@link EventPriority#LOW} so TiC's own {@code BreakSpeed} handler fires first.
+ */
+public final class DualToolHandler {
+
+    private DualToolHandler() {}
+
+    @SubscribeEvent(priority = EventPriority.LOW)
+    public static void onBreakSpeed(net.minecraftforge.event.entity.player.PlayerEvent.BreakSpeed event) {
+        EntityPlayer player = event.getEntityPlayer();
+        ItemStack mainhand = player.getHeldItemMainhand();
+        ItemStack offhand = player.getHeldItemOffhand();
+
+        if (offhand.isEmpty()) return;
+
+        IBlockState state = event.getState();
+
+        if (mainhand.getItem() instanceof IGTTool && offhand.getItem() instanceof TinkerToolCore) {
+            if (!canHarvestForDrops(player, mainhand, state) && ToolHelper.canHarvest(offhand, state)) {
+                float speed = ToolHelper.calcDigSpeed(offhand, state);
+                BlockPos pos = event.getPos();
+                if (pos == null || !ForgeHooks.canHarvestBlock(state.getBlock(), player, player.world, pos)) {
+                    speed *= (100.0f / 30.0f);
+                }
+                event.setNewSpeed(speed);
+            }
+        }
+
+        if (mainhand.getItem() instanceof TinkerToolCore && offhand.getItem() instanceof IGTTool) {
+            if (!ToolHelper.canHarvest(mainhand, state) && canHarvestForDrops(player, offhand, state)) {
+                float speed = offhand.getItem().getDestroySpeed(offhand, state);
+                if (speed > 1.0f) {
+                    int efficiency = EnchantmentHelper.getEnchantmentLevel(Enchantments.EFFICIENCY, offhand);
+                    if (efficiency > 0) speed += efficiency * efficiency + 1;
+                }
+                event.setNewSpeed(speed);
+            }
+        }
+    }
+
+    /**
+     * Damages the off-hand tool after a block is broken via off-hand mining.
+     * For Case 1, also spawns drops using the off-hand TiC tool when
+     * {@code ForgeHooks.canHarvestBlock} returns {@code false} for the GT main-hand tool.
+     *
+     * Runs at {@link EventPriority#LOWEST} so cancellations by other mods are resolved first.
+     */
+    @SubscribeEvent(priority = EventPriority.LOWEST)
+    public static void onBlockBreak(BlockEvent.BreakEvent event) {
+        if (event.isCanceled()) return;
+
+        EntityPlayer player = event.getPlayer();
+        if (player == null || player.world.isRemote) return;
+
+        ItemStack mainhand = player.getHeldItemMainhand();
+        ItemStack offhand = player.getHeldItemOffhand();
+
+        if (offhand.isEmpty()) return;
+
+        IBlockState state = event.getState();
+
+        if (mainhand.getItem() instanceof IGTTool && offhand.getItem() instanceof TinkerToolCore) {
+            if (!canHarvestForDrops(player, mainhand, state) && ToolHelper.canHarvest(offhand, state)) {
+                if (!ForgeHooks.canHarvestBlock(state.getBlock(), player, player.world, event.getPos())) {
+                    state.getBlock().harvestBlock(player.world, player, event.getPos(), state,
+                            player.world.getTileEntity(event.getPos()), offhand);
+                }
+                offhand.getItem().onBlockDestroyed(offhand, player.world, state,
+                        event.getPos(), player);
+            }
+        }
+
+        if (mainhand.getItem() instanceof TinkerToolCore && offhand.getItem() instanceof IGTTool) {
+            if (!ToolHelper.canHarvest(mainhand, state) && canHarvestForDrops(player, offhand, state)) {
+                offhand.getItem().onBlockDestroyed(offhand, player.world, state,
+                        event.getPos(), player);
+            }
+        }
+    }
+
+    private static boolean canHarvestForDrops(EntityPlayer player, ItemStack stack, IBlockState state) {
+        if (state.getMaterial().isToolNotRequired()) return true;
+        Block block = state.getBlock();
+        String toolType = block.getHarvestTool(state);
+        if (stack.isEmpty() || toolType == null) {
+            return player.canHarvestBlock(state);
+        }
+        int level = stack.getItem().getHarvestLevel(stack, toolType, player, state);
+        if (level < 0) return player.canHarvestBlock(state);
+        return level >= block.getHarvestLevel(state);
+    }
+}

src/main/java/com/github/gtexpert/gtmt/integration/tic/TiCModule.java

@@ -1,6 +1,6 @@
 package com.github.gtexpert.gtmt.integration.tic;
 
-import java.util.Collections;
+import java.util.Arrays;
 import java.util.List;
 
 import net.minecraft.block.Block;
@@ -16,6 +16,8 @@
 import com.github.gtexpert.gtmt.api.modules.TModule;
 import com.github.gtexpert.gtmt.api.util.Mods;
 import com.github.gtexpert.gtmt.integration.IntegrationSubmodule;
+import com.github.gtexpert.gtmt.integration.tic.materials.ElasticMaterialRegistrar;
+import com.github.gtexpert.gtmt.integration.tic.materials.ToolMaterialRegistrar;
 import com.github.gtexpert.gtmt.modules.Modules;
 
 @TModule(
@@ -29,18 +31,19 @@ public class TiCModule extends IntegrationSubmodule {
     @NotNull
     @Override
     public List<Class<?>> getEventBusSubscribers() {
-        return Collections.singletonList(TiCModule.class);
+        return Arrays.asList(TiCModule.class, DualToolHandler.class);
     }
 
     @Override
     public void registerBlocks(RegistryEvent.Register<Block> event) {
-        TiCMaterials.register(event.getRegistry());
+        ToolMaterialRegistrar.register(event.getRegistry());
+        ElasticMaterialRegistrar.register(event.getRegistry());
         TiCSmeltery.register();
     }
 
     @SubscribeEvent
     @SideOnly(Side.CLIENT)
     public static void onRegisterModels(ModelRegistryEvent event) {
-        TiCMaterials.registerFluidModels();
+        ToolMaterialRegistrar.registerFluidModels();
     }
 }

src/main/java/com/github/gtexpert/gtmt/integration/tic/api/ElasticMaterials.java

@@ -0,0 +1,137 @@
+package com.github.gtexpert.gtmt.integration.tic.api;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import gregtech.api.unification.material.Material;
+import gregtech.api.unification.material.Materials;
+
+/**
+ * Registry for TiC BowString and Fletching material stats derived from GT polymer materials.
+ *
+ * <p>
+ * GTMT automatically registers every GT material that carries the {@code POLYMER} property
+ * as a TiC BowString and Fletching material. Registrations made here take priority over
+ * GTMT's auto-assigned default stats (modifier = 1.0 / accuracy = 1.0).
+ *
+ * <p>
+ * All registrations must occur before GTMT's {@code registerBlocks} phase
+ * (your mod's {@code preInit} or {@code init}).
+ */
+public final class ElasticMaterials {
+
+    // -------------------------------------------------------------------------
+    // Entry type
+    // -------------------------------------------------------------------------
+
+    /** BowString and Fletching stats for a single GT material. */
+    public static final class Entry {
+
+        private final float stringModifier;
+        private final float fletchingAccuracy;
+        private final float fletchingModifier;
+
+        public Entry(float stringModifier, float fletchingAccuracy, float fletchingModifier) {
+            this.stringModifier = stringModifier;
+            this.fletchingAccuracy = fletchingAccuracy;
+            this.fletchingModifier = fletchingModifier;
+        }
+
+        /** BowString draw-speed modifier (1.0 = neutral). */
+        public float stringModifier() {
+            return stringModifier;
+        }
+
+        /** Fletching accuracy (1.0 = perfect, lower = spread). */
+        public float fletchingAccuracy() {
+            return fletchingAccuracy;
+        }
+
+        /** Fletching damage modifier (1.0 = neutral). */
+        public float fletchingModifier() {
+            return fletchingModifier;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Registry
+    // -------------------------------------------------------------------------
+
+    private static final Map<Material, Entry> ENTRIES = new LinkedHashMap<>();
+
+    static {
+        // Natural rubber — slimeball-tier baseline
+        registerIfAbsent(Materials.Rubber, 1.0f, 1.0f, 1.0f);
+        // Vulcanised silicone — more durable
+        registerIfAbsent(Materials.SiliconeRubber, 1.05f, 1.0f, 1.05f);
+        // SBR — best synthetic rubber
+        registerIfAbsent(Materials.StyreneButadieneRubber, 1.1f, 1.0f, 1.1f);
+        // Polyethylene — stiffer plastic, lower tier
+        registerIfAbsent(Materials.Polyethylene, 0.8f, 0.9f, 0.8f);
+    }
+
+    /**
+     * Returns an unmodifiable view of the elastic-material registry.
+     * Used internally by {@code TiCMaterials} when registering BowString/Fletching materials.
+     */
+    public static Map<Material, Entry> getEntries() {
+        return Collections.unmodifiableMap(ENTRIES);
+    }
+
+    /**
+     * Registers BowString and Fletching stats for a GT polymer material.
+     *
+     * <p>
+     * Call this before GTMT's {@code registerBlocks} phase to override the stats
+     * GTMT would otherwise auto-assign.
+     *
+     * <p>
+     * Example — register a custom high-grade polymer:
+     *
+     * <pre>
+     * {@code
+     * ElasticMaterials.register(MyMaterials.KEVLAR, 1.3f, 1.0f, 1.2f);
+     * }
+     * </pre>
+     *
+     * @param material          GT material (must carry the {@code POLYMER} property,
+     *                          or be a recognised elastic material)
+     * @param stringModifier    BowString draw-speed modifier (must be &gt; 0)
+     * @param fletchingAccuracy Fletching accuracy (must be &gt; 0 and ≤ 1)
+     * @param fletchingModifier Fletching damage modifier (must be &gt; 0)
+     * @throws IllegalArgumentException if material is null or any stat is out of range
+     */
+    public static void register(Material material,
+                                float stringModifier,
+                                float fletchingAccuracy,
+                                float fletchingModifier) {
+        validate(material, stringModifier, fletchingAccuracy, fletchingModifier);
+        ENTRIES.put(material, new Entry(stringModifier, fletchingAccuracy, fletchingModifier));
+    }
+
+    /**
+     * Fills stats only if the material has not already been registered externally.
+     * Called internally by the static initializer and by {@code TiCMaterials} for
+     * auto-detected POLYMER materials.
+     */
+    public static void registerIfAbsent(Material material,
+                                        float stringModifier,
+                                        float fletchingAccuracy,
+                                        float fletchingModifier) {
+        validate(material, stringModifier, fletchingAccuracy, fletchingModifier);
+        ENTRIES.putIfAbsent(material, new Entry(stringModifier, fletchingAccuracy, fletchingModifier));
+    }
+
+    private static void validate(Material material,
+                                 float stringModifier,
+                                 float fletchingAccuracy,
+                                 float fletchingModifier) {
+        if (material == null) throw new IllegalArgumentException("material must not be null");
+        if (stringModifier <= 0) throw new IllegalArgumentException("stringModifier must be > 0");
+        if (fletchingAccuracy <= 0) throw new IllegalArgumentException("fletchingAccuracy must be > 0");
+        if (fletchingModifier <= 0) throw new IllegalArgumentException("fletchingModifier must be > 0");
+    }
+
+    private ElasticMaterials() {}
+}