@EventHandler
public void onBlockBreak(BlockBreakEvent event) {
    Player player = event.getPlayer();
    if (!Main.isPlayerInGame(player)) {
        return;
    }

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

    Block block = event.getBlock();
    for (RescuePlatform checkedPlatform : getCreatedPlatforms(game, player)) {
        if (checkedPlatform != null) {
            for (Block platformBlock : checkedPlatform.getPlatformBlocks()) {
                if (platformBlock.equals(block) && !checkedPlatform.canBreak()) {
                    event.setCancelled(true);
                }
            }
        }
    }
}
 

@Override
public BlockBreakHandler getItemHandler() {
    return new BlockBreakHandler() {

        @Override
        public boolean isPrivate() {
            return false;
        }

        @Override
        public boolean onBlockBreak(BlockBreakEvent e, ItemStack item, int fortune, List<ItemStack> drops) {
            if (isItem(item)) {
                damageItem(e.getPlayer(), item);

                if (Tag.LEAVES.isTagged(e.getBlock().getType()) && ThreadLocalRandom.current().nextInt(100) < CHANCE) {
                    ItemStack sapling = new ItemStack(Material.getMaterial(e.getBlock().getType().toString().replace("LEAVES", "SAPLING")));
                    drops.add(sapling);
                }

                return true;
            }
            return false;
        }

    };
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onMonitorBreakBlock(BlockBreakEvent event) {
    try {
        final Block block = event.getBlock();
        final Location location = block.getLocation();
        final IslandManager islandManager = IridiumSkyblock.getIslandManager();
        final Island island = islandManager.getIslandViaLocation(location);
        if (island == null) return;

        if (Utils.isBlockValuable(block)) {
            final Material material = block.getType();
            final String materialName = XMaterial.matchXMaterial(material).name();
            island.valuableBlocks.computeIfPresent(materialName, (name, original) -> original - 1);
            if (island.updating)
                island.tempValues.remove(location);

            Bukkit.getScheduler().runTask(IridiumSkyblock.getInstance(), island::calculateIslandValue);
        }

        island.failedGenerators.remove(location);
    } catch (Exception e) {
        IridiumSkyblock.getInstance().sendErrorMessage(e);
    }
}
 

@Override
public boolean onBreak(BlockBreakEvent event) {
    Player breaker = event.getPlayer();
    if (owner.getMembers().contains(breaker)) {
        MessageUtil.sendMessage(breaker, DMessage.ERROR_BLOCK_OWN_TEAM.getMessage());
        return true;
    }

    for (DGamePlayer player : owner.getDGamePlayers()) {
        player.setLives(1);
    }
    owner.setLives(0);

    owner.getGameWorld().sendMessage(DMessage.GROUP_BED_DESTROYED.getMessage(owner.getName(), api.getPlayerCache().getGamePlayer(breaker).getName()));
    Block block1 = event.getBlock();
    if (DungeonsXL.BLOCK_ADAPTER.isBedHead(block)) {
        Block block2 = getAttachedBlock(block1);
        if (block2 != null) {
            block2.setType(VanillaItem.AIR.getMaterial());
        }
    }
    block1.setType(VanillaItem.AIR.getMaterial());
    return true;
}
 

@EventHandler
public void signRemoved(BlockBreakEvent event) {
	if (Util.get().isSpawnWorld(event.getBlock().getWorld())) {
		 Location blockLocation = event.getBlock().getLocation();
	        World w = blockLocation.getWorld();
	    	Block b = w.getBlockAt(blockLocation);
			if(b.getType() == Material.WALL_SIGN || b.getType() == SkyWarsReloaded.getNMS().getMaterial("SIGN_POST").getType()){
		    	Sign sign = (Sign) b.getState();
		    	Location loc = sign.getLocation();
		    	boolean removed = false;
		    	for (GameMap gMap : GameMap.getMaps()) {
		    		if (!removed) {
			    		removed = gMap.removeSign(loc);
		    		}
		    	}
		    	if (!removed) {
		    		removed = SkyWarsReloaded.getLB().removeLeaderSign(loc);
		    	}
		    	if (removed) {
			    	event.getPlayer().sendMessage(new Messaging.MessageFormatter().format("signs.remove"));
		    	}
			}
	}
}
 

@EventHandler(ignoreCancelled = true)
public void onBlockBreak(BlockBreakEvent event) {
    String playerID = PlayerConverter.getID(event.getPlayer());
    // if the player has this objective, the event isn't canceled,
    // the block is correct and conditions are met
    if (containsPlayer(playerID) && selector.match(event.getBlock()) && checkConditions(playerID)) {
        // remove the block from the total amount
        BlockData playerData = (BlockData) dataMap.get(playerID);
        playerData.remove();
        // complete the objective
        if (playerData.getAmount() == neededAmount) {
            completeObjective(playerID);
        } else if (notify && playerData.getAmount() % notifyInterval == 0) {
            // or maybe display a notification
            if (playerData.getAmount() > neededAmount) {
                Config.sendNotify(playerID, "blocks_to_break",
                        new String[]{String.valueOf(playerData.getAmount() - neededAmount)},
                        "blocks_to_break,info");
            } else {
                Config.sendNotify(playerID, "blocks_to_place",
                        new String[]{String.valueOf(neededAmount - playerData.getAmount())},
                        "blocks_to_place,info");
            }
        }
    }
}
 

@EventHandler
public void onBlockBreak(BlockBreakEvent event) {
    if (event.isCancelled()) {
        return;
    }

    if (event.getBlock().getState() instanceof Sign) {
        Location loc = event.getBlock().getLocation();
        if (manager.isSignRegistered(loc)) {
            if (event.getPlayer().hasPermission(owner.getSignCreationPermission())) {
                manager.unregisterSign(loc);
            } else {
                event.getPlayer().sendMessage(owner.returnTranslate("sign_can_not_been_destroyed"));
                event.setCancelled(true);
            }
        }
    }

}
 

@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
	cancelItems = parseResult.mark == 0 || parseResult.mark == 1;
	cancelExps = parseResult.mark == 0 || parseResult.mark == 2;
	if (ScriptLoader.isCurrentEvent(BlockBreakEvent.class)) {
		if (cancelItems && !CAN_CANCEL_BLOCK_ITEM_DROPS) {
			Skript.error("Cancelling drops of items in a block break event requires Minecraft 1.12 or newer");
			return false;
		}
	} else if (!ScriptLoader.isCurrentEvent(EntityDeathEvent.class)) {
		Skript.error("The cancel drops effect can't be used outside of a death" +
			(CAN_CANCEL_BLOCK_ITEM_DROPS ? " or block break" : "") + " event");
		return false;
	}
	if (isDelayed.isTrue()) {
		Skript.error("Can't cancel the drops anymore after the event has already passed");
		return false;
	}
	return true;
}
 

@EventHandler(priority = EventPriority.HIGH)
public void onSignBreak(BlockBreakEvent event) {
	if(event.isCancelled()) {
		return;
	}
	Block block = event.getBlock();
	// Check if it is a sign
	if(Materials.isSign(block.getType())) {
		// Check if the rent sign is really the same as a saved rent
		RegionSign regionSign = SignsFeature.getSignByLocation(block.getLocation());
		if(regionSign == null) {
			return;
		}
		// Remove the sign of the rental region if the player has permission
		if(event.getPlayer().hasPermission("areashop.delsign")) {
			regionSign.remove();
			plugin.message(event.getPlayer(), "delsign-success", regionSign.getRegion());
		} else { // Cancel the breaking of the sign
			event.setCancelled(true);
			plugin.message(event.getPlayer(), "delsign-noPermission", regionSign.getRegion());
		}
	}
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onIndirectDoorBreak(BlockBreakEvent event) {
	if (event.getBlock().getType().toString().contains("DOOR"))
		return;
	Material mat = event.getBlock().getRelative(BlockFace.UP).getType();
	if (mat == Carbon.injector().spruceDoorBlockMat)
		event.getBlock().getWorld().dropItemNaturally(event.getBlock().getRelative(BlockFace.UP).getLocation(), new ItemStack(Carbon.injector().spruceDoorMat, 1));
	else if (mat == Carbon.injector().birchDoorBlockMat)
		event.getBlock().getWorld().dropItemNaturally(event.getBlock().getRelative(BlockFace.UP).getLocation(), new ItemStack(Carbon.injector().birchDoorMat, 1));
	else if (mat == Carbon.injector().jungleDoorBlockMat)
		event.getBlock().getWorld().dropItemNaturally(event.getBlock().getRelative(BlockFace.UP).getLocation(), new ItemStack(Carbon.injector().jungleDoorMat, 1));
	else if (mat == Carbon.injector().acaciaDoorBlockMat)
		event.getBlock().getWorld().dropItemNaturally(event.getBlock().getRelative(BlockFace.UP).getLocation(), new ItemStack(Carbon.injector().acaciaDoorMat, 1));
	else if (mat == Carbon.injector().darkOakDoorBlockMat)
		event.getBlock().getWorld().dropItemNaturally(event.getBlock().getRelative(BlockFace.UP).getLocation(), new ItemStack(Carbon.injector().darkOakDoorMat, 1));
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBreak(BlockBreakEvent e) {
    ItemStack item = e.getPlayer().getInventory().getItemInMainHand();

    if (item.getType() != Material.AIR && item.getAmount() > 0) {
        List<ItemStack> drops = new ArrayList<>(e.getBlock().getDrops(item));
        int dropAmount = 1;

        if (item.getEnchantments().containsKey(Enchantment.LOOT_BONUS_BLOCKS) && !item.getEnchantments().containsKey(Enchantment.SILK_TOUCH)) {
            Random random = ThreadLocalRandom.current();
            dropAmount = random.nextInt(item.getEnchantmentLevel(Enchantment.LOOT_BONUS_BLOCKS) + 2) - 1;
            dropAmount = Math.max(dropAmount, 1);
            dropAmount = (e.getBlock().getType() == Material.LAPIS_ORE ? 4 + random.nextInt(5) : 1) * (dropAmount + 1);
        }

        if (!item.getEnchantments().containsKey(Enchantment.SILK_TOUCH) && MaterialCollections.getAllOres().contains(e.getBlock().getType()) && Talisman.checkFor(e, SlimefunItems.TALISMAN_MINER)) {
            for (ItemStack drop : drops) {
                if (!drop.getType().isBlock()) {
                    int amount = Math.max(1, (dropAmount * 2) - drop.getAmount());
                    e.getBlock().getWorld().dropItemNaturally(e.getBlock().getLocation(), new CustomItem(drop, amount));
                }
            }
        }
    }
}
 

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

    if (e.getBlock().hasMetadata("ce.Ice"))
        e.setCancelled(true);

    CEventHandler.handleEvent(e.getPlayer(), e, blockBroken);
    if (e.getBlock().hasMetadata("ce.mine")) {
        Block b = e.getBlock();
        b.removeMetadata("ce.mine", Main.plugin);
        Block[] blocks = { b.getRelative(0, 1, 0), b.getRelative(1, 0, 0), b.getRelative(-1, 0, 0), b.getRelative(0, 0, 1), b.getRelative(0, 0, -1) };

        for (Block block : blocks) {
            if (block.hasMetadata("ce.mine.secondary")) {
                String[] s = block.getMetadata("ce.mine.secondary").get(0).asString().split(" ");
                Location loc = new Location(e.getPlayer().getWorld(), Integer.parseInt(s[0]), Integer.parseInt(s[1]), Integer.parseInt(s[2]));
                Location blockLoc = b.getLocation();
                if (loc.getBlockX() == blockLoc.getBlockX() && loc.getBlockY() == blockLoc.getBlockY() && loc.getBlockZ() == blockLoc.getBlockZ())
                    block.removeMetadata("ce.mine.secondary", Main.plugin);
            }
        }
    }

}
 

@Override
public void onBlockBreak(BlockBreakEvent event, PlayerDetails details) {
	Block root = event.getBlock();
	if (isLog(root.getType())) {
		// Find the blocks
		Set<Block> blocks = getTreeBlocks(root);
		if (blocks.size() > 0) {
			root.getWorld().playSound(root.getLocation(), Sound.ENTITY_ZOMBIE_BREAK_WOODEN_DOOR, 0.5f, 1);
		}
		// Destroy them.
		for (Block block : blocks) {
			block.breakNaturally();
		}
		// Apply durability.
		if (event.getPlayer().getGameMode() != GameMode.CREATIVE) {
			UtilsMc.offsetItemStackDamage(details.getItem(), blocks.size());
		}
	}
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void unregisterSign(BlockBreakEvent event) {
    // Do nothing if block is not a registered sign.
    BlockPos pos = BlockPos.of(event.getBlock());
    if (!signs.containsValue(pos)) {
        return;
    }

    if (!(event.getBlock().getState() instanceof Sign)) {
        removeSign(pos);
        return;
    }

    if (!event.getPlayer().hasPermission("factionstop.sign.break")) {
        event.getPlayer().sendMessage(plugin.getSettings().getPermissionMessage());
        event.setCancelled(true);
        return;
    }

    removeSign(pos);
}
 

@EventHandler
public void BlockBreakEvent(BlockBreakEvent e) {

    String noPerm = wild.getConfig().getString("No-Break");
    if (e.getBlock().getState() instanceof Sign) {
        Sign sign = (Sign) e.getBlock().getState();
        if (sign.getLine(0).equalsIgnoreCase("§4====================") &&
                sign.getLine(1).equalsIgnoreCase("[§1Wild§0]") &&
                sign.getLine(2).equalsIgnoreCase("§4====================")) {
            if (!e.getPlayer().hasPermission("wild.wildtp.break.sign")) {
                e.getPlayer().sendMessage(ChatColor.translateAlternateColorCodes( '&', noPerm));
                e.setCancelled(true);
            } else {
                e.getPlayer().sendMessage(ChatColor.GREEN + "You have broken a wildtp sign");
            }
        }
    }
}
 

@EventHandler
public void onMine(BlockBreakEvent event) {

    if (event.isCancelled()) return;
    if (!EliteMobs.validWorldList.contains(event.getPlayer().getWorld())) return;
    if (event.getPlayer().getGameMode() == GameMode.CREATIVE || event.getPlayer().getGameMode() == GameMode.SPECTATOR) return;
    if (!event.getPlayer().hasPermission("elitemobs.events.balrog")) return;
    if (event.getPlayer().getInventory().getItemInMainHand().hasItemMeta() &&
            event.getPlayer().getInventory().getItemInMainHand().getEnchantments().containsKey(Enchantment.SILK_TOUCH))
        return;
    if (!(event.getBlock().getType().equals(Material.DIAMOND_ORE) || event.getBlock().getType().equals(Material.IRON_ORE) ||
            event.getBlock().getType().equals(Material.COAL_ORE) || event.getBlock().getType().equals(Material.REDSTONE_ORE) ||
            event.getBlock().getType().equals(Material.LAPIS_ORE) || event.getBlock().getType().equals(Material.GOLD_ORE))) return;
    if (ThreadLocalRandom.current().nextDouble() > ConfigValues.eventsConfig.getDouble(EventsConfig.BALROG_CHANCE_ON_MINE)) return;

    Balrog.spawnBalrog(event.getBlock().getLocation());

}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onSignOrChestBreak(BlockBreakEvent e) {
    if (e.isCancelled()
            || e.getBlock() == null
            || (e.getBlock().getType() != SkyBlockMenu.WALL_SIGN_MATERIAL && !(e.getBlock().getType() == Material.CHEST || e.getBlock().getType() == Material.TRAPPED_CHEST))
            || e.getBlock().getLocation() == null
            || !plugin.getWorldManager().isSkyAssociatedWorld(e.getBlock().getLocation().getWorld())
            ) {
        return;
    }
    if (e.getBlock().getType() == SkyBlockMenu.WALL_SIGN_MATERIAL) {
        logic.removeSign(e.getBlock().getLocation());
    } else {
        logic.removeChest(e.getBlock().getLocation());
    }
}
 

@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onLeafBreak(BlockBreakEvent event) {
    if (!plugin.getWorldManager().isSkyWorld(event.getPlayer().getWorld())) {
        return;
    }
    if (event.getBlock().getType() != Material.OAK_LEAVES || (event.getBlock().getData() & 0x3) != 0) {
        return;
    }
    // Ok, a player broke an OAK LEAF in the Skyworld
    String islandName = WorldGuardHandler.getIslandNameAt(event.getPlayer().getLocation());
    IslandInfo islandInfo = plugin.getIslandInfo(islandName);
    if (islandInfo != null && islandInfo.getLeafBreaks() == 0) {
        // Add an oak-sapling
        event.getBlock().getWorld().dropItemNaturally(event.getBlock().getLocation(), new ItemStack(Material.OAK_SAPLING, 1));
        islandInfo.setLeafBreaks(islandInfo.getLeafBreaks() + 1);
    }
}
 

@EventHandler
public void onBlockBreak(BlockBreakEvent e) {

    if (isActivated(Scenario.CUTCLEAN) || isActivated(Scenario.TRIPLEORES) || isActivated(Scenario.VEINMINER)){
        return;
    }

    Block block = e.getBlock();
    Location loc = e.getBlock().getLocation().add(0.5, 0, 0.5);

    if (block.getType() == Material.GOLD_ORE){
        block.setType(Material.AIR);
        loc.getWorld().dropItem(loc,new ItemStack(Material.GOLD_INGOT, 2));
        UhcItems.spawnExtraXp(loc,6);
    }
}
 

/**
 * Prevents blocks from being broken
 *
 * @param e - event
 */
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onBlockBreak(final BlockBreakEvent e) {
    if (DEBUG) {
        plugin.getLogger().info(e.getEventName());
    }

    if (Settings.allowedFakePlayers.contains(e.getPlayer().getName())) return;

    if (inWorld(e.getPlayer())) {
        if (actionAllowed(e.getPlayer(), e.getBlock().getLocation(), SettingsFlag.BREAK_BLOCKS)) {
            return;
        }
        // Everyone else - not allowed
        Util.sendMessage(e.getPlayer(), ChatColor.RED + plugin.myLocale(e.getPlayer().getUniqueId()).islandProtected);
        e.setCancelled(true);
    }
}
 

@Test
public void regionShouldBeDestroyedAndRebuilt() {
    loadRegionTypeCobble();
    HashMap<UUID, String> owners = new HashMap<>();
    UUID uuid = new UUID(1, 4);
    owners.put(uuid, Constants.OWNER);
    Location location1 = new Location(Bukkit.getWorld("world"), 4, 0, 0);
    RegionManager.getInstance().addRegion(new Region("cobble", owners, location1, getRadii(), new HashMap<>(),0));
    BlockBreakEvent event = new BlockBreakEvent(TestUtil.blockUnique, TestUtil.player);
    CivilianListener civilianListener = new CivilianListener();
    civilianListener.onCivilianBlockBreak(event);
    ProtectionHandler protectionHandler = new ProtectionHandler();
    protectionHandler.onBlockBreak(event);
    BlockPlaceEvent event1 = mock(BlockPlaceEvent.class);
    Block block2 = TestUtil.createUniqueBlock(Material.CHEST, "Civs cobble", location1, false);
    when(event1.getBlockPlaced()).thenReturn(block2);
    ItemStack itemStack = TestUtil.createUniqueItemStack(Material.CHEST, "Civs Cobble");
    when(event1.getItemInHand()).thenReturn(itemStack);
    when(event1.getPlayer()).thenReturn(TestUtil.player);
    RegionListener regionListener = new RegionListener();
    regionListener.onBlockPlace(event1);
    assertNotNull(RegionManager.getInstance().getRegionAt(location1));
}
 

@Test
public void blockBreakInProtectionShouldBeCancelled() {
    RegionsTests.loadRegionTypeCobble();
    Player player = mock(Player.class);
    when(player.getGameMode()).thenReturn(GameMode.SURVIVAL);
    UUID uuid = new UUID(1, 2);
    when(player.getUniqueId()).thenReturn(uuid);
    Player player2 = mock(Player.class);
    when(player2.getGameMode()).thenReturn(GameMode.SURVIVAL);
    UUID uuid2 = new UUID(1, 3);
    when(player2.getUniqueId()).thenReturn(uuid2);

    HashMap<UUID, String> owners = new HashMap<>();
    owners.put(uuid2, Constants.OWNER);
    Location regionLocation = new Location(Bukkit.getWorld("world"), 0,0,0);
    HashMap<String, String> effects = new HashMap<>();
    effects.put("block_break", null);
    effects.put("block_build", null);
    RegionManager.getInstance().addRegion(new Region("cobble", owners, regionLocation, RegionsTests.getRadii(), effects,0));
    ProtectionHandler protectionHandler = new ProtectionHandler();
    BlockBreakEvent event = new BlockBreakEvent(TestUtil.block3, player);
    protectionHandler.onBlockBreak(event);
    assertTrue(event.isCancelled());
}
 

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onBlockBreakWithSignOnIt(BlockBreakEvent event) {
    Block block = event.getBlock();
    Player player = event.getPlayer();

    Block blockAbove = block.getRelative(BlockFace.UP);
    //get the above block and return if there is nothing
    if (blockAbove == null) {
        return;
    }

    //return if above block is not a sign
    if (!Category.SIGNS.containsBlock(blockAbove)) {
        return;
    }

    //let onBreak() method to handle the sign
    BlockBreakEvent bbe = new BlockBreakEvent(blockAbove, player);
    onBlockBreak(bbe);

    //follow the onBreak()
    event.setCancelled(bbe.isCancelled());
}
 

@EventHandler(ignoreCancelled = true)
public void onSignDestroy(BlockBreakEvent event) {
    if (event.getBlock().getType().name().contains("SIGN")) {
        Sign sign = (Sign) event.getBlock().getState();
        if (plugin.matchesSignVariable(sign.getLine(1))) {
            if (!event.getPlayer().hasPermission("randomteleport.sign.destroy")) {
                event.setCancelled(true);
                plugin.sendMessage(event.getPlayer(), "sign.no-permission.destroy", "perm", "randomteleport.sign.destroy");
            } else {
                plugin.sendMessage(event.getPlayer(), "sign.destroyed", "preset", sign.getLine(2));
            }
        }
    }
}
 

@Override
public void effect(Event e, ItemStack item, int level) {
	BlockBreakEvent event = (BlockBreakEvent) e;
	Player player = event.getPlayer();
	
	player.addPotionEffect(new PotionEffect(PotionEffectType.FAST_DIGGING, Duration, Strength+level-1), false);
}
 

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onBlockBreak_DurabilityCheck(BlockBreakEvent event) {
	Player player = event.getPlayer();
	ItemStack tool = player.getInventory().getItemInMainHand();
	if (modManager.isToolViable(tool)) {
		modManager.durabilityCheck(event, player, tool);
	}
}
 

/**
 * Set furnaces as inactive
 *
 * @param event block break event
 */
@EventHandler
public void onBlockBreak(BlockBreakEvent event) {
    Material bType = event.getBlock().getType();

    //Ignore blocks that aren't furnaces or saplings:
    if ((bType != Material.FURNACE && bType != Material.BLAST_FURNACE && bType != Material.SMOKER) && !bType.name().endsWith("SAPLING")) {
        return;
    }

    //Ignore if the block's world-climate is disabled:
    if (!ClimateEngine.getInstance().isClimateEngineEnabled(event.getBlock().getWorld().getUID())) {
        return;
    }

    //Delete tracked records:
    Location location = event.getBlock().getLocation();
    if (bType == Material.FURNACE || bType == Material.BLAST_FURNACE || bType == Material.SMOKER) {
        //Furnace destroyed:
        // - Any "contribution" records based on a deleted furnace will
        //   no longer be able to look it up (this is OK, just be aware)
        FurnaceTable furnaceTable = gw.getTableManager().getFurnaceTable();
        if (furnaceTable.deleteLocation(location) == null) {
            gw.getLogger().info(String.format("Untracked furnace destroyed @ %s", location.toString()));
        }
    } else if (event.getBlock().getType().name().endsWith("SAPLING")) {
        //Sapling destroyed:
        // - Any "reduction" records based on a deleted sapling will
        //   no longer be able to look it up (this is OK, just be aware)
        TreeTable treeTable = gw.getTableManager().getTreeTable();
        if (treeTable.deleteLocation(location) == null) {
            gw.getLogger().info(String.format("Untracked sapling destroyed @ %s", location.toString()));
        }
    }
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onBlockBreak(BlockBreakEvent event) {
	if (blockBroken) {
		return;
	}
	
	String varname = this.getString("varname");
	String locString = this.getParent().componentVars.get(varname);
	if (locString == null) {
		return;
	}

	bcoord = new BlockCoord(this.getParent().componentVars.get(varname));
	
	BlockCoord breakCoord = new BlockCoord(event.getBlock());

	if (breakCoord.getX() == bcoord.getX() &&
	    breakCoord.getY() == bcoord.getY() &&
	    breakCoord.getZ() == bcoord.getZ()) {
		
		Resident resident = CivGlobal.getResident(event.getPlayer().getName());
		if (resident.getTown() == this.getParentTown()) {
			brokenByTown = true;
			CivMessage.send(event.getPlayer(), CivColor.LightGreen+"You seem to have found something interesting....");
		}
		
		blockBroken = true;
		
		this.getParent().componentVars.put(getString("playername_var"), event.getPlayer().getName());
	}
}
 

@EventHandler(priority = EventPriority.HIGH)
public void onBreak(BlockBreakEvent br) {
  if (br.isCancelled()) {
    return;
  }

  Block toDestroy = br.getBlock();
  if (br.getBlock().getType() != Material.TRIPWIRE) {
    Block relative = br.getBlock().getRelative(BlockFace.UP);
    // check above
    if (!relative.getType().equals(Material.TRIPWIRE)) {
      return;
    }

    toDestroy = relative;
  }

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

  if (game == null) {
    return;
  }

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

  if (br.getBlock().equals(toDestroy)) {
    br.setCancelled(true);
    return;
  }

  toDestroy.setType(Material.AIR);
}
 

@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onBlockBreak(BlockBreakEvent event) {
    if (event == null || !terraformEnabled) {
        return;
    }
    Block block = event.getBlock();
    Player player = event.getPlayer();
    if (!plugin.getWorldManager().isSkyNether(block.getWorld()) || !plugin.getWorldManager().isSkyNether(player.getWorld())) {
        return; // Bail out, not our problem
    }
    if (player.getGameMode() != GameMode.SURVIVAL) {
        return;
    }
    if (!plugin.playerIsOnIsland(player)) {
        return;
    }
    if (!terraFormMap.containsKey(block.getType())) {
        return; // Not a block we terra-form on.
    }
    // TODO: 10/07/2016 - R4zorax: Handle dual-wielding (would break 1.8 compatibility)
    ItemStack tool = event.getPlayer().getItemInHand();
    if (event.getBlock().getDrops(tool).isEmpty()) {
        return; // Only terra-form when stuff is mined correctly
    }
    double toolWeight = getToolWeight(tool);
    Location playerLocation = player.getEyeLocation();
    Location blockLocation = LocationUtil.centerInBlock(block.getLocation());
    Vector v = new Vector(blockLocation.getX(), blockLocation.getY(), blockLocation.getZ());
    v.subtract(new Vector(playerLocation.getX(), playerLocation.getY(), playerLocation.getZ()));
    v.normalize();
    // Disable spawning above the player... enabling the player to clear a region
    if (playerLocation.getPitch() >= minPitch && playerLocation.getPitch() <= maxPitch) {
        ProtectedCuboidRegion islandRegion = WorldGuardHandler.getIslandRegion(playerLocation);
        List<Material> yield = getYield(block.getType(), toolWeight);
        for (Material mat : yield) {
            spawnBlock(mat, blockLocation, v, islandRegion);
        }
    }
}