import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
public boolean onItemUse(ItemStack itemStack, Player player, HandType currHand, BlockSnapshot clickedBlock,
        Direction side, Vector3d hitPoint) {
    CustomWorld world = WorldManager.toCustomWorld(player.getWorld());
    Vector3d pos;
    if (hitPoint == null) {
        pos = clickedBlock.getPosition().add(side.asBlockOffset()).toDouble().add(0.5, 0, 0.5);
    } else {
        pos = clickedBlock.getPosition().toDouble().add(hitPoint);
    }
    TurtleEntity turtle = new TurtleEntity(player.getWorld());
    turtle.setPosition(pos);
    Vector3d r = player.getHeadRotation();
    turtle.setRotation(new Vector3d(r.getX(), r.getY() + 180, r.getZ()));
    if (world.spawnEntity(turtle)) {
        if (player.gameMode().get() != GameModes.CREATIVE) {
            itemStack.setQuantity(itemStack.getQuantity() - 1);
            if (itemStack.getQuantity() == 0) {
                itemStack = null;
            }
            player.setItemInHand(currHand, itemStack);
        }
    }
    return false;
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
private void handleFinishItemInteraction0(AbstractSlot slot, HandType handType) {
    final Optional<ItemStack> handItem = slot.peek();
    if (handItem.isPresent()) {
        final CauseStack causeStack = CauseStack.current();
        try (CauseStack.Frame frame = causeStack.pushCauseFrame()) {
            frame.pushCause(this.player);
            frame.addContext(ContextKeys.PLAYER, this.player);
            if (handItem.isPresent()) {
                final LanternItemType itemType = (LanternItemType) handItem.get().getType();
                frame.addContext(ContextKeys.USED_ITEM_STACK, handItem.get());
                frame.addContext(ContextKeys.USED_SLOT, slot);
                frame.addContext(ContextKeys.INTERACTION_HAND, handType);
                frame.addContext(ContextKeys.ITEM_TYPE, itemType);

                final BehaviorContextImpl context = new BehaviorContextImpl(causeStack);
                if (context.process(itemType.getPipeline().pipeline(FinishUsingItemBehavior.class),
                        (ctx, behavior) -> behavior.tryUse(itemType.getPipeline(), ctx)).isSuccess()) {
                    context.accept();
                }
            }
        }
    }
    resetItemUseTime();
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
private boolean handleHandItemInteraction(BehaviorContextImpl context, HandType handType, AbstractSlot slot,
        @Nullable BehaviorContext.Snapshot snapshot) {
    final Optional<HandType> activeHand = this.player.get(LanternKeys.ACTIVE_HAND).orElse(Optional.empty());
    // The player is already interacting
    if (activeHand.isPresent()) {
        return true;
    }
    final Optional<ItemStack> handItem = slot.peek();
    if (handItem.isPresent()) {
        final LanternItemType itemType = (LanternItemType) handItem.get().getType();
        context.addContext(ContextKeys.USED_ITEM_STACK, handItem.get());
        context.addContext(ContextKeys.USED_SLOT, slot);
        context.addContext(ContextKeys.INTERACTION_HAND, handType);
        context.addContext(ContextKeys.ITEM_TYPE, itemType);

        final BehaviorResult result = context.process(itemType.getPipeline().pipeline(InteractWithItemBehavior.class),
                (ctx, behavior) -> behavior.tryInteract(itemType.getPipeline(), ctx));
        if (result.isSuccess()) {
            return true;
        }
        if (snapshot != null) {
            context.popSnapshot(snapshot);
        }
    }
    return false;
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
protected void handleEvent(EntityProtocolUpdateContext context, EntityEvent event) {
    if (event instanceof DamagedEntityEvent) {
        context.sendToAll(() -> new MessagePlayOutEntityAnimation(getRootEntityId(), 1));
    } else if (event instanceof SwingHandEntityEvent) {
        final HandType handType = ((SwingHandEntityEvent) event).getHandType();
        if (handType == HandTypes.MAIN_HAND) {
            context.sendToAllExceptSelf(() -> new MessagePlayOutEntityAnimation(getRootEntityId(), 0));
        } else if (handType == HandTypes.OFF_HAND) {
            context.sendToAllExceptSelf(() -> new MessagePlayOutEntityAnimation(getRootEntityId(), 3));
        } else {
            super.handleEvent(context, event);
        }
    } else {
        super.handleEvent(context, event);
    }
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
public MessagePlayInUseEntity decode(CodecContext context, ByteBuffer buf) throws CodecException {
    final int entityId = buf.readVarInt();
    final int action = buf.readVarInt();
    if (action == 1) {
        return new MessagePlayInUseEntity.Attack(entityId);
    } else if (action == 0 || action == 2) {
        Vector3d position = null;
        if (action == 2) {
            final double x = buf.readFloat();
            final double y = buf.readFloat();
            final double z = buf.readFloat();
            position = new Vector3d(x, y, z);
        }
        final HandType hand = buf.readVarInt() == 0 ? HandTypes.MAIN_HAND : HandTypes.OFF_HAND;
        return new MessagePlayInUseEntity.Interact(entityId, hand, position);
    } else {
        throw new DecoderException("Received a UseEntity message with a unknown action: " + action);
    }
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
public void onEntityActivated(Entity entity, Player player, HandType currHand) {
    if (ItemWrench.isPlayerUsing(player, currHand)) {
        // TODO code editor
    } else {
    }
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
public void onEntityHit(Entity entity, Player player, HandType currHand) {
    remove();
    Optional<String> dropRule = this.world.getGameRule("doEntityDrops");
    if (player.gameMode().get() != GameModes.CREATIVE && (!dropRule.isPresent()
            || Boolean.parseBoolean(dropRule.get()))) {
        dropAsItem();
    }
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Listener
public void onEntityInteract(InteractEntityEvent event, @First Player player) {
    HandType hand = Utils.getEventHand(event);
    CustomWorld world = WorldManager.toCustomWorld(event.getTargetEntity().getWorld());
    EntityTracker tracker = world.getEntityTracker(event.getTargetEntity());
    if (tracker == null) {
        return;
    }
    if (event instanceof InteractEntityEvent.Primary) {
        tracker.onEntityHit(event.getTargetEntity(), player, hand);
    } else if (event instanceof InteractEntityEvent.Secondary) {
        tracker.onEntityActivated(event.getTargetEntity(), player, hand);
    }
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Listener
public void onBlockInteract(InteractBlockEvent.Secondary event, @First Player player) {
    HandType hand = Utils.getEventHand(event);
    Optional<ItemStack> opItem = player.getItemInHand(hand);
    if (!opItem.isPresent() || !CustomItem.isCustomItem(opItem.get())) {
        return;
    }
    boolean useResult = CustomItem.fromItemStack(opItem.get()).onItemUse(opItem.get(), player, hand,
            event.getTargetBlock(), event.getTargetSide(), event.getInteractionPoint().orElse(null));
    event.setCancelled(useResult);
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
public static boolean isPlayerUsing(Player player, HandType currHand) {
    Optional<ItemStack> opItem = player.getItemInHand(currHand);
    if (!opItem.isPresent()) {
        return false;
    }
    CustomItem item = CustomItem.fromItemStack(opItem.get());
    return item == ItemRegistry.get("wrench");
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
public boolean onBlockHit(CustomWorld world, Vector3i pos, Player player, HandType currHand, Direction side,
        Vector3d clickPoint) {
    Cause breakCause = Cause.builder()
            .named("plugin", Industrialization.toContainer())
            .named(NamedCause.SOURCE, player)
            .build();
    world.getWorld().setBlockType(pos, BlockTypes.AIR, BlockChangeFlag.ALL, breakCause);
    // Sponge broke and doesn't fire the event (SpongeCommon#998)
    BlockSnapshot from = world.getWorld().createSnapshot(pos);
    BlockSnapshot to = from.withState(BlockTypes.AIR.getDefaultState());
    List<Transaction<BlockSnapshot>> tr = Lists.newArrayList(new Transaction<>(from, to));
    Sponge.getEventManager().post(SpongeEventFactory.createChangeBlockEventBreak(breakCause, tr));
    return false;
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
public boolean onBlockActivated(CustomWorld world, Vector3i pos, Player player, HandType currHand, Direction side,
        Vector3d clickPoint) {
    TileAutoCrafting te = (TileAutoCrafting) world.getBlockData(pos);
    Optional<Container> optContainer = player.openInventory(
            te.getInventory().getAPIInventory(), Cause.source(this).notifier(player).build());
    if (optContainer.isPresent()) {
        te.addContainer(optContainer.get());
    }
    return false;
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Listener
public void onBlockInteract(InteractBlockEvent event, @First Player player) {
    HandType hand = Utils.getEventHand(event);
    BlockSnapshot blockSnapshot = event.getTargetBlock();
    if (blockSnapshot == BlockSnapshot.NONE) {
        return;
    }
    CustomWorld world = WorldManager.toCustomWorld(player.getWorld());
    Vector3i pos = blockSnapshot.getPosition();
    BlockNature block = world.getBlock(pos);
    if (block == null) {
        return;
    }
    Direction side = event.getTargetSide();
    Vector3d point = event.getInteractionPoint().orElse(null);
    boolean allowInteract = !event.isCancelled();
    if (event instanceof InteractBlockEvent.Primary) {
        allowInteract = block.onBlockHit(world, pos, player, hand, side, point);
    } else if (event instanceof InteractBlockEvent.Secondary) {
        if (player.getItemInHand(hand).isPresent() && player.get(Keys.IS_SNEAKING).get()) {
            // Pass on the item click without telling the block
            allowInteract = true;
        } else {
            allowInteract = block.onBlockActivated(world, pos, player, hand, side, point);
        }
    }
    event.setCancelled(!allowInteract);

}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
public static HandType getEventHand(InteractEvent event) {
    HandType hand;
    if (event instanceof InteractBlockEvent.Primary.OffHand) {
        hand = HandTypes.OFF_HAND;
    } else if (event instanceof InteractBlockEvent.Secondary.OffHand) {
        hand = HandTypes.OFF_HAND;
    } else if (event instanceof InteractEntityEvent.Primary.OffHand) {
        hand = HandTypes.OFF_HAND;
    } else if (event instanceof InteractEntityEvent.Secondary.OffHand) {
        hand = HandTypes.OFF_HAND;
    } else {
        hand = HandTypes.MAIN_HAND;
    }
    return hand;
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
/**
 * Pulses the interaction handler.
 */
void pulse() {
    if (this.diggingBlock != null) {
        final int breakState = (int) Math.round(((double) Math.max(0, this.diggingEndTime - System.nanoTime())
                / (double) this.diggingDuration) * 10.0);
        if (this.lastBreakState != breakState) {
            sendBreakUpdate(breakState);
            this.lastBreakState = breakState;
        }
    }
    final HandType activeHand = this.player.get(LanternKeys.ACTIVE_HAND).orElse(Optional.empty()).orElse(null);
    final AbstractSlot slot = activeHand == null ? null : activeHand == HandTypes.MAIN_HAND ?
            this.player.getInventory().getHotbar().getSelectedSlot() : this.player.getInventory().getOffhand();
    // The interaction just started
    if (!Objects.equals(activeHand, this.lastActiveHand)) {
        this.lastActiveHand = activeHand;
        this.lastActiveItemStack = slot == null ? null : slot.getRawItemStack();
    } else if (activeHand != null) {
        if (this.activeHandStartTime == -1L) {
            this.activeHandStartTime = LanternGame.currentTimeTicks();
        }
        final ItemStack itemStack = slot.getRawItemStack();
        if (itemStack == null || this.lastActiveItemStack != itemStack) {
            // Stop the interaction
            resetItemUseTime();
        } else {
            final MaximumUseDurationProperty property = itemStack.getProperty(MaximumUseDurationProperty.class).orElse(null);
            if (property != null) {
                // Check if the interaction reached it's max time
                final long time = LanternGame.currentTimeTicks();
                if (time - this.activeHandStartTime > property.getValue()) {
                    handleFinishItemInteraction0(slot, activeHand);
                }
            }
        }
    }
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
public void handleFinishItemInteraction(MessagePlayInOutFinishUsingItem message) {
    final Optional<HandType> activeHand = this.player.get(LanternKeys.ACTIVE_HAND).orElse(Optional.empty());
    // The player is already interacting
    if (!activeHand.isPresent() || this.activeHandStartTime == -1L) {
        return;
    }

    // Try the action of the hotbar item first
    final AbstractSlot slot = activeHand.get() == HandTypes.MAIN_HAND ?
            this.player.getInventory().getHotbar().getSelectedSlot() : this.player.getInventory().getOffhand();

    final ItemStack rawItemStack = slot.getRawItemStack();
    if (rawItemStack == null) {
        return;
    }

    // Require a minimum amount of ticks for the interaction to succeed
    final MinimumUseDurationProperty property = rawItemStack.getProperty(MinimumUseDurationProperty.class).orElse(null);
    if (property != null) {
        final long time = LanternGame.currentTimeTicks();
        if (time - this.activeHandStartTime < property.getValue()) {
            resetItemUseTime();
            return;
        }
    }

    handleFinishItemInteraction0(slot, activeHand.get());
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
private boolean handleItemInteraction(BehaviorContextImpl context, @Nullable BehaviorContext.Snapshot snapshot) {
    final Optional<HandType> activeHand = this.player.get(LanternKeys.ACTIVE_HAND).orElse(Optional.empty());
    if (activeHand.isPresent() || handleMainHandItemInteraction(context, snapshot) || handleOffHandItemInteraction(context, null)) {
        context.accept();
        return true;
    } else {
        context.revert();
        return false;
    }
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
protected void handleEvent(EntityProtocolUpdateContext context, EntityEvent event) {
    if (event instanceof SwingHandEntityEvent) {
        final HandType handType = ((SwingHandEntityEvent) event).getHandType();
        // Doesn't matter which hand type, just play the swing animation,
        // the golem will use both arms at the same time
        if (handType == HandTypes.MAIN_HAND || handType == HandTypes.OFF_HAND) {
            context.sendToAll(() -> new MessagePlayOutEntityStatus(getRootEntityId(), 4));
        }
    } else {
        super.handleEvent(context, event);
    }
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
private byte getHandData() {
    final Optional<HandType> activeHand = this.entity.get(LanternKeys.ACTIVE_HAND).orElse(Optional.empty());
    byte value;
    if (activeHand.isPresent()) {
        value = 0x1;
        if (activeHand.get() == HandTypes.OFF_HAND) {
            value |= 0x2;
        }
    } else {
        value = 0;
    }
    return value;
}
 

import org.spongepowered.api.data.type.HandType; //导入依赖的package包/类
@Override
public MessagePlayInPlayerBlockPlacement decode(CodecContext context, ByteBuffer buf) throws CodecException {
    final Vector3i position = buf.read(Types.VECTOR_3_I);
    final Direction face = fromFace(buf.readVarInt());
    final HandType hand = buf.readVarInt() == 0 ? HandTypes.MAIN_HAND : HandTypes.OFF_HAND;
    final double ox = buf.readFloat();
    final double oy = buf.readFloat();
    final double oz = buf.readFloat();
    final Vector3d offset = new Vector3d(ox, oy, oz);
    return new MessagePlayInPlayerBlockPlacement(position, offset, face, hand);
}