@EventHandler
public void onExplode(EntityExplodeEvent event) {
    if (event.isCancelled()) {
        return;
    }

    final String explosionExceptionTypeName = Main.getConfigurator().config.getString("destroy-placed-blocks-by-explosion-except", null);
    final boolean destroyPlacedBlocksByExplosion = Main.getConfigurator().config.getBoolean("destroy-placed-blocks-by-explosion", true);

    for (String gameName : Main.getGameNames()) {
        Game game = Main.getGame(gameName);
        if (game.getStatus() == GameStatus.RUNNING || game.getStatus() == GameStatus.GAME_END_CELEBRATING) {
            if (GameCreator.isInArea(event.getLocation(), game.getPos1(), game.getPos2())) {
                if (destroyPlacedBlocksByExplosion) {
                    event.blockList().removeIf(block -> (explosionExceptionTypeName != null && !explosionExceptionTypeName.equals("") && block.getType().name().contains(explosionExceptionTypeName)) || !game.isBlockAddedDuringGame(block.getLocation()));
                } else {
                    event.blockList().clear();
                }
            }
        }
    }

}
 

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

    for (int i = 0, a = e.blockList().size(); i < a; i++) {
        final Block b = e.blockList().get(i);
        final Shop shop = getShopNature(b.getLocation(), true);

        if (shop == null) {
            continue;
        }
        if (plugin.getConfig().getBoolean("protect.explode")) {
            e.setCancelled(true);
        } else {
            plugin.log("Deleting shop "+shop+" request by block break (explode).");
            shop.delete();
        }
    }
}
 

@EventHandler
public void onExplode(EntityExplodeEvent event) {
    if (event.isCancelled()) {
        return;
    }

    final String explosionExceptionTypeName = Main.getConfigurator().config.getString("destroy-placed-blocks-by-explosion-except", null);
    final boolean destroyPlacedBlocksByExplosion = Main.getConfigurator().config.getBoolean("destroy-placed-blocks-by-explosion", true);

    for (String gameName : Main.getGameNames()) {
        Game game = Main.getGame(gameName);
        if (game.getStatus() == GameStatus.RUNNING || game.getStatus() == GameStatus.GAME_END_CELEBRATING) {
            if (GameCreator.isInArea(event.getLocation(), game.getPos1(), game.getPos2())) {
                if (destroyPlacedBlocksByExplosion) {
                    event.blockList().removeIf(block -> (explosionExceptionTypeName != null && !explosionExceptionTypeName.equals("") && block.getType().name().contains(explosionExceptionTypeName)) || !game.isBlockAddedDuringGame(block.getLocation()));
                } else {
                    event.blockList().clear();
                }
            }
        }
    }

}
 

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

    LWC lwc = LWC.getInstance();

    for (Block block : event.blockList()) {
        Protection protection = plugin.getLWC().findProtection(block.getLocation());

        if (protection != null) {
            boolean ignoreExplosions = Boolean
                    .parseBoolean(lwc.resolveProtectionConfiguration(protection.getBlock(), "ignoreExplosions"));

            if (!(ignoreExplosions || protection.hasFlag(Flag.Type.ALLOWEXPLOSIONS))) {
                event.setCancelled(true);
            }
        }
    }
}
 

/**
 * This handler only checks to see if the event should be cancelled. It does not change the
 * state of any Destroyables.
 */
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void testBlockChange(BlockTransformEvent event) {
    if(this.match.getWorld() != event.getWorld() || !this.anyDestroyableAffected(event)) {
        return;
    }

    // This is a temp fix until there is a tracker for placed minecarts (only dispensed are tracked right now)
    if((event.getCause() instanceof EntityExplodeEvent &&
       ((EntityExplodeEvent) event.getCause()).getEntity() instanceof ExplosiveMinecart) ||
       event.getCause() instanceof BlockPistonExtendEvent ||
       event.getCause() instanceof BlockPistonRetractEvent) {

        event.setCancelled(true);
        return;
    }

    for(Destroyable destroyable : this.destroyables) {
        String reasonKey = destroyable.testBlockChange(event.getOldState(), event.getNewState(), ParticipantBlockTransformEvent.getPlayerState(event));
        if(reasonKey != null) {
            event.setCancelled(true, new TranslatableComponent(reasonKey));
            return;
        }
    }
}
 

private void explodeInRegion(boolean throwException, Location regionLocation) throws SuccessException {
    RegionsTests.loadRegionTypeCobble();
    HashMap<UUID, String> people = new HashMap<>();
    people.put(TestUtil.player.getUniqueId(), Constants.OWNER);
    HashMap<String, String> effects = new HashMap<>();
    Region region = new Region("cobble", people,
            regionLocation,
            RegionsTests.getRadii(),
            effects,0);
    RegionManager.getInstance().addRegion(region);
    TNTPrimed tntPrimed = mock(TNTPrimed.class);
    ArrayList<Block> blockList = new ArrayList<>();
    if (throwException) {
        when(Bukkit.getServer().getScheduler()).thenThrow(new SuccessException());
    }
    EntityExplodeEvent event = new EntityExplodeEvent(tntPrimed,
            regionLocation.add(0, 1,0),
            blockList,
            (float) 2);
    if (throwException) {
        ProtectionHandler protectionHandler = new ProtectionHandler();
        protectionHandler.onEntityExplode(event);
    }
}
 

private static void cancelExplosionEvent(boolean hardCancel, @Nonnull EntityExplodeEvent e) {
    if (hardCancel) {
        // This explosion event occurred within a claimed chunk.
        e.setYield(0);
        e.setCancelled(true);
    } else {
        // This explosion occurred outside of a claimed chunk but it might
        // interfere with claimed blocks.
        final ChunkHandler CHUNK_HANDLER = ClaimChunk.getInstance().getChunkHandler();

        // Remove all of the blocks within claimed chunks from this event
        // so they are not destroyed.
        // Unfortunately, there is no way to remove specific entities from
        // the damage list, so entities will not be protected from
        // explosions by this method.
        e.blockList().removeIf(block -> CHUNK_HANDLER.isClaimed(block.getChunk()));
    }
}
 

/**
 * Prevent the Nether spawn from being blown up
 * 
 * @param e - event
 */
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onExplosion(final EntityExplodeEvent e) {
    if (Settings.newNether) {
        // Not used in the new nether
        return;
    }
    // Find out what is exploding
    Entity expl = e.getEntity();
    if (expl == null) {
        return;
    }
    // Check world
    if (!e.getEntity().getWorld().getName().equalsIgnoreCase(Settings.worldName + "_nether")
            || e.getEntity().getWorld().getName().equalsIgnoreCase(Settings.worldName + "_the_end")) {
        return;
    }
    Location spawn = e.getLocation().getWorld().getSpawnLocation();
    Location loc = e.getLocation();
    if (spawn.distance(loc) < Settings.netherSpawnRadius) {
        e.blockList().clear();
    }
}
 

@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void MobExplosion(final EntityExplodeEvent e) {
    if (DEBUG) {
        plugin.getLogger().info(e.getEventName());
    }
    // Only cover in the island world
    if (e.getEntity() == null || !IslandGuard.inWorld(e.getEntity())) {
        return;
    }
    if (mobSpawnInfo.containsKey(e.getEntity())) {
        // We know about this mob
        if (DEBUG) {
            plugin.getLogger().info("DEBUG: We know about this mob");
        }
        if (!mobSpawnInfo.get(e.getEntity()).inIslandSpace(e.getLocation())) {
            // Cancel the explosion and block damage
            if (DEBUG) {
                plugin.getLogger().info("DEBUG: cancel flying mob explosion");
            }
            e.blockList().clear();
            e.setCancelled(true);
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void onEntityExplode(EntityExplodeEvent event) {
    IEntity entity = plugin.wrapEntity(event.getEntity());
    if (manager.isPlotWorld(entity)) {
        PlotMapInfo pmi = manager.getMap(entity.getLocation());

        if (pmi != null && pmi.isDisableExplosion()) {
            event.setCancelled(true);
        } else {
            PlotId id = manager.getPlotId(entity.getLocation());
            if (id == null) {
                event.setCancelled(true);
            }
        }
    }
}
 

@EventHandler(ignoreCancelled = true)
public void onEntityExplode(EntityExplodeEvent event) {
    if (event == null || ChunkManager.getInstance().getDisabledWorlds().contains(event.getLocation().getWorld().getName())) {
        return; // do not do anything in case explosions get cancelled
    }

    final Entity detonator = event.getEntity();
    if (detonator == null || detonator.hasMetadata("ObbyEntity")) {
        return;
    }
    if (event.getLocation().getBlock().hasMetadata("ObbyEntity")) {
        return;
    }
    if (event.getYield() <= 0.51) {
        return;
    }

    ChunkManager.getInstance().handleExplosion(event);
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onEntityExplode(EntityExplodeEvent event) {
    if (!event.isCancelled()) {
        Player player = TntTracker.getWhoPlaced(event.getEntity()) != null && Bukkit.getOfflinePlayer(TntTracker.getWhoPlaced(event.getEntity())).isOnline() ? Bukkit.getPlayer(TntTracker.getWhoPlaced(event.getEntity())) : null;
        if (player != null) {
            List<Block> toRemove = new ArrayList<>();
            for (Block block : event.blockList()) {
                if (filter == null || filter.evaluate(player, block, event).equals(FilterState.ALLOW)) {
                    if (region == null || region.contains(block.getLocation().toVector().add(new Vector(0.5, 0.5, 0.5)))) {
                        for (ItemStack drop : this.drops) {
                            GameHandler.getGameHandler().getMatchWorld().dropItemNaturally(block.getLocation(), drop);
                        }
                        if (this.experience != 0) {
                            ExperienceOrb xp = GameHandler.getGameHandler().getMatchWorld().spawn(block.getLocation(), ExperienceOrb.class);
                            xp.setExperience(this.experience);
                        }
                        toRemove.add(block);
                        block.setType(replaceType);
                        block.setData((byte) replaceDamage);
                    }
                }
            }
            event.blockList().removeAll(toRemove);
        }
    }
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onEntityExplode(EntityExplodeEvent event) {
    if (event.isCancelled() || GameHandler.getGameHandler().getMatch().getModules().getModule(TitleRespawn.class).isDeadUUID(event.getEntity().getUniqueId())) return;
    for (Block block : event.blockList()) {
        for (Player player : Bukkit.getOnlinePlayers()) {
            Location location = block.getLocation();
            location.setY(location.getY() + 1);
            Location playerLoc = player.getLocation();
            if (playerLoc.getBlockX() == location.getBlockX() && playerLoc.getBlockY() == location.getBlockY() && playerLoc.getBlockZ() == location.getBlockZ()) {
                Description description = null;
                if (player.getLocation().add(new Vector(0, 1, 0)).getBlock().getType().equals(Material.LADDER)) {
                    description = Description.OFF_A_LADDER;
                } else if (player.getLocation().add(new Vector(0, 1, 0)).getBlock().getType().equals(Material.VINE)) {
                    description = Description.OFF_A_VINE;
                } else if (player.getLocation().getBlock().getType().equals(Material.WATER) || player.getLocation().getBlock().getType().equals(Material.STATIONARY_WATER)) {
                    description = Description.OUT_OF_THE_WATER;
                } else if (player.getLocation().getBlock().getType().equals(Material.LAVA) || player.getLocation().getBlock().getType().equals(Material.STATIONARY_LAVA)) {
                    description = Description.OUT_OF_THE_LAVA;
                }
                OfflinePlayer damager = (TntTracker.getWhoPlaced(event.getEntity()) != null ? Bukkit.getOfflinePlayer(TntTracker.getWhoPlaced(event.getEntity())) : null);
                Bukkit.getServer().getPluginManager().callEvent(new TrackerDamageEvent(player, damager, damager != null && damager.getPlayer() != null ? ((Player) damager).getInventory().getItemInMainHand() : new ItemStack(Material.AIR), Cause.TNT, description, Type.SPLEEFED));
            }
        }
    }
}
 

public ControllableEnderDragonBase(int id, EntityManager manager) {
    super(id, ControllableEntityType.ENDERDRAGON, manager);
    Bukkit.getPluginManager().registerEvents(new Listener() {

        @EventHandler
        public void onEntityExplode(EntityExplodeEvent event) {
            if (!shouldDestroyBlocks()) {
                Entity entity = event.getEntity();
                if (entity instanceof EnderDragon && entity.equals(getBukkitEntity())) {
                    event.setCancelled(true);
                } else if (entity instanceof ComplexEntityPart && ((ComplexEntityPart) entity).getParent().equals(getBukkitEntity())) {
                    event.setCancelled(true);
                }
            }
        }

    }, EntityAPI.getCore());
}
 

@EventHandler
public void onEntityExplode(EntityExplodeEvent event) {
    try {
        final Entity entity = event.getEntity();
        final Location location = entity.getLocation();
        final IslandManager islandManager = IridiumSkyblock.getIslandManager();
        if (!islandManager.isIslandWorld(location)) return;

        if (!IridiumSkyblock.getConfiguration().allowExplosions)
            event.setCancelled(true);
    } catch (Exception ex) {
        IridiumSkyblock.getInstance().sendErrorMessage(ex);
    }
}
 

private ParticipantState getActor(BlockTransformEvent event) {
  // Legacy maps assume that all TNT damage is done by "world"
  if (match.getMap().getProto().isOlderThan(MapProtos.FILTER_OWNED_TNT)
      && event.getCause() instanceof EntityExplodeEvent) return null;

  return ParticipantBlockTransformEvent.getPlayerState(event);
}
 

/**
 * This handler only checks to see if the event should be cancelled. It does not change the state
 * of any Destroyables.
 */
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void testBlockChange(BlockTransformEvent event) {
  if (this.match.getWorld() != event.getWorld() || !this.anyDestroyableAffected(event)) {
    return;
  }

  // This is a temp fix until there is a tracker for placed minecarts (only dispensed are tracked
  // right now)
  if ((event.getCause() instanceof EntityExplodeEvent
          && ((EntityExplodeEvent) event.getCause()).getEntity() instanceof ExplosiveMinecart)
      || event.getCause() instanceof BlockPistonExtendEvent
      || event.getCause() instanceof BlockPistonRetractEvent) {

    event.setCancelled(true);
    return;
  }

  for (Destroyable destroyable : this.destroyables) {
    String reasonKey =
        destroyable.testBlockChange(
            event.getOldState(),
            event.getNewState(),
            ParticipantBlockTransformEvent.getPlayerState(event));
    if (reasonKey != null) {
      event.setCancelled(true, TranslatableComponent.of(reasonKey));
      return;
    }
  }
}
 

@EventWrapper
public void onEntityExplode(final EntityExplodeEvent event) {
  ParticipantState playerState = Trackers.getOwner(event.getEntity());

  for (Block block : event.blockList()) {
    if (block.getType() != Material.TNT) {
      // Don't cancel the explosion when individual blocks are cancelled
      callEvent(event, block.getState(), BlockStates.toAir(block), playerState)
          .setPropagateCancel(false);
    }
  }
}
 

private void finishEntityExplode(
    EntityExplodeEvent causeEvent, Collection<BlockTransformEvent> wrapperEvents) {
  // Remove blocks from the explosion if their wrapper event was cancelled
  for (BlockTransformEvent wrapper : wrapperEvents) {
    if (wrapper.isCancelled()) {
      causeEvent.blockList().remove(wrapper.getOldState().getBlock());
    }
  }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBreak(final ParticipantBlockTransformEvent event) {
  if (!event.isBreak()) return;
  if (!Materials.isSolid(event.getOldState())) return;

  final Block block = event.getBlock();
  DamageInfo breaker = null;

  if (event.getCause() instanceof EntityExplodeEvent) {
    PhysicalInfo explosive =
        tracker.resolveInfo(
            ((EntityExplodeEvent) event.getCause()).getEntity(), PhysicalInfo.class);
    if (explosive != null) {
      breaker = new ExplosionInfo(explosive);
    }
  }

  if (breaker == null) {
    breaker = new PlayerInfo(event.getPlayerState());
  }

  final SpleefInfo info = new SpleefInfo(breaker, match.getTick());
  brokenBlocks.put(block, info);

  match
      .getExecutor(MatchScope.RUNNING)
      .schedule(
          () -> {
            // Only remove the BrokenBlock if it's the same one we added. It may have been
            // replaced since then.
            if (info == brokenBlocks.get(block)) {
              brokenBlocks.remove(block);
            }
          },
          (MAX_SPLEEF_TICKS + 1) * TimeUtils.TICK,
          TimeUnit.MILLISECONDS);
}
 

private Optional<ParticipantState> getActor(BlockTransformEvent event) {
    // Legacy maps assume that all TNT damage is done by "world"
    if(getMatch().getMapInfo().proto.isOlderThan(ProtoVersions.FILTER_OWNED_TNT) &&
       event.getCause() instanceof EntityExplodeEvent) {
        return Optional.empty();
    }

    return Optional.ofNullable(ParticipantBlockTransformEvent.getPlayerState(event));
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void dispenserNukes(BlockTransformEvent event) {
    BlockState oldState = event.getOldState();
    if(oldState instanceof Dispenser &&
       this.properties.dispenserNukeLimit > 0 &&
       this.properties.dispenserNukeMultiplier > 0 &&
       event.getCause() instanceof EntityExplodeEvent) {

        EntityExplodeEvent explodeEvent = (EntityExplodeEvent) event.getCause();
        Dispenser dispenser = (Dispenser) oldState;
        int tntLimit = Math.round(this.properties.dispenserNukeLimit / this.properties.dispenserNukeMultiplier);
        int tntCount = 0;

        for(ItemStack stack : dispenser.getInventory().contents()) {
            if(stack != null && stack.getType() == Material.TNT) {
                int transfer = Math.min(stack.getAmount(), tntLimit - tntCount);
                if(transfer > 0) {
                    stack.setAmount(stack.getAmount() - transfer);
                    tntCount += transfer;
                }
            }
        }

        tntCount = (int) Math.ceil(tntCount * this.properties.dispenserNukeMultiplier);

        for(int i = 0; i < tntCount; i++) {
            TNTPrimed tnt = this.getMatch().getWorld().spawn(BlockUtils.base(dispenser), TNTPrimed.class);

            tnt.setFuseTicks(10 + this.getMatch().getRandom().nextInt(10)); // between 0.5 and 1.0 seconds, same as vanilla TNT chaining

            Random random = this.getMatch().getRandom();
            Vector velocity = new Vector(random.nextGaussian(), random.nextGaussian(), random.nextGaussian()); // uniform random direction
            velocity.normalize().multiply(0.5 + 0.5 * random.nextDouble());
            tnt.setVelocity(velocity);

            callPrimeEvent(tnt, explodeEvent.getEntity(), false);
        }
    }
}
 

@EventWrapper
public void onEntityExplode(final EntityExplodeEvent event) {
    ParticipantState playerState = entityResolver.getOwner(event.getEntity());

    for(Block block : event.blockList()) {
        if(block.getType() != Material.TNT) {
            // Don't cancel the explosion when individual blocks are cancelled
            callEvent(event, block.getState(), BlockStateUtils.toAir(block), playerState).setPropagateCancel(false);
        }
    }
}
 

private void finishEntityExplode(EntityExplodeEvent causeEvent, Collection<BlockTransformEvent> wrapperEvents) {
    // Remove blocks from the explosion if their wrapper event was cancelled
    for(BlockTransformEvent wrapper : wrapperEvents) {
        if(wrapper.isCancelled()) {
            causeEvent.blockList().remove(wrapper.getOldState().getBlock());
        }
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBreak(final ParticipantBlockTransformEvent event) {
    if(!event.isBreak()) return;
    if(!Materials.isColliding(event.getOldState())) return;

    final Block block = event.getBlock();
    DamageInfo breaker = null;

    if(event.getCause() instanceof EntityExplodeEvent) {
        PhysicalInfo explosive = entityResolver.resolveInfo(((EntityExplodeEvent) event.getCause()).getEntity(),
                                                            PhysicalInfo.class);
        if(explosive != null) {
            breaker = new ExplosionInfo(explosive);
        }
    }

    if(breaker == null) {
        breaker = new PlayerInfo(event.getPlayerState());
    }

    final SpleefInfo info = new SpleefInfo(breaker, match.getClock().now());
    brokenBlocks.put(block, info);

    match.getScheduler(MatchScope.RUNNING).createDelayedTask(MAX_SPLEEF_TICKS + 1, () -> {
        // Only remove the BrokenBlock if it's the same one we added. It may have been replaced since then.
        if(info == brokenBlocks.get(block)) {
            brokenBlocks.remove(block);
        }
    });
}
 

@EventHandler
public void onExplode(EntityExplodeEvent event){
    if(StackTools.hasSizeMoreThanOne(event.getEntity())){
        int stackSize = StackTools.getSize(event.getEntity());
        event.setYield(event.getYield() + (event.getYield() * (stackSize - 1) * 0.5f));
    }
}
 

private void explodeInProtectedRegion(Location regionLocation, boolean useTown) {
    Region region;
    HashMap<UUID, String> people = new HashMap<>();
    people.put(TestUtil.player.getUniqueId(), Constants.OWNER);
    HashMap<String, String> effects = new HashMap<>();
    if (useTown) {
        RegionsTests.loadRegionTypeCobble();
        region = new Region("cobble", people,
                regionLocation,
                RegionsTests.getRadii(),
                effects,0);
        TownTests.loadTownTypeHamlet2();
        TownTests.loadTown("testTown", "hamlet2", regionLocation);
    } else {
        RegionsTests.loadRegionTypeShelter();
        effects.put("block_explosion", "");
        region = new Region("cobble", people,
                regionLocation,
                RegionsTests.getRadii(),
                effects,0);
    }
    try {
        when(Bukkit.getServer().getScheduler()).thenThrow(new SuccessException());
    } catch (SuccessException e) {
        // Do nothing
    }
    RegionManager.getInstance().addRegion(region);
    TNTPrimed tntPrimed = mock(TNTPrimed.class);
    ArrayList<Block> blockList = new ArrayList<>();
    EntityExplodeEvent event = new EntityExplodeEvent(tntPrimed,
            regionLocation.add(0, 1,0),
            blockList,
            (float) 2);
    ProtectionHandler protectionHandler = new ProtectionHandler();
    protectionHandler.onEntityExplode(event);
}
 

@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
	if (!ScriptLoader.isCurrentEvent(EntityExplodeEvent.class)) {
		Skript.error("Exploded blocks can only be retrieved from an explode event.");
		return false;
	}
	return true;
}
 

@EventHandler(priority=EventPriority.MONITOR, ignoreCancelled=true)
public void onEntityExplode(EntityExplodeEvent e) {
    Entity entity = e.getEntity();
    if(!(entity instanceof Creeper)) return;

    Creeper creeper = (Creeper) entity;
    checkEnemyDeathUntag(creeper);
}
 

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onEntityExplode(EntityExplodeEvent event) {
    if (plugin.getGameWorld(event.getEntity().getWorld()) == null) {
        return;
    }
    if (event.getEntity() instanceof LivingEntity) {
        // Disable Creeper explosions in gameWorlds
        event.setCancelled(true);
    } else {// TODO respect block breaking game rules
        // Disable drops from TNT
        event.setYield(0);
    }
}