@EventHandler
public void onTNTSheepInteractOtherUser(PlayerInteractEntityEvent event) {
    Player player = event.getPlayer();
    if (Main.isPlayerInGame(player)) {
        GamePlayer gamePlayer = Main.getPlayerGameProfile(player);
        Game game = gamePlayer.getGame();

        Entity rightClicked = event.getRightClicked();
        Entity vehicle = rightClicked.getVehicle();
        List<SpecialItem> sheeps = game.getActivedSpecialItems(TNTSheep.class);
        for (SpecialItem item : sheeps) {
            if (item instanceof TNTSheep) {
                TNTSheep sheep = (TNTSheep) item;
                if (sheep.getEntity().equals(rightClicked) || sheep.getEntity().equals(vehicle)) {
                    event.setCancelled(true);
                    return;
                }
            }
        }
    }
}
 

@EventHandler
public void onTNTSheepInteractOtherUser(PlayerInteractEntityEvent event) {
    Player player = event.getPlayer();
    if (Main.isPlayerInGame(player)) {
        GamePlayer gamePlayer = Main.getPlayerGameProfile(player);
        Game game = gamePlayer.getGame();

        Entity rightClicked = event.getRightClicked();
        Entity vehicle = rightClicked.getVehicle();
        List<SpecialItem> sheeps = game.getActivedSpecialItems(TNTSheep.class);
        for (SpecialItem item : sheeps) {
            if (item instanceof TNTSheep) {
                TNTSheep sheep = (TNTSheep) item;
                if (sheep.getEntity().equals(rightClicked) || sheep.getEntity().equals(vehicle)) {
                    event.setCancelled(true);
                    return;
                }
            }
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void checkItemFrameRotate(PlayerInteractEntityEvent event) {
    if(event.getRightClicked() instanceof ItemFrame) {
        ItemFrame itemFrame = (ItemFrame) event.getRightClicked();
        if(itemFrame.getItem() != null) {
            // If frame contains an item, right-click will rotate it, which is handled as a "use" event
            this.handleUse(event, getHangingBlockState(itemFrame), this.match.getParticipant(event.getPlayer()));
        } else if(event.getPlayer().getItemInHand() != null) {
            // If the frame is empty and it's right clicked with an item, this will place the item in the frame,
            // which is handled as a "place" event, with the placed item as the block material
            BlockState blockState = BlockStateUtils.cloneWithMaterial(itemFrame.getLocation().getBlock(),
                                                                      event.getPlayer().getItemInHand().getData());
            this.handleHangingPlace(event, blockState, event.getPlayer());
        }
    }
}
 

@EventHandler
public void onStickInteract(PlayerInteractEntityEvent event){
    Player player = event.getPlayer();
    Entity entity = event.getRightClicked();
    if(!(entity instanceof Mob)){
        return;
    }
    if(event.getHand() != EquipmentSlot.HAND) {
        return;
    }
    if (sm.getStickTools().isStackingStick(player.getInventory().getItemInMainHand())) {
        if (player.isSneaking()) {
            sm.getStickTools().toggleMode(player);
        } else {
            if(!(StackTools.hasValidMetadata(player, GlobalValues.STICK_MODE))){
                player.setMetadata(GlobalValues.STICK_MODE, new FixedMetadataValue(sm, 1));
            }
            sm.getStickTools().performAction(player, entity);
        }
    }
}
 

@EventHandler(priority = HIGHEST, ignoreCancelled = true)
public void onPlayerInteractItemFrame(PlayerInteractEntityEvent ev) {
    if (!(ev.getRightClicked() instanceof ItemFrame)) return;
    ItemFrame f = (ItemFrame) ev.getRightClicked();
    if (f.getItem() == null || f.getItem().getType() == Material.AIR) return;
    ExhibitionFrame fr = ExhibitionFrame.fromItemFrame(f);
    if (fr.isSet()) {
        new Message(I18n.format("user.exhibition.looking_at")).append(fr.getItemInFrame()).send(ev.getPlayer());
        ev.getPlayer().sendMessage(I18n.format("user.exhibition.provided_by", fr.getOwnerName()));
        for (String line : fr.getDescriptions()) {
            ev.getPlayer().sendMessage(line);
        }
        ev.setCancelled(true);
        if (fr.hasItem() && fr.getItemInFrame().getType() == Material.WRITTEN_BOOK) {
            ev.getPlayer().openBook(fr.getItemInFrame());
        }
    }
}
 

@EventHandler
public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
    Player p = event.getPlayer();
    Entity e = event.getRightClicked();
    if (p.getItemInHand() != null && p.getItemInHand().isSimilar(SelectorLayout.getSelectorItem())) {
        SelectorLayout.getSelectorMenu().showTo(p);
        event.setCancelled(true);
        return;
    }

    if (ReflectionUtil.getEntityHandle(e) instanceof IEntityPet) {
        IPet pet = ((IEntityPet) ReflectionUtil.getEntityHandle(e)).getPet();
        event.setCancelled(true);
        PetInteractEvent iEvent = new PetInteractEvent(pet, p, PetInteractEvent.Action.RIGHT_CLICK, false);
        EchoPet.getPlugin().getServer().getPluginManager().callEvent(iEvent);
        if (!iEvent.isCancelled()) {
            pet.getEntityPet().onInteract(p);
            return;
        }
    }
}
 

@EventHandler
public void onInteractEntity(PlayerInteractEntityEvent iee) {
  Player p = iee.getPlayer();
  Game g = BedwarsRel.getInstance().getGameManager().getGameOfPlayer(p);
  if (g == null) {
    return;
  }

  if (g.getState() == GameState.WAITING) {
    iee.setCancelled(true);
    return;
  }

  if (g.getState() == GameState.RUNNING) {
    this.inGameInteractEntity(iee, g, p);
  }
}
 

@EventHandler(ignoreCancelled = true)
public void onInteractEvent(PlayerInteractEntityEvent e) {
    RedProtect.get().logger.debug(LogLevel.ENTITY, "EntityListener - Is PlayerInteractEntityEvent");

    Player p = e.getPlayer();
    if (p == null) {
        return;
    }
    Location l = e.getRightClicked().getLocation();
    Region r = RedProtect.get().rm.getTopRegion(l);
    Entity et = e.getRightClicked();
    if (r != null && !r.canInteractPassives(p) && (et instanceof Animals || et instanceof Villager || et instanceof Golem || (et instanceof WaterMob && !r.canFish(p)))) {
        if (et instanceof Tameable) {
            Tameable tam = (Tameable) et;
            if (tam.isTamed() && tam.getOwner() != null && tam.getOwner().getName().equals(p.getName())) {
                return;
            }
        }
        e.setCancelled(true);
        RedProtect.get().lang.sendMessage(p, "entitylistener.region.cantinteract");
    }
}
 

@EventHandler(ignoreCancelled = true)
public void onItemFrameClick(final PlayerInteractEntityEvent event) {
    if (event.getPlayer().getGameMode() == GameMode.CREATIVE) {
        return;
    }
    // this prevents the journal from being placed inside of item frame
    if (event.getRightClicked() instanceof ItemFrame) {
        ItemStack item = null;
        item = (event.getHand() == EquipmentSlot.HAND) ? event.getPlayer().getInventory().getItemInMainHand()
                : event.getPlayer().getInventory().getItemInOffHand();

        final String playerID = PlayerConverter.getID(event.getPlayer());
        if (Journal.isJournal(playerID, item) || Utils.isQuestItem(item)) {
            event.setCancelled(true);
        }
    }
}
 

private PlayerInteractEntityEvent callIronGolemEvent(EquipmentSlot hand, ItemStack itemInHand) {
    // Fake Player with an Iron Ingot
    Player player = server.addPlayer();

    if (hand == EquipmentSlot.HAND) {
        player.getInventory().setItemInMainHand(itemInHand);
    }
    else {
        player.getInventory().setItemInOffHand(itemInHand);
    }

    // Fake Iron Golem
    IronGolem golem = Mockito.mock(IronGolem.class);
    Mockito.when(golem.getType()).thenReturn(EntityType.IRON_GOLEM);

    // Fake Event
    PlayerInteractEntityEvent event = new PlayerInteractEntityEvent(player, golem, hand);
    listener.onIronGolemHeal(event);
    return event;
}
 

@EventHandler
public void onPlayerInteractEntity(PlayerInteractEntityEvent event)
{
	if((!MCVersion.isDualWieldingMC() || event.getHand().equals(EquipmentSlot.HAND)) && event.getPlayer().isSneaking() && event.getPlayer().hasPermission(Permissions.KISS) && event.getRightClicked() instanceof Player)
	{
		MarriagePlayer player = getMarriagePlugin().getPlayerData(event.getPlayer());
		Long time = wait.get(player);
		if(time == null || time < System.currentTimeMillis() - waitTime)
		{
			MarriagePlayer player2 = getMarriagePlugin().getPlayerData((Player) event.getRightClicked());
			if(player.isPartner(player2) && getMarriagePlugin().isInRangeSquared(event.getPlayer(), (Player) event.getRightClicked(), interactRange))
			{
				kiss(player, player2);
			}
		}
	}
}
 

@EventHandler
public void onVillagerInteract(PlayerInteractEntityEvent event) {
    if (Main.isPlayerInGame(event.getPlayer())) {
        GamePlayer gPlayer = Main.getPlayerGameProfile(event.getPlayer());
        Game game = gPlayer.getGame();
        if (event.getRightClicked().getType().isAlive() && !gPlayer.isSpectator
                && gPlayer.getGame().getStatus() == GameStatus.RUNNING) {
            for (GameStore store : game.getGameStores()) {
                if (store.getEntity().equals(event.getRightClicked())) {
                    event.setCancelled(true);

                    BedwarsOpenShopEvent openShopEvent = new BedwarsOpenShopEvent(gPlayer.getGame(),
                            event.getPlayer(), store, event.getRightClicked());
                    Main.getInstance().getServer().getPluginManager().callEvent(openShopEvent);

                    if (openShopEvent.getResult() != Result.ALLOW) {
                        return;
                    }

                    Main.openStore(event.getPlayer(), store);
                    return;
                }
            }

        }
    }
}
 

@EventHandler
public void handleRightClick(PlayerInteractEntityEvent event) {
    if ((event.getRightClicked() instanceof Villager)) {
        event.setCancelled(true);
        event.getPlayer().openMerchantCopy((Villager)event.getRightClicked());
    }
}
 

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

@EventHandler(priority = EventPriority.LOW)
public void onPlayerInteractEvent(PlayerInteractEntityEvent event) {
    if (event.getHand().equals(EquipmentSlot.HAND) && event.getPlayer().hasPermission("cardinal.punish.freeze") && event.getRightClicked() instanceof Player) {
        ItemStack item = event.getPlayer().getInventory().getItem(event.getHand());
        if (item != null && item.getType() == Material.ICE
                && item.getItemMeta() != null && item.getItemMeta().getDisplayName() != null
                && item.getItemMeta().getDisplayName().equals(ChatColor.AQUA + ChatConstant.UI_FREEZE_ITEM.getMessage(event.getPlayer().getLocale()))) {
            event.setCancelled(true);
            togglePlayerFreeze((Player) event.getRightClicked(), event.getPlayer());
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void rightClickDefuse(final PlayerInteractEntityEvent event) {
  ItemStack hand = event.getPlayer().getItemInHand();
  if (hand == null || hand.getType() != DEFUSE_ITEM) return;

  this.participantDefuse(event.getPlayer(), event.getRightClicked());
}
 

@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = false)
void onEntityInteract(PlayerInteractEntityEvent event) {
	if (!(event.getRightClicked() instanceof LivingEntity)) return;
	LivingEntity shopEntity = (LivingEntity) event.getRightClicked();
	Player player = event.getPlayer();
	String playerName = player.getName();
	Log.debug("Player " + playerName + " is interacting with entity at " + shopEntity.getLocation());
	Shopkeeper shopkeeper = plugin.getShopkeeperByEntity(shopEntity); // also check for citizens npc shopkeepers

	if (event.isCancelled() && !Settings.bypassShopInteractionBlocking) {
		Log.debug("  Cancelled by another plugin");
	} else if (shopkeeper != null) {
		// only trigger shopkeeper interaction for main-hand events:
		if (NMSManager.getProvider().isMainHandInteraction(event)) {
			shopkeeper.onPlayerInteraction(player);
		}

		// if citizens npc: don't cancel the event, let Citizens perform other actions as appropriate
		if (shopkeeper.getShopObject().getObjectType() != DefaultShopObjectTypes.CITIZEN()) {
			// always cancel interactions with shopkeepers, to prevent any default behavior:
			event.setCancelled(true);

			// update inventory in case interaction would trigger feeding normally:
			player.updateInventory();
		}
	} else {
		Log.debug("  Non-shopkeeper");
	}
}
 

@EventHandler
public void onVillagerInteract(PlayerInteractEntityEvent event) {
    if (Main.isPlayerInGame(event.getPlayer())) {
        GamePlayer gPlayer = Main.getPlayerGameProfile(event.getPlayer());
        Game game = gPlayer.getGame();
        if (event.getRightClicked().getType().isAlive() && !gPlayer.isSpectator
                && gPlayer.getGame().getStatus() == GameStatus.RUNNING) {
            for (GameStore store : game.getGameStores()) {
                if (store.getEntity().equals(event.getRightClicked())) {
                    event.setCancelled(true);

                    BedwarsOpenShopEvent openShopEvent = new BedwarsOpenShopEvent(gPlayer.getGame(),
                            event.getPlayer(), store, event.getRightClicked());
                    Main.getInstance().getServer().getPluginManager().callEvent(openShopEvent);

                    if (openShopEvent.getResult() != Result.ALLOW) {
                        return;
                    }

                    Main.openStore(event.getPlayer(), store);
                    return;
                }
            }

        }
    }
}
 

@EventHandler
private void playerInteractEntity(PlayerInteractEntityEvent event) {
	Player player = event.getPlayer();
	ItemStack item = player.getInventory().getItemInMainHand();
	CustomItem customItem = CustomItemManager.getCustomItem(item);

	if (customItem != null) {
		if (verifyCustomItem(customItem, event.getPlayer(), false)) {
			event.setCancelled(true);
			customItem.onInteractEntity(event, new PlayerDetails(item, event.getPlayer()));
		}
	}
}
 

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

    getMatch().callEvent(new ObserverInteractEvent(player,
                                                   convertClick(ClickType.RIGHT, event.getPlayer()),
                                                   null,
                                                   event.getRightClicked(),
                                                   event.getPlayer().getInventory().getItem(event.getHand())));
}
 

@ListenerScope(MatchScope.LOADED)
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void processItemRemoval(PlayerInteractEntityEvent event) {
    if(event.getRightClicked() instanceof Villager) {
        event.setCancelled(true);
        event.getPlayer().openMerchantCopy((Villager) event.getRightClicked());
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void rightClickDefuse(final PlayerInteractEntityEvent event) {
    ItemStack hand = event.getPlayer().getItemInHand();
    if(hand == null || hand.getType() != DEFUSE_ITEM) return;

    this.participantDefuse(event.getPlayer(), event.getRightClicked());
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
void onEntityInteract(PlayerInteractEntityEvent event) {
	if (!(event.getRightClicked() instanceof Villager)) return;
	Villager villager = (Villager) event.getRightClicked();

	if (plugin.isShopkeeper(villager)) return; // shopkeeper interaction is handled elsewhere
	Log.debug("Interaction with Non-shopkeeper villager ..");

	if (villager.hasMetadata("NPC")) {
		// ignore any interaction with citizens2 NPCs
		Log.debug("  ignoring (probably citizens2) NPC");
		return;
	}

	if (Settings.disableOtherVillagers) {
		// don't allow trading with other villagers
		event.setCancelled(true);
		Log.debug("  trade prevented");
	}

	// only trigger hiring for main-hand events:
	if (!NMSManager.getProvider().isMainHandInteraction(event)) return;

	if (Settings.hireOtherVillagers) {
		Player player = event.getPlayer();
		// allow hiring of other villagers
		Log.debug("  possible hire ..");
		if (this.handleHireOtherVillager(player, villager)) {
			// hiring was successful -> prevent normal trading
			Log.debug("    ..success (normal trading prevented)");
			event.setCancelled(true);
		} else {
			// hiring was not successful -> no preventing of normal villager trading
			Log.debug("    ..failed");
		}
	}
}
 

@Override
public boolean init(final Expression<?>[] exprs, final int matchedPattern, final Kleenean isDelayed, final ParseResult parseResult) {
	clickable = ClickableType.getClickable(parseResult.mark);
	switch (clickable) {
		case BLOCK_AND_ITEMS:
			final Object type = exprs[0] == null ? null : ((Literal<?>) exprs[0]).getSingle();
			if (type instanceof EntityData) {
				entityType = (EntityData<?>) type;
				if (!ScriptLoader.isCurrentEvent(PlayerInteractEntityEvent.class) && !ScriptLoader.isCurrentEvent(PlayerInteractAtEntityEvent.class)) {
					Skript.error("The expression 'clicked entity' may only be used in a click event", ErrorQuality.SEMANTIC_ERROR);
					return false;
				}
			} else {
				itemType = (ItemType) type;
				if (!ScriptLoader.isCurrentEvent(PlayerInteractEvent.class)) {
					Skript.error("The expression 'clicked block' may only be used in a click event", ErrorQuality.SEMANTIC_ERROR);
					return false;
				}
			}
			break;
		case INVENTORY:
		case ACTION:
		case TYPE:
		case SLOT:
			if (!ScriptLoader.isCurrentEvent(InventoryClickEvent.class)) {
				Skript.error("The expression '" + clickable.getName() + "' may only be used in an inventory click event", ErrorQuality.SEMANTIC_ERROR);
				return false;
			}
			break;
	}
	return true;
}
 

@EventHandler
public void on(PlayerInteractEntityEvent event) {
	if (event.getRightClicked().getType() == EntityType.ITEM_FRAME) {
		Callback<PlayerInteractEntityEvent> callback;
		while ((callback = entityInteractMap.remove(event.getPlayer().getUniqueId())) != null)
			callback.call(event);
	}
}
 

public void listenForEntityInteract(Player player, Callback<PlayerInteractEntityEvent> callback) {
	if (callback == null) { return; }
	if (player != null) {
		entityInteractMap.put(player.getUniqueId(), callback);
	} else {
		callback.call(null);
	}
}
 

@EventHandler(priority= EventPriority.HIGH, ignoreCancelled=true)
public void onInteract(PlayerInteractEntityEvent e) {
    FileConfiguration config = this.expansion.getConfig("cheat-prevention.yml");
    if(!config.getBoolean("prevent-entity-interaction")) return;

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

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

@EventHandler(priority = EventPriority.HIGHEST)
public void onInteractOtherUser(PlayerInteractEntityEvent event) {
  if (event.getPlayer() == null) {
    return;
  }

  Player player = event.getPlayer();
  Game game = BedwarsRel.getInstance().getGameManager().getGameOfPlayer(player);

  if (game == null) {
    return;
  }

  if (game.getState() != GameState.RUNNING) {
    return;
  }

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

  if (event.getRightClicked() instanceof ITNTSheep) {
    event.setCancelled(true);
    return;
  }

  if (event.getRightClicked().getVehicle() != null
      && event.getRightClicked().getVehicle() instanceof ITNTSheep) {
    event.setCancelled(true);
    return;
  }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerInteractEntityEvent(PlayerInteractEntityEvent event) {
	if (shouldHandleEvent(event)) {
		Tameable tameable = (Tameable) event.getRightClicked();
		AnimalTamer currentOwner = tameable.getOwner();
		if (currentOwner == null || currentOwner.getName() == null) {
			return;
		}
		// Has the player clicked on one of his own pets?
		Player player = event.getPlayer();
		boolean isOwner = player.getUniqueId().equals(currentOwner.getUniqueId());
		// Retrieve new owner from the map and delete corresponding entry.
		Player newOwner = plugin.getSetOwnerCommand().collectPendingSetOwnershipRequest(player);
		// Has the player requested to free one of his pets?
		boolean freePet = plugin.getFreeCommand().collectPendingFreeRequest(player);

		// Cannot change ownership or free pet if not owner and no bypass permission.
		if ((newOwner != null || freePet) && !isOwner && !player.hasPermission("petmaster.admin")) {
			player.sendMessage(plugin.getChatHeader() + plugin.getPluginLang()
					.getString("not-owner", "You do not own this pet!").replace("PLAYER", player.getName()));
			return;
		}

		if (newOwner != null) {
			changeOwner(player, currentOwner, newOwner, tameable);
		} else if (freePet) {
			freePet(player, currentOwner, tameable);
		} else if ((displayToOwner || !isOwner) && player.hasPermission("petmaster.showowner")) {
			displayHologramAndMessage(player, currentOwner, tameable);
		}
	}
}
 

@EventHandler(priority = EventPriority.HIGH)
public void onPlayerClickPlayer(PlayerInteractEntityEvent event) {
	if(ConfigManager.getServerVersion().isNewerThan(ConfigManager.ServerVersion.MINECRAFT_1_8_R3) && event.getHand() == EquipmentSlot.OFF_HAND) {
		return;
	}

	Player player = event.getPlayer();
	if((event.getRightClicked() instanceof Player) && player.isSneaking()) {
		if(Permission.NOVAGUILDS_PLAYERINFO.has(player)) {
			NovaPlayer nCPlayer = PlayerManager.getPlayer(event.getRightClicked());
			plugin.getPlayerManager().sendPlayerInfo(player, nCPlayer);
		}
	}
}