@EventHandler
public void onVillagerTrade(InventoryOpenEvent event) {
    if (!plugin.getWorldManager().isSkyAssociatedWorld(event.getPlayer().getWorld())) {
        return;
    }
    if (!(event.getPlayer() instanceof Player)) {
        return;
    }
    if (!anyVillagerTradingAllowed && event.getInventory().getType() == InventoryType.MERCHANT) {
        event.setCancelled(true);
        event.getPlayer().sendMessage(tr("\u00a7eVillager-trading isn't allowed."));
        return;
    }
    if (visitorVillagerTradingProtected
            && event.getPlayer() instanceof Player
            && !(event.getPlayer().hasPermission("usb.mod.bypassprotection"))
            && event.getInventory().getType() == InventoryType.MERCHANT
            && !plugin.playerIsOnIsland((Player)event.getPlayer())) {
        event.setCancelled(true);
        event.getPlayer().sendMessage(tr("\u00a7eTrading isn't allowed on other islands. Do it in spawn."));
    }
}
 

public void setValues(String name, List<String> title, int titleUpdate, InventoryType inventoryType, HashMap<Integer, Integer> rows, HashMap<Button, Loc> buttons, String openRequirement, List<AbstractAction> openDenyActions, String closeRequirement, List<AbstractAction> closeDenyActions, String keepOpenRequirement, List<String> openCommands, List<AbstractAction> openActions, List<AbstractAction> closeActions, boolean lockPlayerInv, boolean updateInventory, boolean transferArgs, int forceTransferArgsAmount, List<String> bindItemLore, List<String> dependExpansions) {
    this.name = name;
    this.titles = title;
    this.titleUpdate = titleUpdate;
    this.titleIndex = new HashMap<>();
    this.shapeIndex = new HashMap<>();
    this.type = inventoryType;
    this.rows = rows;
    this.buttons = buttons;
    this.openRequirement = openRequirement;
    this.openDenyActions = openDenyActions;
    this.closeRequirement = closeRequirement;
    this.closeDenyActions = closeDenyActions;
    this.keepOpenRequirement = keepOpenRequirement;
    this.openCommands = openCommands;
    this.openActions = openActions;
    this.closeActions = closeActions;
    this.lockPlayerInv = lockPlayerInv;
    this.updateInventory = updateInventory;
    this.transferArgs = transferArgs;
    this.forceTransferArgsAmount = forceTransferArgsAmount;
    this.bindItemLore = bindItemLore != null && !bindItemLore.isEmpty() ? TLocale.Translate.setColored(bindItemLore) : bindItemLore;
    this.dependExpansions = dependExpansions;
    checkDepends();
}
 

@EventHandler
public void onInventoryClick(InventoryClickEvent event) {
    if (event.isCancelled()) {
        return;
    }

    if (event.getClickedInventory() == null) {
        return;
    }

    if (event.getClickedInventory().getType() == InventoryType.PLAYER) {
        Player p = (Player) event.getWhoClicked();
        if (Main.isPlayerInGame(p)) {
            GamePlayer gPlayer = Main.getPlayerGameProfile(p);
            Game game = gPlayer.getGame();
            if (game.getStatus() == GameStatus.WAITING || gPlayer.isSpectator) {
                event.setCancelled(true);
            }
        }
    }
}
 

public static String getNotchInventoryType(InventoryType type) {
    switch (type) {
        case WORKBENCH:
            return "minecraft:crafting_table";
        case FURNACE:
            return "minecraft:furnace";
        case DISPENSER:
            return "minecraft:dispenser";
        case ENCHANTING:
            return "minecraft:enchanting_table";
        case BREWING:
            return "minecraft:brewing_stand";
        case BEACON:
            return "minecraft:beacon";
        case ANVIL:
            return "minecraft:anvil";
        case HOPPER:
            return "minecraft:hopper";
        case DROPPER:
            return "minecraft:dropper";
        case SHULKER_BOX:
            return "minecraft:shulker_box";
        default:
            return "minecraft:chest";
    }
}
 

@EventHandler (ignoreCancelled = true)
public void onAnvilRename(InventoryClickEvent e) {
  if (e.getInventory() == null || e.getInventory().getType() == null) {
    return;
  }

  if (e.getCurrentItem() == null || e.getCurrentItem().getType() == null) {
    return;
  }

  if (e.getInventory().getType() != InventoryType.ANVIL || e.getCurrentItem().getType() != XMaterial.SPAWNER.parseMaterial()) {
    return;
  }

  if (!plugin.getConfigurationHandler().getBoolean("anvil", "prevent-anvil")) {
    return;
  }

  Player player = (Player) e.getWhoClicked();
  e.setCancelled(true);
  player.sendMessage(plugin.getConfigurationHandler().getMessage("anvil", "prevented"));
}
 

public PlayerData(final Player p) {
  	if (SkyWarsReloaded.getCfg().debugEnabled()) {
      	Util.get().logToFile(ChatColor.RED + "[skywars] " + ChatColor.YELLOW + "Creating " + p.getName() + "'s Datafile");
  	}
  	this.beingRestored = false;
      this.uuid = p.getUniqueId();
      this.sb = p.getScoreboard();
      this.health = p.getHealth();
      this.food = p.getFoodLevel();
      this.sat = p.getSaturation();
if (!SkyWarsReloaded.getCfg().displayPlayerExeperience()) {
	xp = p.getExp();
}
      inv = Bukkit.createInventory(null, InventoryType.PLAYER, p.getName());
      inv.setContents(p.getInventory().getContents());
  	if (SkyWarsReloaded.getCfg().debugEnabled()) {
  		Util.get().logToFile(ChatColor.RED + "[skywars] " + ChatColor.YELLOW + p.getName() + "'s Datafile has been created");
  	}
  }
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onChestClose(InventoryCloseEvent e) {
    if (!(e.getPlayer() instanceof Player))
        return;
    final Player p = (Player) e.getPlayer();
    if (!playerStateInfoMap.containsKey(p)) return;
    if (!(p.getInventory().getType() == InventoryType.CHEST ||
            plugin.getVersionUtil().isOneDotXOrHigher(11)
                    && isShulkerBox(p.getInventory()))) {
        return;
    }
    new BukkitRunnable() {
        @Override
        public void run() {
            StateInfo stateInfo = playerStateInfoMap.get(p);
            if (stateInfo == null) return;
            restoreState(stateInfo, p);
            playerStateInfoMap.remove(p);
        }
    }.runTaskLater(plugin, 1);
}
 

@Override
protected void run(Player player) {
    final PlayerInventory inv = player.getInventory();

    // clear main inventory
    contents = inv.getContents();
    inv.clear();

    // clear armour slots
    armourContents = inv.getArmorContents();
    inv.setArmorContents(null);

    // clear if they have something on their cursour currently
    onCursor = player.getItemOnCursor();
    player.setItemOnCursor(new ItemStack(Material.AIR));

    // if they have a crafting inventory open clear items from it too
    // stops storing items in crafting slots bypassing clear inventories
    final InventoryView openInventory = player.getOpenInventory();
    if (openInventory.getType() == InventoryType.CRAFTING) {
        crafting = Optional.of(openInventory.getTopInventory().getContents());
        openInventory.getTopInventory().clear();
    } else {
        crafting = Optional.absent();
    }
}
 

@EventHandler
public void furnaceShiftClickFix(InventoryClickEvent event){
	final Player p = (Player)event.getWhoClicked();
	if(p != null){
		//p.sendMessage("Clicked");
		if(event.getInventory().getType().equals(InventoryType.FURNACE)){
		//	p.sendMessage("It's a furnace");
			if(event.isShiftClick()){
			//	p.sendMessage("Update ivnentory");
				new BukkitRunnable(){

					@Override
					public void run() {
						p.updateInventory();
						
					}
					
				}.runTaskLater(ProRecipes.getPlugin(), 0);
				
			}
		}
	}
	
}
 

/**
 * Remove the store/unstore event possibility when an inventory is closed.
 *
 * @param evt The InventoryCloseEvent used to remove the possibility of a store/unstore
 *            event
 */
@EventHandler
public void onClose(InventoryCloseEvent evt) {
    if (evt.getView().getBottomInventory().getType() == InventoryType.PLAYER
            && (evt.getView().getTopInventory().getType() == InventoryType.CHEST
            || evt.getView().getTopInventory().getType() == InventoryType.ENDER_CHEST
            || evt.getView().getTopInventory().getType() == InventoryType.HOPPER
            || evt.getView().getTopInventory().getType() == InventoryType.DISPENSER
            || evt.getView().getTopInventory().getType() == InventoryType.DROPPER)) {
        if (storePossible.contains(evt.getPlayer())) {
            storePossible.remove(evt.getPlayer());
        } else if (unstorePossible.contains(evt.getPlayer())) {
            unstorePossible.remove(evt.getPlayer());
        }
    }
}
 

@EventHandler(priority=EventPriority.HIGH, ignoreCancelled=true)
public void onTag(PlayerTagEvent e) {
    Player player = e.getPlayer();
    InventoryView openView = player.getOpenInventory();
    if(openView == null) return;

    Inventory topInv = openView.getTopInventory();
    if(topInv == null) return;

    InventoryType type = openView.getType();
    if(type == InventoryType.CRAFTING) return;

    player.closeInventory();
    String message = this.plugin.getLanguageMessageColoredWithPrefix("cheat-prevention.inventory.force-closed");
    this.plugin.sendMessage(player, message);
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void onItemMove(InventoryMoveItemEvent e) {
    if ((e.getSource().getType().equals(InventoryType.CHEST)) && (!e.getInitiator().getType().equals(InventoryType.PLAYER))) {

        if (e.getSource().getHolder() instanceof DoubleChest) {
            DoubleChest dc = (DoubleChest) e.getSource().getHolder();
            Chest r = (Chest) dc.getRightSide();
            Chest l = (Chest) dc.getLeftSide();

            if (shopUtils.isShop(r.getLocation()) || shopUtils.isShop(l.getLocation())) e.setCancelled(true);

        } else if (e.getSource().getHolder() instanceof Chest) {
            Chest c = (Chest) e.getSource().getHolder();

            if (shopUtils.isShop(c.getLocation())) e.setCancelled(true);
        }
    }
}
 

private boolean isShulkerBox(InventoryView inv) {
    try {
        return inv.getType() == InventoryType.SHULKER_BOX;
    } catch (NoSuchFieldError e) {
        return false;
    }
}
 

@EventHandler
public void onInventoryOpen(InventoryOpenEvent event) {
    if (event.isCancelled() || !(event.getPlayer() instanceof Player)) {
        return;
    }

    Player player = (Player) event.getPlayer();
    if (Main.isPlayerInGame(player)) {
        GamePlayer gProfile = Main.getPlayerGameProfile(player);
        if (gProfile.getGame().getStatus() == GameStatus.RUNNING) {
            if (gProfile.isSpectator) {
                // TODO spectator compass exclude
                event.setCancelled(true);
                return;
            }
            if (event.getInventory().getType() == InventoryType.ENCHANTING
                    || event.getInventory().getType() == InventoryType.CRAFTING
                    || event.getInventory().getType() == InventoryType.ANVIL
                    || event.getInventory().getType() == InventoryType.BREWING
                    || event.getInventory().getType() == InventoryType.FURNACE
                    || event.getInventory().getType() == InventoryType.WORKBENCH) {
                if (!gProfile.getGame().getOriginalOrInheritedCrafting()) {
                    event.setCancelled(true);
                }
            }
        }
    }
}
 

protected static boolean allowedInventoryType(InventoryType type) {
  switch (type) {
    case CREATIVE:
    case PLAYER:
      return true;
    default:
      return false;
  }
}
 

@EventHandler(ignoreCancelled = true)
public void onIngredientPut(InventoryClickEvent event) {
    if (event.getInventory().getType() != InventoryType.BREWING)
        return;
    if (event.getRawSlot() == 3 || event.getClick().equals(ClickType.SHIFT_LEFT)) {
        String playerID = PlayerConverter.getID((Player) event.getWhoClicked());
        if (!containsPlayer(playerID))
            return;
        locations.put(((BrewingStand) event.getInventory().getHolder()).getLocation(), playerID);
    }
}
 

@EventHandler(ignoreCancelled = true)
public void onShiftSmelting(InventoryClickEvent event) {
    if (event.getInventory().getType().equals(InventoryType.FURNACE) && event.getRawSlot() == 2
            && event.getClick().equals(ClickType.SHIFT_LEFT) && event.getWhoClicked() instanceof Player) {
        String playerID = PlayerConverter.getID((Player) event.getWhoClicked());
        if (containsPlayer(playerID))
            event.setCancelled(true);
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onMove(PlayerMoveEvent e) {
    Player p = e.getPlayer();
    if (playerStateInfoMap.containsKey(p)) {
        if (!(p.getOpenInventory().getType() == InventoryType.CHEST ||
                plugin.getVersionUtil().isOneDotXOrHigher(11)
                        && isShulkerBox(p.getOpenInventory()))) {
            restoreState(playerStateInfoMap.get(p), p);
            playerStateInfoMap.remove(p);
        }
    }
}
 

@EventHandler
public void onInventoryOpen(InventoryOpenEvent event) {
    if (event.isCancelled() || !(event.getPlayer() instanceof Player)) {
        return;
    }

    Player player = (Player) event.getPlayer();
    if (Main.isPlayerInGame(player)) {
        GamePlayer gProfile = Main.getPlayerGameProfile(player);
        if (gProfile.getGame().getStatus() == GameStatus.RUNNING) {
            if (gProfile.isSpectator) {
                // TODO spectator compass exclude
                event.setCancelled(true);
                return;
            }
            if (event.getInventory().getType() == InventoryType.ENCHANTING
                    || event.getInventory().getType() == InventoryType.CRAFTING
                    || event.getInventory().getType() == InventoryType.ANVIL
                    || event.getInventory().getType() == InventoryType.BREWING
                    || event.getInventory().getType() == InventoryType.FURNACE
                    || event.getInventory().getType() == InventoryType.WORKBENCH) {
                if (!gProfile.getGame().getOriginalOrInheritedCrafting()) {
                    event.setCancelled(true);
                }
            }
        }
    }
}
 

@EventHandler
public void onClick(final InventoryClickEvent e) {
    if (e.getInventory().getType().equals(InventoryType.CHEST)) {
        GuiWindow window = GuiWindow.getWindow(e.getView().getTitle());
        if (window != null) {
            GuiItem item = window.getItem(e.getRawSlot());
            if (item != null) {
                item.handleClick(e);
            }
            
            e.setResult(Event.Result.DENY);
        }
    }
}
 

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);
}
 

@Override
protected void inventoryDrag(InventoryDragEvent event) {
	InventoryView view = event.getView();
	for (int slot : event.getRawSlots()) {
		if (view.getInventory(slot).getType() != InventoryType.PLAYER) {
			event.setCancelled(true);
			return;
		}
	}
}
 

/**
 * Retrieve the window type to use for display. 
 * @return The current inventory type
*/
public InventoryType getInventoryType() {
	int id = handle.getIntegers().read(1);
	
	if (id >= 0 && id <= inventoryByID.size())
		return inventoryByID.get(id);
	else
		throw new IllegalArgumentException("Cannot find inventory type " + id);
}
 

@EventHandler
public void onInteract(final InventoryInteractEvent e) {
    if (GuiWindow.getWindow(e.getView().getTitle()) != null) {
        if (e.getInventory().getType().equals(InventoryType.CHEST)) {
            e.setResult(Event.Result.DENY);
        }
    }
}
 

@Override
public InventoryType getType() {
    InventoryType type = viewing.getType();
    if (type == InventoryType.CRAFTING && player.getGameMode() == GameMode.CREATIVE) {
        return InventoryType.CREATIVE;
    }
    return type;
}
 

public static Inventory mockInventory(InventoryType type, ItemStack... contents) {
    Inventory inv = Mockito.mock(Inventory.class);

    when(inv.getType()).thenReturn(type);
    when(inv.getContents()).thenReturn(contents);

    return inv;
}
 

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;
}
 

@EventHandler(ignoreCancelled = true)
public void onItemMove(final InventoryClickEvent event) {
    if (!(event.getWhoClicked() instanceof Player)) {
        return;
    }
    if (event.getWhoClicked().getGameMode() == GameMode.CREATIVE) {
        return;
    }
    final String playerID = PlayerConverter.getID((Player) event.getWhoClicked());
    ItemStack item;
    switch (event.getAction()) {
    case MOVE_TO_OTHER_INVENTORY:
        item = event.getCurrentItem();
        break;
    case PLACE_ALL:
    case PLACE_ONE:
    case PLACE_SOME:
    case SWAP_WITH_CURSOR:
        if (event.getClickedInventory().getType() != InventoryType.PLAYER) {
            item = event.getCursor();
        } else {
            item = null;
        }
        break;
    case HOTBAR_MOVE_AND_READD:
    case HOTBAR_SWAP:
        if (event.getClickedInventory().getType() != InventoryType.PLAYER) {
            item = event.getWhoClicked().getInventory().getItem(event.getHotbarButton());
        } else {
            item = null;
        }
        break;
    default:
        item = null;
        break;
    }
    if (item != null && (Journal.isJournal(playerID, item) || Utils.isQuestItem(item))) {
        event.setCancelled(true);
    }
}
 

public InventoryType getType() {
    // Thanks to Droppers extending Dispensers, order is important.
    if (inventory instanceof InventoryCrafting) {
        return inventory.getSizeInventory() >= 9 ? InventoryType.WORKBENCH : InventoryType.CRAFTING;
    } else if (inventory instanceof InventoryPlayer) {
        return InventoryType.PLAYER;
    } else if (inventory instanceof TileEntityDropper) {
        return InventoryType.DROPPER;
    } else if (inventory instanceof TileEntityDispenser) {
        return InventoryType.DISPENSER;
    } else if (inventory instanceof TileEntityFurnace) {
        return InventoryType.FURNACE;
    } else if (this instanceof CraftInventoryEnchanting) {
        return InventoryType.ENCHANTING;
    } else if (inventory instanceof TileEntityBrewingStand) {
        return InventoryType.BREWING;
    } else if (inventory instanceof CraftInventoryCustom.MinecraftInventory) {
        return ((CraftInventoryCustom.MinecraftInventory) inventory).getType();
    } else if (inventory instanceof InventoryEnderChest) {
        return InventoryType.ENDER_CHEST;
    } else if (inventory instanceof InventoryMerchant) {
        return InventoryType.MERCHANT;
    } else if (inventory instanceof TileEntityBeacon) {
        return InventoryType.BEACON;
    } else if (this instanceof CraftInventoryAnvil) {
        return InventoryType.ANVIL;
    } else if (inventory instanceof IHopper) {
        return InventoryType.HOPPER;
    } else if (inventory instanceof TileEntityShulkerBox) {
        return InventoryType.SHULKER_BOX;
    } else {
        return InventoryType.CHEST;
    }
}
 

@Override
public InventoryType getType() {
    InventoryType type = viewing.getType();
    if (type == InventoryType.CRAFTING && player.getGameMode() == GameMode.CREATIVE) {
        return InventoryType.CREATIVE;
    }
    return type;
}