From d73796ad4de4c3327ce2cc3ba1280a03f7e854eb Mon Sep 17 00:00:00 2001 From: Xander Victory Date: Tue, 7 Nov 2017 13:24:26 +0800 Subject: [PATCH 1/2] add IToolHammer (cofh) to Configurator --- src/api/java/cofh/api/item/IToolHammer.java | 51 +++++++++++++++++++ .../common/item/ItemConfigurator.java | 28 ++++++++-- 2 files changed, 76 insertions(+), 3 deletions(-) create mode 100644 src/api/java/cofh/api/item/IToolHammer.java diff --git a/src/api/java/cofh/api/item/IToolHammer.java b/src/api/java/cofh/api/item/IToolHammer.java new file mode 100644 index 000000000..5cedeadf7 --- /dev/null +++ b/src/api/java/cofh/api/item/IToolHammer.java @@ -0,0 +1,51 @@ +package cofh.api.item; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.util.math.BlockPos; + +/** + * Implement this interface on subclasses of Item to have that item work as a tool for CoFH mods. + */ +public interface IToolHammer { + + /** + * Called to ensure that the tool can be used on a block. + * + * @param item The ItemStack for the tool. Not required to match equipped item (e.g., multi-tools that contain other tools). + * @param user The entity using the tool. + * @param pos Coordinates of the block. + * @return True if this tool can be used. + */ + boolean isUsable(ItemStack item, EntityLivingBase user, BlockPos pos); + + /** + * Called to ensure that the tool can be used on an entity. + * + * @param item The ItemStack for the tool. Not required to match equipped item (e.g., multi-tools that contain other tools). + * @param user The entity using the tool. + * @param entity The entity the tool is being used on. + * @return True if this tool can be used. + */ + boolean isUsable(ItemStack item, EntityLivingBase user, Entity entity); + + /** + * Callback for when the tool has been used reactively. + * + * @param item The ItemStack for the tool. Not required to match equipped item (e.g., multi-tools that contain other tools). + * @param user The entity using the tool. + * @param pos Coordinates of the block. + */ + void toolUsed(ItemStack item, EntityLivingBase user, BlockPos pos); + + /** + * Callback for when the tool has been used reactively. + * + * @param item The ItemStack for the tool. Not required to match equipped item (e.g., multi-tools that contain other tools). + * @param user The entity using the tool. + * @param entity The entity the tool is being used on. + */ + void toolUsed(ItemStack item, EntityLivingBase user, Entity entity); + +} \ No newline at end of file diff --git a/src/main/java/mekanism/common/item/ItemConfigurator.java b/src/main/java/mekanism/common/item/ItemConfigurator.java index 1cecfe3b3..e3b70de89 100644 --- a/src/main/java/mekanism/common/item/ItemConfigurator.java +++ b/src/main/java/mekanism/common/item/ItemConfigurator.java @@ -1,5 +1,6 @@ package mekanism.common.item; +import cofh.api.item.IToolHammer; import io.netty.buffer.ByteBuf; import java.util.ArrayList; @@ -30,6 +31,8 @@ import mekanism.common.util.MekanismUtils; import mekanism.common.util.SecurityUtils; import net.minecraft.block.Block; import net.minecraft.client.util.ITooltipFlag; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.item.EntityItem; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.IInventory; @@ -53,9 +56,10 @@ import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; @InterfaceList({ - @Interface(iface = "buildcraft.api.tools.IToolWrench", modid = MekanismHooks.BUILDCRAFT_MOD_ID) + @Interface(iface = "buildcraft.api.tools.IToolWrench", modid = MekanismHooks.BUILDCRAFT_MOD_ID), + @Interface(iface = "cofh.api.item.IToolHammer", modid = MekanismHooks.COFH_API_MOD_ID) }) -public class ItemConfigurator extends ItemEnergized implements IMekWrench, IToolWrench, IItemNetwork +public class ItemConfigurator extends ItemEnergized implements IMekWrench, IToolWrench, IItemNetwork, IToolHammer { public final int ENERGY_PER_CONFIGURE = 400; public final int ENERGY_PER_ITEM_DUMP = 8; @@ -282,7 +286,25 @@ public class ItemConfigurator extends ItemEnergized implements IMekWrench, ITool { return getState(stack) == ConfiguratorMode.WRENCH; } - + + /*cofh IToolHammer */ + @Override + public boolean isUsable(ItemStack stack, EntityLivingBase user, BlockPos pos) { + return getState(stack) == ConfiguratorMode.WRENCH; + } + + @Override + public boolean isUsable(ItemStack stack, EntityLivingBase user, Entity entity) { + return getState(stack) == ConfiguratorMode.WRENCH; + } + + @Override + public void toolUsed(ItemStack item, EntityLivingBase user, BlockPos pos) {} + + @Override + public void toolUsed(ItemStack item, EntityLivingBase user, Entity entity) {} + /*end cofh IToolHammer */ + public enum ConfiguratorMode { CONFIGURATE_ITEMS("configurate", "(" + TransmissionType.ITEM.localize() + ")", EnumColor.BRIGHT_GREEN, true), From f6f7678f8b2fc5d9837d518b0e679a0f2c2a19cd Mon Sep 17 00:00:00 2001 From: Xander Victory Date: Tue, 7 Nov 2017 15:38:54 +0800 Subject: [PATCH 2/2] add generic wrench handling to fully transparently support BC & COFH wrenches, and add a bonus IC2 wrench support. --- src/main/java/mekanism/api/IMekWrench.java | 10 +++ .../mekanism/common/block/BlockBasic.java | 41 +++++----- .../common/block/BlockEnergyCube.java | 52 +++++++------ .../mekanism/common/block/BlockGasTank.java | 49 ++++++------ .../mekanism/common/block/BlockMachine.java | 70 +++++++++-------- .../common/block/BlockTransmitter.java | 17 +++-- .../common/integration/MekanismHooks.java | 4 + .../integration/wrenches/BuildCraftProxy.java | 44 +++++++++++ .../integration/wrenches/CofhProxy.java | 44 +++++++++++ .../common/integration/wrenches/IC2Proxy.java | 41 ++++++++++ .../integration/wrenches/MekPassthrough.java | 16 ++++ .../integration/wrenches/MekWrenchProxy.java | 17 +++++ .../common/integration/wrenches/Wrenches.java | 76 +++++++++++++++++++ .../mekanism/common/util/MekanismUtils.java | 3 + .../common/block/BlockGenerator.java | 48 +++++++----- 15 files changed, 408 insertions(+), 124 deletions(-) create mode 100644 src/main/java/mekanism/common/integration/wrenches/BuildCraftProxy.java create mode 100644 src/main/java/mekanism/common/integration/wrenches/CofhProxy.java create mode 100644 src/main/java/mekanism/common/integration/wrenches/IC2Proxy.java create mode 100644 src/main/java/mekanism/common/integration/wrenches/MekPassthrough.java create mode 100644 src/main/java/mekanism/common/integration/wrenches/MekWrenchProxy.java create mode 100644 src/main/java/mekanism/common/integration/wrenches/Wrenches.java diff --git a/src/main/java/mekanism/api/IMekWrench.java b/src/main/java/mekanism/api/IMekWrench.java index fb7bd8419..2214535b6 100644 --- a/src/main/java/mekanism/api/IMekWrench.java +++ b/src/main/java/mekanism/api/IMekWrench.java @@ -2,9 +2,19 @@ package mekanism.api; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumHand; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.RayTraceResult; public interface IMekWrench { boolean canUseWrench(ItemStack stack, EntityPlayer player, BlockPos pos); + + /* easier compat with BC */ + default boolean canUseWrench(EntityPlayer player, EnumHand hand, ItemStack stack, RayTraceResult rayTrace) + { + return canUseWrench(stack, player, rayTrace.getBlockPos() != null ? rayTrace.getBlockPos() : BlockPos.ORIGIN); + } + + default void wrenchUsed(EntityPlayer player, EnumHand hand, ItemStack wrench, RayTraceResult rayTrace){} } diff --git a/src/main/java/mekanism/common/block/BlockBasic.java b/src/main/java/mekanism/common/block/BlockBasic.java index 778f0e764..1d61810aa 100644 --- a/src/main/java/mekanism/common/block/BlockBasic.java +++ b/src/main/java/mekanism/common/block/BlockBasic.java @@ -4,6 +4,7 @@ import java.util.Random; import java.util.UUID; import mekanism.api.Coord4D; +import mekanism.api.IMekWrench; import mekanism.api.energy.IEnergizedItem; import mekanism.api.energy.IStrictEnergyStorage; import mekanism.common.Mekanism; @@ -17,6 +18,7 @@ import mekanism.common.block.states.BlockStateBasic.BasicBlockType; import mekanism.common.block.states.BlockStateFacing; import mekanism.common.content.boiler.SynchronizedBoilerData; import mekanism.common.content.tank.TankUpdateProtocol; +import mekanism.common.integration.wrenches.Wrenches; import mekanism.common.inventory.InventoryBin; import mekanism.common.item.ItemBlockBasic; import mekanism.common.multiblock.IMultiblock; @@ -434,30 +436,31 @@ public abstract class BlockBasic extends Block { TileEntityBin bin = (TileEntityBin)tile; - if(!stack.isEmpty() && MekanismUtils.hasUsableWrench(entityplayer, pos)) + IMekWrench wrenchHandler; + + if(!stack.isEmpty() && (wrenchHandler = Wrenches.getHandler(stack)) != null) { - if(!world.isRemote) + RayTraceResult raytrace = new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos); + if (wrenchHandler.canUseWrench(entityplayer, hand, stack, raytrace)) { - Item tool = stack.getItem(); - - if(entityplayer.isSneaking()) + if(!world.isRemote) { - dismantleBlock(state, world, pos, false); - return true; + wrenchHandler.wrenchUsed(entityplayer, hand, stack, raytrace); + + if(entityplayer.isSneaking()) + { + dismantleBlock(state, world, pos, false); + return true; + } + + int change = bin.facing.rotateY().ordinal(); + + bin.setFacing((short)change); + world.notifyNeighborsOfStateChange(pos, this, true); } - - if(MekanismUtils.isBCWrench(tool)) - { - ((IToolWrench)tool).wrenchUsed(entityplayer, hand, stack, new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos)); - } - - int change = bin.facing.rotateY().ordinal(); - - bin.setFacing((short)change); - world.notifyNeighborsOfStateChange(pos, this, true); + + return true; } - - return true; } if(!world.isRemote) diff --git a/src/main/java/mekanism/common/block/BlockEnergyCube.java b/src/main/java/mekanism/common/block/BlockEnergyCube.java index 101d7e23a..20d0b0df1 100644 --- a/src/main/java/mekanism/common/block/BlockEnergyCube.java +++ b/src/main/java/mekanism/common/block/BlockEnergyCube.java @@ -2,6 +2,7 @@ package mekanism.common.block; import java.util.Random; +import mekanism.api.IMekWrench; import mekanism.api.energy.IEnergizedItem; import mekanism.common.Mekanism; import mekanism.common.MekanismBlocks; @@ -11,6 +12,7 @@ import mekanism.common.base.ISustainedInventory; import mekanism.common.base.ITierItem; import mekanism.common.block.states.BlockStateEnergyCube; import mekanism.common.block.states.BlockStateFacing; +import mekanism.common.integration.wrenches.Wrenches; import mekanism.common.item.ItemBlockEnergyCube; import mekanism.common.security.ISecurityItem; import mekanism.common.security.ISecurityTile; @@ -197,34 +199,34 @@ public class BlockEnergyCube extends BlockContainer if(!stack.isEmpty()) { - Item tool = stack.getItem(); + IMekWrench wrenchHandler = Wrenches.getHandler(stack); + if (wrenchHandler != null) { + RayTraceResult raytrace = new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos); + if(wrenchHandler.canUseWrench(entityplayer, hand, stack, raytrace)) { + if(SecurityUtils.canAccess(entityplayer, tileEntity)) { - if(MekanismUtils.hasUsableWrench(entityplayer, pos)) - { - if(SecurityUtils.canAccess(entityplayer, tileEntity)) - { - if(entityplayer.isSneaking()) - { - dismantleBlock(state, world, pos, false); - - return true; + wrenchHandler.wrenchUsed(entityplayer, hand, stack, raytrace); + + if(entityplayer.isSneaking()) + { + dismantleBlock(state, world, pos, false); + + return true; + } + + if(tileEntity != null) + { + int change = tileEntity.facing.rotateAround(side.getAxis()).ordinal(); + + tileEntity.setFacing((short)change); + world.notifyNeighborsOfStateChange(pos, this, true); + } + } else { + SecurityUtils.displayNoAccess(entityplayer); } - - if(MekanismUtils.isBCWrench(tool)) - { - ((IToolWrench)tool).wrenchUsed(entityplayer, hand, stack, new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos)); - } - - int change = tileEntity.facing.rotateAround(side.getAxis()).ordinal(); - - tileEntity.setFacing((short)change); - world.notifyNeighborsOfStateChange(pos, this, true); + + return true; } - else { - SecurityUtils.displayNoAccess(entityplayer); - } - - return true; } } diff --git a/src/main/java/mekanism/common/block/BlockGasTank.java b/src/main/java/mekanism/common/block/BlockGasTank.java index 188863569..ac0a9fb5a 100644 --- a/src/main/java/mekanism/common/block/BlockGasTank.java +++ b/src/main/java/mekanism/common/block/BlockGasTank.java @@ -2,6 +2,7 @@ package mekanism.common.block; import java.util.Random; +import mekanism.api.IMekWrench; import mekanism.api.gas.IGasItem; import mekanism.common.Mekanism; import mekanism.common.MekanismBlocks; @@ -10,6 +11,7 @@ import mekanism.common.base.ISustainedInventory; import mekanism.common.base.ITierItem; import mekanism.common.block.states.BlockStateFacing; import mekanism.common.block.states.BlockStateGasTank; +import mekanism.common.integration.wrenches.Wrenches; import mekanism.common.security.ISecurityItem; import mekanism.common.security.ISecurityTile; import mekanism.common.tile.TileEntityGasTank; @@ -149,34 +151,37 @@ public class BlockGasTank extends BlockContainer if(!stack.isEmpty()) { - Item tool = stack.getItem(); - - if(MekanismUtils.hasUsableWrench(entityplayer, pos)) + IMekWrench wrenchHandler = Wrenches.getHandler(stack); + if (wrenchHandler != null) { - if(SecurityUtils.canAccess(entityplayer, tileEntity)) + RayTraceResult raytrace = new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos); + if (wrenchHandler.canUseWrench(entityplayer, hand, stack, raytrace)) { - if(entityplayer.isSneaking()) + if (SecurityUtils.canAccess(entityplayer, tileEntity)) { - dismantleBlock(state, world, pos, false); - - return true; + wrenchHandler.wrenchUsed(entityplayer, hand, stack, raytrace); + + if(entityplayer.isSneaking()) + { + dismantleBlock(state, world, pos, false); + + return true; + } + + if(tileEntity != null) + { + int change = tileEntity.facing.rotateY().ordinal(); + + tileEntity.setFacing((short)change); + world.notifyNeighborsOfStateChange(pos, this, true); + } } - - if(MekanismUtils.isBCWrench(tool)) - { - ((IToolWrench)tool).wrenchUsed(entityplayer, hand, stack, new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos)); + else { + SecurityUtils.displayNoAccess(entityplayer); } - - int change = tileEntity.facing.rotateY().ordinal(); - - tileEntity.setFacing((short)change); - world.notifyNeighborsOfStateChange(pos, this, true); + + return true; } - else { - SecurityUtils.displayNoAccess(entityplayer); - } - - return true; } } diff --git a/src/main/java/mekanism/common/block/BlockMachine.java b/src/main/java/mekanism/common/block/BlockMachine.java index 754d29ff5..95a35cec0 100644 --- a/src/main/java/mekanism/common/block/BlockMachine.java +++ b/src/main/java/mekanism/common/block/BlockMachine.java @@ -4,6 +4,7 @@ import java.util.Random; import java.util.UUID; import mekanism.api.Coord4D; +import mekanism.api.IMekWrench; import mekanism.api.energy.IEnergizedItem; import mekanism.api.energy.IStrictEnergyStorage; import mekanism.common.Mekanism; @@ -25,6 +26,7 @@ import mekanism.common.block.states.BlockStateMachine.MachineBlock; import mekanism.common.block.states.BlockStateMachine.MachineType; import mekanism.common.config.MekanismConfig.client; import mekanism.common.content.entangloporter.InventoryFrequency; +import mekanism.common.integration.wrenches.Wrenches; import mekanism.common.item.ItemBlockMachine; import mekanism.common.network.PacketLogisticalSorterGui.LogisticalSorterGuiMessage; import mekanism.common.network.PacketLogisticalSorterGui.SorterGuiPacket; @@ -420,51 +422,55 @@ public abstract class BlockMachine extends BlockContainer if(!stack.isEmpty()) { - Item tool = stack.getItem(); - - if(MekanismUtils.hasUsableWrench(entityplayer, pos)) + IMekWrench wrenchHandler = Wrenches.getHandler(stack); + if(wrenchHandler != null) { - if(SecurityUtils.canAccess(entityplayer, tileEntity)) + RayTraceResult raytrace = new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos); + if(wrenchHandler.canUseWrench(entityplayer, hand, stack, raytrace)) { - if(entityplayer.isSneaking()) + if(SecurityUtils.canAccess(entityplayer, tileEntity)) { - dismantleBlock(state, world, pos, false); + wrenchHandler.wrenchUsed(entityplayer, hand, stack, raytrace); - return true; - } - - if(MekanismUtils.isBCWrench(tool)) - { - ((IToolWrench)tool).wrenchUsed(entityplayer, hand, stack, new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos)); - } - - int change = tileEntity.facing.rotateY().ordinal(); - - if(tileEntity instanceof TileEntityLogisticalSorter) - { - if(!((TileEntityLogisticalSorter)tileEntity).hasInventory()) + if(entityplayer.isSneaking()) { - for(EnumFacing dir : EnumFacing.VALUES) - { - TileEntity tile = Coord4D.get(tileEntity).offset(dir).getTileEntity(world); + dismantleBlock(state, world, pos, false); - if(tile instanceof IInventory) + return true; + } + + if(tileEntity != null) + { + int change = tileEntity.facing.rotateY().ordinal(); + + if(tileEntity instanceof TileEntityLogisticalSorter) + { + if(!((TileEntityLogisticalSorter)tileEntity).hasInventory()) { - change = dir.getOpposite().ordinal(); - break; + for(EnumFacing dir : EnumFacing.VALUES) + { + TileEntity tile = Coord4D.get(tileEntity).offset(dir).getTileEntity(world); + + if(tile instanceof IInventory) + { + change = dir.getOpposite().ordinal(); + break; + } + } } } + + tileEntity.setFacing((short)change); + world.notifyNeighborsOfStateChange(pos, this, true); } } + else + { + SecurityUtils.displayNoAccess(entityplayer); + } - tileEntity.setFacing((short)change); - world.notifyNeighborsOfStateChange(pos, this, true); - } - else { - SecurityUtils.displayNoAccess(entityplayer); + return true; } - - return true; } } diff --git a/src/main/java/mekanism/common/block/BlockTransmitter.java b/src/main/java/mekanism/common/block/BlockTransmitter.java index 27446e95d..da1ca895f 100644 --- a/src/main/java/mekanism/common/block/BlockTransmitter.java +++ b/src/main/java/mekanism/common/block/BlockTransmitter.java @@ -6,6 +6,7 @@ import java.util.Random; import javax.annotation.Nullable; +import mekanism.api.IMekWrench; import mekanism.common.Mekanism; import mekanism.common.MekanismBlocks; import mekanism.common.Tier.BaseTier; @@ -15,6 +16,7 @@ import mekanism.common.block.states.BlockStateTransmitter; import mekanism.common.block.states.BlockStateTransmitter.TransmitterType; import mekanism.common.block.states.BlockStateTransmitter.TransmitterType.Size; import mekanism.common.integration.multipart.MultipartMekanism; +import mekanism.common.integration.wrenches.Wrenches; import mekanism.common.tile.transmitter.TileEntityDiversionTransporter; import mekanism.common.tile.transmitter.TileEntityLogisticalTransporter; import mekanism.common.tile.transmitter.TileEntityMechanicalPipe; @@ -212,14 +214,19 @@ public class BlockTransmitter extends Block implements ITileEntityProvider return false; } - if(MekanismUtils.hasUsableWrench(player, pos) && player.isSneaking()) + IMekWrench wrenchHandler = Wrenches.getHandler(stack); + if(wrenchHandler != null) { - if(!world.isRemote) + RayTraceResult raytrace = new RayTraceResult(new Vec3d(hitX, hitY, hitZ), facing, pos); + if(wrenchHandler.canUseWrench(player, hand, stack, raytrace) && player.isSneaking()) { - dismantleBlock(state, world, pos, false); - } + if(!world.isRemote) + { + dismantleBlock(state, world, pos, false); + } - return true; + return true; + } } return false; diff --git a/src/main/java/mekanism/common/integration/MekanismHooks.java b/src/main/java/mekanism/common/integration/MekanismHooks.java index 1d9fa4ad8..1cf172813 100644 --- a/src/main/java/mekanism/common/integration/MekanismHooks.java +++ b/src/main/java/mekanism/common/integration/MekanismHooks.java @@ -17,6 +17,7 @@ import mekanism.common.block.states.BlockStateTransmitter.TransmitterType; import mekanism.common.integration.computer.CCPeripheral; import mekanism.common.integration.computer.OCDriver; import mekanism.common.integration.crafttweaker.CrafttweakerIntegration; +import mekanism.common.integration.wrenches.Wrenches; import mekanism.common.recipe.RecipeHandler; import mekanism.common.util.MekanismUtils; import net.minecraft.init.Items; @@ -35,6 +36,7 @@ import dan200.computercraft.api.ComputerCraftAPI; public final class MekanismHooks { public static final String COFH_CORE_MOD_ID = "cofhcore"; + public static final String COFH_API_MOD_ID = "cofhapi"; public static final String IC2_MOD_ID = "ic2"; public static final String RAILCRAFT_MOD_ID = "railcraft"; public static final String THERMALEXPANSION_MOD_ID = "thermalexpansion"; @@ -97,6 +99,8 @@ public final class MekanismHooks { CrafttweakerIntegration.applyRecipeChanges(); } + + Wrenches.initialise(); } @Method(modid = MekanismHooks.IC2_MOD_ID) diff --git a/src/main/java/mekanism/common/integration/wrenches/BuildCraftProxy.java b/src/main/java/mekanism/common/integration/wrenches/BuildCraftProxy.java new file mode 100644 index 000000000..d18e5703d --- /dev/null +++ b/src/main/java/mekanism/common/integration/wrenches/BuildCraftProxy.java @@ -0,0 +1,44 @@ +package mekanism.common.integration.wrenches; + +import buildcraft.api.tools.IToolWrench; +import mekanism.api.IMekWrench; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.RayTraceResult; + +/** + * Translates to Buildcraft's IToolWrench + */ +public class BuildCraftProxy implements MekWrenchProxy, IMekWrench +{ + public static final String BUILDCRAFT_WRENCH_CLASS = "buildcraft.api.tools.IToolWrench"; + + @Override + public IMekWrench get(ItemStack stack) + { + return stack.getItem() instanceof IToolWrench ? this : null; + } + + @Override + public boolean canUseWrench(ItemStack stack, EntityPlayer player, BlockPos pos) + { + return false;//compat only, needs raytrace + } + + @Override + public boolean canUseWrench(EntityPlayer player, EnumHand hand, ItemStack stack, RayTraceResult rayTrace) + { + return stack.getItem() instanceof IToolWrench && ((IToolWrench)stack.getItem()).canWrench(player, hand, stack, rayTrace); + } + + @Override + public void wrenchUsed(EntityPlayer player, EnumHand hand, ItemStack stack, RayTraceResult rayTrace) + { + if(stack.getItem() instanceof IToolWrench) + { + ((IToolWrench)stack.getItem()).wrenchUsed(player, hand, stack, rayTrace); + } + } +} diff --git a/src/main/java/mekanism/common/integration/wrenches/CofhProxy.java b/src/main/java/mekanism/common/integration/wrenches/CofhProxy.java new file mode 100644 index 000000000..de5bb0eab --- /dev/null +++ b/src/main/java/mekanism/common/integration/wrenches/CofhProxy.java @@ -0,0 +1,44 @@ +package mekanism.common.integration.wrenches; + +import cofh.api.item.IToolHammer; +import mekanism.api.IMekWrench; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.RayTraceResult; + +/** + * Translates to COFH's IToolHammer + */ +public class CofhProxy implements MekWrenchProxy, IMekWrench +{ + public static final String COFH_HAMMER_CLASS = "cofh.api.item.IToolHammer"; + + @Override + public IMekWrench get(ItemStack stack) + { + return stack.getItem() instanceof IToolHammer ? this : null; + } + + @Override + public boolean canUseWrench(ItemStack stack, EntityPlayer player, BlockPos pos) + { + return stack.getItem() instanceof IToolHammer && ((IToolHammer)stack.getItem()).isUsable(stack, player, pos); + } + + // uses default method + //@Override + //public boolean canUseWrench(EntityPlayer player, EnumHand hand, ItemStack stack, RayTraceResult rayTrace) { + // return false; + //} + + @Override + public void wrenchUsed(EntityPlayer player, EnumHand hand, ItemStack wrench, RayTraceResult rayTrace) + { + if(wrench.getItem() instanceof IToolHammer) + { + ((IToolHammer)wrench.getItem()).toolUsed(wrench, player, rayTrace.getBlockPos() != null ? rayTrace.getBlockPos() : BlockPos.ORIGIN); + } + } +} diff --git a/src/main/java/mekanism/common/integration/wrenches/IC2Proxy.java b/src/main/java/mekanism/common/integration/wrenches/IC2Proxy.java new file mode 100644 index 000000000..882960b76 --- /dev/null +++ b/src/main/java/mekanism/common/integration/wrenches/IC2Proxy.java @@ -0,0 +1,41 @@ +package mekanism.common.integration.wrenches; + +import mekanism.api.IMekWrench; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.math.BlockPos; + +/** + * Translates to IC2's wrench via reflection as it's an internal class. + */ +public class IC2Proxy implements MekWrenchProxy, IMekWrench +{ + public static final String IC2_WRENCH_CLASS = "ic2.core.item.tool.ItemToolWrench"; + + private final Class wrenchClass; + + public IC2Proxy(){ + Class w = null; + try + { + w = Class.forName(IC2_WRENCH_CLASS); + } + catch(ClassNotFoundException e) + { + //no-op + } + this.wrenchClass = w; + } + + @Override + public boolean canUseWrench(ItemStack stack, EntityPlayer player, BlockPos pos) + { + return this.wrenchClass != null && this.wrenchClass.isInstance(stack.getItem()); + } + + @Override + public IMekWrench get(ItemStack stack) + { + return this.wrenchClass != null && this.wrenchClass.isInstance(stack.getItem()) ? this : null; + } +} diff --git a/src/main/java/mekanism/common/integration/wrenches/MekPassthrough.java b/src/main/java/mekanism/common/integration/wrenches/MekPassthrough.java new file mode 100644 index 000000000..73d1d41fa --- /dev/null +++ b/src/main/java/mekanism/common/integration/wrenches/MekPassthrough.java @@ -0,0 +1,16 @@ +package mekanism.common.integration.wrenches; + +import mekanism.api.IMekWrench; +import net.minecraft.item.ItemStack; + +/** + * Default handler for IMekWrench items, returns the Itemstack#item + */ +public class MekPassthrough implements MekWrenchProxy +{ + @Override + public IMekWrench get(ItemStack stack) + { + return stack.getItem() instanceof IMekWrench ? (IMekWrench)stack.getItem() : null; + } +} diff --git a/src/main/java/mekanism/common/integration/wrenches/MekWrenchProxy.java b/src/main/java/mekanism/common/integration/wrenches/MekWrenchProxy.java new file mode 100644 index 000000000..06808e7c7 --- /dev/null +++ b/src/main/java/mekanism/common/integration/wrenches/MekWrenchProxy.java @@ -0,0 +1,17 @@ +package mekanism.common.integration.wrenches; + +import mekanism.api.IMekWrench; +import net.minecraft.item.ItemStack; + +/** + * Abstraction for non-Mek wrench providers. + */ +public interface MekWrenchProxy +{ + /** + * Get a handler for the wrench + * @param stack the instance to be used. + * @return a IMekWrench instance that can handle translation to the external provider. + */ + IMekWrench get(ItemStack stack); +} diff --git a/src/main/java/mekanism/common/integration/wrenches/Wrenches.java b/src/main/java/mekanism/common/integration/wrenches/Wrenches.java new file mode 100644 index 000000000..c44f72356 --- /dev/null +++ b/src/main/java/mekanism/common/integration/wrenches/Wrenches.java @@ -0,0 +1,76 @@ +package mekanism.common.integration.wrenches; + +import mekanism.api.IMekWrench; +import net.minecraft.item.ItemStack; + +import javax.annotation.Nullable; +import java.util.function.Supplier; + +/** + * Generic handler for wrenches, exposed as {@link IMekWrench}. + * Generally you don't want to use the enum directly, instead use {@link Wrenches#getHandler(ItemStack)}, + * and check for nullability. + */ +public enum Wrenches +{ + MEKANISM_PASSTHROUGH(IMekWrench.class.getName(), MekPassthrough::new), + BUILDCRAFT(BuildCraftProxy.BUILDCRAFT_WRENCH_CLASS, BuildCraftProxy::new), + COFH(CofhProxy.COFH_HAMMER_CLASS, CofhProxy::new), + IC2(IC2Proxy.IC2_WRENCH_CLASS, IC2Proxy::new), + ; + + private final String classname; + private Class itemClass; + private final Supplier mekProxy; + private boolean enabled; + private MekWrenchProxy provider; + + Wrenches(String clazz, Supplier mekProxy) + { + this.classname = clazz; + this.mekProxy = mekProxy; + } + + private boolean canHandle(ItemStack it) + { + return (enabled && provider != null && itemClass != null && itemClass.isInstance(it.getItem())); + } + + public static void initialise() + { + for(Wrenches w : values()) + { + try + { + w.itemClass = Class.forName(w.classname); + } catch(ClassNotFoundException e) + { + w.enabled = false; + w.provider = null; + w.itemClass = null; + continue; + } + try + { + w.provider = w.mekProxy.get(); + } catch(Exception e) + { + w.enabled = false; + w.provider = null; + } + } + } + + public static @Nullable + IMekWrench getHandler(ItemStack it) + { + for(Wrenches w : values()) + { + if(w.canHandle(it)) + { + return w.provider.get(it); + } + } + return null; + } +} diff --git a/src/main/java/mekanism/common/util/MekanismUtils.java b/src/main/java/mekanism/common/util/MekanismUtils.java index 34697b307..0d2d8e370 100644 --- a/src/main/java/mekanism/common/util/MekanismUtils.java +++ b/src/main/java/mekanism/common/util/MekanismUtils.java @@ -1496,7 +1496,10 @@ public final class MekanismUtils * @param player - the player using the wrench * @param pos - the coordinate of the block being wrenched * @return if the player can use the wrench + * + * @deprecated use {@link mekanism.common.integration.wrenches.Wrenches#getHandler(ItemStack)} */ + @Deprecated public static boolean hasUsableWrench(EntityPlayer player, BlockPos pos) { ItemStack tool = player.inventory.getCurrentItem(); diff --git a/src/main/java/mekanism/generators/common/block/BlockGenerator.java b/src/main/java/mekanism/generators/common/block/BlockGenerator.java index 4e9b8f6e0..b4005b91e 100644 --- a/src/main/java/mekanism/generators/common/block/BlockGenerator.java +++ b/src/main/java/mekanism/generators/common/block/BlockGenerator.java @@ -2,6 +2,7 @@ package mekanism.generators.common.block; import java.util.Random; +import mekanism.api.IMekWrench; import mekanism.api.energy.IEnergizedItem; import mekanism.common.Mekanism; import mekanism.common.base.IActiveState; @@ -11,6 +12,7 @@ import mekanism.common.base.ISustainedInventory; import mekanism.common.base.ISustainedTank; import mekanism.common.block.states.BlockStateFacing; import mekanism.common.config.MekanismConfig.client; +import mekanism.common.integration.wrenches.Wrenches; import mekanism.common.multiblock.IMultiblock; import mekanism.common.security.ISecurityItem; import mekanism.common.security.ISecurityTile; @@ -378,34 +380,38 @@ public abstract class BlockGenerator extends BlockContainer if(!stack.isEmpty()) { - Item tool = stack.getItem(); - - if(MekanismUtils.hasUsableWrench(entityplayer, pos)) + IMekWrench wrenchHandler = Wrenches.getHandler(stack); + if(wrenchHandler != null) { - if(SecurityUtils.canAccess(entityplayer, tileEntity)) + RayTraceResult raytrace = new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos); + if(wrenchHandler.canUseWrench(entityplayer, hand, stack, raytrace)) { - if(entityplayer.isSneaking()) + if(SecurityUtils.canAccess(entityplayer, tileEntity)) { - dismantleBlock(state, world, pos, false); - - return true; + wrenchHandler.wrenchUsed(entityplayer, hand, stack, raytrace); + + if(entityplayer.isSneaking()) + { + dismantleBlock(state, world, pos, false); + + return true; + } + + if(tileEntity != null) + { + int change = tileEntity.facing.rotateY().ordinal(); + + tileEntity.setFacing((short)change); + world.notifyNeighborsOfStateChange(pos, this, true); + } } - - if(MekanismUtils.isBCWrench(tool)) + else { - ((IToolWrench)tool).wrenchUsed(entityplayer, hand, stack, new RayTraceResult(new Vec3d(hitX, hitY, hitZ), side, pos)); + SecurityUtils.displayNoAccess(entityplayer); } - - int change = tileEntity.facing.rotateY().ordinal(); - - tileEntity.setFacing((short)change); - world.notifyNeighborsOfStateChange(pos, this, true); + + return true; } - else { - SecurityUtils.displayNoAccess(entityplayer); - } - - return true; } }