Player Interact Event

src/main/java/net/minecraftforge/common/ForgeHooks.java

@@ -86,6 +86,7 @@ import net.minecraftforge.event.entity.living.LivingHurtEvent;
 import net.minecraftforge.event.entity.living.LivingSetAttackTargetEvent;
 import net.minecraftforge.event.entity.player.AnvilRepairEvent;
 import net.minecraftforge.event.entity.player.AttackEntityEvent;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
 import net.minecraftforge.event.entity.player.PlayerOpenContainerEvent;
 import net.minecraftforge.event.world.BlockEvent;
 import net.minecraftforge.event.world.NoteBlockEvent;
@@ -934,4 +935,44 @@ public class ForgeHooks
         RayTraceResult git = rayTraceEyes(entity, length);
         return git == null ? null : git.hitVec;
     }
+
+    public static boolean onInteractEntityAt(EntityPlayer player, Entity entity, RayTraceResult ray, ItemStack stack, EnumHand hand)
+    {
+        Vec3d vec3d = new Vec3d(ray.hitVec.xCoord - entity.posX, ray.hitVec.yCoord - entity.posY, ray.hitVec.zCoord - entity.posZ);
+        return onInteractEntityAt(player, entity, vec3d, stack, hand);
+    }
+
+    public static boolean onInteractEntityAt(EntityPlayer player, Entity entity, Vec3d vec3d, ItemStack stack, EnumHand hand)
+    {
+        return MinecraftForge.EVENT_BUS.post(new PlayerInteractEvent.EntityInteractSpecific(player, hand, stack, entity, vec3d));
+    }
+
+    public static boolean onInteractEntity(EntityPlayer player, Entity entity, ItemStack item, EnumHand hand)
+    {
+        return MinecraftForge.EVENT_BUS.post(new PlayerInteractEvent.EntityInteract(player, hand, item, entity));
+    }
+
+    public static boolean onItemRightClick(EntityPlayer player, EnumHand hand, ItemStack stack)
+    {
+        return MinecraftForge.EVENT_BUS.post(new PlayerInteractEvent.RightClickItem(player, hand, stack));
+    }
+
+    public static PlayerInteractEvent.LeftClickBlock onLeftClickBlock(EntityPlayer player, BlockPos pos, EnumFacing face, Vec3d hitVec)
+    {
+        PlayerInteractEvent.LeftClickBlock evt = new PlayerInteractEvent.LeftClickBlock(player, pos, face, hitVec);
+        MinecraftForge.EVENT_BUS.post(evt);
+        return evt;
+    }
+
+    public static PlayerInteractEvent.RightClickBlock onRightClickBlock(EntityPlayer player, EnumHand hand, ItemStack stack, BlockPos pos, EnumFacing face, Vec3d hitVec)
+    {
+        PlayerInteractEvent.RightClickBlock evt = new PlayerInteractEvent.RightClickBlock(player, hand, stack, pos, face, hitVec);
+        MinecraftForge.EVENT_BUS.post(evt);
+        return evt;
+    }
+
+    public static void onEmptyClick(EntityPlayer player, EnumHand hand)
+    {
+        MinecraftForge.EVENT_BUS.post(new PlayerInteractEvent.RightClickEmpty(player, hand));
+    }
 }

src/main/java/net/minecraftforge/event/ForgeEventFactory.java

@@ -61,7 +61,6 @@ import net.minecraftforge.event.entity.living.ZombieEvent.SummonAidEvent;
 import net.minecraftforge.event.entity.player.ArrowLooseEvent;
 import net.minecraftforge.event.entity.player.ArrowNockEvent;
 import net.minecraftforge.event.entity.player.BonemealEvent;
-import net.minecraftforge.event.entity.player.EntityInteractEvent;
 import net.minecraftforge.event.entity.player.EntityItemPickupEvent;
 import net.minecraftforge.event.entity.player.FillBucketEvent;
 import net.minecraftforge.event.entity.player.ItemTooltipEvent;
@@ -69,8 +68,6 @@ import net.minecraftforge.event.entity.player.PlayerDestroyItemEvent;
 import net.minecraftforge.event.entity.player.PlayerDropsEvent;
 import net.minecraftforge.event.entity.player.PlayerEvent;
 import net.minecraftforge.event.entity.player.PlayerFlyableFallEvent;
-import net.minecraftforge.event.entity.player.PlayerInteractEvent;
-import net.minecraftforge.event.entity.player.PlayerInteractEvent.Action;
 import net.minecraftforge.event.entity.player.PlayerSetSpawnEvent;
 import net.minecraftforge.event.entity.player.PlayerSleepInBedEvent;
 import net.minecraftforge.event.entity.player.PlayerWakeUpEvent;
@@ -128,19 +125,6 @@ public class ForgeEventFactory
         return (MinecraftForge.EVENT_BUS.post(event) ? -1 : event.getNewSpeed());
     }
 
-    @Deprecated
-    public static PlayerInteractEvent onPlayerInteract(EntityPlayer player, Action action, World world, BlockPos pos, EnumFacing face)
-    {
-        return onPlayerInteract(player, action, world, pos, face, null);
-    }
-
-    public static PlayerInteractEvent onPlayerInteract(EntityPlayer player, Action action, World world, BlockPos pos, EnumFacing face, Vec3d localPos)
-    {
-        PlayerInteractEvent event = new PlayerInteractEvent(player, action, pos, face, world, localPos);
-        MinecraftForge.EVENT_BUS.post(event);
-        return event;
-    }
-
     public static void onPlayerDestroyItem(EntityPlayer player, ItemStack stack, EnumHand hand)
     {
         MinecraftForge.EVENT_BUS.post(new PlayerDestroyItemEvent(player, stack, hand));
@@ -369,11 +353,6 @@ public class ForgeEventFactory
         }
     }
 
-    public static boolean canInteractWith(EntityPlayer player, Entity entity, ItemStack item, EnumHand hand)
-    {
-        return !MinecraftForge.EVENT_BUS.post(new EntityInteractEvent(player, entity, item, hand));
-    }
-
     public static boolean canMountEntity(Entity entityMounting, Entity entityBeingMounted, boolean isMounting)
     {
         boolean isCanceled = MinecraftForge.EVENT_BUS.post(new EntityMountEvent(entityMounting, entityBeingMounted, entityMounting.worldObj, isMounting));

src/main/java/net/minecraftforge/event/entity/player/EntityInteractEvent.java

@@ -1,41 +0,0 @@
-package net.minecraftforge.event.entity.player;
-
-import net.minecraftforge.fml.common.eventhandler.Cancelable;
-import net.minecraftforge.fml.common.eventhandler.Event.HasResult;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.EnumHand;
-
-/**
- * EntityInteractEvent is fired when a player interacts with an Entity.<br>
- * This event is fired whenever a player interacts with an Entity in
- * EntityPlayer#interactWith(Entity).<br>
- * <br>
- * {@link #target} contains the Entity the player interacted with. <br>
- * <br>
- * This event is {@link Cancelable}.<br>
- * If this event is canceled, the player does not interact with the Entity.<br>
- * <br>
- * This event does not have a result. {@link HasResult}<br>
- * <br>
- * This event is fired on the {@link MinecraftForge#EVENT_BUS}.
- **/
-@Cancelable
-public class EntityInteractEvent extends PlayerEvent
-{
-    private final Entity target;
-    private final ItemStack item;
-    private final EnumHand hand;
-    public EntityInteractEvent(EntityPlayer player, Entity target, ItemStack item, EnumHand hand)
-    {
-        super(player);
-        this.target = target;
-        this.item = item;
-        this.hand = hand;
-    }
-
-    public Entity getTarget() { return this.target; }
-    public ItemStack getItem() { return this.item; }
-    public EnumHand getHand() { return this.hand; }
-}

src/main/java/net/minecraftforge/event/entity/player/PlayerInteractEvent.java

@@ -1,88 +1,336 @@
 package net.minecraftforge.event.entity.player;
 
+import com.google.common.base.Preconditions;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.eventhandler.Cancelable;
+import net.minecraftforge.fml.relauncher.Side;
+
+import javax.annotation.Nullable;
+
 import static net.minecraftforge.fml.common.eventhandler.Event.Result.DEFAULT;
 import static net.minecraftforge.fml.common.eventhandler.Event.Result.DENY;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.math.Vec3d;
-import net.minecraft.world.World;
-import net.minecraftforge.fml.common.eventhandler.Cancelable;
 
 /**
  * PlayerInteractEvent is fired when a player interacts in some way.
- * <br>
- * This event is fired whenever a player interacts in
- * Minecraft#func_147121_ag(),
- * NetHandlerPlayServer#processPlayerBlockPlacement(C08PacketPlayerBlockPlacement),
- * ItemInWorldManager#activateBlockOrUseItem(EntityPlayer, World, ItemStack, int, int, int, int, float, float, float),
- * ItemInWorldManager#onBlockClicked(int, int, int, int). <br>
- * <br>
- * This event is fired via the {@link ForgeEventFactory#onPlayerInteract(EntityPlayer, Action, BlockPos, EnumFacing)}.
- * <br>
- * {@link #action} contains the Action the player performed during this interaction. <br>
- * {@link #pos} contains the coordinate of where this event occurred.<br>
- * {@link #face} contains the face of the block that was interacted with. May be null if unknown. <br>
- * {@link #world} contains the world in which this event is occurring. <br>
- * <br>
- * This event is {@link Cancelable}.<br>
- * If this event is canceled, the player does not interact.<br>
- * <br>
- * This event does not have a result. {@link HasResult}<br>
- * <br>
- * This event is fired on the {@link MinecraftForge#EVENT_BUS}.
+ * All subclasses are fired on {@link MinecraftForge#EVENT_BUS}.
+ * See the individual documentation on each subevent for more details.
  **/
-@Cancelable
 public class PlayerInteractEvent extends PlayerEvent
 {
-    public static enum Action
-    {
-        RIGHT_CLICK_AIR,
-        RIGHT_CLICK_BLOCK,
-        LEFT_CLICK_BLOCK
-    }
-
-    private final Action action;
-    private final World world;
+    private final EnumHand hand;
+    private final ItemStack stack;
     private final BlockPos pos;
-    private final EnumFacing face; // Can be null if unknown
-    private final Vec3d localPos; // Can be null if unknown
+    private final EnumFacing face;
 
-    private Result useBlock = DEFAULT;
-    private Result useItem = DEFAULT;
-
-    @Deprecated
-    public PlayerInteractEvent(EntityPlayer player, Action action, BlockPos pos, EnumFacing face, World world)
+    private PlayerInteractEvent(EntityPlayer player, EnumHand hand, ItemStack stack, BlockPos pos, EnumFacing face)
     {
-        this(player, action, pos, face, world, null);
-    }
-
-    public PlayerInteractEvent(EntityPlayer player, Action action, BlockPos pos, EnumFacing face, World world, Vec3d localPos)
-    {
-        super(player);
-        this.action = action;
-        this.pos = pos;
+        super(Preconditions.checkNotNull(player, "Null player in PlayerInteractEvent!"));
+        this.hand = Preconditions.checkNotNull(hand, "Null hand in PlayerInteractEvent!");
+        this.stack = stack;
+        this.pos = Preconditions.checkNotNull(pos, "Null position in PlayerInteractEvent!");
         this.face = face;
-        if (face == null) setUseBlock(DENY);
-        this.world = world;
-        this.localPos = localPos;
     }
 
-    @Override
-    public void setCanceled(boolean cancel)
+    /**
+     * This event is fired on both sides whenever a player right clicks an entity.
+     *
+     * "Interact at" is an interact where the local vector (which part of the entity you clicked) is known.
+     * The state of this event affects whether {@link Entity#applyPlayerInteraction} is called.
+     * If {@link Entity#applyPlayerInteraction} returns {@link net.minecraft.util.EnumActionResult#SUCCESS}, then processing ends.
+     * Otherwise processing will continue to {@link EntityInteract}
+     *
+     * Canceling the event clientside will cause processing to continue to {@link EntityInteract},
+     * while canceling serverside will simply do no further processing.
+     */
+    @Cancelable
+    public static class EntityInteractSpecific extends PlayerInteractEvent
     {
-        super.setCanceled(cancel);
-        setUseBlock((cancel ? DENY : getUseBlock() == DENY ? DEFAULT : getUseBlock()));
-        setUseItem((cancel ? DENY : getUseItem() == DENY ? DEFAULT : getUseItem()));
+        private final Vec3d localPos;
+        private final Entity target;
+
+        public EntityInteractSpecific(EntityPlayer player, EnumHand hand, ItemStack stack, Entity target, Vec3d localPos)
+        {
+            super(player, hand, stack, new BlockPos(target), null);
+            this.localPos = localPos;
+            this.target = target;
+        }
+
+        /**
+         * Returns the local interaction position. This is a 3D vector, where (0, 0, 0) is centered exactly at the
+         * center of the entity's bounding box at their feet. This means the X and Z values will be in the range
+         * [-width / 2, width / 2] while Y values will be in the range [0, height]
+         * @return The local position
+         */
+        public Vec3d getLocalPos()
+        {
+            return localPos;
+        }
+
+        public Entity getTarget()
+        {
+            return target;
+        }
+    }
+
+    /**
+     * This event is fired on both sides when the player right clicks an entity.
+     * It is responsible for all general entity interactions.
+     *
+     * This event is fired completely independently of the above {@link EntityInteractSpecific}, except for the case
+     * where the above call to {@link Entity#applyPlayerInteraction} returns {@link net.minecraft.util.EnumActionResult#SUCCESS}.
+     * In that case, general entity interactions, and hence this event, will not be called. See the above javadoc for more details.
+     *
+     * This event's state affects whether {@link Entity#processInitialInteract} and {@link net.minecraft.item.Item#itemInteractionForEntity} are called.
+     *
+     * Canceling the event clientside will cause processing to continue to {@link RightClickItem},
+     * while canceling serverside will simply do no further processing.
+     */
+    @Cancelable
+    public static class EntityInteract extends PlayerInteractEvent
+    {
+        private final Entity target;
+
+        public EntityInteract(EntityPlayer player, EnumHand hand, ItemStack stack, Entity target)
+        {
+            super(player, hand, stack, new BlockPos(target), null);
+            this.target = target;
+        }
+
+        public Entity getTarget()
+        {
+            return target;
+        }
+    }
+
+    /**
+     * This event is fired on both sides whenever the player right clicks while targeting a block.
+     * This event controls which of {@link net.minecraft.block.Block#onBlockActivated} and/or {@link net.minecraft.item.Item#onItemUse}
+     * will be called after {@link net.minecraft.item.Item#onItemUseFirst} is called.
+     * Canceling the event will cause none of the above three to be called.
+     * There are various results to this event, see the getters below.
+     * Note that handling things differently on the client vs server may cause desynchronizations!
+     */
+    @Cancelable
+    public static class RightClickBlock extends PlayerInteractEvent
+    {
+        private Result useBlock = DEFAULT;
+        private Result useItem = DEFAULT;
+        private final Vec3d hitVec;
+
+        public RightClickBlock(EntityPlayer player, EnumHand hand, ItemStack stack,
+                               BlockPos pos, EnumFacing face, Vec3d hitVec) {
+            super(player, hand, stack, pos, face);
+            this.hitVec = hitVec;
+        }
+
+        /**
+         * @return The hit vector of this click
+         */
+        public Vec3d getHitVec()
+        {
+            return hitVec;
+        }
+
+        /**
+         * @return If {@link net.minecraft.block.Block#onBlockActivated} should be called
+         */
+        public Result getUseBlock()
+        {
+            return useBlock;
+        }
+
+        /**
+         * @return If {@link net.minecraft.item.Item#onItemUse} should be called
+         */
+        public Result getUseItem()
+        {
+            return useItem;
+        }
+
+        /**
+         * DENY: Block will never be used.
+         * DEFAULT: Default behaviour (sneak will not use block, unless all items return true in {@link net.minecraft.item.Item#doesSneakBypassUse}).
+         * ALLOW: Block will always be used, regardless of sneaking and doesSneakBypassUse.
+         */
+        public void setUseBlock(Result triggerBlock)
+        {
+            this.useBlock = triggerBlock;
+        }
+
+        /**
+         * DENY: The item will never be used.
+         * DEFAULT: The item will be used if the block fails.
+         * ALLOW: The item will always be used.
+         */
+        public void setUseItem(Result triggerItem)
+        {
+            this.useItem = triggerItem;
+        }
+
+        @Override
+        public void setCanceled(boolean canceled)
+        {
+            super.setCanceled(canceled);
+            useBlock = DENY;
+            useItem = DENY;
+        }
+    }
+
+    /**
+     * This event is fired on both sides before the player triggers {@link net.minecraft.item.Item#onItemRightClick}.
+     * Note that this is NOT fired if the player is targeting a block. For that case, see {@link RightClickBlock}.
+     * Canceling the event clientside causes processing to continue to the other hands,
+     * while canceling serverside will simply do no further processing.
+     */
+    @Cancelable
+    public static class RightClickItem extends PlayerInteractEvent
+    {
+        public RightClickItem(EntityPlayer player, EnumHand hand, ItemStack stack)
+        {
+            super(player, hand, stack, new BlockPos(player), null);
+        }
+    }
+
+    /**
+     * This event is fired on the client side when the player right clicks empty space with an empty hand.
+     * The server is not aware of when the client right clicks empty space with an empty hand, you will need to tell the server yourself.
+     * This event cannot be canceled.
+     */
+    public static class RightClickEmpty extends PlayerInteractEvent
+    {
+        public RightClickEmpty(EntityPlayer player, EnumHand hand)
+        {
+            super(player, hand, null, new BlockPos(player), null);
+        }
+    }
+
+    /**
+     * This event is fired when a player left clicks while targeting a block.
+     * This event controls which of {@link net.minecraft.block.Block#onBlockClicked} and/or the item harvesting methods will be called
+     * Canceling the event will cause none of the above noted methods to be called.
+     * There are various results to this event, see the getters below.
+     * Note that if the event is canceled and the player holds down left mouse, the event will continue to fire.
+     * This is due to how vanilla calls the left click handler methods.
+     */
+    @Cancelable
+    public static class LeftClickBlock extends PlayerInteractEvent
+    {
+        private Result useBlock = DEFAULT;
+        private Result useItem = DEFAULT;
+        private final Vec3d hitVec;
+
+        public LeftClickBlock(EntityPlayer player, BlockPos pos, EnumFacing face, Vec3d hitVec)
+        {
+            super(player, EnumHand.MAIN_HAND, player.getHeldItem(EnumHand.MAIN_HAND), pos, face);
+            this.hitVec = hitVec;
+        }
+
+        /**
+         * @return The local hit vector of this click
+         */
+        public Vec3d getHitVec()
+        {
+            return hitVec;
+        }
+
+        /**
+         * @return If {@link net.minecraft.block.Block#onBlockClicked} should be called
+         */
+        public Result getUseBlock()
+        {
+            return useBlock;
+        }
+
+        /**
+         * @return If the block should be attempted to be mined with the current item
+         */
+        public Result getUseItem()
+        {
+            return useItem;
+        }
+
+        public void setUseBlock(Result triggerBlock)
+        {
+            this.useBlock = triggerBlock;
+        }
+
+        public void setUseItem(Result triggerItem)
+        {
+            this.useItem = triggerItem;
+        }
+
+        @Override
+        public void setCanceled(boolean canceled)
+        {
+            super.setCanceled(canceled);
+            useBlock = DENY;
+            useItem = DENY;
+        }
+    }
+
+    /**
+     * @return The hand involved in this interaction. Will never be null.
+     */
+    public EnumHand getHand()
+    {
+        return hand;
+    }
+
+    /**
+     * @return The itemstack involved in this interaction, or null if the hand was empty.
+     */
+    @Nullable
+    public ItemStack getItemStack()
+    {
+        return stack;
+    }
+
+    /**
+     * If the interaction was on an entity, will be a BlockPos centered on the entity.
+     * If the interaction was on a block, will be the position of that block.
+     * Otherwise, will be a BlockPos centered on the player.
+     * Will never be null.
+     * @return The position involved in this interaction.
+     */
+    public BlockPos getPos()
+    {
+        return pos;
+    }
+
+    /**
+     * @return The face involved in this interaction. For all non-block interactions, this will return null.
+     */
+    @Nullable
+    public EnumFacing getFace()
+    {
+        return face;
+    }
+
+    /**
+     * @return Convenience method to get the world of this interaction.
+     */
+    public World getWorld()
+    {
+        return getEntityPlayer().getEntityWorld();
+    }
+
+    /**
+     * @return The effective, i.e. logical, side of this interaction. This will be {@link Side#CLIENT} on the client thread, and {@link Side#SERVER} on the server thread.
+     */
+    public Side getSide()
+    {
+        return getWorld().isRemote ? Side.CLIENT : Side.SERVER;
     }
 
-    public Action getAction() { return action; }
-    public World getWorld() { return world; }
-    public BlockPos getPos() { return pos; }
-    public EnumFacing getFace() { return face; }
-    public Vec3d getLocalPos() { return localPos; }
-    public Result getUseBlock() { return useBlock; }
-    public void setUseBlock(Result useBlock) { this.useBlock = useBlock; }
-    public Result getUseItem() { return useItem; }
-    public void setUseItem(Result useItem) { this.useItem = useItem; }
 }