org.bukkit.Material Java Examples

private void breakLog(Block log, Block android, BlockMenu menu, BlockFace face) {
    ItemStack drop = new ItemStack(log.getType());

    if (menu.fits(drop, getOutputSlots())) {
        menu.pushItem(drop, getOutputSlots());
        log.getWorld().playEffect(log.getLocation(), Effect.STEP_SOUND, log.getType());

        if (log.getY() == android.getRelative(face).getY()) {
            Optional<Material> sapling = MaterialConverter.getSaplingFromLog(log.getType());

            if (sapling.isPresent()) {
                log.setType(sapling.get());
            }
        }
        else {
            log.setType(Material.AIR);
        }
    }
}
 

@Override
public int spaceForItem(TPDirection insertDirection, ItemStack insertion) {
    if (isInvLocked(cachedInvHolder)) {
        return 0;
    }

    int space = 0;

    for (int i = 0; i < cachedInv.getSize(); i++) {
        ItemStack item = cachedInv.getItem(i);
        if (item == null || item.getType() == Material.AIR) {
            space += insertion.getMaxStackSize();
        } else if (item.isSimilar(insertion) && item.getAmount() < item.getMaxStackSize()) {
            space += item.getMaxStackSize() - item.getAmount();
        }
    }

    return space;
}
 

/**
 * Add all NBT Data from a Map. The String is the NBT Key, the Object is the
 * data you wish to store. Valid types are: Void, byte, short, int, long,
 * float, double, byte[], int[], String, List and Map.
 * 
 * @param nbtData
 */
public void addAllNBTData(Map<? extends String, ? extends Object> nbtData) {
	if (itemStack == null || itemStack.getType().equals(Material.AIR))
		return;
	ItemStack stack = NbtFactory.getCraftItemStack(itemStack);
	NbtCompound nbt = NbtFactory.fromItemTag(stack);
	nbt.putAll(nbtData);
	updateLore();
}
 

@EventHandler
public void onTeamChestBuilt(BedwarsPlayerBuildBlock event) {
    if (event.isCancelled()) {
        return;
    }

    Block block = event.getBlock();
    RunningTeam team = event.getTeam();

    if (block.getType() != Material.ENDER_CHEST) {
        return;
    }

    String unhidden = APIUtils.unhashFromInvisibleStringStartsWith(event.getItemInHand(), TEAM_CHEST_PREFIX);

    if (unhidden != null || Main.getConfigurator().config.getBoolean("specials.teamchest.turn-all-enderchests-to-teamchests")) {
        team.addTeamChest(block);
        String message = i18n("team_chest_placed");
        for (Player pl : team.getConnectedPlayers()) {
            pl.sendMessage(message);
        }
    }
}
 

@EventHandler(ignoreCancelled = true)
public void onLeftClick(PlayerInteractEvent event) {
    if (!(event.getAction() == Action.LEFT_CLICK_AIR || event.getAction() == Action.LEFT_CLICK_BLOCK)) {
        return;
    }
    ItemStack itemStack = ReflectionUtils.invokeMethod(event.getPlayer(), this.getItemInHandMethod);
    if (itemStack != null && itemStack.getType() != Material.AIR) {
        NBTItem nbtItem = new NBTItem(itemStack);
        if (!nbtItem.hasKey("HubBasics")) return;
        event.setCancelled(true);
        CustomItem item = HubBasics.getInstance().getItemManager().get(nbtItem.getString("HubBasics"));
        if (item == null) {
            itemStack.setType(Material.AIR); // Destroy old item
            return;
        }
        if (!item.getRunOnLeftClick()) return;
        item.onCommand(event.getPlayer());
    }
}
 

/**
 * Creates a door with a given time in seconds.
 *
 * @param player the player who is setting the arena up
 * @param input  the time, in seconds, the door will take to open
 */
private void addDoor(Player player, String input) {
    Block block = player.getEyeLocation().getBlock();
    Material material = block.getType();
    if (material != Material.SIGN_POST && material != Material.WALL_SIGN) {
        Messages.BLOCK_NOT_SIGN.send(player);
        return;
    }

    int seconds = Utils.getNumber(player, input);

    if (seconds < 0) {
        Messages.BAD_SECONDS.send(player);
        return;
    }

    int signID = editedFile.createListLocation(player, block.getLocation(), "Doors");
    editedFile.getConfig().set("Doors." + signID + ".Timer", seconds);
    editedFile.saveFile();
    Messages.CREATED_SIGN.send(player, signID, seconds);
}
 

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onInteract(PlayerInteractEvent clickEvent) {
    Player player = clickEvent.getPlayer();
    PlayerInventory inventory = player.getInventory();

    ItemStack mainHandItem;
    if (mainHandSupported) {
        mainHandItem = inventory.getItemInMainHand();
    } else {
        mainHandItem = inventory.getItemInHand();
    }

    if (isOurGraph(mainHandItem)) {
        inventory.setItemInMainHand(new ItemStack(Material.AIR));
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onInteract(final PlayerInteractEvent event) {
    if(cancelUnlessInteracting(event, event.getPlayer())) {
        // Allow the how-to book to be read
        if(event.getMaterial() == Material.WRITTEN_BOOK) {
            event.setUseItemInHand(Event.Result.ALLOW);
        } else {
            event.setUseItemInHand(Event.Result.DENY);
            event.setUseInteractedBlock(Event.Result.DENY);
        }

        MatchPlayer player = getMatch().getPlayer(event.getPlayer());
        if(player == null) return;

        if(!player.isSpawned()) {
            ClickType clickType = convertClick(event.getAction(), event.getPlayer());
            if(clickType == null) return;

            getMatch().callEvent(new ObserverInteractEvent(player, clickType, event.getClickedBlock(), null, event.getItem()));
        }

        // Right-clicking armor will put it on unless we do this
        event.getPlayer().updateInventory();
    }
}
 

private boolean removeSign(CommandSender commandSender, Player player) {
    if (checkSignSelectorActive(commandSender)) {
        return true;
    }

    Block block = player.getTargetBlock((Set<Material>) null, 15);
    if (block.getState() instanceof org.bukkit.block.Sign) {
        if (SignSelector.getInstance().containsPosition(block.getLocation())) {
            Sign sign = SignSelector.getInstance().getSignByPosition(block.getLocation());

            if (sign != null) {
                CloudAPI.getInstance().getNetworkConnection().sendPacket(new PacketOutRemoveSign(sign));
                commandSender.sendMessage(CloudAPI.getInstance().getPrefix() + "The sign has been removed");
            }
        }
    }
    return false;
}
 

public static Material changeMaterialColor(Material material, TeamColor teamColor) {
    String materialName = material.name();

    try {
        materialName = material.toString().substring(material.toString().indexOf("_") + 1);
    } catch (StringIndexOutOfBoundsException ignored) {
    }

    String teamMaterialColor = teamColor.material1_13;

    if (Main.autoColoredMaterials.contains(materialName)) {
        return Material.getMaterial(teamMaterialColor + "_" + materialName);
    } else if (material.toString().contains("GLASS")) {
        return Material.getMaterial(teamMaterialColor + "_STAINED_GLASS");
    } else if (material.toString().contains("GLASS_PANE")) {
        return Material.getMaterial(teamMaterialColor + "_STAINED_GLASS_PANE");
    }
    return material;

}
 

public InventoryView openEnchanting(Location location, boolean force) {
    if (!force) {
        Block block = location.getBlock();
        if (block.getType() != Material.ENCHANTMENT_TABLE) {
            return null;
        }
    }
    if (location == null) {
        location = getLocation();
    }
    getHandle().displayGUIEnchantment(location.getBlockX(), location.getBlockY(), location.getBlockZ(), null);
    if (force) {
        getHandle().openContainer.checkReachable = false;
    }
    return getHandle().openContainer.getBukkitView();
}
 

@EventHandler(priority = EventPriority.LOW)
public void onInventoryClick(final InventoryClickEvent event)
{
    final User user = UserManager.getUser(event.getWhoClicked().getUniqueId());

    if (user != null &&
        // Quickbar actions can be performed outside the inventory.
        event.getSlotType() != InventoryType.SlotType.QUICKBAR)
    {
        // Only update if the inventory is currently closed to not interfere with opening time checks.
        if (!user.hasOpenInventory()) {
            user.getTimestampMap().updateTimeStamp(TimestampKey.INVENTORY_OPENED);
        }

        user.getTimestampMap().updateTimeStamp(TimestampKey.LAST_INVENTORY_CLICK);
        if (event.getCurrentItem() != null) {
            user.getTimestampMap().updateTimeStamp(TimestampKey.LAST_INVENTORY_CLICK_ON_ITEM);
        }

        user.getDataMap().setValue(DataKey.LAST_RAW_SLOT_CLICKED, event.getRawSlot());
        user.getDataMap().setValue(DataKey.LAST_MATERIAL_CLICKED, event.getCurrentItem() == null ?
                                                                  Material.AIR :
                                                                  event.getCurrentItem().getType());
    }
}
 

@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);
    }
}
 

@Override
public void test() throws Exception {
	ItemStack item = new ItemStack(Material.STONE, 1);
	ItemMeta meta = item.getItemMeta();
	meta.setLore(Lists.newArrayList("Firest Line", "Second Line"));
	item.setItemMeta(meta);
	String nbt = NBTItem.convertItemtoNBT(item).toString();
	if (!nbt.contains("Firest Line") || !nbt.contains("Second Line"))
		throw new NbtApiException("The Item nbt '" + nbt + "' didn't contain the lore");
	ItemStack rebuild = NBTItem.convertNBTtoItem(new NBTContainer(nbt));
	if (!item.isSimilar(rebuild))
		throw new NbtApiException("Rebuilt item did not match the original!");
	
	NBTContainer cont = new NBTContainer();
	cont.setItemStack("testItem", item);
	if(!cont.getItemStack("testItem").isSimilar(item))
		throw new NbtApiException("Rebuilt item did not match the original!");
}
 

@Override
public void reload() {
	FileConfiguration config = getConfig();
	config.options().copyDefaults(true);

	config.addDefault("Allowed", true);
	config.addDefault("Color", "%YELLOW%");
	config.addDefault("MaxLevel", 2);
	config.addDefault("SlotCost", 1);

	config.addDefault("EnchantCost", 10);
	config.addDefault("Enchantable", true);

	config.addDefault("Recipe.Enabled", false);

	ConfigurationManager.saveConfig(config);
	ConfigurationManager.loadConfig("Modifiers" + File.separator, getFileName());

	init(Material.BLAZE_ROD);
}
 

@Override
public ItemStack getColorItem(String mat, byte color) {
	if (mat.equalsIgnoreCase("wool")) {
		return new ItemStack(Material.WOOL, 1, (short) color);
	} else if (mat.equalsIgnoreCase("glass")) {
		return new ItemStack(Material.STAINED_GLASS, 1, (short) color);
	} else if (mat.equalsIgnoreCase("banner")) {
		return new ItemStack(Material.BANNER, 1, (short) color);
	} else {
		return new ItemStack(Material.STAINED_GLASS, 1, (short) color);
	}
}
 

private void getTownRingSettings(FileConfiguration config) {
    townRings = config.getBoolean("town-rings", true);
    try {
        townRingMat = Material.valueOf(config.getString("town-ring-material", "GLOWSTONE"));
    } catch (Exception e) {
        townRingMat = Material.GLOWSTONE;
        Civs.logger.severe("Unable to read town-ring-material");
    }
}
 

protected static ItemStack createPlaceholder(Material material, String name, String lore) {
	ArrayList<String> loreList = new ArrayList<String>(2);
	if (lore != null) {
		loreList.add(lore);
	}
	loreList.add("§oThis is a placeholder item.");
	loreList.add("§oClick to remove.");
	return UtilsMc.newSingleItemStack(material, name, loreList);
}
 

/**
 * Toggles an {@link ItemStack} to be Soulbound.<br>
 * If true is passed, this will add the {@link #SOULBOUND_LORE} and
 * add a {@link NamespacedKey} to the item so it can be quickly identified
 * by {@link #isSoulbound(ItemStack)}.<br>
 * If false is passed, this property will be removed.
 *
 * @param item
 *            The {@link ItemStack} you want to add/remove Soulbound from.
 * @param makeSoulbound
 *            If they item should be soulbound.
 * 
 * @see #isSoulbound(ItemStack)
 */
public static void setSoulbound(ItemStack item, boolean makeSoulbound) {
    if (item == null || item.getType() == Material.AIR) {
        throw new IllegalArgumentException("A soulbound item cannot be null or air!");
    }

    boolean isSoulbound = isSoulbound(item);
    ItemMeta meta = item.getItemMeta();

    if (SlimefunPlugin.getMinecraftVersion().isAtLeast(MinecraftVersion.MINECRAFT_1_14)) {
        PersistentDataContainer container = meta.getPersistentDataContainer();

        if (makeSoulbound && !isSoulbound) {
            container.set(SOULBOUND_KEY, PersistentDataType.BYTE, (byte) 1);
        }

        if (!makeSoulbound && isSoulbound) {
            container.remove(SOULBOUND_KEY);
        }
    }

    List<String> lore = meta.hasLore() ? meta.getLore() : new ArrayList<>();

    if (makeSoulbound && !isSoulbound) {
        lore.add(SOULBOUND_LORE);
    }

    if (!makeSoulbound && isSoulbound) {
        lore.remove(SOULBOUND_LORE);
    }

    meta.setLore(lore);
    item.setItemMeta(meta);
}
 

public static ItemStack getEnchantmentBook(LinkedHashMap<Enchantment, Integer> enchants, int amount) {
  final ItemStack s = new ItemStack(Material.ENCHANTED_BOOK, amount);
  final EnchantmentStorageMeta sm = (EnchantmentStorageMeta) s;
  for(Enchantment enchant : enchants.keySet()) {
    sm.addStoredEnchant(enchant, enchants.get(enchant), true);
  }
  s.setItemMeta(sm);
  return s;
}
 

public IndustrialMiner(Category category, SlimefunItemStack item, Material baseMaterial, boolean silkTouch, int range) {
    super(category, item, new ItemStack[] { null, null, null, new CustomItem(Material.PISTON, "Piston (facing up)"), new ItemStack(Material.CHEST), new CustomItem(Material.PISTON, "Piston (facing up)"), new ItemStack(baseMaterial), new ItemStack(SlimefunPlugin.getMinecraftVersion().isAtLeast(MinecraftVersion.MINECRAFT_1_14) ? Material.BLAST_FURNACE : Material.FURNACE), new ItemStack(baseMaterial) }, new ItemStack[0], BlockFace.UP);

    this.range = range;
    this.silkTouch = silkTouch;

    registerDefaultFuelTypes();
}
 

protected int getPriceFromColumn(Inventory inventory, int column) {
	ItemStack lowCostItem = inventory.getItem(column + 18);
	ItemStack highCostItem = inventory.getItem(column + 9);
	int cost = 0;
	if (lowCostItem != null && lowCostItem.getType() == Settings.currencyItem && lowCostItem.getAmount() > 0) {
		cost += lowCostItem.getAmount();
	}
	if (Settings.highCurrencyItem != Material.AIR && highCostItem != null && highCostItem.getType() == Settings.highCurrencyItem && highCostItem.getAmount() > 0) {
		cost += highCostItem.getAmount() * Settings.highCurrencyValue;
	}
	return cost;
}
 

protected ItemStack createItem(Material icon, int subType, String title, List<String> lore) {
    ItemStack itemStack = new ItemStack(icon, 1, (short) (subType & 0xff));
    ItemMeta meta = itemStack.getItemMeta();
    meta.setDisplayName(title);
    meta.setLore(lore);
    itemStack.setItemMeta(meta);
    return itemStack;
}
 

/**
 * Gets material by id
 *
 * @param id id
 * @return material enum
 */
public static Material getMaterial(int id) {
	for(Material material : Material.values()) {
		if(material.getId() == id) {
			return material;
		}
	}

	return null;
}
 

@Test
public void testSetSoulbound() {
    ItemStack item = new CustomItem(Material.DIAMOND, "&cI wanna be soulbound!");

    Assertions.assertFalse(SlimefunUtils.isSoulbound(item));

    SlimefunUtils.setSoulbound(item, true);
    Assertions.assertTrue(SlimefunUtils.isSoulbound(item));
    Assertions.assertEquals(1, item.getItemMeta().getLore().size());

    SlimefunUtils.setSoulbound(item, false);
    Assertions.assertFalse(SlimefunUtils.isSoulbound(item));
    Assertions.assertEquals(0, item.getItemMeta().getLore().size());
}
 

private void checkSuccess() {
	new BukkitRunnable() {
		@Override
		public void run() {
			if (ent.getLocation().getBlockY() == prevY && !success) {
				ent.getWorld().getBlockAt(ent.getLocation()).setType(Material.ENDER_CHEST);
				setLocation(ent.getWorld().getBlockAt(ent.getLocation()));
				ent.remove();
			} else {
				prevY = ent.getLocation().getY();
				checkSuccess();
			}
		}
	}.runTaskLater(SkyWarsReloaded.get(), 10L);
}
 

/**
 * Returns whether the NPC can take durability from the held item.
 */
public boolean shouldTakeDura() {
    ItemStack it = getHeldItem();
    if (it == null) {
        return false;
    }
    Material type = it.getType();
    return SentinelVersionCompat.BOW_MATERIALS.contains(type) || SentinelVersionCompat.SWORD_MATERIALS.contains(type)
            || SentinelVersionCompat.PICKAXE_MATERIALS.contains(type) || SentinelVersionCompat.AXE_MATERIALS.contains(type);
}
 

@Override
public boolean checkMaterial(FallingBlock fb, Material mat) {
	if (fb.getMaterial().equals(mat)) {
		return true;
	}
	return false;
}
 

private static ItemStack getSkull(String id, String texture) {
    if (SlimefunPlugin.getMinecraftVersion() == MinecraftVersion.UNIT_TEST) {
        return new ItemStack(Material.PLAYER_HEAD);
    }

    return SkullItem.fromBase64(getTexture(id, texture));
}
 

@EventWrapper
public void onBlockSpread(final BlockSpreadEvent event) {
  // This fires for: fire, grass, mycelium, mushrooms, and vines
  // Fire is already handled by BlockIgniteEvent
  if (event.getNewState().getType() != Material.FIRE) {
    this.callEvent(
        new BlockTransformEvent(event, event.getBlock().getState(), event.getNewState()));
  }
}