@Override
public BehaviourItem[] getDefaultMovementBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(0, new BehaviourFloat(this)),
            new BehaviourItem(1, new BehaviourAvoidEntity(this, Zombie.class, 8.0F, 0.6D, 0.6D)),
            new BehaviourItem(1, new BehaviourTradeWithPlayer(this)),
            new BehaviourItem(1, new BehaviourLookAtTradingPlayer(this)),
            new BehaviourItem(2, new BehaviourMoveIndoors(this)),
            new BehaviourItem(3, new BehaviourRestrictOpenDoor(this)),
            new BehaviourItem(4, new BehaviourOpenDoor(this, true)),
            new BehaviourItem(5, new BehaviourMoveTowardsRestriction(this, 0.6D)),
            new BehaviourItem(6, new BehaviourMakeLove(this)),
            new BehaviourItem(7, new BehaviourTakeFlower(this)),
            new BehaviourItem(8, new BehaviourVillagerPlay(this, 0.32D)),
            new BehaviourItem(9, new BehaviourInteract(this, HumanEntity.class, 3.0F, 1.0F)),
            new BehaviourItem(9, new BehaviourInteract(this, Villager.class, 3.0F, 1.0F)),
            new BehaviourItem(9, new BehaviourRandomStroll(this, 0.6D)),
            new BehaviourItem(10, new BehaviourLookAtNearestEntity(this, InsentientEntity.class, 8.0F))
    };
}
 

@EventHandler(priority=EventPriority.HIGH, ignoreCancelled=true)
public void onOpenInventory(InventoryOpenEvent e) {
    FileConfiguration config = this.expansion.getConfig("cheat-prevention.yml");
    if(!config.getBoolean("inventories.close-on-tag")) return;

    HumanEntity human = e.getPlayer();
    if(!(human instanceof Player)) return;

    Player player = (Player) human;
    ICombatManager manager = this.plugin.getCombatManager();
    if(!manager.isInCombat(player)) return;

    e.setCancelled(true);
    String message = this.plugin.getLanguageMessageColoredWithPrefix("cheat-prevention.inventory.no-opening");
    this.plugin.sendMessage(player, message);
}
 

@Override
public ItemStack getItem(HumanEntity who, int slot) {
    if (((pageAction == PageAction.FIRST || pageAction == PageAction.LAST) && gui.getPageAmount() < 3)
            || (pageAction == PageAction.NEXT && gui.getPageNumber() + 1 >= gui.getPageAmount())
            || (pageAction == PageAction.PREVIOUS && gui.getPageNumber() == 0)) {
        return gui.getFiller() != null ? gui.getFiller().getItem(who, slot) : null;
    }
    if (pageAction == PageAction.PREVIOUS) {
        setNumber(gui.getPageNumber());
    } else if (pageAction == PageAction.NEXT) {
        setNumber(gui.getPageNumber() + 2);
    } else if (pageAction == PageAction.LAST) {
        setNumber(gui.getPageAmount());
    }
    return super.getItem(who, slot).clone();
}
 

@Override
public BehaviourItem[] getDefaultTargetingBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(1, new BehaviourFloat(this)),
            new BehaviourItem(2, new BehaviourSit(this)),
            new BehaviourItem(3, new BehaviourTempt(this, Material.RAW_FISH, true, 0.6D)),
            new BehaviourItem(4, new BehaviourAvoidEntity(this, HumanEntity.class, 16.0F, 0.8D, 1.33D)),
            new BehaviourItem(5, new BehaviourFollowTamer(this, 10.0F, 5.0F)),
            new BehaviourItem(6, new BehaviourSitOnBlock(this, 1.33D)),
            new BehaviourItem(7, new BehaviourLeapAtTarget(this, 0.3F)),
            new BehaviourItem(8, new BehaviourOcelotAttack(this)),
            new BehaviourItem(9, new BehaviourBreed(this, 0.8D)),
            new BehaviourItem(10, new BehaviourRandomStroll(this, 0.8D)),
            new BehaviourItem(11, new BehaviourLookAtNearestEntity(this, HumanEntity.class, 10.0F)),
    };
}
 

@EventHandler(priority=EventPriority.HIGHEST, ignoreCancelled=true)
public void StopClicking(InventoryClickEvent event)
{
    HumanEntity entity = event.getWhoClicked();
    ItemStack stack = event.getCurrentItem();
    InventoryType top = event.getView().getTopInventory().getType();
    
    if (stack != null && (entity instanceof Player)) 
    {
    	if (top == InventoryType.PLAYER || top == InventoryType.WORKBENCH || top == InventoryType.CRAFTING) 
    		return;

    	if(KitUtils.isSoulbound(stack))
          event.setCancelled(true); 
    }
 }
 

@EventHandler
public void onInvClick(InventoryClickEvent event) {
    HumanEntity human = event.getWhoClicked();
    if (human instanceof Player) {
        Player player = (Player) human;
        Inventory inv = event.getView().getTopInventory();
        if (inv.getHolder() != null && inv.getHolder() instanceof InventoryMenu && event.getRawSlot() >= 0 && event.getRawSlot() < size) {
            InventoryMenu menu = (InventoryMenu) inv.getHolder();
            event.setCancelled(true);
            MenuIcon icon = slots.get(event.getSlot());
            if (icon != null) {
                icon.onClick(player);
                player.closeInventory();
            }
        }
    }
}
 

/**
   * Handles the disabling of the plugin
   *
   * @param event the event fired
   * @since 0.5.19
   */
  @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
  public void onPluginDisable(@NotNull PluginDisableEvent event) {
      Plugin thisPlugin = JavaPlugin.getProvidingPlugin(getClass());
      if (event.getPlugin() != thisPlugin) {
          return;
      }

      int counter = 0; //callbacks might open GUIs, eg. in nested menus
int maxCount = 10;
      while (!activeGuiInstances.isEmpty() && counter++ < maxCount) {
          for (Gui gui : new ArrayList<>(activeGuiInstances)) {
              for (HumanEntity viewer : gui.getViewers()) {
                  viewer.closeInventory();
              }
          }
      }

      if (counter == maxCount) {
	thisPlugin.getLogger().warning("Unable to close GUIs on plugin disable: they keep getting opened "
			+ "(tried: " + maxCount + " times)");
}
  }
 

private void onInventoryOpen(Event event, Location location, Object target, HumanEntity player) {
    GDCauseStackManager.getInstance().pushCause(player);
    if (event instanceof InventoryOpenEvent) {
        final InventoryOpenEvent inventoryEvent = (InventoryOpenEvent) event;
        target = inventoryEvent.getView().getType();
    }
    if (!GDFlags.INTERACT_INVENTORY || !GriefDefenderPlugin.getInstance().claimsEnabledForWorld(player.getWorld().getUID())) {
        return;
    }

    if (GriefDefenderPlugin.isTargetIdBlacklisted(Flags.INTERACT_INVENTORY.getName(), target, player.getWorld().getUID())) {
        return;
    }

    String targetId = GDPermissionManager.getInstance().getPermissionIdentifier(target);
    GDTimings.PLAYER_INTERACT_INVENTORY_OPEN_EVENT.startTiming();
    final GDClaim claim = this.dataStore.getClaimAt(location);
    final GDPermissionUser user = PermissionHolderCache.getInstance().getOrCreateUser(player.getUniqueId());
    if (user.getInternalPlayerData() != null && user.getInternalPlayerData().eventResultCache != null && user.getInternalPlayerData().eventResultCache.checkEventResultCache(claim, Flags.INTERACT_BLOCK_SECONDARY.getName()) == Tristate.TRUE) {
        GDPermissionManager.getInstance().processResult(claim, Flags.INTERACT_INVENTORY.getPermission(), "cache", Tristate.TRUE, user);
        GDTimings.PLAYER_INTERACT_INVENTORY_OPEN_EVENT.stopTiming();
        return;
    }
    final Tristate result = GDPermissionManager.getInstance().getFinalPermission(event, location, claim, Flags.INTERACT_INVENTORY, player, target, user, TrustTypes.CONTAINER, true);
    if (result == Tristate.FALSE) {
        final Component message = GriefDefenderPlugin.getInstance().messageData.getMessage(MessageStorage.PERMISSION_INVENTORY_OPEN,
                ImmutableMap.of(
                "player", claim.getOwnerDisplayName(),
                "block", targetId));
        GriefDefenderPlugin.sendClaimDenyMessage(claim, player, message);
        ((Cancellable) event).setCancelled(true);
    }

    GDTimings.PLAYER_INTERACT_INVENTORY_OPEN_EVENT.stopTiming();
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerInteractInventoryClick(InventoryClickEvent event) {
    final HumanEntity player = event.getWhoClicked();
    GDCauseStackManager.getInstance().pushCause(player);
    if (!GDFlags.INTERACT_INVENTORY_CLICK || event.getClickedInventory() == null || !GriefDefenderPlugin.getInstance().claimsEnabledForWorld(player.getWorld().getUID())) {
        return;
    }

    GDTimings.PLAYER_INTERACT_INVENTORY_CLICK_EVENT.startTiming();
    final Location location = player.getLocation();
    final GDClaim claim = this.dataStore.getClaimAt(location);
    final ItemStack cursorItem = event.getCursor();
    final Inventory source = event.getInventory();
    final ItemStack target = event.getCurrentItem();

    if (GriefDefenderPlugin.isTargetIdBlacklisted(Flags.INTERACT_INVENTORY_CLICK.getName(), target, player.getWorld().getUID())) {
        GDTimings.PLAYER_INTERACT_INVENTORY_CLICK_EVENT.stopTiming();
        return;
    }

    final GDPermissionUser user = PermissionHolderCache.getInstance().getOrCreateUser(player.getUniqueId());
    final Tristate result = GDPermissionManager.getInstance().getFinalPermission(event, location, claim, Flags.INTERACT_INVENTORY_CLICK, source, target, user, TrustTypes.CONTAINER, true);
    if (result == Tristate.FALSE) {
        final Component message = GriefDefenderPlugin.getInstance().messageData.getMessage(MessageStorage.PERMISSION_INTERACT_ITEM,
                ImmutableMap.of(
                "player", claim.getOwnerDisplayName(),
                "item", ItemTypeRegistryModule.getInstance().getNMSKey(target)));
        GriefDefenderPlugin.sendClaimDenyMessage(claim, player, message);
        event.setCancelled(true);
    }
    GDTimings.PLAYER_INTERACT_INVENTORY_CLICK_EVENT.stopTiming();
}
 

@Override
public BehaviourItem[] getDefaultMovementBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(0, new BehaviourFloat(this)),
            new BehaviourItem(1, new BehaviourPanic(this, 2.0D)),
            new BehaviourItem(2, new BehaviourBreed(this, 1.0D)),
            new BehaviourItem(3, new BehaviourTempt(this, Material.WHEAT, false, 1.25D)),
            new BehaviourItem(4, new BehaviourFollowParent(this, 1.25D)),
            new BehaviourItem(5, new BehaviourRandomStroll(this, 1.0D)),
            new BehaviourItem(6, new BehaviourLookAtNearestEntity(this, HumanEntity.class, 6.0F)),
            new BehaviourItem(7, new BehaviourLookAtRandom(this))
    };
}
 

private void cancel() {
  inv1.setItem(49, null);
  inv2.setItem(49, null);
  cancelled = true;
  Bukkit.getScheduler()
      .runTaskLater(
          pl,
          () -> {
            new ArrayList<>(inv1.getViewers()).forEach(HumanEntity::closeInventory);
            new ArrayList<>(inv2.getViewers()).forEach(HumanEntity::closeInventory);
            new ArrayList<>(spectatorInv.getViewers()).forEach(HumanEntity::closeInventory);
            HandlerList.unregisterAll(this);
          },
          200L);
}
 

@Override
public BehaviourItem[] getDefaultTargetingBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(0, new BehaviourHurtByTarget(this, true, false, true)),
            new BehaviourItem(1, new BehaviourMoveTowardsNearestAttackableTarget(this, HumanEntity.class, 0, true))
    };
}
 

/**
 * Sets the title for this inventory. This will (unlike most other methods) directly update itself in order
 * to ensure all viewers will still be viewing the new inventory as well.
 *
 * @param title the title
 */
public void setTitle(@NotNull String title) {
    //copy the viewers
    List<HumanEntity> viewers = getViewers();

    this.inventory = Bukkit.createInventory(this, this.inventory.getSize(), title);
    this.title = title;

    viewers.forEach(humanEntity -> humanEntity.openInventory(inventory));
}
 

public void close() {
    if (inventory == null) {
        return;
    }
    for (HumanEntity player : inventory.getViewers()) {
        player.closeInventory();
    }
    inventory = null; // Destory
}
 

@Override
public GroupDataEntity a(GroupDataEntity groupdataentity) {
    groupdataentity = super.a(groupdataentity);
    if (this.world.worldProvider instanceof WorldProviderHell && this.aI().nextInt(5) > 0) {
        if (this.controllableEntity != null) {
            this.controllableEntity.getMind().getMovementBehaviourSelector().addBehaviour(new BehaviourMeleeAttack(this.controllableEntity, HumanEntity.class, false, 1.2D), 4);
        }
        this.setSkeletonType(1);
        this.setEquipment(0, new ItemStack(Items.STONE_SWORD));
        this.getAttributeInstance(GenericAttributes.e).setValue(4.0D);
    } else {
        this.controllableEntity.getMind().getMovementBehaviourSelector().addBehaviour(new BehaviourRangedAttack(this.controllableEntity, 60, 15.0F, 1.0D), 4);
        this.bA();
        this.bB();
    }

    this.h(this.random.nextFloat() < 0.55F * this.world.b(this.locX, this.locY, this.locZ));
    if (this.getEquipment(4) == null) {
        Calendar calendar = this.world.V();

        if (calendar.get(2) + 1 == 10 && calendar.get(5) == 31 && this.random.nextFloat() < 0.25F) {
            this.setEquipment(4, new ItemStack(this.random.nextFloat() < 0.1F ? Blocks.JACK_O_LANTERN : Blocks.PUMPKIN));
            this.dropChances[4] = 0.0F;
        }
    }

    return groupdataentity;
}
 

/**
 * Sets the amount of rows for this inventory.
 * This will (unlike most other methods) directly update itself in order to ensure all viewers will still be viewing the new inventory as well.
 *
 * @param rows the amount of rows in range 1..6.
 */
public void setRows(int rows) {
    if (!(rows >= 1 && rows <= 6)) {
        throw new IllegalArgumentException("Rows should be between 1 and 6");
    }

    //copy the viewers
    List<HumanEntity> viewers = getViewers();

    this.inventory = Bukkit.createInventory(this, rows * 9, getTitle());

    viewers.forEach(humanEntity -> humanEntity.openInventory(inventory));
}
 

@Test
public void shouldAllowInventoryClickEvent() {
    // given
    InventoryClickEvent event = mock(InventoryClickEvent.class);
    HumanEntity player = mock(Player.class);
    given(event.getWhoClicked()).willReturn(player);
    given(listenerService.shouldCancelEvent(player)).willReturn(false);

    // when
    listener.onPlayerInventoryClick(event);

    // then
    verify(event, only()).getWhoClicked();
}
 

@Override
public BehaviourItem[] getDefaultMovementBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(1, new BehaviourFloat(this)),
            new BehaviourItem(2, new BehaviourSit(this)),
            new BehaviourItem(3, new BehaviourLeapAtTarget(this, 0.4F)),
            new BehaviourItem(4, new BehaviourMeleeAttack(this, true, 1.0D)),
            new BehaviourItem(5, new BehaviourFollowTamer(this, 10.0F, 2.0F, 1.0D)),
            new BehaviourItem(6, new BehaviourBreed(this, 1.0D)),
            new BehaviourItem(7, new BehaviourRandomStroll(this, 1.0D)),
            new BehaviourItem(8, new BehaviourBeg(this, new Material[]{Material.BONE})),
            new BehaviourItem(9, new BehaviourLookAtNearestEntity(this, HumanEntity.class, 8.0F)),
            new BehaviourItem(9, new BehaviourLookAtRandom(this))
    };
}
 

public MinecraftInventory(InventoryHolder owner, int size, String title) {
    Validate.notNull(title, "Title cannot be null");
    this.items = NonNullList.withSize(size, ItemStack.EMPTY);
    this.title = title;
    this.viewers = new ArrayList<HumanEntity>();
    this.owner = owner;
    this.type = InventoryType.CHEST;
}
 

public void printTutorial(HumanEntity player, Civilian civilian) {
    String tutorialUrl = ConfigManager.getInstance().getTutorialUrl();
    player.sendMessage(Util.parseColors(ConfigManager.getInstance().getTopGuideSpacer()));
    TutorialManager.getInstance().sendMessageForCurrentTutorialStep(civilian, false);
    player.sendMessage(LocaleManager.getInstance().getTranslation(civilian.getLocale(), "tutorial-click"));
    player.sendMessage(tutorialUrl);
    player.sendMessage(Util.parseColors(ConfigManager.getInstance().getBottomGuideSpacer()));
}
 

protected Collection<HumanEntity> getCurrentViewers() {
    final List<HumanEntity> viewers = Lists.newArrayList();
    for (final Inventory openedInventory : openedInventories) {
        viewers.addAll(openedInventory.getViewers());
    }

    return viewers;
}
 

@Override
public BehaviourItem[] getDefaultTargetingBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(1, new BehaviourHurtByTarget(this, false)),
            new BehaviourItem(2, new BehaviourMoveTowardsNearestAttackableTarget(this, HumanEntity.class, 0, true))
    };
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryCloseServerSide(InventoryCloseEvent e) {
    HumanEntity hE = e.getPlayer();
    if(!(hE instanceof Player))
        return;

    HawkPlayer pp = hawk.getHawkPlayer((Player) hE);
    pp.sendSimulatedAction(new Runnable() {
        @Override
        public void run() {
            pp.setInventoryOpen((byte)0);
        }
    });
}
 

@Override
public ItemStack getItem(HumanEntity who, int slot) {
    if (item == null) {
        return null;
    }
    ItemStack clone = item.clone();
    gui.setItemText(clone, getText());
    if (number > 0 && number <= 64) {
        clone.setAmount(number);
    }
    return clone;
}
 

@Override
public BehaviourItem[] getDefaultMovementBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(0, new BehaviourFloat(this)),
            new BehaviourItem(1, new BehaviourPanic(this, 1.2D)),
            new BehaviourItem(1, new BehaviourTameByRiding(this, 1.2D)),
            new BehaviourItem(2, new BehaviourBreed(this, 1.0D)),
            new BehaviourItem(4, new BehaviourFollowParent(this, 1.25D)),
            new BehaviourItem(6, new BehaviourRandomStroll(this, 0.7D)),
            new BehaviourItem(7, new BehaviourLookAtNearestEntity(this, HumanEntity.class, 6.0F)),
            new BehaviourItem(8, new BehaviourLookAtRandom(this))
    };
}
 

@Override
public BehaviourItem[] getDefaultMovementBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(1, new BehaviourMeleeAttack(this, true, 1.0D)),
            new BehaviourItem(2, new BehaviourMoveTowardsTarget(this, 32.0F)),
            new BehaviourItem(3, new BehaviourMoveThroughVillage(this, true, 0.6D)),
            new BehaviourItem(4, new BehaviourMoveTowardsRestriction(this, 1.0D)),
            new BehaviourItem(5, new BehaviourOfferFlower(this, LivingEntity.class)),
            new BehaviourItem(6, new BehaviourRandomStroll(this)),
            new BehaviourItem(7, new BehaviourLookAtNearestEntity(this, HumanEntity.class, 6.0F)),
            new BehaviourItem(8, new BehaviourLookAtRandom(this))
    };
}
 

/**
 * Close the GUI for everyone viewing it
 * @param clearHistory  Whether or not to close the GUI completely (by clearing the history)
 */
public void close(boolean clearHistory) {
    for (Inventory inventory : inventories.values()) {
        for (HumanEntity viewer : new ArrayList<>(inventory.getViewers())) {
            if (clearHistory) {
                clearHistory(viewer);
            }
            viewer.closeInventory();
        }
    }
}
 

/**
 * Add a new history entry to the end of the history
 * @param player    The player to add the history entry for
 * @param gui       The GUI to add to the history
 */
public static void addHistory(HumanEntity player, InventoryGui gui) {
    GUI_HISTORY.putIfAbsent(player.getUniqueId(), new ArrayDeque<>());
    Deque<InventoryGui> history = getHistory(player);
    if (history.peekLast() != gui) {
        history.add(gui);
    }
}
 

/**
 * Go back one entry in the history
 * @param player    The player to show the previous gui to
 * @return          <tt>true</tt> if there was a gui to show; <tt>false</tt> if not
 */
public static boolean goBack(HumanEntity player) {
    Deque<InventoryGui> history = getHistory(player);
    history.pollLast();
    if (history.isEmpty()) {
        return false;
    }
    InventoryGui previous = history.peekLast();
    if (previous != null) {
        previous.show(player, false);
    }
    return true;
}
 

@Override
public BehaviourItem[] getDefaultTargetingBehaviours() {
    return new BehaviourItem[]{
            new BehaviourItem(1, new BehaviourHurtByTarget(this, true, false, true)),
            new BehaviourItem(2, new BehaviourMoveTowardsNearestAttackableTarget(this, HumanEntity.class, 0, true))
    };
}