299 lines
8.1 KiB
Java
299 lines
8.1 KiB
Java
package com.craftaro.epicenchants.utils.objects;
|
|
|
|
import com.craftaro.third_party.com.cryptomorin.xseries.XMaterial;
|
|
import com.craftaro.core.third_party.de.tr7zw.nbtapi.NBTItem;
|
|
import com.craftaro.epicenchants.objects.Placeholder;
|
|
import com.craftaro.epicenchants.wrappers.EnchantmentWrapper;
|
|
import com.craftaro.epicenchants.utils.single.ConfigParser;
|
|
import com.craftaro.epicenchants.utils.single.GeneralUtils;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.configuration.ConfigurationSection;
|
|
import org.bukkit.enchantments.Enchantment;
|
|
import org.bukkit.entity.LivingEntity;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.inventory.ItemFlag;
|
|
import org.bukkit.inventory.ItemStack;
|
|
import org.bukkit.inventory.meta.ItemMeta;
|
|
import org.bukkit.inventory.meta.SkullMeta;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.stream.Collectors;
|
|
|
|
import static com.craftaro.epicenchants.utils.single.GeneralUtils.color;
|
|
|
|
public class ItemBuilder {
|
|
private final ItemStack item;
|
|
private ItemMeta meta;
|
|
private final Set<EnchantmentWrapper> enchantmentWrappers;
|
|
|
|
/*
|
|
* Constructors:
|
|
*/
|
|
public ItemBuilder(Material material) {
|
|
this(new ItemStack(material));
|
|
}
|
|
|
|
public ItemBuilder(Material material, int amount) {
|
|
this(new ItemStack(material, amount));
|
|
}
|
|
|
|
public ItemBuilder(Material material, byte data) {
|
|
this(new ItemStack(material, 1, data));
|
|
}
|
|
|
|
public ItemBuilder(Material material, int amount, byte data) {
|
|
this(new ItemStack(material, amount, data));
|
|
}
|
|
|
|
public ItemBuilder(ConfigurationSection section, Player player, Placeholder... placeholders) {
|
|
this(section, placeholders);
|
|
|
|
if (XMaterial.PLAYER_HEAD.isSimilar(this.item)) {
|
|
((SkullMeta) this.item.getItemMeta()).setOwner(player.getName());
|
|
}
|
|
}
|
|
|
|
public ItemBuilder(ConfigurationSection section, Placeholder... placeholders) {
|
|
this(Material.valueOf(section.getString("material")), (byte) (section.contains("data") ? section.getInt("data") : 0));
|
|
|
|
if (section.contains("enchants")) {
|
|
section.getStringList("enchants").stream()
|
|
.map(ConfigParser::parseEnchantmentWrapper)
|
|
.forEach(this::addEnchantWrapper);
|
|
}
|
|
|
|
if (section.contains("display-name")) {
|
|
String displayName = section.getString("display-name");
|
|
for (Placeholder placeholder : placeholders) {
|
|
displayName = displayName.replace(placeholder.getPlaceholder(), placeholder.getToReplace().toString());
|
|
}
|
|
name(color(displayName));
|
|
}
|
|
|
|
if (section.contains("lore")) {
|
|
List<String> lore = section.getStringList("lore");
|
|
outer:
|
|
for (int i = 0; i < lore.size(); i++) {
|
|
String string = lore.get(i);
|
|
|
|
for (Placeholder placeholder : placeholders) {
|
|
if (placeholder.getToReplace() instanceof ArrayList && string.contains(placeholder.getPlaceholder())) {
|
|
lore.remove(i);
|
|
lore.addAll(i, (ArrayList<String>) placeholder.getToReplace());
|
|
continue outer;
|
|
} else {
|
|
string = string.replace(placeholder.getPlaceholder(), placeholder.getToReplace().toString());
|
|
}
|
|
}
|
|
|
|
lore.set(i, string);
|
|
}
|
|
lore(lore.stream().map(GeneralUtils::color).collect(Collectors.toList()));
|
|
}
|
|
}
|
|
|
|
public ItemBuilder(ItemStack item) {
|
|
this.item = item;
|
|
this.meta = item.getItemMeta();
|
|
this.enchantmentWrappers = new HashSet<>();
|
|
}
|
|
|
|
/*
|
|
* Meta:
|
|
*/
|
|
public boolean hasMeta() {
|
|
return getMeta() != null;
|
|
}
|
|
|
|
public ItemBuilder meta(ItemMeta meta) {
|
|
this.meta = meta;
|
|
return this;
|
|
}
|
|
|
|
/*
|
|
* Name:
|
|
*/
|
|
public boolean hasName() {
|
|
return this.meta.hasDisplayName();
|
|
}
|
|
|
|
public ItemBuilder name(String name) {
|
|
this.meta.setDisplayName(name);
|
|
return this;
|
|
}
|
|
|
|
/*
|
|
* Lore:
|
|
*/
|
|
public boolean hasLore() {
|
|
return this.meta.hasLore();
|
|
}
|
|
|
|
public ItemBuilder lore(String... lore) {
|
|
return lore(Arrays.asList(lore));
|
|
}
|
|
|
|
public ItemBuilder lore(List<String> lore) {
|
|
this.meta.setLore(lore);
|
|
return this;
|
|
}
|
|
|
|
public ItemBuilder addLore(List<String> lore) {
|
|
if (!this.meta.hasLore()) {
|
|
this.meta.setLore(lore);
|
|
return this;
|
|
}
|
|
|
|
List<String> toAdd = this.meta.getLore();
|
|
toAdd.addAll(lore);
|
|
this.meta.setLore(toAdd);
|
|
return this;
|
|
}
|
|
|
|
public ItemBuilder removeLore(String string) {
|
|
if (this.meta == null || !this.meta.hasLore()) {
|
|
return this;
|
|
}
|
|
|
|
this.meta.setLore(this.meta.getLore().stream().filter(s -> !s.startsWith(string)).collect(Collectors.toList()));
|
|
return this;
|
|
}
|
|
|
|
public ItemBuilder removeLore(int index) {
|
|
if (!this.meta.hasLore()) {
|
|
return this;
|
|
}
|
|
|
|
List<String> lore = this.meta.getLore();
|
|
|
|
if (index >= lore.size()) {
|
|
return this;
|
|
}
|
|
|
|
lore.remove(index);
|
|
|
|
this.meta.setLore(lore);
|
|
return this;
|
|
}
|
|
|
|
public ItemBuilder addLore(String... lore) {
|
|
return addLore(Arrays.asList(lore));
|
|
}
|
|
|
|
/*
|
|
* Enchantments:
|
|
*/
|
|
public boolean hasEnchants() {
|
|
return this.meta.hasEnchants();
|
|
}
|
|
|
|
public boolean hasEnchant(Enchantment enchantment) {
|
|
return this.meta.hasEnchant(enchantment);
|
|
}
|
|
|
|
public boolean hasConflictingEnchant(Enchantment enchantment) {
|
|
return this.meta.hasConflictingEnchant(enchantment);
|
|
}
|
|
|
|
public ItemBuilder addEnchant(Enchantment enchantment, int level) {
|
|
this.meta.addEnchant(enchantment, level, true);
|
|
return this;
|
|
}
|
|
|
|
public ItemBuilder removeEnchant(Enchantment enchantment) {
|
|
this.meta.removeEnchant(enchantment);
|
|
return this;
|
|
}
|
|
|
|
public ItemBuilder addEnchantWrapper(EnchantmentWrapper enchantmentWrapper) {
|
|
this.enchantmentWrappers.add(enchantmentWrapper);
|
|
return this;
|
|
}
|
|
|
|
/*
|
|
* Skulls:
|
|
*/
|
|
public boolean hasSkullOwner() {
|
|
return ((SkullMeta) this.meta).hasOwner();
|
|
}
|
|
|
|
public String getSkullOwner() {
|
|
return ((SkullMeta) this.meta).getOwner();
|
|
}
|
|
|
|
public ItemBuilder skullOwner(String owner) {
|
|
this.item.setDurability((short) 3);
|
|
((SkullMeta) this.meta).setOwner(owner);
|
|
return this;
|
|
}
|
|
|
|
public ItemBuilder durability(int durability) {
|
|
this.item.setDurability((short) durability);
|
|
return this;
|
|
}
|
|
|
|
/*
|
|
* Flags:
|
|
*/
|
|
public boolean hasFlag(ItemFlag flag) {
|
|
return this.meta.hasItemFlag(flag);
|
|
}
|
|
|
|
public ItemBuilder addFlags(ItemFlag... flags) {
|
|
this.meta.addItemFlags(flags);
|
|
return this;
|
|
}
|
|
|
|
public ItemBuilder removeFlags(ItemFlag... flags) {
|
|
this.meta.removeItemFlags(flags);
|
|
return this;
|
|
}
|
|
|
|
public NBTItem nbt() {
|
|
return new NBTItem(build());
|
|
}
|
|
|
|
/*
|
|
* Build the ItemStack.
|
|
*/
|
|
public ItemStack build() {
|
|
this.item.setItemMeta(this.meta);
|
|
return this.item;
|
|
}
|
|
|
|
public ItemStack buildWithWrappers(int level, Player user, LivingEntity opponent) {
|
|
this.item.setItemMeta(this.meta);
|
|
this.enchantmentWrappers.forEach(enchant -> this.item.addUnsafeEnchantment(enchant.getEnchantment(), enchant.getAmplifier(level, user, opponent)));
|
|
return this.item;
|
|
}
|
|
|
|
public Map<Enchantment, Integer> getEnchants() {
|
|
return this.meta.getEnchants();
|
|
}
|
|
|
|
public Set<ItemFlag> getFlags() {
|
|
return this.meta.getItemFlags();
|
|
}
|
|
|
|
public List<String> getLore() {
|
|
return this.meta.getLore();
|
|
}
|
|
|
|
public ItemMeta getMeta() {
|
|
return this.meta;
|
|
}
|
|
|
|
/*
|
|
* NBT
|
|
*/
|
|
|
|
public String getName() {
|
|
return this.meta.getDisplayName();
|
|
}
|
|
}
|