org.bukkit.event.block.BlockDamageEvent Java Examples

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void checkBlockDamage(final BlockDamageEvent event) {
  MatchPlayer player = this.match.getParticipant(event.getPlayer());
  if (player == null) return;

  PlayerBlockQuery query = new PlayerBlockQuery(event, player, event.getBlock().getState());

  for (RegionFilterApplication rfa : this.rfaContext.get(RFAScope.BLOCK_BREAK)) {
    if (rfa.earlyWarning && rfa.region.contains(event.getBlock())) {
      if (processQuery(rfa, query)) {
        if (event.isCancelled() && rfa.message != null) {
          player.sendWarning(rfa.message);
        }
        if (this.useRegionPriority || rfa.useRegionPriority) {
          break;
        }
      }
    }
  }
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void processBlockDamage(BlockDamageEvent event) {
  if (this.match.getWorld() != event.getBlock().getWorld()) return;

  Block block = event.getBlock();
  MaterialData material = block.getState().getData();
  MatchPlayer player = this.match.getPlayer(event.getPlayer());

  for (Destroyable destroyable : this.destroyables) {
    if (player != null
        && player.getParty() == destroyable.getOwner()
        && !destroyable.isDestroyed()
        && destroyable.getBlockRegion().contains(block)
        && destroyable.hasMaterial(material)) {

      event.setCancelled(true);
      // TODO: translate this
      player.sendWarning(TextComponent.of("You may not damage your own objective."));
    }
  }
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void damageCheck(BlockDamageEvent event) {
  Block block = event.getBlock();
  if (block.getWorld() != this.match.getWorld()) return;
  MatchPlayer player = this.match.getPlayer(event.getPlayer());
  Vector center = BlockVectors.center(block).toVector();

  for (Core core : this.cores) {
    if (!core.hasLeaked()
        && core.getCasingRegion().contains(center)
        && player.getParty() == core.getOwner()) {
      event.setCancelled(true);
      player.sendWarning(TranslatableComponent.of("core.damageOwn"));
    }
  }
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void checkBlockDamage(final BlockDamageEvent event) {
    MatchPlayer player = this.match.getParticipant(event.getPlayer());
    if(player == null) return;

    PlayerBlockEventQuery query = new PlayerBlockEventQuery(player, event, event.getBlock().getState());

    for(EventRule rule : this.ruleContext.get(EventRuleScope.BLOCK_BREAK)) {
        if(rule.earlyWarning() && rule.region().contains(event.getBlock())) {
            if(processQuery(rule, query)) {
                if(event.isCancelled() && rule.message() != null) {
                    player.sendWarning(rule.message(), true);
                }
                if(this.useRegionPriority) {
                    break;
                }
            }
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void processBlockDamage(BlockDamageEvent event) {
    if(this.match.getWorld() != event.getBlock().getWorld()) return;

    Block block = event.getBlock();
    MaterialData material = block.getState().getData();
    MatchPlayer player = this.match.getPlayer(event.getPlayer());

    for(Destroyable destroyable : this.destroyables) {
        if(player != null &&
           player.getParty() == destroyable.getOwner() &&
           !destroyable.isDestroyed() &&
           destroyable.getBlockRegion().contains(block) &&
           destroyable.hasMaterial(material)) {

            event.setCancelled(true);
            player.sendWarning(new TranslatableComponent("match.destroyable.damageOwn"), true);
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void damageCheck(BlockDamageEvent event) {
    Block block = event.getBlock();
    if(block.getWorld() != this.match.getWorld()) return;
    MatchPlayer player = this.match.getPlayer(event.getPlayer());
    Vector center = BlockUtils.center(block).toVector();

    for(Core core : this.cores) {
        if(!core.hasLeaked() && core.getCasingRegion().contains(center) && player.getParty() == core.getOwner()) {
            event.setCancelled(true);
            player.sendWarning(PGMTranslations.t("match.core.damageOwn", player), true);
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onBlockDamage(BlockDamageEvent event) {
    Player player = event.getPlayer();
    if (GameManager.getInstance().isSpectator(player)) {
        event.setCancelled(true);
    }
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void onBlockDamage(BlockDamageEvent event) {
    Location location = BukkitUtil.adapt(event.getBlock().getLocation());

    if (manager.isPlotWorld(location)) {
        PlotId id = manager.getPlotId(location);

        if (id == null) {
            event.setCancelled(true);
        } else {
            event.setCancelled(api.isPlotLocked(id));

        }
    }
}
 

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onPlayerBlockDamage(final BlockDamageEvent event) {
  cancelUnlessInteracting(event, event.getPlayer());
}
 

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onPlayerBlockDamage(final BlockDamageEvent event) {
    cancelUnlessInteracting(event, event.getPlayer());
}
 

void onEvent(BlockDamageEvent event) {
    swinging = false;
}
 

@EventHandler
public void onPlayerDig(BlockDamageEvent event) {
    PlayerStaminaState state = states.get(event.getPlayer());
    if(state != null) state.onEvent(event);
}
 

@Override
public void onBlockDamage(BlockDamageEvent event) {
	// TODO Auto-generated method stub
	
}
 

@Override
public void onBlockDamage(BlockDamageEvent arg0) {		
}
 

@Override
public void onBlockDamage(BlockDamageEvent event) {		
}
 

public abstract void onBlockDamage(BlockDamageEvent event);