org.bukkit.event.player.PlayerItemHeldEvent Java Examples

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
void onItemHeld(PlayerItemHeldEvent event) {
	Player player = event.getPlayer();
	if (player.getGameMode() == GameMode.CREATIVE) return;
	ItemStack newItemInHand = player.getInventory().getItem(event.getNewSlot());
	if (!Settings.isShopCreationItem(newItemInHand)) {
		return;
	}

	if (!ShopkeepersPlugin.getInstance().hasCreatePermission(player)) {
		// player cannot create any shopkeeper at all
		return;
	}

	// print info message about usage:
	Utils.sendMessage(player, Settings.msgCreationItemSelected);
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onItemHeld(PlayerItemHeldEvent event) {
	if (event.isCancelled()) {
		return;
	}
	
	ItemStack stack = event.getPlayer().getItemInHand();
	if (stack == null) {
		return;
	}

	LoreMaterial material = LoreMaterial.getMaterial(stack);
	if (material != null) {
		material.onHold(event);
	}
}
 

@EventHandler(priority = EventPriority.NORMAL)
public void OnInventoryHold(PlayerItemHeldEvent event) {
	
	ItemStack stack = event.getPlayer().getInventory().getItem(event.getNewSlot());
	if (stack == null) {
		return;
	}
	
	LoreCraftableMaterial craftMat = LoreCraftableMaterial.getCraftMaterial(stack);
	if (craftMat == null) {
		return;
	}
	
	craftMat.onHold(event);
}
 

@Test
public void shouldHandleSimpleCancelableEvents() {
    withServiceMock(listenerService)
        .check(listener::onPlayerShear, PlayerShearEntityEvent.class)
        .check(listener::onPlayerFish, PlayerFishEvent.class)
        .check(listener::onPlayerBedEnter, PlayerBedEnterEvent.class)
        .check(listener::onPlayerDropItem, PlayerDropItemEvent.class)
        .check(listener::onPlayerHitPlayerEvent, EntityDamageByEntityEvent.class)
        .check(listener::onPlayerConsumeItem, PlayerItemConsumeEvent.class)
        .check(listener::onPlayerInteract, PlayerInteractEvent.class)
        .check(listener::onPlayerPickupItem, PlayerPickupItemEvent.class)
        .check(listener::onPlayerInteractEntity, PlayerInteractEntityEvent.class)
        .check(listener::onPlayerHeldItem, PlayerItemHeldEvent.class);
}
 

@Override
public void onHold(PlayerItemHeldEvent event) {	
	
	Resident resident = CivGlobal.getResident(event.getPlayer());
	if (!resident.hasTechForItem(event.getPlayer().getInventory().getItem(event.getNewSlot()))) {		
		CivMessage.send(resident, CivColor.Rose+"Warning - "+CivColor.LightGray+
				"You do not have the required technology to use this item. It's defense output will be reduced in half.");
	}
}
 

@Override
public void onHold(PlayerItemHeldEvent event) {	
	
	Resident resident = CivGlobal.getResident(event.getPlayer());
	if (!resident.hasTechForItem(event.getPlayer().getInventory().getItem(event.getNewSlot()))) {		
		CivMessage.send(resident, CivColor.Rose+"Warning - "+CivColor.LightGray+
				"You do not have the required technology to use this item. It's attack output will be reduced in half.");
	}
}
 

@Override
public void onHold(PlayerItemHeldEvent event) {	
	
	Resident resident = CivGlobal.getResident(event.getPlayer());
	if (!resident.hasTechForItem(event.getPlayer().getInventory().getItem(event.getNewSlot()))) {		
		CivMessage.send(resident, CivColor.Rose+"Warning - "+CivColor.LightGray+
				"You do not have the required technology to use this item. It's attack output will be reduced in half.");
	}
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void OnItemHeldChange(PlayerItemHeldEvent event) {
	Inventory inv = event.getPlayer().getInventory();
	ItemStack stack = inv.getItem(event.getNewSlot());
	
	BonusGoodie goodie = CivGlobal.getBonusGoodie(stack);
	if (goodie == null) {
		return;
	}
	
	CivMessage.send(event.getPlayer(), CivColor.Purple+"Bonus Goodie: "+CivColor.Yellow+goodie.getDisplayName());
	
}
 

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void item(PlayerItemHeldEvent e) {
    if (!useEnhanceProtection) {
        return;
    }
    if (DisplayItem.getNowUsing() != DisplayType.REALITEM) {
        return;
    }
    final ItemStack stack = e.getPlayer().getInventory().getItemInMainHand();
    final ItemStack stackOffHand = e.getPlayer().getInventory().getItemInOffHand();
    if (DisplayItem.checkIsGuardItemStack(stack)) {
        e.getPlayer().getInventory().setItemInMainHand(new ItemStack(Material.AIR, 0));
        // You shouldn't be able to pick up that...
        sendAlert(
                "[DisplayGuard] Player "
                        + e.getPlayer().getName()
                        + " helded the displayItem, QuickShop already cancelled and removed it.");
        e.setCancelled(true);
        Util.inventoryCheck(e.getPlayer().getInventory());
    }
    if (DisplayItem.checkIsGuardItemStack(stackOffHand)) {
        e.getPlayer().getInventory().setItemInOffHand(new ItemStack(Material.AIR, 0));
        // You shouldn't be able to pick up that...
        sendAlert(
                "[DisplayGuard] Player "
                        + e.getPlayer().getName()
                        + " helded the displayItem, QuickShop already cancelled and removed it.");
        e.setCancelled(true);
        Util.inventoryCheck(e.getPlayer().getInventory());
    }
}
 

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void playerItemHeldEvent(PlayerItemHeldEvent event) {
    if (event.getPlayer() != player) {
        return;
    }

    if (!controls.containsKey(CONTROL.SCROLL)) {
        return;
    }

    event.setCancelled(true);

    if (debounce) {
        return;
    }

    // Cheat and assume the closest distance between previous and new slots is the direction scrolled
    int slotDistance = event.getPreviousSlot() - event.getNewSlot();

    if (slotDistance > 5 || (slotDistance < 0 && slotDistance >= -5)) {
        // Scrolled down
        if (selectedOption < options.size() - 1) {
            oldSelectedOption = selectedOption;
            selectedOption++;
            updateDisplay();
            debounce = true;
        }
    } else if (slotDistance != 0) {
        // Scrolled up
        if (selectedOption > 0) {
            oldSelectedOption = selectedOption;
            selectedOption--;
            updateDisplay();
            debounce = true;
        }
    }

}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerItemHoldEvent(final PlayerItemHeldEvent event) {
    final Player bukkitPlayer = event.getPlayer();
    if (bukkitPlayer.isSneaking()) {
        return;
    }
    FawePlayer<Object> fp = FawePlayer.wrap(bukkitPlayer);
    com.sk89q.worldedit.entity.Player player = fp.getPlayer();
    LocalSession session = fp.getSession();
    Tool tool = session.getTool(player);
    if (tool instanceof ScrollTool) {
        final int slot = event.getNewSlot();
        final int oldSlot = event.getPreviousSlot();
        final int ri;
        if ((((slot - oldSlot) <= 4) && ((slot - oldSlot) > 0)) || (((slot - oldSlot) < -4))) {
            ri = 1;
        } else {
            ri = -1;
        }
        ScrollTool scrollable = (ScrollTool) tool;
        if (scrollable.increment(player, ri)) {
            if (Settings.IMP.EXPERIMENTAL.PERSISTENT_BRUSHES) {
                bukkitPlayer.getInventory().setHeldItemSlot(oldSlot);
            } else {
                final PlayerInventory inv = bukkitPlayer.getInventory();
                final ItemStack item = inv.getItem(slot);
                final ItemStack newItem = inv.getItem(oldSlot);
                inv.setItem(slot, newItem);
                inv.setItem(oldSlot, item);
                bukkitPlayer.updateInventory();
            }
        }
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerHeldItem(PlayerItemHeldEvent e) {
    Player player = e.getPlayer();
    ItemStack oldItem = player.getInventory().getItem(e.getPreviousSlot());
    ItemStack newItem = player.getInventory().getItem(e.getNewSlot());

    if ((oldItem == null && newItem == null) || (oldItem != null && newItem != null && oldItem.getType() == newItem.getType())) {
        return;
    }

    Bukkit.getScheduler().runTask(plugin, () ->
            plugin.updateHoldingSelectionItem(plugin.getPlayerInfos(player)));
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onItemSwitch(PlayerItemHeldEvent event) {
	if (event.isCancelled())
		return;
	Player player = event.getPlayer();
	Bukkit.getScheduler().scheduleSyncDelayedTask(AdditionsAPI.getInstance(), () -> {
		sendDurabilityBossBar(player, player.getInventory().getItemInMainHand(), EquipmentSlot.HAND);
		sendDurabilityBossBar(player, player.getInventory().getItemInOffHand(), EquipmentSlot.OFF_HAND);
	});
}
 

@EventHandler(ignoreCancelled = true)
public void onSwap(PlayerItemHeldEvent event) {
    if (!main.configStore.actionStore.enabled)
        return;

    ActionStore.ActionType actionType = ActionStore.ActionType.SWAP;
    Player player = event.getPlayer();

    ItemStack itemStack = player.getInventory().getItem(event.getNewSlot());

    actionHelper.executeTriggers(actionType, player, itemStack);
}
 

@EventHandler(priority = EventPriority.MONITOR) 
public void OnItemHeldChange(PlayerItemHeldEvent event) {
	if (isPlayerInPlacementMode(event.getPlayer())) {
		removeFromPlacementMode(event.getPlayer(), true);
	}
}
 

@EventHandler
public void onItemHeldChange(PlayerItemHeldEvent itemHeldEvent) {
    checkSafety(itemHeldEvent);
}
 

@EventHandler
public void onItemHeldChange(PlayerItemHeldEvent itemHeldEvent) {
    checkSafety(itemHeldEvent);
}
 

@Override
public void onHold(PlayerItemHeldEvent event) {
	for (ItemComponent comp : this.components.values()) {
		comp.onHold(event);
	} 
}
 

@Override
public void onHold(PlayerItemHeldEvent event) {
}
 

@Override
public void onHold(PlayerItemHeldEvent event) {
}
 

@EventHandler
public void onPlayerMoveItemHand(PlayerItemHeldEvent e){
    if(!auth(e)) e.setCancelled(true);
}
 

@SuppressWarnings("unchecked")
@Override
public boolean setTime(final int time) {
	return super.setTime(time, getExpr(), PlayerItemHeldEvent.class, PlayerBucketFillEvent.class, PlayerBucketEmptyEvent.class);
}
 

@EventHandler(ignoreCancelled = true, priority = EventPriority.LOWEST)
public void onPlayerHeldItem(PlayerItemHeldEvent event) {
    if (listenerService.shouldCancelEvent(event)) {
        event.setCancelled(true);
    }
}
 

public abstract void onHold(PlayerItemHeldEvent event); 

public void onHold(PlayerItemHeldEvent event) {	}