@EventHandler
public void onDrop(PlayerDropItemEvent event) {
    Player player = event.getPlayer();
    if (event.isCancelled() || !Main.isPlayerInGame(player)) {
        return;
    }

    GamePlayer gPlayer = Main.getPlayerGameProfile(player);
    Game game = gPlayer.getGame();
    if (gPlayer.isSpectator) {
        return;
    }

    WarpPowder warpPowder = (WarpPowder) game.getFirstActivedSpecialItemOfPlayer(player, WarpPowder.class);
    if (warpPowder != null) {
        if (warpPowder.getStack().equals(event.getItemDrop().getItemStack())) {
            event.setCancelled(true);
        }
    }
}
 

/**
 * Effect if a player drops an item
 *
 * @param event the event
 */
@EventHandler(ignoreCancelled = true)
public void effect(PlayerDropItemEvent event) {
	Item item = event.getItemDrop();
	ItemStack tool = item.getItemStack();

	if (!(modManager.isArmorViable(tool) || modManager.isToolViable(tool) || modManager.isWandViable(tool))) {
		return;
	}

	if (!modManager.hasMod(tool, this)) {
		return;
	}

	if (toolDroppable) {
		return;
	}

	ChatWriter.logModifier(event.getPlayer(), event, this, tool, "Tool not droppable");

	event.setCancelled(true);
}
 

@EventHandler
public void onDrop(PlayerDropItemEvent event) {
    Player player = event.getPlayer();
    if (event.isCancelled() || !Main.isPlayerInGame(player)) {
        return;
    }

    GamePlayer gPlayer = Main.getPlayerGameProfile(player);
    Game game = gPlayer.getGame();
    if (gPlayer.isSpectator) {
        return;
    }

    WarpPowder warpPowder = (WarpPowder) game.getFirstActivedSpecialItemOfPlayer(player, WarpPowder.class);
    if (warpPowder != null) {
        if (warpPowder.getStack().equals(event.getItemDrop().getItemStack())) {
            event.setCancelled(true);
        }
    }
}
 

@EventHandler
public void onPlayerDropItem(PlayerDropItemEvent event) {
    if(this.ignoreNextDropEvent) {
        this.ignoreNextDropEvent = false;
    } else {
        // If the ignore flag is clear, this drop was caused by something other than
        // an inventory click (e.g. drop key, death, etc), so an event has not yet been fired
        int initialQuantity = event.getItemDrop().getItemStack().getAmount();
        ItemStack stack = event.getItemDrop().getItemStack();
        PlayerItemTransferEvent transferEvent = new PlayerItemTransferEvent(event, ItemTransferEvent.Type.DROP, event.getPlayer(),
                                                                            Optional.of(new InventorySlot(event.getPlayer().getInventory())),
                                                                            Optional.empty(),
                                                                            stack, event.getItemDrop(), initialQuantity,
                                                                            event.getPlayer().getOpenInventory().getCursor());
        this.callEvent(transferEvent);

        if(!transferEvent.isCancelled() && transferEvent.getQuantity() < initialQuantity) {
            int diff = initialQuantity - transferEvent.getQuantity();
            stack.setAmount(stack.getAmount() - diff);
            stack = stack.clone();
            stack.setAmount(diff);
            event.getPlayer().getInventory().addItem(stack);
        }
    }
}
 

/**
 * Prevents enhanced item from dropping.
 *
 * @param e
 */
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onItemDrop(PlayerDropItemEvent e) {
    Item droppedItem = e.getItemDrop();
    ItemStack DroppedItemStack = droppedItem.getItemStack();
    Player p = e.getPlayer();
    // Checks if the item is a bounded item
    if ((DroppedItemStack.hasItemMeta()) && (DroppedItemStack.getItemMeta()
            .getLore() != null)) {
        if (DroppedItemStack.getItemMeta().getLore().contains(Util.UNIQUEID + Util.toColor(
                SettingsManager.lang.getString("lore.untradeableLore")))) {
            e.setCancelled(true);
            Util.sendMessage(SettingsManager.lang.getString(
                    "messages.noDrop"), p);
        }
    }
}
 

@Test(expected = SuccessException.class)
public void playerShouldNotBeAbleToDropItem() {
    RegionsTests.loadRegionTypeCobble();
    Item item = mock(Item.class);
    ItemStack itemStack = mock(ItemStack.class);
    ItemMeta itemMeta = mock(ItemMeta.class);
    when(itemMeta.getDisplayName()).thenReturn("Cobble");
    ArrayList<String> lore = new ArrayList<>();
    lore.add(TestUtil.player.getUniqueId().toString());
    lore.add("Civs Cobble");
    when(itemStack.hasItemMeta()).thenReturn(true);
    when(itemMeta.getLore()).thenReturn(lore);
    when(itemStack.getItemMeta()).thenReturn(itemMeta);
    when(item.getItemStack()).thenReturn(itemStack);
    doThrow(new SuccessException()).when(item).remove();
    PlayerDropItemEvent playerDropItemEvent = new PlayerDropItemEvent(TestUtil.player, item);
    CivilianListener civilianListener = new CivilianListener();
    civilianListener.onCivilianDropItem(playerDropItemEvent);
}
 

@EventHandler(priority=EventPriority.HIGHEST, ignoreCancelled=true)
public void StopDrops(PlayerDropItemEvent event)
{
    Player player = event.getPlayer();
    Item item = event.getItemDrop();
    if(item != null)
    {
	    ItemStack stack = item.getItemStack();
	    if(stack != null)
	    {
		    if(KitUtils.isSoulbound(stack))
		    {
			    player.playSound(player.getLocation(), Sound.BLAZE_HIT, 1.0F, 0.3F);
			    event.getItemDrop().remove();
		    }
	    }
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerDrop(final PlayerDropItemEvent event) {

    final PlayerStat stat = PlayerStat.ITEMS_DROPPED;

    // Get player
    final Player player = event.getPlayer();

    // Do general check
    if (!plugin.doGeneralCheck(player, stat))
        return;

    PlayerStatSpecification specification = new ItemsDroppedSpecification(player.getUniqueId(),
            event.getItemDrop().getItemStack().getAmount(), player.getWorld().getName(),
            event.getItemDrop().getItemStack().getType());

    // Update value to new stat.
    plugin.getDataManager().setPlayerInfo(player.getUniqueId(), stat, specification.constructQuery());

}
 

@EventHandler
public void onDrop(PlayerDropItemEvent die) {
  Player p = die.getPlayer();
  Game g = BedwarsRel.getInstance().getGameManager().getGameOfPlayer(p);
  if (g == null) {
    return;
  }

  if (g.getState() != GameState.WAITING) {
    if (g.isSpectator(p)) {
      die.setCancelled(true);
    }

    return;
  }

  die.setCancelled(true);
}
 

@EventHandler
public void onDrop(PlayerDropItemEvent event) {
  Player p = event.getPlayer();
  Game g = BedwarsRel.getInstance().getGameManager().getGameOfPlayer(p);
  if (g == null) {
    return;
  }

  if (g.getState() == GameState.RUNNING
      && event.getItemDrop().getItemStack().getItemMeta().getDisplayName() != null
      && event.getItemDrop().getItemStack().getItemMeta().getDisplayName()
      .equals(BedwarsRel._l("ingame.specials.warp-powder.cancel"))) {
    event.setCancelled(true);
  }

}
 

@EventHandler(ignoreCancelled = true)
public void onItemDrop(PlayerDropItemEvent event) {
    if (!cratesPlus.getConfigHandler().isDisableKeySwapping())
        return;
    String title;
    ItemStack item = event.getItemDrop().getItemStack();

    for (Map.Entry<String, Crate> crate : cratesPlus.getConfigHandler().getCrates().entrySet()) {
        if (!(crate.getValue() instanceof KeyCrate)) {
            continue;
        }
        KeyCrate keyCrate = (KeyCrate) crate.getValue();
        Key key = keyCrate.getKey();
        if (key == null)
            continue;
        title = key.getName();

        if (item.hasItemMeta() && item.getItemMeta().hasDisplayName() && item.getItemMeta().getDisplayName().contains(title)) {
            MessageHandler.sendMessage(event.getPlayer(), "&cYou can not drop crate keys", crate.getValue(), null);
            event.setCancelled(true);
            return;
        }
    }

}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerDropItem(PlayerDropItemEvent event) {
    final Player player = event.getPlayer();
    GDCauseStackManager.getInstance().pushCause(player);
    if (!GDFlags.ITEM_DROP) {
        return;
    }

    final World world = event.getPlayer().getWorld();
    if (!GriefDefenderPlugin.getInstance().claimsEnabledForWorld(world.getUID())) {
        return;
    }
    if (GriefDefenderPlugin.isSourceIdBlacklisted(Flags.ITEM_DROP.getName(), player, world.getUID())) {
        return;
    }

    if (GriefDefenderPlugin.isTargetIdBlacklisted(Flags.ITEM_DROP.getName(), event.getItemDrop(), world.getUID())) {
        return;
    }

    final Location location = event.getItemDrop().getLocation();
    final GDClaim targetClaim = GriefDefenderPlugin.getInstance().dataStore.getClaimAt(location);

    if (GDPermissionManager.getInstance().getFinalPermission(event, location, targetClaim, Flags.ITEM_DROP, player, event.getItemDrop(), player, TrustTypes.ACCESSOR, true) == Tristate.FALSE) {
        event.setCancelled(true);
    }
}
 

@Override
public void onEvent(PlayerDropItemEvent event) {
  super.onEvent(event);
  if (this.isCarrier(event.getPlayer()) && this.isFlag(event.getItemDrop().getItemStack())) {
    event.getItemDrop().remove();
    this.dropFlag();
  }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerDropItem(PlayerDropItemEvent event) {
    if (testDestroy(event.getPlayer(), event.getItemDrop().getItemStack())) {
        event.getItemDrop().setMetadata(ITEM_THROWER_META,
                new FixedMetadataValue(Cardinal.getInstance(), event.getPlayer().getUniqueId()));
    }
}
 

@EventHandler(ignoreCancelled = true)
public void onItemDrop(PlayerDropItemEvent event) {
	if (MineTinker.getPlugin().getConfig().getBoolean("ItemBehaviour.DisableDroppingBehaviour")) {
		return;
	}

	Item item = event.getItemDrop();
	ItemStack is = item.getItemStack();

	boolean isMineTinker = false;

	if (MineTinker.getPlugin().getConfig().getBoolean("ItemBehaviour.ForModItems")) {
		isMineTinker = modManager.isModifierItem(is);
	}
	if (modManager.isArmorViable(is) || modManager.isToolViable(is) || modManager.isWandViable(is)) {
		isMineTinker = true;
	}

	if (!isMineTinker) {
		return;
	}

	if (MineTinker.getPlugin().getConfig().getBoolean("ItemBehaviour.ShowName") && is.getItemMeta() != null) {
		item.setCustomName(is.getItemMeta().getDisplayName());
		item.setCustomNameVisible(true);
	}

	if (MineTinker.getPlugin().getConfig().getBoolean("ItemBehaviour.SetGlowing")) {
		item.setGlowing(true);
	}

	if (MineTinker.getPlugin().getConfig().getBoolean("ItemBehaviour.SetInvulnerable")) {
		item.setInvulnerable(true);
	}
}
 

@EventHandler(priority = EventPriority.HIGH)
public void onPlayerDropItem(PlayerDropItemEvent event) {
    if (event.isCancelled() || !LWC.ENABLED) {
        return;
    }

    Player player = event.getPlayer();

    LWCDropItemEvent evt = new LWCDropItemEvent(player, event);
    plugin.getLWC().getModuleLoader().dispatchEvent(evt);

    if (evt.isCancelled()) {
        event.setCancelled(true);
    }
}
 

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onPlayerDropItem(final PlayerDropItemEvent event) {
    match.player(event.getPlayer()).ifPresent(player -> {
        if(!player.canInteract()) {
            if(player.isSpawned()) {
                // If player is spawned (but frozen), force them to keep the item
                event.setCancelled(true);
            } else {
                // If player is observing, just destroy the item
                event.getItemDrop().remove();
            }
        }
    });
}
 

@EventHandler
private void playerDropItem(PlayerDropItemEvent event) {
	CustomItem customItem = CustomItemManager.getCustomItem(event.getItemDrop().getItemStack());
	if (verifyCustomItem(customItem, event.getPlayer(), true)) {
		customItem.onDrop(event);
	}
}
 

@EventHandler
public void onItemDrop(PlayerDropItemEvent event) {
    if (isPicker(event.getPlayer()) && event.getItemDrop().getItemStack().isSimilar(bannerItem)) {
        event.getItemDrop().remove();
        spawnFlag();
    }
}
 

@Override
public void onEvent(PlayerDropItemEvent event) {
    super.onEvent(event);
    if(this.isCarrier(event.getPlayer()) && this.isFlag(event.getItemDrop().getItemStack())) {
        event.getItemDrop().remove();
        dropFlag();
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void handleItemDrop(final PlayerDropItemEvent event) {
    ParticipantState player = PGM.getMatchManager().getParticipantState(event.getPlayer());
    if(player == null) return;

    Competitor team = player.getParty();
    Item itemDrop = event.getItemDrop();
    ItemStack item = itemDrop.getItemStack();

    if (this.isDestroyableWool(item, team)) {
        this.droppedWools.put(itemDrop, player.getPlayerId());
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerDropItem(PlayerDropItemEvent event) {
	Player player = event.getPlayer();
	ItemStack item = event.getItemDrop().getItemStack();
	GameManager gm = GameManager.getGameManager();

	if (gm.getGameState() == GameState.WAITING && GameItem.isGameItem(item)){
		event.setCancelled(true);
		return;
	}
}
 

@EventHandler(ignoreCancelled = true)
public void onDrop(PlayerDropItemEvent event)
{
	Material itemType = event.getItemDrop().getItemStack().getType();
	if(itemType == Material.SHULKER_SHELL || SHULKER_BOX_MATERIALS.contains(itemType))
	{
		event.setCancelled(true);
	}
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerDropCustomItemLowest(PlayerDropCustomItemEvent customEvent) {
	if (customEvent.isCancelled())
		return;

	CustomItem cItem = customEvent.getCustomItem();
	ItemPermissions perm = cItem.getPermissions();

	PlayerDropItemEvent event = customEvent.getPlayerDropItemEvent();
	if (!PermissionUtils.allowedAction(event.getPlayer(), perm.getType(), perm.getDrop()))
		event.setCancelled(true);
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerDropItem(PlayerDropItemEvent event) {
	if (event.isCancelled())
		return;

	ItemStack item = event.getItemDrop().getItemStack();

	if (!AdditionsAPI.isCustomItem(item))
		return;
	CustomItemStack cStack = new CustomItemStack(item);

	Bukkit.getPluginManager().callEvent(new PlayerDropCustomItemEvent(event, cStack));
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onDrop(PlayerDropItemEvent event)
{
	UUID uuid = event.getPlayer().getUniqueId();
	
	if((options.modeItemChange || !modeCoordinator.isInMode(uuid)) && !freezeHandler.isFrozen(uuid))
	{
		return;
	}
	
	event.setCancelled(true);
}
 

public static void load(CSCoreLib plugin) {
	plugin.getServer().getPluginManager().registerEvents(new CustomBookOverlayListener(), plugin);
	plugin.getServer().getPluginManager().registerEvents(new Listener() {

		@EventHandler
		public void onDrop(PlayerDropItemEvent e) {
			if (opening.contains(e.getPlayer().getUniqueId())) e.setCancelled(true);
		}

	}, plugin);
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onDropItem(PlayerDropItemEvent event) {
    if (event.getItemDrop().getItemStack().isSimilar(SelectorLayout.getSelectorItem()) && !(ConfigOptions.instance.getConfig().getBoolean("petSelector.allowDrop", true))) {
        event.setCancelled(true);
        event.getPlayer().updateInventory();
    }
}
 

@EventHandler
public void onDropItem(PlayerDropItemEvent event) {
  if (cancelled) return;
  if (player1.equals(event.getPlayer()) || player2.equals(event.getPlayer())) {
    event.setCancelled(true);
    if (accept1 && accept2) {
      giveOnCursor(event.getPlayer());
    }
  }
}
 

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onDrop(PlayerDropItemEvent dropItemEvent) {
    Item itemDrop = dropItemEvent.getItemDrop();
    ItemStack mapItem = itemDrop.getItemStack();
    if (isOurGraph(mapItem)) {
        mapItem.setAmount(0);
    }
}