684 lines
23 KiB
Java
684 lines
23 KiB
Java
/*
|
|
* WorldGuard, a suite of tools for Minecraft
|
|
* Copyright (C) sk89q <http://www.sk89q.com>
|
|
* Copyright (C) WorldGuard team and contributors
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify it
|
|
* under the terms of the GNU Lesser General Public License as published by the
|
|
* Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
|
|
* for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package com.sk89q.worldguard.bukkit.listener;
|
|
|
|
import com.sk89q.worldedit.blocks.BlockID;
|
|
import com.sk89q.worldedit.blocks.BlockType;
|
|
import com.sk89q.worldedit.blocks.ItemType;
|
|
import com.sk89q.worldguard.bukkit.ConfigurationManager;
|
|
import com.sk89q.worldguard.bukkit.WorldConfiguration;
|
|
import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
|
|
import com.sk89q.worldguard.protection.ApplicableRegionSet;
|
|
import com.sk89q.worldguard.protection.flags.DefaultFlag;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.World;
|
|
import org.bukkit.block.Block;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.entity.Snowman;
|
|
import org.bukkit.event.EventHandler;
|
|
import org.bukkit.event.EventPriority;
|
|
import org.bukkit.event.Listener;
|
|
import org.bukkit.event.block.BlockBreakEvent;
|
|
import org.bukkit.event.block.BlockBurnEvent;
|
|
import org.bukkit.event.block.BlockExplodeEvent;
|
|
import org.bukkit.event.block.BlockFadeEvent;
|
|
import org.bukkit.event.block.BlockFormEvent;
|
|
import org.bukkit.event.block.BlockFromToEvent;
|
|
import org.bukkit.event.block.BlockIgniteEvent;
|
|
import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
|
|
import org.bukkit.event.block.BlockPhysicsEvent;
|
|
import org.bukkit.event.block.BlockPlaceEvent;
|
|
import org.bukkit.event.block.BlockRedstoneEvent;
|
|
import org.bukkit.event.block.BlockSpreadEvent;
|
|
import org.bukkit.event.block.EntityBlockFormEvent;
|
|
import org.bukkit.event.block.LeavesDecayEvent;
|
|
import org.bukkit.inventory.ItemStack;
|
|
|
|
/**
|
|
* The listener for block events.
|
|
*
|
|
* @author sk89q
|
|
*/
|
|
public class WorldGuardBlockListener implements Listener {
|
|
|
|
private WorldGuardPlugin plugin;
|
|
|
|
/**
|
|
* Construct the object.
|
|
*
|
|
* @param plugin The plugin instance
|
|
*/
|
|
public WorldGuardBlockListener(WorldGuardPlugin plugin) {
|
|
this.plugin = plugin;
|
|
}
|
|
|
|
/**
|
|
* Register events.
|
|
*/
|
|
public void registerEvents() {
|
|
plugin.getServer().getPluginManager().registerEvents(this, plugin);
|
|
}
|
|
|
|
/**
|
|
* Get the world configuration given a world.
|
|
*
|
|
* @param world The world to get the configuration for.
|
|
* @return The configuration for {@code world}
|
|
*/
|
|
protected WorldConfiguration getWorldConfig(World world) {
|
|
return plugin.getGlobalStateManager().get(world);
|
|
}
|
|
|
|
/**
|
|
* Get the world configuration given a player.
|
|
*
|
|
* @param player The player to get the wold from
|
|
* @return The {@link WorldConfiguration} for the player's world
|
|
*/
|
|
protected WorldConfiguration getWorldConfig(Player player) {
|
|
return getWorldConfig(player.getWorld());
|
|
}
|
|
|
|
/*
|
|
* Called when a block is broken.
|
|
*/
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
|
public void onBlockBreak(BlockBreakEvent event) {
|
|
Player player = event.getPlayer();
|
|
Block target = event.getBlock();
|
|
WorldConfiguration wcfg = getWorldConfig(player);
|
|
|
|
if (!wcfg.itemDurability) {
|
|
ItemStack held = player.getItemInHand();
|
|
if (held.getType() != Material.AIR && !(ItemType.usesDamageValue(held.getTypeId())|| BlockType.usesData(held.getTypeId()))) {
|
|
held.setDurability((short) 0);
|
|
player.setItemInHand(held);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when fluids flow.
|
|
*/
|
|
@EventHandler(ignoreCancelled = true)
|
|
public void onBlockFromTo(BlockFromToEvent event) {
|
|
World world = event.getBlock().getWorld();
|
|
Block blockFrom = event.getBlock();
|
|
Block blockTo = event.getToBlock();
|
|
|
|
boolean isWater = blockFrom.getTypeId() == 8 || blockFrom.getTypeId() == 9;
|
|
boolean isLava = blockFrom.getTypeId() == 10 || blockFrom.getTypeId() == 11;
|
|
boolean isAir = blockFrom.getTypeId() == 0;
|
|
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
|
|
|
|
if (cfg.activityHaltToggle) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.simulateSponge && isWater) {
|
|
int ox = blockTo.getX();
|
|
int oy = blockTo.getY();
|
|
int oz = blockTo.getZ();
|
|
|
|
for (int cx = -wcfg.spongeRadius; cx <= wcfg.spongeRadius; cx++) {
|
|
for (int cy = -wcfg.spongeRadius; cy <= wcfg.spongeRadius; cy++) {
|
|
for (int cz = -wcfg.spongeRadius; cz <= wcfg.spongeRadius; cz++) {
|
|
Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
|
|
if (sponge.getTypeId() == 19
|
|
&& (!wcfg.redstoneSponges || !sponge.isBlockIndirectlyPowered())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*if (plugin.classicWater && isWater) {
|
|
int blockBelow = blockFrom.getRelative(0, -1, 0).getTypeId();
|
|
if (blockBelow != 0 && blockBelow != 8 && blockBelow != 9) {
|
|
blockFrom.setTypeId(9);
|
|
if (blockTo.getTypeId() == 0) {
|
|
blockTo.setTypeId(9);
|
|
}
|
|
return;
|
|
}
|
|
}*/
|
|
|
|
// Check the fluid block (from) whether it is air.
|
|
// If so and the target block is protected, cancel the event
|
|
if (wcfg.preventWaterDamage.size() > 0) {
|
|
int targetId = blockTo.getTypeId();
|
|
|
|
if ((isAir || isWater) &&
|
|
wcfg.preventWaterDamage.contains(targetId)) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (wcfg.allowedLavaSpreadOver.size() > 0 && isLava) {
|
|
int targetId = blockTo.getRelative(0, -1, 0).getTypeId();
|
|
|
|
if (!wcfg.allowedLavaSpreadOver.contains(targetId)) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (wcfg.highFreqFlags && isWater
|
|
&& !plugin.getGlobalRegionManager().allows(DefaultFlag.WATER_FLOW,
|
|
blockFrom.getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.highFreqFlags && isLava
|
|
&& !plugin.getGlobalRegionManager().allows(DefaultFlag.LAVA_FLOW,
|
|
blockFrom.getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.disableObsidianGenerators && (isAir || isLava)
|
|
&& (blockTo.getTypeId() == BlockID.REDSTONE_WIRE
|
|
|| blockTo.getTypeId() == BlockID.TRIPWIRE)) {
|
|
blockTo.setTypeId(BlockID.AIR);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when a block gets ignited.
|
|
*/
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
|
public void onBlockIgnite(BlockIgniteEvent event) {
|
|
IgniteCause cause = event.getCause();
|
|
Block block = event.getBlock();
|
|
World world = block.getWorld();
|
|
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(world);
|
|
|
|
if (cfg.activityHaltToggle) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
boolean isFireSpread = cause == IgniteCause.SPREAD;
|
|
|
|
if (wcfg.preventLightningFire && cause == IgniteCause.LIGHTNING) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.preventLavaFire && cause == IgniteCause.LAVA) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.disableFireSpread && isFireSpread) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.blockLighter && (cause == IgniteCause.FLINT_AND_STEEL || cause == IgniteCause.FIREBALL)
|
|
&& event.getPlayer() != null
|
|
&& !plugin.hasPermission(event.getPlayer(), "worldguard.override.lighter")) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.fireSpreadDisableToggle && isFireSpread) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.disableFireSpreadBlocks.size() > 0 && isFireSpread) {
|
|
int x = block.getX();
|
|
int y = block.getY();
|
|
int z = block.getZ();
|
|
|
|
if (wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y - 1, z))
|
|
|| wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x + 1, y, z))
|
|
|| wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x - 1, y, z))
|
|
|| wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z - 1))
|
|
|| wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z + 1))) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (wcfg.useRegions) {
|
|
ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation());
|
|
|
|
if (wcfg.highFreqFlags && isFireSpread
|
|
&& !set.allows(DefaultFlag.FIRE_SPREAD)) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.highFreqFlags && cause == IgniteCause.LAVA
|
|
&& !set.allows(DefaultFlag.LAVA_FIRE)) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (cause == IgniteCause.FIREBALL && event.getPlayer() == null) {
|
|
// wtf bukkit, FIREBALL is supposed to be reserved to players
|
|
if (!set.allows(DefaultFlag.GHAST_FIREBALL)) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (cause == IgniteCause.LIGHTNING && !set.allows(DefaultFlag.LIGHTNING)) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when a block is destroyed from burning.
|
|
*/
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
|
public void onBlockBurn(BlockBurnEvent event) {
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
|
|
|
|
if (cfg.activityHaltToggle) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.disableFireSpread) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.fireSpreadDisableToggle) {
|
|
Block block = event.getBlock();
|
|
event.setCancelled(true);
|
|
checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), BlockID.FIRE);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.disableFireSpreadBlocks.size() > 0) {
|
|
Block block = event.getBlock();
|
|
|
|
if (wcfg.disableFireSpreadBlocks.contains(block.getTypeId())) {
|
|
event.setCancelled(true);
|
|
checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), BlockID.FIRE);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (wcfg.isChestProtected(event.getBlock())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.useRegions) {
|
|
Block block = event.getBlock();
|
|
int x = block.getX();
|
|
int y = block.getY();
|
|
int z = block.getZ();
|
|
ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation());
|
|
|
|
if (!set.allows(DefaultFlag.FIRE_SPREAD)) {
|
|
checkAndDestroyAround(block.getWorld(), x, y, z, BlockID.FIRE);
|
|
event.setCancelled(true);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void checkAndDestroyAround(World world, int x, int y, int z, int required) {
|
|
checkAndDestroy(world, x, y, z + 1, required);
|
|
checkAndDestroy(world, x, y, z - 1, required);
|
|
checkAndDestroy(world, x, y + 1, z, required);
|
|
checkAndDestroy(world, x, y - 1, z, required);
|
|
checkAndDestroy(world, x + 1, y, z, required);
|
|
checkAndDestroy(world, x - 1, y, z, required);
|
|
}
|
|
|
|
private void checkAndDestroy(World world, int x, int y, int z, int required) {
|
|
if (world.getBlockTypeIdAt(x, y, z) == required) {
|
|
world.getBlockAt(x, y, z).setTypeId(BlockID.AIR);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when block physics occurs.
|
|
*/
|
|
@EventHandler(ignoreCancelled = true)
|
|
public void onBlockPhysics(BlockPhysicsEvent event) {
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
|
|
|
|
if (cfg.activityHaltToggle) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
int id = event.getBlock().getTypeId();
|
|
|
|
if (id == 13 && wcfg.noPhysicsGravel) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (id == 12 && wcfg.noPhysicsSand) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (id == 90 && wcfg.allowPortalAnywhere) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.ropeLadders && event.getBlock().getType() == Material.LADDER) {
|
|
if (event.getBlock().getRelative(0, 1, 0).getType() == Material.LADDER) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when a player places a block.
|
|
*/
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
|
public void onBlockPlace(BlockPlaceEvent event) {
|
|
Block target = event.getBlock();
|
|
World world = target.getWorld();
|
|
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(world);
|
|
|
|
if (wcfg.simulateSponge && target.getType() == Material.SPONGE) {
|
|
if (wcfg.redstoneSponges && target.isBlockIndirectlyPowered()) {
|
|
return;
|
|
}
|
|
|
|
int ox = target.getX();
|
|
int oy = target.getY();
|
|
int oz = target.getZ();
|
|
|
|
SpongeUtil.clearSpongeWater(plugin, world, ox, oy, oz);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when redstone changes.
|
|
*/
|
|
@EventHandler(priority = EventPriority.HIGH)
|
|
public void onBlockRedstoneChange(BlockRedstoneEvent event) {
|
|
Block blockTo = event.getBlock();
|
|
World world = blockTo.getWorld();
|
|
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(world);
|
|
|
|
if (wcfg.simulateSponge && wcfg.redstoneSponges) {
|
|
int ox = blockTo.getX();
|
|
int oy = blockTo.getY();
|
|
int oz = blockTo.getZ();
|
|
|
|
for (int cx = -1; cx <= 1; cx++) {
|
|
for (int cy = -1; cy <= 1; cy++) {
|
|
for (int cz = -1; cz <= 1; cz++) {
|
|
Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
|
|
if (sponge.getTypeId() == 19
|
|
&& sponge.isBlockIndirectlyPowered()) {
|
|
SpongeUtil.clearSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
|
|
} else if (sponge.getTypeId() == 19
|
|
&& !sponge.isBlockIndirectlyPowered()) {
|
|
SpongeUtil.addSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
|
public void onLeavesDecay(LeavesDecayEvent event) {
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
|
|
|
|
if (cfg.activityHaltToggle) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.disableLeafDecay) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.useRegions) {
|
|
if (!plugin.getGlobalRegionManager().allows(DefaultFlag.LEAF_DECAY,
|
|
event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when a block is formed based on world conditions.
|
|
*/
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
|
public void onBlockForm(BlockFormEvent event) {
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
|
|
|
|
if (cfg.activityHaltToggle) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
int type = event.getNewState().getTypeId();
|
|
|
|
if (event instanceof EntityBlockFormEvent) {
|
|
if (((EntityBlockFormEvent) event).getEntity() instanceof Snowman) {
|
|
if (wcfg.disableSnowmanTrails) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (type == BlockID.ICE) {
|
|
if (wcfg.disableIceFormation) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.ICE_FORM, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (type == BlockID.SNOW) {
|
|
if (wcfg.disableSnowFormation) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
if (wcfg.allowedSnowFallOver.size() > 0) {
|
|
int targetId = event.getBlock().getRelative(0, -1, 0).getTypeId();
|
|
|
|
if (!wcfg.allowedSnowFallOver.contains(targetId)) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.SNOW_FALL, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when a block spreads based on world conditions.
|
|
*/
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
|
public void onBlockSpread(BlockSpreadEvent event) {
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
|
|
|
|
if (cfg.activityHaltToggle) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
int fromType = event.getSource().getTypeId();
|
|
|
|
if (fromType == BlockID.RED_MUSHROOM || fromType == BlockID.BROWN_MUSHROOM) {
|
|
if (wcfg.disableMushroomSpread) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.MUSHROOMS, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (fromType == BlockID.GRASS) {
|
|
if (wcfg.disableGrassGrowth) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.GRASS_SPREAD, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (fromType == BlockID.MYCELIUM) {
|
|
if (wcfg.disableMyceliumSpread) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.useRegions
|
|
&& !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.MYCELIUM_SPREAD, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (fromType == BlockID.VINE) {
|
|
if (wcfg.disableVineGrowth) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.useRegions
|
|
&& !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.VINE_GROWTH, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when a block fades.
|
|
*/
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
|
public void onBlockFade(BlockFadeEvent event) {
|
|
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
|
|
|
|
switch (event.getBlock().getTypeId()) {
|
|
case BlockID.ICE:
|
|
if (wcfg.disableIceMelting) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.ICE_MELT, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
break;
|
|
|
|
case BlockID.SNOW:
|
|
if (wcfg.disableSnowMelting) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.SNOW_MELT, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
break;
|
|
|
|
case BlockID.SOIL:
|
|
if (wcfg.disableSoilDehydration) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
|
|
DefaultFlag.SOIL_DRY, event.getBlock().getLocation())) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
@EventHandler(ignoreCancelled = true)
|
|
public void onBlockExplode(BlockExplodeEvent event) {
|
|
ConfigurationManager cfg = plugin.getGlobalStateManager();
|
|
|
|
if (cfg.activityHaltToggle) {
|
|
event.setCancelled(true);
|
|
return;
|
|
}
|
|
|
|
WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
|
|
if (wcfg.blockOtherExplosions) {
|
|
event.setCancelled(true);
|
|
}
|
|
}
|
|
|
|
}
|