@EventHandler(priority = EventPriority.HIGHEST)
public void onInteract(final PlayerInteractEvent event) {
  if (cancelUnlessInteracting(event, event.getPlayer())) {
    // Allow the how-to book to be read
    if (event.getMaterial() == Material.WRITTEN_BOOK) {
      event.setUseItemInHand(Event.Result.ALLOW);
    }

    MatchPlayer player = match.getPlayer(event.getPlayer());
    if (player == null) return;

    ClickType clickType = convertClick(event.getAction(), event.getPlayer());
    if (clickType == null) return;

    match.callEvent(
        new ObserverInteractEvent(
            player, clickType, event.getClickedBlock(), null, event.getItem()));
  }
}
 

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onDamage(final EntityDamageEvent event) {
  cancelUnlessInteracting(event, event.getEntity());
  if (event instanceof EntityDamageByEntityEvent) {
    EntityDamageByEntityEvent entityEvent = (EntityDamageByEntityEvent) event;
    if (cancelUnlessInteracting(event, entityEvent.getDamager())) {
      MatchPlayer player = match.getPlayer(entityEvent.getDamager());
      if (player == null) return;

      match.callEvent(
          new ObserverInteractEvent(
              player,
              ClickType.LEFT,
              null,
              event.getEntity(),
              player.getInventory().getItemInHand()));
    }
  }
}
 

/**
 * Prevents enhanced item from storing.
 *
 * @param e
 */
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onInventoryClick(InventoryClickEvent e) {
    if ((e.getInventory().getType() != InventoryType.CRAFTING) && (e.getInventory().getType() != InventoryType.PLAYER)) {
        if ((e.getClick().equals(ClickType.NUMBER_KEY)) && (e.getWhoClicked().getInventory().getItem(e.getHotbarButton()) != null)) {
            ItemStack itemMoved = e.getWhoClicked().getInventory().getItem(e.getHotbarButton());
            if ((itemMoved.hasItemMeta()) && (itemMoved.getItemMeta().hasLore())) {
                if (itemMoved.getItemMeta().getLore().contains(Util.UNIQUEID + Util.toColor(SettingsManager.lang.getString("lore.untradeableLore")))) {
                    e.setCancelled(true);
                    Util.sendMessage(SettingsManager.lang.getString("messages.noStorage"), e.getWhoClicked());
                }
            }
        }
        if (e.getCurrentItem() != null) {
            if ((e.getCurrentItem().hasItemMeta()) && (e.getCurrentItem().getItemMeta().hasLore())) {
                if (e.getCurrentItem().getItemMeta().getLore().contains(Util.UNIQUEID + Util.toColor(SettingsManager.lang.getString("lore.untradeableLore")))) {
                    e.setCancelled(true);
                    Util.sendMessage(SettingsManager.lang.getString("messages.noStorage"), e.getWhoClicked());
                }
            }
        }
    }
}
 

public void onClick(Player player, Button button, ClickType clickType, InventoryClickEvent event) {
    List<AbstractAction> actions = getActions().getOrDefault(clickType, new ArrayList<>());
    Notifys.debug(player, "ClickType: {0}, Actions: {1}. &8{2}", clickType.name(), actions.size(), actions);

    ArgsCache.getEvent().put(player.getUniqueId(), event);
    ArgsCache.getClickedItem().put(player.getUniqueId(), item);
    ArgsCache.getClickedButtons().put(player.getUniqueId(), button);

    TrAction.runActions(actions, player);
    if (getActions().get(null) != null) {
        TrAction.runActions(getActions().get(null), player);
    }

    ArgsCache.clear(player);
    button.refreshConditionalIcon(player, event);
}
 

public static void addNavigationButtons(GUI.Window currentPage) {
	ItemMeta forwardMeta = forwardStack.getItemMeta();
	if (forwardMeta != null) {
		forwardMeta.setDisplayName(ChatColor.GREEN + LanguageManager.getString("GUIs.Forward"));
		forwardStack.setItemMeta(forwardMeta);
	}

	ItemMeta backMeta = backStack.getItemMeta();
	if (backMeta != null) {
		backMeta.setDisplayName(ChatColor.RED + LanguageManager.getString("GUIs.Back"));
		backStack.setItemMeta(backMeta);
	}

	GUI.Window.Button back = currentPage.addButton(0, 5, backStack);
	back.addAction(ClickType.LEFT, new ButtonAction.PAGE_DOWN(back));

	GUI.Window.Button forward = currentPage.addButton(8, 5, forwardStack);
	forward.addAction(ClickType.LEFT, new ButtonAction.PAGE_UP(forward));
}
 

@EventHandler
public void rightClickIcon(final ObserverInteractEvent event) {
    if(event.getClickType() != ClickType.RIGHT) return;

    MatchPlayer player = event.getPlayer();
    if(!canUse(player)) return;

    ItemStack hand = event.getClickedItem();
    if(ItemUtils.isNothing(hand)) return;

    String displayName = hand.getItemMeta().getDisplayName();
    if(displayName == null) return;

    if(hand.getType() == Button.JOIN.material) {
        event.setCancelled(true);
        if(canOpenWindow(player)) {
            showWindow(player);
        } else {
            // If there is nothing to pick, just join immediately
            jmm.requestJoin(player, JoinRequest.user());
        }
    } else if(hand.getType() == Button.LEAVE.material) {
        event.setCancelled(true);
        jmm.requestObserve(player);
    }
}
 

@EventHandler(ignoreCancelled = true)
public void showInventories(final ObserverInteractEvent event) {
    if(event.getClickType() != ClickType.RIGHT) return;
    if(event.getPlayer().isDead()) return;

    if(event.getClickedParticipant() != null) {
        event.setCancelled(true);
        if(canPreviewInventory(event.getPlayer(), event.getClickedParticipant())) {
            this.previewPlayerInventory(event.getPlayer().getBukkit(), event.getClickedParticipant().getInventory());
        }
    } else if(event.getClickedEntity() instanceof InventoryHolder && !(event.getClickedEntity() instanceof Player)) {
        event.setCancelled(true);
        this.previewInventory(event.getPlayer().getBukkit(), ((InventoryHolder) event.getClickedEntity()).getInventory());
    } else if(event.getClickedBlockState() instanceof InventoryHolder) {
        event.setCancelled(true);
        this.previewInventory(event.getPlayer().getBukkit(), ((InventoryHolder) event.getClickedBlockState()).getInventory());
    }
}
 

@EventHandler
@Override
public void onInventoryClick(InventoryClickEvent e) {
    if (e.getInventory().equals(getInventory())) {
        e.setCancelled(true);
        if (e.getClickedInventory() == null || !e.getClickedInventory().equals(getInventory())) return;
        if (islands.containsKey(e.getSlot())) {
            Island island = IridiumSkyblock.getIslandManager().getIslandViaId(islands.get(e.getSlot()));
            User u = User.getUser((OfflinePlayer) e.getWhoClicked());
            if (island.isVisit() || u.bypassing) {
                if (e.getClick() == ClickType.RIGHT) {
                    if (island.hasVoted(u)) {
                        island.removeVote(u);
                    } else {
                        island.addVote(u);
                    }
                } else {
                    e.getWhoClicked().closeInventory();
                    island.teleportHome((Player) e.getWhoClicked());
                }
            } else {
                e.getWhoClicked().sendMessage(Utils.color(IridiumSkyblock.getMessages().playersIslandIsPrivate.replace("%prefix%", IridiumSkyblock.getConfiguration().prefix)));
            }
        } else if (e.getSlot() == getInventory().getSize() - 7) {
            if (IridiumSkyblock.visitGUI.containsKey(page - 1))
                e.getWhoClicked().openInventory(IridiumSkyblock.visitGUI.get(page - 1).getInventory());
        } else if (e.getSlot() == getInventory().getSize() - 3) {
            if (IridiumSkyblock.visitGUI.containsKey(page + 1))
                e.getWhoClicked().openInventory(IridiumSkyblock.visitGUI.get(page + 1).getInventory());
        }
    }
}
 

/**
 * Creates a dummy {@link InventoryClick} to use as a starting data point.
 */
public static InventoryClick dummyClick()
{
    return new InventoryClick(Bukkit.createInventory(null, InventoryType.CHEST), new double[]{
            0,
            0
    }, ClickType.CREATIVE);
}
 

@EventHandler
@Override
public void onInventoryClick(InventoryClickEvent e) {
    if (e.getInventory().equals(getInventory())) {
        Player p = (Player) e.getWhoClicked();
        User u = User.getUser(p);
        e.setCancelled(true);
        if (e.getClickedInventory() == null || !e.getClickedInventory().equals(getInventory())) return;
        if (warps.containsKey(e.getSlot())) {
            Island.Warp warp = warps.get(e.getSlot());
            if (e.getClick().equals(ClickType.RIGHT)) {
                u.getIsland().removeWarp(warps.get(e.getSlot()));
                getInventory().clear();
                addContent();
            } else {
                if (warp.getPassword().isEmpty()) {
                    p.teleport(warp.getLocation());
                    p.sendMessage(Utils.color(IridiumSkyblock.getMessages().teleporting.replace("%prefix%", IridiumSkyblock.getConfiguration().prefix)));
                } else {
                    p.sendMessage(Utils.color(IridiumSkyblock.getMessages().enterPassword.replace("%prefix%", IridiumSkyblock.getConfiguration().prefix)));
                    u.warp = warp;
                }
            }
            p.closeInventory();
        }
    }
}
 

ClickType convertClick(ClickType clickType, Player player) {
  if (clickType == ClickType.RIGHT && player.isSneaking()) {
    return ClickType.SHIFT_RIGHT;
  } else {
    return clickType;
  }
}
 

private CraftItemEvent mockCraftingEvent(ItemStack item) {
    Recipe recipe = new ShapedRecipe(new NamespacedKey(plugin, "test_recipe"), new ItemStack(Material.EMERALD));
    Player player = server.addPlayer();

    CraftingInventory inv = Mockito.mock(CraftingInventory.class);
    Mockito.when(inv.getContents()).thenReturn(new ItemStack[] { item, null, null, null, null, null, null, null, null });

    InventoryView view = player.openInventory(inv);
    CraftItemEvent event = new CraftItemEvent(recipe, view, SlotType.RESULT, 9, ClickType.LEFT, InventoryAction.PICKUP_ALL);

    listener.onCraft(event);
    return event;
}
 

void callObserverInteractEvent(PlayerInteractEntityEvent event) {
  MatchPlayer player = match.getPlayer(event.getPlayer());
  if (player == null) return;

  match.callEvent(
      new ObserverInteractEvent(
          player,
          convertClick(ClickType.RIGHT, event.getPlayer()),
          null,
          event.getRightClicked(),
          event.getPlayer().getItemInHand()));
}
 

@Override
protected boolean click(Player p, int rawSlot, ClickType ct) {
    updateResultWithDelay();

    CraftingPipe pipe = (CraftingPipe) duct;

    // clicked change output direction
    if (rawSlot == 8) {
        save(p);
        pipe.updateOutputDirection(true);
        return true;
    }

    // retrieve cached items
    if (rawSlot == 4 * 9 + 8) {
        List<ItemStack> cachedItems = new ArrayList<>(pipe.getCachedItems());
        pipe.getCachedItems().clear();
        transportPipes.runTaskSync(() -> {
            Map<Integer, ItemStack> overflow = p.getInventory().addItem(cachedItems.toArray(new ItemStack[0]));
            for (ItemStack overflowItem : overflow.values()) {
                p.getWorld().dropItem(p.getLocation(), overflowItem);
            }
        });

        save(p);
        populate();

        return true;
    }

    // clicked on recipe items
    if (slotInRecipeGrid(rawSlot)) {
        return false;
    }

    return rawSlot < inv.getSize();
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void cancelArmorEquip(ObserverInteractEvent event) {
  if (event.getClickType() == ClickType.RIGHT
      && event.getClickedItem() != null
      && event.getClickedItem().getType() == Button.TEAM_JOIN.material) {
    event.setCancelled(true);
    event.getPlayer().getBukkit().updateInventory();
  }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void rightClickIcon(final ObserverInteractEvent event) {
  final boolean right = event.getClickType() == ClickType.RIGHT;
  final boolean left = event.getClickType() == ClickType.LEFT;
  if ((!right && !left) || InventoryUtils.isNothing(event.getClickedItem())) return;

  final ItemStack hand = event.getClickedItem();
  String displayName = hand.getItemMeta().getDisplayName();
  if (displayName == null) return;

  final MatchPlayer player = event.getPlayer();
  if (!canUse(player)) return;

  boolean handled = false;
  final JoinMatchModule jmm = match.needModule(JoinMatchModule.class);

  if (hand.getType() == Button.JOIN.material) {
    handled = true;
    if (right && canOpenWindow(player) && settingEnabled(player, true)) {
      showWindow(player);
    } else {
      // If there is nothing to pick or setting is disabled, just join immediately
      jmm.join(player, null);
    }
  } else if (hand.getType() == Button.LEAVE.material && left) {
    jmm.leave(player);
  }

  if (handled) {
    event.setCancelled(true);

    // Unfortunately, not opening the window seems to cause the player to put the helmet
    // on their head, no matter what we do server-side. So, we have to force an inventory
    // update to resync them.
    player.getBukkit().updateInventory();
  }
}
 

@Override
public void onInventoryClick(InventoryMenu menu, MatchPlayer player, ClickType clickType) {
  FlySpeed speed = FlySpeed.of(player.getBukkit().getFlySpeed());
  if (clickType.isRightClick()) {
    player.getBukkit().setFlySpeed(speed.getPrev().getValue());
  } else {
    player.getBukkit().setFlySpeed(speed.getNext().getValue());
  }
  menu.refreshWindow(player);
}
 

@SuppressWarnings("deprecation")
@Override
public void performAction(InventoryClickEvent event, ItemStack stack) {
	AttributeUtil attrs = new AttributeUtil(stack);
	attrs.removeCivCraftProperty("GUI");
	attrs.removeCivCraftProperty("GUI_ACTION");

	ItemStack is = attrs.getStack();
	if (event.getClick().equals(ClickType.SHIFT_LEFT) ||
		event.getClick().equals(ClickType.SHIFT_RIGHT)) {
		is.setAmount(is.getMaxStackSize());
	}
	
	event.setCursor(is);
}
 

private InventoryClickEvent getEvent(InventoryHolder holder) {
    // These values are not checked anywhere.
    InventoryView inventoryView = mock(InventoryView.class);
    InventoryType.SlotType slotType = InventoryType.SlotType.QUICKBAR;
    ClickType clickType = ClickType.LEFT;
    InventoryAction inventoryAction = InventoryAction.NOTHING;

    Inventory fakeInventory = mock(Inventory.class);
    doReturn(holder).when(fakeInventory).getHolder();
    doReturn(fakeInventory).when(inventoryView).getTopInventory();

    return new InventoryClickEvent(inventoryView, slotType, 1, clickType, inventoryAction);
}
 

public Click(InventoryGui gui, int slot, GuiElement element, ClickType type, InventoryClickEvent event) {
    this.gui = gui;
    this.slot = slot;
    this.element = element;
    this.type = type;
    this.event = event;
}
 

@GameEvent
public void openVoteMenu(@Nonnull PlayerInteractEvent event, User user) {
    if ((event.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK) && openMenuItem.equals(event.getItem())) {
        InventoryMenuBuilder builder = new InventoryMenuBuilder().withSize(9).withTitle("Vote for a map");
        for (int id : availableMaps.keySet()) {
            MapInfo info = availableMaps.get(id);
            ItemStack item = new ItemBuilder(Material.PAPER).amount(id).name(info.getDisplayName()).lore(info.getAuthor()).build();
            builder.withItem(id - 1, item, (player, clickType, itemStack) -> confirmVote(user, id), ClickType.LEFT);
        }
        builder.show(user.getPlayer());
    }
}
 

private InventoryClickEvent mockGrindStoneEvent(ItemStack item) {
    Player player = server.addPlayer();
    Inventory inv = TestUtilities.mockInventory(InventoryType.GRINDSTONE, item, null);
    InventoryView view = player.openInventory(inv);
    InventoryClickEvent event = new InventoryClickEvent(view, SlotType.CONTAINER, 2, ClickType.LEFT, InventoryAction.PICKUP_ONE);

    listener.onGrindstone(event);
    return event;
}
 

/**
 * Clears all bindings on this slot for a given click type.
 *
 * @return this slot
 */
@Nonnull
@Override
public Slot clearBindings(ClickType type) {
    this.handlers.remove(type);
    return this;
}
 

@Nonnull
@Override
public Slot bind(@Nonnull ClickType type, @Nonnull Consumer<InventoryClickEvent> handler) {
    Objects.requireNonNull(type, "type");
    Objects.requireNonNull(handler, "handler");
    this.handlers.computeIfAbsent(type, t -> ConcurrentHashMap.newKeySet()).add(handler);
    return this;
}
 

@Nonnull
@Override
public Slot bind(@Nonnull ClickType type, @Nonnull Runnable handler) {
    Objects.requireNonNull(type, "type");
    Objects.requireNonNull(handler, "handler");
    this.handlers.computeIfAbsent(type, t -> ConcurrentHashMap.newKeySet()).add(Item.transformRunnable(handler));
    return this;
}
 

private boolean isAllowed(String id, ItemStack item) throws InterruptedException {
    Player player = server.addPlayer();
    Inventory inv = openMockBackpack(player, id, 9).getInventory();

    int slot = 7;
    inv.setItem(slot, item);
    InventoryClickEvent event = new InventoryClickEvent(player.getOpenInventory(), SlotType.CONTAINER, slot, ClickType.LEFT, InventoryAction.PICKUP_ONE);
    listener.onClick(event);
    return !event.isCancelled();
}
 

@Nonnull
@Override
public <T extends Runnable> Slot bindAllRunnables(@Nonnull Iterable<Map.Entry<ClickType, T>> handlers) {
    Objects.requireNonNull(handlers, "handlers");
    for (Map.Entry<ClickType, T> handler : handlers) {
        bind(handler.getKey(), handler.getValue());
    }
    return this;
}
 

@Nonnull
@Override
public <T extends Consumer<InventoryClickEvent>> Slot bindAllConsumers(@Nonnull Iterable<Map.Entry<ClickType, T>> handlers) {
    Objects.requireNonNull(handlers, "handlers");
    for (Map.Entry<ClickType, T> handler : handlers) {
        bind(handler.getKey(), handler.getValue());
    }
    return this;
}
 

@EventHandler
public void onInvClick(InventoryClickEvent e) {
    if (e.getInventory() != null && e.getInventory().equals(inv) && e.getWhoClicked() instanceof Player) {
        if (itemService.isItemWildcardOrBarrier(e.getCurrentItem())) {
            e.setCancelled(true);
            return;
        }
        //don't call click method when double clicked, because before a double click, left click was already registered twice
        if (e.getClick() != ClickType.DOUBLE_CLICK && click((Player) e.getWhoClicked(), e.getRawSlot(), e.getClick())) {
            e.setCancelled(true);
        } else if (e.getClick() == ClickType.DOUBLE_CLICK && e.getAction() == InventoryAction.COLLECT_TO_CURSOR && collect_to_cursor((Player) e.getWhoClicked(), e.getCursor(), e.getRawSlot())) {
            e.setCancelled(true);
        }
    }
}
 

@Nonnull
public Builder bind(@Nullable Consumer<InventoryClickEvent> handler, @Nonnull ClickType... types) {
    for (ClickType type : types) {
        bind(type, handler);
    }
    return this;
}