@EventHandler(priority = EventPriority.MONITOR)
public void onGrenadeExplode(final ProjectileHitEvent event) {
  if (event.getEntity().getShooter() instanceof Player) {
    Grenade grenade = Grenade.get(event.getEntity());
    if (grenade != null) {
      event
          .getWorld()
          .createExplosion(
              event.getEntity(),
              event.getEntity().getLocation(),
              grenade.power,
              grenade.fire,
              grenade.destroy);
      event.getEntity().remove();
    }
  }
}
 

@EventHandler(ignoreCancelled = true)
public void onDamagePlayer(ProjectileHitEvent event) {
    if (event.getHitEntity() instanceof Player) {

        Player player = (Player) event.getHitEntity();
        Projectile projectile = event.getEntity();
        Region r = RedProtect.get().rm.getTopRegion(projectile.getLocation());

        double damage;
        if (getConfig().getString("projectile-damage").endsWith("%")) {
            damage = (player.getAttribute(Attribute.GENERIC_MAX_HEALTH).getBaseValue() / 100) * Double.valueOf(getConfig().getString("projectile-damage", "100%").replace("%", ""));
        } else {
            damage = getConfig().getInt("projectile-damage");
        }

        if (r != null && r.getFlagBool("killer-projectiles") && getConfig().getStringList("allowed-types").contains(projectile.getType().name())) {
            player.setHealth(damage);
        }
    }
}
 

@EventHandler
public void onHit(ProjectileHitEvent event) {
    Projectile projectile = event.getEntity();

    if (projectile instanceof Arrow) {
        projectile.remove();
    } else if (projectile instanceof Snowball && event.getEntity() instanceof Player) {
        ((Player) event.getEntity()).addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 20 * 2, 1));
    } else if (projectile instanceof Egg && projectile.getShooter() instanceof Player) {
        projectile.getWorld().createExplosion(projectile.getLocation(), 0.0F);

        for (Entity entity : projectile.getNearbyEntities(5, 5, 5)) {
            if (entity instanceof Player) {
                Player player = (Player) entity;
                if (plugin.getGameArena().isZombie(player)) {
                    player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, 20 * 5, 1));
                    player.addPotionEffect(new PotionEffect(PotionEffectType.CONFUSION, 20 * 5, 1));
                }
            }
        }
    }
}
 

@EventHandler
public void onHit(ProjectileHitEvent event) {
	if (!this.isAllowed()) return;

	Projectile arrow = event.getEntity();
	if (!(arrow instanceof Arrow)) return;

	if (!(arrow.getShooter() instanceof Player)) return;

	Player player = (Player) arrow.getShooter();
	if(!player.hasPermission("minetinker.modifiers.magical.use")) return;

	String customName = arrow.getCustomName();
	if (customName == null) return;

	String[] name = customName.split(":");
	if (name.length != 3) return;
	if (!name[0].equals(this.getKey())) return;

	try {
		//int modLevel = Integer.parseInt(name[1]);

		Entity entity = Bukkit.getServer().getEntity(UUID.fromString(name[2]));
		if (entity != null) {
			entity.remove();
		}

		arrow.remove();
	} catch (NumberFormatException ignored) {}
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onGrenadeExplode(final ProjectileHitEvent event) {
    if (event.getEntity().getShooter() instanceof Player) {
        Grenade grenade = Grenade.get(event.getEntity());
        if(grenade != null) {
            NMSHacks.createExplosion(event.getEntity(), event.getEntity().getLocation(), grenade.power, grenade.fire, grenade.destroy);
            event.getEntity().remove();
        }
    }
}
 

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onProjectileHit(ProjectileHitEvent event) {
    match.player(event.getActor()).ifPresent(shooter -> {
        final Projectile projectile = event.getEntity();
        projectile.removeMetadata(TRAIL_META, PGM.get());
        // Restore critical metadata to arrows if applicable
        if(projectile instanceof Arrow) {
            final Arrow arrow = (Arrow) projectile;
            if(arrow.hasMetadata(CRITICAL_META)) {
                arrow.setCritical(arrow.getMetadata(CRITICAL_META, PGM.get()).asBoolean());
            }
        }
    });
}
 

@EventHandler
public void onProjectileHitEvent(ProjectileHitEvent event) {
    final Projectile projectile = event.getEntity();
    final ProjectileDefinition projectileDefinition = Projectiles.getProjectileDefinition(projectile);
    if(projectileDefinition == null) return;

    final Filter filter = projectileDefinition.destroyFilter();
    if(filter == null) return;

    final BlockIterator blockIterator = new BlockIterator(projectile.getWorld(), projectile.getLocation().toVector(), projectile.getVelocity().normalize(), 0d, 2);
    Block hitBlock = null;
    while(blockIterator.hasNext()) {
        hitBlock = blockIterator.next();
        if(hitBlock.getType() != Material.AIR) break;
    }

    if(hitBlock != null) {
        final MatchPlayer shooter = projectile.getShooter() instanceof Player ? getMatch().getPlayer((Player) projectile.getShooter()) : null;
        final IQuery query = shooter != null ? new PlayerBlockEventQuery(shooter, event, hitBlock.getState())
                                             : new BlockEventQuery(event, hitBlock);

        if(filter.query(query).isAllowed()) {
            final BlockTransformEvent bte = new BlockTransformEvent(event, hitBlock, Material.AIR);
            match.callEvent(bte);

            if(!bte.isCancelled()) {
                hitBlock.setType(Material.AIR);
                projectile.remove();
            }
        }
    }
}
 

@EventHandler
public void onProjectileHit(ProjectileHitEvent e){
    if (e.getEntityType() != EntityType.EGG){
        return;
    }

    EntityType type = getRandomEntity();
    Location loc = e.getEntity().getLocation();
    loc.getWorld().spawnEntity(loc, type);
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onArrowHit(ProjectileHitEvent event) {
	if (event.getEntityType() != EntityType.ARROW && event.getEntityType() != EntityType.SPECTRAL_ARROW)
		return;
	if (ArrowFromCustomBowHit.containsArrow(event.getEntity())) {
		BowStackContainer container = ArrowFromCustomBowHit.getBowStackContainer(event.getEntity());
		Bukkit.getServer().getPluginManager()
				.callEvent(new ArrowFromCustomBowHitEvent(event, container.getOwner(), container.getBowStack()));
	}
}
 

@EventHandler
private void onChorusBreak(ProjectileHitEvent event) {
    if (!(event.getEntity().getShooter() instanceof Player)) return;

    if (event.getHitBlock() != null && event.getHitBlock().getType() == Material.CHORUS_FLOWER) {
        Player p = (Player) event.getEntity().getShooter();
        Region r = RedProtect.get().rm.getTopRegion(event.getHitBlock().getLocation());
        if (r != null && !r.canBuild(p)) {
            event.getEntity().remove();
            event.getHitBlock().setType(Material.AIR);
            Bukkit.getScheduler().runTask(RedProtect.get(), () -> event.getHitBlock().setType(Material.CHORUS_FLOWER));
            RedProtect.get().lang.sendMessage(p, "blocklistener.region.cantbreak");
        }
    }
}
 

@Override
public Block getHitBlock(ProjectileHitEvent event) {
	BlockIterator iterator = new BlockIterator(event.getEntity().getWorld(), event.getEntity().getLocation().toVector(), event.getEntity().getVelocity().normalize(), 0.0D, 4);
	Block hitBlock = null;
	while (iterator.hasNext()) {
		hitBlock = iterator.next();
		if (hitBlock.getType() != Material.AIR) {
			break;
		}
	}
	return hitBlock;
}
 

@Override
public Block getHitBlock(ProjectileHitEvent event) {
	BlockIterator iterator = new BlockIterator(event.getEntity().getWorld(), event.getEntity().getLocation().toVector(), event.getEntity().getVelocity().normalize(), 0.0D, 4);
	Block hitBlock = null;
	while (iterator.hasNext()) {
		hitBlock = iterator.next();
		if (hitBlock.getType() != Material.AIR) {
			break;
		}
	}
	return hitBlock;
}
 

@Override
public Block getHitBlock(ProjectileHitEvent event) {
	BlockIterator iterator = new BlockIterator(event.getEntity().getWorld(), event.getEntity().getLocation().toVector(), event.getEntity().getVelocity().normalize(), 0.0D, 4);
	Block hitBlock = null;
	while (iterator.hasNext()) {
		hitBlock = iterator.next();
		if (hitBlock.getType() != Material.AIR) {
			break;
		}
	}
	return hitBlock;
}
 

@Override
public Block getHitBlock(ProjectileHitEvent event) {
	BlockIterator iterator = new BlockIterator(event.getEntity().getWorld(), event.getEntity().getLocation().toVector(), event.getEntity().getVelocity().normalize(), 0.0D, 4);
	Block hitBlock = null;
	while (iterator.hasNext()) {
		hitBlock = iterator.next();
		if (hitBlock.getType() != Material.AIR) {
			break;
		}
	}
	return hitBlock;
}
 

@Override
public Block getHitBlock(ProjectileHitEvent event) {
	BlockIterator iterator = new BlockIterator(event.getEntity().getWorld(), event.getEntity().getLocation().toVector(), event.getEntity().getVelocity().normalize(), 0.0D, 4);
	Block hitBlock = null;
	while (iterator.hasNext()) {
		hitBlock = iterator.next();
		if (hitBlock.getType() != Material.AIR) {
			break;
		}
	}
	return hitBlock;
}
 

@Override
public Block getHitBlock(ProjectileHitEvent event) {
	BlockIterator iterator = new BlockIterator(event.getEntity().getWorld(), event.getEntity().getLocation().toVector(), event.getEntity().getVelocity().normalize(), 0.0D, 4);
	Block hitBlock = null;
	while (iterator.hasNext()) {
		hitBlock = iterator.next();
		if (hitBlock.getType() != Material.AIR) {
			break;
		}
	}
	return hitBlock;
}
 

@EventHandler(priority = EventPriority.NORMAL)
public void onProjectileHitEvent(ProjectileHitEvent event) {
	if (event.getEntity() instanceof Arrow) {
		ArrowFiredCache afc = CivCache.arrowsFired.get(event.getEntity().getUniqueId());
		if (afc != null) {
			afc.setHit(true);
		}
	}

	if (event.getEntity() instanceof Fireball) {
		CannonFiredCache cfc = CivCache.cannonBallsFired.get(event.getEntity().getUniqueId());
		if (cfc != null) {

			cfc.setHit(true);

			FireworkEffect fe = FireworkEffect.builder().withColor(Color.RED).withColor(Color.BLACK).flicker(true).with(Type.BURST).build();

			Random rand = new Random();
			int spread = 30;
			for (int i = 0; i < 15; i++) {
				int x = rand.nextInt(spread) - spread/2;
				int y = rand.nextInt(spread) - spread/2;
				int z = rand.nextInt(spread) - spread/2;


				Location loc = event.getEntity().getLocation();
				Location location = new Location(loc.getWorld(), loc.getX(),loc.getY(), loc.getZ());
				location.add(x, y, z);

				TaskMaster.syncTask(new FireWorkTask(fe, loc.getWorld(), loc, 5), rand.nextInt(30));
			}

		}
	}
}
 

@EventHandler
public void onArrowHit(ProjectileHitEvent e) {
    Slimefun.runSync(() -> {
        if (e.getEntity().isValid() && e.getEntity() instanceof Arrow) {
            projectiles.remove(e.getEntity().getUniqueId());
        }
    }, 4L);
}
 

@EventHandler
public void onArrowHitSurface(ProjectileHitEvent e) {
    if (!isEnabled()) {
        return;
    }

    Slimefun.runSync(() -> {
        if (e.getEntity() instanceof Arrow) {
            handleGrapplingHook((Arrow) e.getEntity());
        }
    }, 2L);
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void antiArrowSpam(ProjectileHitEvent event) {

    // Destroys the Arrows of the Minigun
    if (event.getEntityType().equals(EntityType.ARROW)) {
        Arrow arrow = (Arrow) event.getEntity();
        ProjectileSource shooter = arrow.getShooter();
        if (shooter instanceof Player)
            if (arrow.hasMetadata("ce.minigunarrow"))
                if (((Player) shooter).getGameMode().equals(GameMode.CREATIVE))
                    arrow.remove();
    }

}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void ProjectileHitEvent(ProjectileHitEvent e) {

    ProjectileSource shooter = e.getEntity().getShooter();

    if (shooter instanceof Player) {
        if (e.getEntity().hasMetadata("ce.projectile.item")) {
            CItem ci = Tools.getItemByOriginalname(e.getEntity().getMetadata("ce.projectile.item").get(0).asString());
            if (ci != null)
                ci.effect(e, (Player) shooter);
        }
    }
}
 

@EventHandler
private void projectileHit(ProjectileHitEvent event) {
	Projectile projectile = event.getEntity();
	if (projectile.hasMetadata("CustomItem-bow")) {
		Object[] data = (Object[]) projectile.getMetadata("CustomItem-bow").get(0).value();
		((CustomBow) data[0]).onProjectileHit(event, (DelayedPlayerDetails) data[1]);
	}
}
 

@Override
public void onProjectileHit(ProjectileHitEvent event, DelayedPlayerDetails details) {
	event.getEntity().remove();
	Block b = event.getEntity().getLocation().getBlock();
	if (b.isEmpty()) {
		b.setType(Material.TORCH);
	}
}
 

@EventHandler
public void onProjectileHitEvent(ProjectileHitEvent event) {
  Projectile projectile = event.getEntity();
  ProjectileDefinition projectileDefinition = getProjectileDefinition(projectile);
  if (projectileDefinition == null) return;
  Filter filter = projectileDefinition.destroyFilter;
  if (filter == null) return;

  BlockIterator it =
      new BlockIterator(
          projectile.getWorld(),
          projectile.getLocation().toVector(),
          projectile.getVelocity().normalize(),
          0d,
          2);

  Block hitBlock = null;
  while (it.hasNext()) {
    hitBlock = it.next();

    if (hitBlock.getType() != Material.AIR) {
      break;
    }
  }

  if (hitBlock != null) {
    MatchPlayer player =
        projectile.getShooter() instanceof Player
            ? match.getPlayer((Player) projectile.getShooter())
            : null;
    Query query =
        player != null
            ? new PlayerBlockQuery(event, player, hitBlock.getState())
            : new BlockQuery(event, hitBlock);

    if (filter.query(query).isAllowed()) {
      BlockTransformEvent bte = new BlockTransformEvent(event, hitBlock, Material.AIR);
      match.callEvent(bte);
      if (!bte.isCancelled()) {
        hitBlock.setType(Material.AIR);
        projectile.remove();
      }
    }
  }
}
 

/**
 * @return The original ProjectileHitEvent
 */
public ProjectileHitEvent getEvent() {
	return event;
}
 

public ArrowFromCustomBowHitEvent(ProjectileHitEvent event, LivingEntity shooter, CustomItemStack cBowStack) {
	super(cBowStack);
	this.projectileHitEvent = event;
	this.shooter = shooter;
}
 

/**
 * @return the projectileHitEvent
 */
public ProjectileHitEvent getProjectileHitEvent() {
	return projectileHitEvent;
}
 

/**
 * @param projectileHitEvent the projectileHitEvent to set
 */
public ArrowFromCustomBowHitEvent setProjectileHitEvent(ProjectileHitEvent projectileHitEvent) {
	this.projectileHitEvent = projectileHitEvent;
	return this;
}
 

public boolean denyEntLingPot(ProjectileHitEvent e, World world) {
    return false;
}
 

public Entity getEntLingPot(ProjectileHitEvent e) {
    return e.getEntity();
}