org.bukkit.entity.Hanging Java Examples

private void handleHangingBreak(Event event, Hanging hanging, Entity breaker) {
  BlockState blockState = getHangingBlockState(hanging);
  if (blockState == null) return;

  Query query = makeBlockQuery(event, breaker, blockState);

  for (RegionFilterApplication rfa : this.rfaContext.get(RFAScope.BLOCK_BREAK)) {
    if (rfa.region.contains(blockState)) {
      if (processQuery(rfa, query)) {
        sendCancelMessage(rfa, query);
        if (this.useRegionPriority || rfa.useRegionPriority) break;
      }
    }
  }
}
 

public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) {
	if (l == 0) {
		return false;
	}
	if (l == 1) {
		return false;
	}
	int i1 = Direction.e[l];
	EntityHanging entityhanging = a(world, i, j, k, i1);
	if (!entityhuman.a(i, j, k, l, itemstack)) {
		return false;
	}
	if ((entityhanging != null) && (entityhanging.survives())) {
		if (!world.isStatic) {
			Player who = entityhuman == null ? null : (Player) entityhuman.getBukkitEntity();
			Block blockClicked = world.getWorld().getBlockAt(i, j, k);
			BlockFace blockFace = CraftBlock.notchToBlockFace(l);

			HangingPlaceEvent event = new HangingPlaceEvent((Hanging) entityhanging.getBukkitEntity(), who, blockClicked, blockFace);
			world.getServer().getPluginManager().callEvent(event);

			PaintingPlaceEvent paintingEvent = null;
			if ((entityhanging instanceof EntityPainting)) {
				paintingEvent = new PaintingPlaceEvent((Painting) entityhanging.getBukkitEntity(), who, blockClicked, blockFace);
				paintingEvent.setCancelled(event.isCancelled());
				world.getServer().getPluginManager().callEvent(paintingEvent);
			}
			if ((event.isCancelled()) || ((paintingEvent != null) && (paintingEvent.isCancelled()))) {
				return false;
			}
			world.addEntity(entityhanging);
		}
		itemstack.count -= 1;
	}
	return true;
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onHangingBreak(HangingBreakEvent event) {
  Hanging hanging = event.getEntity();
  if (event.getCause().equals(RemoveCause.OBSTRUCTION)) {
    hanging.getLocation().getBlock().breakNaturally();
    event.setCancelled(true);
  } else if (event.getCause().equals(RemoveCause.EXPLOSION)) {
    event.setCancelled(true);
  }

}
 

private static Material getHangingType(Hanging hanging) {
    if(hanging instanceof Painting) {
        return Material.PAINTING;
    } else if(hanging instanceof ItemFrame) {
        return Material.ITEM_FRAME;
    } else if(hanging instanceof LeashHitch) {
        return Material.LEASH;
    } else {
        return null;
    }
}
 

private void handleHangingBreak(Event event, Hanging hanging, Entity breaker) {
    BlockState blockState = getHangingBlockState(hanging);
    if(blockState == null) return;

    IEventQuery query = makeBlockQuery(event, breaker, blockState);

    for(EventRule rule : this.ruleContext.get(EventRuleScope.BLOCK_BREAK)) {
        if(rule.region().contains(blockState)) {
            if(processQuery(rule, query)) {
                sendCancelMessage(rule, query);
                if(this.useRegionPriority) break;
            }
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void checkItemFrameItemRemove(EntityDamageByEntityEvent event) {
    // This event is fired when popping an item out of an item frame, without breaking the frame itself
    if(event.getEntity() instanceof ItemFrame && ((ItemFrame) event.getEntity()).getItem() != null) {
        this.handleHangingBreak(event, (Hanging) event.getEntity(), event.getDamager());
    }
}
 

private static Material getHangingType(Hanging hanging) {
  if (hanging instanceof Painting) {
    return Material.PAINTING;
  } else if (hanging instanceof ItemFrame) {
    return Material.ITEM_FRAME;
  } else if (hanging instanceof LeashHitch) {
    return Material.LEASH;
  } else {
    return null;
  }
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void checkItemFrameItemRemove(EntityDamageByEntityEvent event) {
  // This event is fired when popping an item out of an item frame, without breaking the frame
  // itself
  if (event.getEntity() instanceof ItemFrame
      && ((ItemFrame) event.getEntity()).getItem() != null) {
    this.handleHangingBreak(event, (Hanging) event.getEntity(), event.getDamager());
  }
}
 

public HangingBreakByEntityEvent(final Hanging hanging, final Entity remover, final RemoveCause cause) {
    super(hanging, cause);
    this.remover = remover;
}
 

protected HangingEvent(final Hanging painting) {
    this.hanging = painting;
}
 

public HangingBreakEvent(final Hanging hanging, final RemoveCause cause) {
    super(hanging);
    this.cause = cause;
}
 

public HangingBreakByEntityEvent(final Hanging hanging, final Entity remover) {
    this(hanging, remover, RemoveCause.ENTITY);
}
 

public HangingPlaceEvent(final Hanging hanging, final Player player, final Block block, final BlockFace blockFace) {
    super(hanging);
    this.player = player;
    this.block = block;
    this.blockFace = blockFace;
}
 

private static BlockState getHangingBlockState(Hanging hanging) {
    Block block = hanging.getLocation().getBlock();
    Material type = getHangingType(hanging);
    return type == null ? null : BlockStateUtils.cloneWithMaterial(block, type);
}
 

private static BlockState getHangingBlockState(Hanging hanging) {
  Block block = hanging.getLocation().getBlock();
  Material type = getHangingType(hanging);
  return type == null ? null : BlockStates.cloneWithMaterial(block, type);
}
 

/**
 * Handles what happens when a player breaks a block.
 *
 * @param event the passed Bukkit event
 * @return if the event is cancelled
 */
public boolean onBreak(BlockBreakEvent event) {
    Player player = event.getPlayer();
    Block block = event.getBlock();
    for (DungeonSign sign : getDungeonSigns()) {
        if (sign == null) {
            continue;
        }
        if ((block.equals(sign.getSign().getBlock()) || block.equals(BlockUtil.getAttachedBlock(sign.getSign().getBlock()))) && sign.isProtected()) {
            return true;
        }
    }

    for (GameBlock gameBlock : gameBlocks) {
        if (block.equals(gameBlock.getBlock())) {
            if (gameBlock.onBreak(event)) {
                return true;
            }

        } else if (gameBlock instanceof MultiBlock) {
            if (block.equals(((MultiBlock) gameBlock).getAttachedBlock())) {
                if (gameBlock.onBreak(event)) {
                    return true;
                }
            }
        }
    }

    Game game = getGame();
    if (game == null) {
        return true;
    }

    if (!getRules().getState(GameRule.BREAK_BLOCKS) && !getRules().getState(GameRule.BREAK_PLACED_BLOCKS)) {
        return true;
    }

    // Cancel if a protected entity is attached
    for (Entity entity : getWorld().getNearbyEntities(block.getLocation(), 2, 2, 2)) {
        if (!(entity instanceof Hanging)) {
            continue;
        }
        if (entity.getLocation().getBlock().getRelative(((Hanging) entity).getAttachedFace()).equals(block)) {
            Hanging hanging = (Hanging) entity;
            if (getRules().getState(GameRule.DAMAGE_PROTECTED_ENTITIES).contains(caliburn.getExMob(hanging))) {
                event.setCancelled(true);
                break;
            }
        }
    }

    Map<ExItem, HashSet<ExItem>> whitelist = getRules().getState(GameRule.BREAK_WHITELIST);
    ExItem material = VanillaItem.get(block.getType());
    ExItem breakTool = caliburn.getExItem(player.getItemInHand());

    if (getRules().getState(GameRule.BREAK_PLACED_BLOCKS) && placedBlocks.contains(block)) {
        return false;
    }
    if (whitelist != null && whitelist.containsKey(material)
            && (whitelist.get(material) == null
            || whitelist.get(material).isEmpty()
            || whitelist.get(material).contains(breakTool))) {
        return false;
    }

    return true;
}
 

/**
 * Gets the hanging entity involved in this event.
 *
 * @return the hanging entity
 */
public Hanging getEntity() {
    return hanging;
}