diff --git a/build.gradle.kts b/build.gradle.kts index 25b11d7a..27ba54d0 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -22,7 +22,6 @@ repositories { mavenCentral() maven("https://repo.papermc.io/repository/maven-public/") maven("https://oss.sonatype.org/content/groups/public/") - maven("https://repo.extendedclip.com/content/repositories/placeholderapi/") maven("https://nexus.iridiumdevelopment.net/repository/maven-releases/") maven("https://jitpack.io") maven("https://maven.enginehub.org/repo/") @@ -30,11 +29,11 @@ repositories { maven("https://nexus.neetgames.com/repository/maven-releases/") maven("https://repo.jsinco.dev/releases") maven("https://maven.playpro.com/") + maven("https://repo.okaeri.cloud/releases") } dependencies { - compileOnly("me.clip:placeholderapi:2.11.6") - compileOnly("com.github.Zrips:jobs:v4.17.2") { + compileOnly("com.github.Zrips:Jobs:v5.2.6.2") { isTransitive = false } compileOnly("net.dmulloy2:ProtocolLib:5.4.0") @@ -47,9 +46,10 @@ dependencies { compileOnly("dev.lumas.glowapi:LumaGlowAPI:c57567c") implementation("com.iridium:IridiumColorAPI:1.0.9") + implementation("eu.okaeri:okaeri-configs-yaml-snakeyaml:6.1.0-beta.1") // PaperWeight - paperweight.paperDevBundle("1.21.10-R0.1-SNAPSHOT") + paperweight.paperDevBundle("1.21.11-R0.1-SNAPSHOT") } tasks { @@ -66,6 +66,7 @@ tasks { shadowJar { val pack = "dev.lumas.lumaitems.shaded" relocate("com.iridium.iridiumcolorapi", "$pack.iridiumcolorapi") + relocate("eu.okaeri", "$pack.okaeri") exclude("kotlin/**") minimize() archiveClassifier.set("") diff --git a/src/main/java/dev/lumas/lumaitems/LumaItems.java b/src/main/java/dev/lumas/lumaitems/LumaItems.java index 11a7614b..b48f112a 100644 --- a/src/main/java/dev/lumas/lumaitems/LumaItems.java +++ b/src/main/java/dev/lumas/lumaitems/LumaItems.java @@ -1,30 +1,23 @@ package dev.lumas.lumaitems; -import com.comphenix.protocol.ProtocolLibrary; -import com.comphenix.protocol.ProtocolManager; import dev.lumas.lumacore.manager.modules.ModuleManager; import dev.lumas.lumacore.reflect.ReflectionUtil; -import dev.lumas.lumaitems.api.LumaItemsAPI; import dev.lumas.lumaitems.events.items.PassiveListeners; import dev.lumas.lumaitems.guis.AbstractGui; import dev.lumas.lumaitems.enums.Action; -import dev.lumas.lumaitems.manager.FileManager; import dev.lumas.lumaitems.manager.GlowManager; import dev.lumas.lumaitems.manager.ItemManager; import dev.lumas.lumaitems.relics.RelicCrafting; import dev.lumas.lumaitems.relics.RelicDisassembler; +import dev.lumas.lumaitems.util.Executors; import dev.lumas.lumaitems.util.Util; -import net.coreprotect.CoreProtect; -import net.coreprotect.CoreProtectAPI; import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.event.HandlerList; import org.bukkit.plugin.java.JavaPlugin; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import java.io.File; -import java.lang.reflect.Field; import java.util.Set; import java.util.logging.Level; @@ -32,25 +25,19 @@ public final class LumaItems extends JavaPlugin { private static LumaItems instance; private static PassiveListeners passiveListeners; - private static ItemManager itemManagerInstance; + private static ItemManager itemManager; private static ModuleManager moduleManager; - // TODO: please move this to some kind of actual hook manager/registry - private static boolean withProtocolLib; - private static boolean withMythicMobs; - private static boolean withmcMMO; - private static boolean withCoreProtect; - private static boolean withLumaGlowAPI; - @Override public void onLoad() { instance = this; + passiveListeners = new PassiveListeners(this); + itemManager = new ItemManager(); moduleManager = new ModuleManager(this); } @Override public void onEnable() { - FileManager.generateDefaultFiles(); // TODO: Replace FileManager with Okaeri long start = System.currentTimeMillis(); ReflectionUtil reflectionUtil = ReflectionUtil.of(getClass()); reflectionUtil.whitelistPackages( @@ -60,22 +47,13 @@ public void onEnable() { "events.items" ); - withProtocolLib = getServer().getPluginManager().isPluginEnabled("ProtocolLib"); - withMythicMobs = getServer().getPluginManager().isPluginEnabled("MythicMobs"); - withmcMMO = getServer().getPluginManager().isPluginEnabled("mcMMO"); - withCoreProtect = getServer().getPluginManager().isPluginEnabled("CoreProtect"); - withLumaGlowAPI = getServer().getPluginManager().isPluginEnabled("LumaGlowAPI"); - - passiveListeners = new PassiveListeners(this); - itemManagerInstance = new ItemManager(this); - Set> classSet = reflectionUtil.getAllClassesFor(); moduleManager.reflectivelyRegisterModules(classSet); if (!Bukkit.getOnlinePlayers().isEmpty()) { log("Players are online, registering items asynchronously"); - Bukkit.getScheduler().runTaskAsynchronously(this, () -> { + Executors.async(task -> { try { - initItemManager(itemManagerInstance); + initItemManager(itemManager); } catch (Throwable e) { getLogger().log(Level.SEVERE, "An error occurred while registering items asynchronously", e); getServer().getPluginManager().disablePlugin(this); @@ -83,7 +61,7 @@ public void onEnable() { log("Finished asynchronous item registration!" + " Took " + (System.currentTimeMillis() - start) + "ms"); }); } else { - initItemManager(itemManagerInstance); + initItemManager(itemManager); log("Finished synchronous item registration!" + " Took " + (System.currentTimeMillis() - start) + "ms"); } @@ -119,20 +97,6 @@ public void onDisable() { player.closeInventory(); } } - - - // stupid and unnecessary - try { - Field singleTonField = LumaItemsAPI.class.getDeclaredField("singleton"); - singleTonField.setAccessible(true); - if (singleTonField.get(LumaItemsAPI.class) == null) { - return; - } - singleTonField.set(null, null); - LumaItems.log("API Singleton instance has been reset!"); - } catch (NoSuchFieldException | IllegalAccessException e) { - LumaItems.log("Failed to reset API Singleton instance!", e); - } } @NotNull @@ -145,30 +109,8 @@ public static LumaItems getInstance() { return instance; } - @Nullable - public static ProtocolManager getProtocolManager() { - return withProtocolLib ? ProtocolLibrary.getProtocolManager() : null; - } - - @Nullable - public static CoreProtectAPI getCoreProtectAPI() { - return withCoreProtect ? CoreProtect.getInstance().getAPI() : null; - } - - public static boolean isWithMythicMobs() { - return withMythicMobs; - } - - public static boolean isWithmcMMO() { - return withmcMMO; - } - - public static boolean isWithLumaGlowAPI() { - return withLumaGlowAPI; - } - - public static ItemManager getItemManagerInstance() { - return itemManagerInstance; + public static ItemManager getItemManager() { + return itemManager; } public static void log(String m) { diff --git a/src/main/java/dev/lumas/lumaitems/api/LumaItemsAPI.java b/src/main/java/dev/lumas/lumaitems/api/LumaItemsAPI.java index 476931bd..a5479480 100644 --- a/src/main/java/dev/lumas/lumaitems/api/LumaItemsAPI.java +++ b/src/main/java/dev/lumas/lumaitems/api/LumaItemsAPI.java @@ -5,6 +5,7 @@ import dev.lumas.lumaitems.items.ItemFactory; import dev.lumas.lumaitems.manager.CustomItem; import dev.lumas.lumaitems.manager.ItemManager; +import dev.lumas.lumaitems.registry.Registry; import org.bukkit.NamespacedKey; import org.bukkit.inventory.ItemStack; import org.bukkit.persistence.PersistentDataType; @@ -83,8 +84,8 @@ public CustomItem getCustomItem(ItemStack itemStack) { if (!itemStack.hasItemMeta()) return null; var meta = itemStack.getItemMeta(); - for (var customItem : ItemManager.CUSTOM_ITEMS.entrySet()) { - if (meta.getPersistentDataContainer().has(customItem.getKey(), PersistentDataType.SHORT)) { + for (var customItem : Registry.CUSTOM_ITEMS) { + if (meta.getPersistentDataContainer().has(customItem.getKey().asNameSpacedKey(), PersistentDataType.SHORT)) { return customItem.getValue(); } } @@ -124,7 +125,7 @@ public List getAllItems() { * @param customItem CustomItem to register */ public void registerCustomItem(CustomItem customItem) { - LumaItems.getItemManagerInstance().registerItem(customItem); + LumaItems.getItemManager().registerItem(customItem); } /** @@ -139,7 +140,7 @@ public void registerCustomItem(CustomItem customItem) { public void registerForPackage(String pack, File file) throws IOException { try (URLClassLoader classLoader = new URLClassLoader(new URL[]{ file.toURI().toURL() }, this.getClass().getClassLoader())) { ClassPath classPath = ClassPath.from(classLoader); - LumaItems.getItemManagerInstance().registerForPackage(pack, classPath); + LumaItems.getItemManager().registerForPackage(pack, classPath); } } diff --git a/src/main/java/dev/lumas/lumaitems/commands/SwapHandsCommand.kt b/src/main/java/dev/lumas/lumaitems/commands/SwapHandsCommand.kt index dd26e360..5ad5eee7 100644 --- a/src/main/java/dev/lumas/lumaitems/commands/SwapHandsCommand.kt +++ b/src/main/java/dev/lumas/lumaitems/commands/SwapHandsCommand.kt @@ -7,6 +7,8 @@ import dev.lumas.lumacore.manager.commands.CommandInfo import dev.lumas.lumacore.manager.modules.AutoRegister import dev.lumas.lumacore.manager.modules.RegisterType import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.hooks.ProtocolLibHook +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.MiniMessageUtil import org.bukkit.command.CommandSender import org.bukkit.entity.Player @@ -22,7 +24,7 @@ import org.bukkit.entity.Player class SwapHandsCommand : AbstractCommand() { override fun handle(sender: CommandSender, label: String, args: Array): Boolean { - val protocolManager = LumaItems.getProtocolManager() ?: run { + val protocolManager = Registry.HOOKS.getOrThrow(ProtocolLibHook::class).getProtocolManager() ?: run { MiniMessageUtil.msg(sender, "Couldn't find ProtocolLib!") return true } diff --git a/src/main/java/dev/lumas/lumaitems/commands/subcommands/GiveAstralCommand.kt b/src/main/java/dev/lumas/lumaitems/commands/subcommands/GiveAstralCommand.kt index f259ea39..2095b6da 100644 --- a/src/main/java/dev/lumas/lumaitems/commands/subcommands/GiveAstralCommand.kt +++ b/src/main/java/dev/lumas/lumaitems/commands/subcommands/GiveAstralCommand.kt @@ -3,10 +3,12 @@ package dev.lumas.lumaitems.commands.subcommands import dev.lumas.lumacore.manager.commands.CommandInfo import dev.lumas.lumacore.manager.modules.AutoRegister import dev.lumas.lumacore.manager.modules.RegisterType +import dev.lumas.lumacore.utility.Text import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.commands.CommandManager import dev.lumas.lumaitems.commands.SubCommand -import dev.lumas.lumaitems.manager.FileManager +import dev.lumas.lumaitems.configuration.files.AstralYml +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.relics.RelicCrafting import org.bukkit.command.CommandSender import org.bukkit.entity.Player @@ -22,12 +24,10 @@ import org.bukkit.entity.Player ) class GiveAstralCommand : SubCommand { - private val file = FileManager("astral.yml").generateYamlFile() - override fun execute(plugin: LumaItems, sender: CommandSender, label: String, args: Array): Boolean { val player = sender as? Player ?: return false if (args.size != 1) { - player.sendMessage("Invalid arguments") + Text.msg(player, "Invalid arguments") return false } val items = RelicCrafting.getItemsFromClass(args[0]) @@ -38,7 +38,11 @@ class GiveAstralCommand : SubCommand { } override fun tabComplete(plugin: LumaItems, sender: CommandSender, args: Array): List? { - return file.getConfigurationSection("astral-orb-rarities")?.getKeys(false)?.toList() + return Registry.CONFIGS.getOrThrow(AstralYml::class) + .astralOrbRarities + .keys + .map { it.setClass.simpleName } + .toList() } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/commands/subcommands/GiveItemCommand.kt b/src/main/java/dev/lumas/lumaitems/commands/subcommands/GiveItemCommand.kt index 9585b03a..9c092bb9 100644 --- a/src/main/java/dev/lumas/lumaitems/commands/subcommands/GiveItemCommand.kt +++ b/src/main/java/dev/lumas/lumaitems/commands/subcommands/GiveItemCommand.kt @@ -7,6 +7,8 @@ import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.commands.CommandManager import dev.lumas.lumaitems.commands.SubCommand import dev.lumas.lumaitems.manager.ItemManager +import dev.lumas.lumaitems.registry.Registry +import dev.lumas.lumaitems.registry.StringIdentifier import dev.lumas.lumaitems.util.MiniMessageUtil import dev.lumas.lumaitems.util.Util import org.bukkit.command.CommandSender @@ -63,7 +65,7 @@ class GiveItemCommand : SubCommand { override fun tabComplete(plugin: LumaItems, sender: CommandSender, args: Array): List? { return when (args.size) { 1 -> { - val list: MutableList = ItemManager.CUSTOM_ITEMS_BY_NAME.keys.toMutableList() + val list: MutableList = Registry.NAMED_CUSTOM_ITEMS.keySet(StringIdentifier::class).map { it.key() }.toMutableList() list.add("all") list } diff --git a/src/main/java/dev/lumas/lumaitems/configuration/ConfigManager.java b/src/main/java/dev/lumas/lumaitems/configuration/ConfigManager.java new file mode 100644 index 00000000..e2fa9c4a --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/ConfigManager.java @@ -0,0 +1,60 @@ +package dev.lumas.lumaitems.configuration; + +import com.google.common.base.Preconditions; +import dev.lumas.lumaitems.LumaItems; +import dev.lumas.lumaitems.configuration.serdes.AstralSetClassTransformer; +import dev.lumas.lumaitems.configuration.serdes.EnchantmentTransformer; +import dev.lumas.lumaitems.configuration.serdes.LocationTransformer; +import dev.lumas.lumaitems.configuration.serdes.PairedEnchantmentTransformer; +import dev.lumas.lumaitems.registry.Registry; +import dev.lumas.lumaitems.registry.RegistryCrafter; +import eu.okaeri.configs.OkaeriConfig; +import eu.okaeri.configs.serdes.standard.StandardSerdes; +import eu.okaeri.configs.yaml.snakeyaml.YamlSnakeYamlConfigurer; + +import java.nio.file.Path; + +public class ConfigManager implements RegistryCrafter.Extension { + + public static final Path DATA_FOLDER = LumaItems.getInstance().getDataPath(); + + @Override + public T craft(Class clazz) { + File annotation = clazz.getAnnotation(File.class); + if (annotation == null) { + throw new IllegalStateException("OkaeriFile must be annotated with @File"); + } + + String fileName = annotation.value(); + Preconditions.checkNotNull(fileName, "Dynamic file name could not be resolved for " + clazz.getName()); + Path bindFile = DATA_FOLDER.resolve(fileName); + + + return eu.okaeri.configs.ConfigManager.create((Class) clazz, (it) -> { + it.configure(configurer -> { + configurer.configurer(new YamlSnakeYamlConfigurer(), new StandardSerdes()); + configurer.removeOrphans(true); + configurer.bindFile(bindFile); + configurer.serdes(serdes -> { + serdes.add(new LocationTransformer()); + serdes.add(new EnchantmentTransformer()); + serdes.add(new PairedEnchantmentTransformer()); + serdes.add(new AstralSetClassTransformer()); + }); + }); + + it.saveDefaults(); + it.load(true); + }); + } + + + public static T get(Class clazz) { + return Registry.CONFIGS.values().stream() + .filter(it -> it.getClass().equals(clazz)) + .map(it -> (T) it) + .findFirst() + .orElseThrow(() -> new IllegalStateException("No config found for class " + clazz.getName())); + } + +} diff --git a/src/main/java/dev/lumas/lumaitems/util/NeedsEdits.java b/src/main/java/dev/lumas/lumaitems/configuration/File.java similarity index 69% rename from src/main/java/dev/lumas/lumaitems/util/NeedsEdits.java rename to src/main/java/dev/lumas/lumaitems/configuration/File.java index b2ab8762..875fd337 100644 --- a/src/main/java/dev/lumas/lumaitems/util/NeedsEdits.java +++ b/src/main/java/dev/lumas/lumaitems/configuration/File.java @@ -1,12 +1,12 @@ -package dev.lumas.lumaitems.util; +package dev.lumas.lumaitems.configuration; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; -@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) -public @interface NeedsEdits { - boolean review() default false; +@Target(ElementType.TYPE) +public @interface File { + String value() default ""; } diff --git a/src/main/java/dev/lumas/lumaitems/configuration/OkaeriFile.java b/src/main/java/dev/lumas/lumaitems/configuration/OkaeriFile.java new file mode 100644 index 00000000..2418bd4d --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/OkaeriFile.java @@ -0,0 +1,20 @@ +package dev.lumas.lumaitems.configuration; + +import dev.lumas.lumaitems.registry.Identifier; +import dev.lumas.lumaitems.registry.RegistryItem; +import dev.lumas.lumaitems.registry.StringIdentifier; +import eu.okaeri.configs.OkaeriConfig; +import org.jetbrains.annotations.NotNull; + +public abstract class OkaeriFile extends OkaeriConfig implements RegistryItem { + + @NotNull + @Override + public Identifier identifier() { + File annotation = getClass().getAnnotation(File.class); + if (annotation == null) { + throw new IllegalStateException("OkaeriFile must be annotated with @File"); + } + return StringIdentifier.of(annotation.value()); + } +} diff --git a/src/main/java/dev/lumas/lumaitems/configuration/files/AstralYml.kt b/src/main/java/dev/lumas/lumaitems/configuration/files/AstralYml.kt new file mode 100644 index 00000000..b2b868a1 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/files/AstralYml.kt @@ -0,0 +1,325 @@ +package dev.lumas.lumaitems.configuration.files + +import dev.lumas.lumaitems.configuration.File +import dev.lumas.lumaitems.configuration.OkaeriFile +import dev.lumas.lumaitems.configuration.model.AstralSetClass +import dev.lumas.lumaitems.configuration.model.PairedEnchantment +import dev.lumas.lumaitems.enums.ToolType +import dev.lumas.lumaitems.items.astral.sets.ArchaelSet +import dev.lumas.lumaitems.items.astral.sets.BlitzSet +import dev.lumas.lumaitems.items.astral.sets.FalterSet +import dev.lumas.lumaitems.items.astral.sets.HarbingerSet +import dev.lumas.lumaitems.items.astral.sets.KazkanSet +import dev.lumas.lumaitems.items.astral.sets.MagmaticSet +import dev.lumas.lumaitems.items.astral.sets.MelukaSet +import dev.lumas.lumaitems.items.astral.sets.ReforgedSet +import dev.lumas.lumaitems.items.astral.sets.ValleySet +import dev.lumas.lumaitems.items.astral.sets.VenomSet +import dev.lumas.lumaitems.items.astral.sets.VerdantSet +import dev.lumas.lumaitems.items.astral.upgrades.AstralMaterial +import dev.lumas.lumaitems.registry.Registry +import eu.okaeri.configs.OkaeriConfig +import eu.okaeri.configs.annotation.Comment +import eu.okaeri.configs.annotation.CustomKey +import org.bukkit.enchantments.Enchantment +import org.jetbrains.annotations.Range + +@File("astral.yml") +class AstralYml : OkaeriFile() { + + @Comment("Class name and then chance of item") + @CustomKey("astral-orb-rarities") + var astralOrbRarities: Map = mapOf( + AstralSetClass(MagmaticSet::class) to 35, + AstralSetClass(ArchaelSet::class) to 38, + AstralSetClass(VenomSet::class) to 43, + AstralSetClass(MagmaticSet::class) to 0, + AstralSetClass(FalterSet::class) to 3, + AstralSetClass(MelukaSet::class) to 42, + AstralSetClass(ValleySet::class) to 70, + AstralSetClass(BlitzSet::class) to 10, + AstralSetClass(ReforgedSet::class) to 20, + AstralSetClass(KazkanSet::class) to 11, + AstralSetClass(HarbingerSet::class) to 8, + AstralSetClass(VerdantSet::class) to 25 + ) + + @Comment("All sets by default will start from tier 1. Do not go below tier 2 here.") + @CustomKey("astral-upgrades") + var astralUpgrades: Map> = buildMap { + buildTiers("magmatic-set") { + tier(2) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.MENDING, 1), + PairedEnchantment(Enchantment.FIRE_ASPECT, 3), + PairedEnchantment(Enchantment.EFFICIENCY, 5), + PairedEnchantment(Enchantment.LOOTING, 3), + PairedEnchantment(Enchantment.FORTUNE, 3), + PairedEnchantment(Enchantment.UNBREAKING, 6), + PairedEnchantment(Enchantment.FEATHER_FALLING, 4) + ) + } + } + + buildTiers("venom-set") { + tier(2) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.MENDING, 1), + PairedEnchantment(Enchantment.PROTECTION, 6), + PairedEnchantment(Enchantment.SHARPNESS, 7), + PairedEnchantment(Enchantment.UNBREAKING, 6), + PairedEnchantment(Enchantment.THORNS, 5) + ) + } + } + + buildTiers("meluka-set") { + tier(2) { + material(AstralMaterial.IRON) + enchants( + PairedEnchantment(Enchantment.EFFICIENCY, 5), + PairedEnchantment(Enchantment.UNBREAKING, 5), + PairedEnchantment(Enchantment.RESPIRATION, 4), + PairedEnchantment(Enchantment.DEPTH_STRIDER, 4), + PairedEnchantment(Enchantment.PROTECTION, 6) + ) + } + tier(3) { + material(AstralMaterial.DIAMOND) + enchants( + PairedEnchantment(Enchantment.EFFICIENCY, 6), + PairedEnchantment(Enchantment.MENDING, 1), + PairedEnchantment(Enchantment.UNBREAKING, 6), + PairedEnchantment(Enchantment.RESPIRATION, 5) + ) + } + tier(4) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.EFFICIENCY, 7), + PairedEnchantment(Enchantment.UNBREAKING, 7), + PairedEnchantment(Enchantment.RESPIRATION, 6), + PairedEnchantment(Enchantment.PROTECTION, 7) + ) + } + } + + buildTiers("archael-set") { + tier(2) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.MENDING, 1), + PairedEnchantment(Enchantment.UNBREAKING, 6), + PairedEnchantment(Enchantment.PROJECTILE_PROTECTION, 6) + ) + } + } + + buildTiers("mistral-set") { + tier(2) { + material(AstralMaterial.DIAMOND) + enchants( + PairedEnchantment(Enchantment.PROTECTION, 6), + PairedEnchantment(Enchantment.PROJECTILE_PROTECTION, 7), + PairedEnchantment(Enchantment.SHARPNESS, 7), + PairedEnchantment(Enchantment.EFFICIENCY, 7), + PairedEnchantment(Enchantment.MENDING, 1) + ) + } + tier(3) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.UNBREAKING, 8), + PairedEnchantment(Enchantment.EFFICIENCY, 8), + PairedEnchantment(Enchantment.LUCK_OF_THE_SEA, 5) + ) + } + } + + buildTiers("falter-set") { + tier(2) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.EFFICIENCY, 10), + PairedEnchantment(Enchantment.UNBREAKING, 10) + ) + } + } + + buildTiers("reforged-set") { + tier(2) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.PROTECTION, 8), + PairedEnchantment(Enchantment.SOUL_SPEED, 3), + PairedEnchantment(Enchantment.AQUA_AFFINITY, 1), + PairedEnchantment(Enchantment.UNBREAKING, 7) + ) + } + } + + buildTiers("valley-set") { + tier(2) { + material(AstralMaterial.DIAMOND) + enchants( + PairedEnchantment(Enchantment.EFFICIENCY, 7, ToolType.AXE, ToolType.PICKAXE, ToolType.SHOVEL, ToolType.HOE), + PairedEnchantment(Enchantment.UNBREAKING, 7) + ) + } + tier(3) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.EFFICIENCY, 8, ToolType.AXE, ToolType.PICKAXE, ToolType.SHOVEL, ToolType.HOE), + PairedEnchantment(Enchantment.LURE, 5) + ) + } + } + + buildTiers("blitz-set") { + tier(2) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.MENDING, 1), + PairedEnchantment(Enchantment.UNBREAKING, 7), + PairedEnchantment(Enchantment.EFFICIENCY, 6, ToolType.AXE), + PairedEnchantment(Enchantment.FORTUNE, 4, ToolType.AXE), + PairedEnchantment(Enchantment.FEATHER_FALLING, 5, ToolType.ELYTRA), + PairedEnchantment(Enchantment.BLAST_PROTECTION, 4, ToolType.ELYTRA) + ) + } + } + + buildTiers("kazkan-set") { + tier(2) { + material(AstralMaterial.DIAMOND) + enchants( + PairedEnchantment(Enchantment.UNBREAKING, 8, ToolType.AXE, ToolType.CROSSBOW, ToolType.MAGICAL, ToolType.SHIELD), + PairedEnchantment(Enchantment.MENDING, 1, ToolType.AXE, ToolType.CROSSBOW, ToolType.MAGICAL, ToolType.SHIELD), + PairedEnchantment(Enchantment.FIRE_ASPECT, 3, ToolType.MAGICAL), + PairedEnchantment(Enchantment.SHARPNESS, 7, ToolType.AXE), + PairedEnchantment(Enchantment.LOOTING, 4, ToolType.AXE), + PairedEnchantment(Enchantment.BANE_OF_ARTHROPODS, 6, ToolType.AXE), + PairedEnchantment(Enchantment.QUICK_CHARGE, 3, ToolType.CROSSBOW), + PairedEnchantment(Enchantment.PIERCING, 5, ToolType.CROSSBOW) + ) + } + tier(3) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.UNBREAKING, 9), + PairedEnchantment(Enchantment.FIRE_ASPECT, 5, ToolType.MAGICAL), + PairedEnchantment(Enchantment.KNOCKBACK, 3, ToolType.MAGICAL), + PairedEnchantment(Enchantment.SHARPNESS, 8, ToolType.AXE), + PairedEnchantment(Enchantment.LOOTING, 5, ToolType.AXE), + PairedEnchantment(Enchantment.BANE_OF_ARTHROPODS, 7, ToolType.AXE), + PairedEnchantment(Enchantment.QUICK_CHARGE, 4, ToolType.CROSSBOW), + PairedEnchantment(Enchantment.PIERCING, 6, ToolType.CROSSBOW) + ) + } + } + + buildTiers("harbinger-set") { + tier(2) { + material(AstralMaterial.DIAMOND) + enchants( + PairedEnchantment(Enchantment.MENDING, 1), + PairedEnchantment(Enchantment.UNBREAKING, 6), + PairedEnchantment(Enchantment.PROTECTION, 8), + PairedEnchantment(Enchantment.RESPIRATION, 2, ToolType.HELMET), + PairedEnchantment(Enchantment.AQUA_AFFINITY, 1, ToolType.HELMET), + PairedEnchantment(Enchantment.FEATHER_FALLING, 4, ToolType.BOOTS, ToolType.ELYTRA), + PairedEnchantment(Enchantment.SWIFT_SNEAK, 2, ToolType.LEGGINGS), + PairedEnchantment(Enchantment.SOUL_SPEED, 2, ToolType.BOOTS) + ) + } + tier(3) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.UNBREAKING, 8), + PairedEnchantment(Enchantment.PROTECTION, 10), + PairedEnchantment(Enchantment.RESPIRATION, 3, ToolType.HELMET), + PairedEnchantment(Enchantment.FEATHER_FALLING, 6, ToolType.BOOTS, ToolType.ELYTRA), + PairedEnchantment(Enchantment.SWIFT_SNEAK, 3, ToolType.LEGGINGS), + PairedEnchantment(Enchantment.SOUL_SPEED, 3, ToolType.BOOTS) + ) + } + } + + buildTiers("verdant-set") { + tier(2) { + material(AstralMaterial.NETHERITE) + enchants( + PairedEnchantment(Enchantment.MENDING, 1), + PairedEnchantment(Enchantment.UNBREAKING, 7), + PairedEnchantment(Enchantment.EFFICIENCY, 6, ToolType.AXE, ToolType.PICKAXE, ToolType.HOE, ToolType.SHOVEL), + PairedEnchantment(Enchantment.FORTUNE, 3, ToolType.AXE, ToolType.PICKAXE, ToolType.HOE, ToolType.SHOVEL), + PairedEnchantment(Enchantment.PROTECTION, 5, ToolType.HELMET, ToolType.CHESTPLATE, ToolType.LEGGINGS, ToolType.BOOTS), + PairedEnchantment(Enchantment.FIRE_PROTECTION, 4, ToolType.HELMET, ToolType.CHESTPLATE, ToolType.LEGGINGS, ToolType.BOOTS), + PairedEnchantment(Enchantment.BLAST_PROTECTION, 4, ToolType.HELMET, ToolType.CHESTPLATE, ToolType.LEGGINGS, ToolType.BOOTS), + PairedEnchantment(Enchantment.RESPIRATION, 3, ToolType.HELMET), + PairedEnchantment(Enchantment.FEATHER_FALLING, 5, ToolType.BOOTS) + ) + } + } + } + + + inline fun MutableMap>.buildTiers(key: String, block: MutableList.() -> Unit) { + this[key] = buildList(block) + } + + + inline fun MutableList.tier(int: @Range(from = 1, to = Int.MAX_VALUE.toLong()) Int, block: OkaeriAstralUpgradeTier.Builder.() -> Unit) { + add(OkaeriAstralUpgradeTier.Builder().tier(int).apply(block).build()) + } + + + class OkaeriAstralUpgradeTier( + var tier: @Range(from = 1, to = Int.MAX_VALUE.toLong()) Int, + var material: AstralMaterial, + var enchants: List + ) : OkaeriConfig() { + + fun isMaxTier(): Boolean { + val configUpgradeTiers = Registry.CONFIGS.getOrThrow(AstralYml::class).astralUpgrades + return isMaxTier(configUpgradeTiers.values) + } + + fun isMaxTier(upgradeTiers: Collection>): Boolean { + val tierListForThisTier = upgradeTiers.find { it.contains(this) } ?: throw IllegalArgumentException("Tier list for this tier not found $this") + return this.tier >= tierListForThisTier.maxOf { it.tier } + } + + class Builder { + var tier: Int = 1 + var material: AstralMaterial = AstralMaterial.DIAMOND + var enchants: List = listOf() + + fun tier(tier: Int): Builder { + this.tier = tier + return this + } + + fun material(material: AstralMaterial): Builder { + this.material = material + return this + } + + fun enchants(enchants: List): Builder { + this.enchants = enchants + return this + } + + fun enchants(vararg enchants: PairedEnchantment): Builder { + this.enchants = enchants.toList() + return this + } + + fun build(): OkaeriAstralUpgradeTier { + return OkaeriAstralUpgradeTier(tier, material, enchants) + } + } + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/configuration/files/HeadsYml.kt b/src/main/java/dev/lumas/lumaitems/configuration/files/HeadsYml.kt new file mode 100644 index 00000000..d36f4dcd --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/files/HeadsYml.kt @@ -0,0 +1,40 @@ +package dev.lumas.lumaitems.configuration.files + +import dev.lumas.lumaitems.configuration.File +import dev.lumas.lumaitems.configuration.OkaeriFile +import eu.okaeri.configs.annotation.Comment +import eu.okaeri.configs.annotation.CustomKey + +@File("heads.yml") +class HeadsYml : OkaeriFile() { + + @Comment("Easter 2024") + @CustomKey("easter-egg") + var easterEgg: List = listOf( + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNDY0MmFmYTM5Njg1M2I4MWIxN2JlZjVjOGQ3YTQ0YzEyZGU2ODlhNTZhZjQ3NDg0NjY3OTgzOTlkYTNjZmVhZSJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTM5NjQyNWIyNjc3NDFkZGU0YTNhYzQ4OTBiN2Y5NWE4YjI5ODJkYTlmNGE5NWE2ZWE0ZDU1NjFkOTczNyJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvM2YxYzI1YmY2MWEyYmJjN2E5OTU4ZTliOWRiYzlmZjdlMDg3N2M2MjJlNDdmYmNkNTUzNmU5YmUzZDAxMWIzMyJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZmMyMzNlOTI3ZWNmNjE4ZWE4YWY4NTI0ZjU4Mzk3NWFjOWM4NmQ1ZThkNzFlZTdmZTM4MzQzMTY0Y2I2In19fQ==", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZmRlMGE1MGIyYzA3NjVmMDY4NjhmNjBjYWNlYzNmMmNhYWNkY2RkODU1NGI0Y2FkYjlkNjQ2NDAyNzVkNzE5NiJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTdmMGRjOThkZTRiZDIzMWVlODM0OGQ3NzdkMjkxYjdhNGEyYWQ5ZGY0MWJiMzllZGNmODcwYTllM2ZhYzZlNCJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTg0ZTc2ZGM4NzMzZjk2YTg0NjhkMzhmNzNhNWY3NzA4OTZkNWExMjljY2E4YzI5ZWZlOTkxOTdjYjY2NmFmMiJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNjIzZmNiMTU2ZTQ1ZmViNGM3NzU5MjZiZWQ4MjMwZjhkNjUwYzdiZmJjMzQ2MGQwYmI2ZWExMDhiYjFjZWQ5ZCJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvODBiOGVmNTJmYjdkNWZjMDE2ODJlNmYxYjAyNGUwY2MxYjc2YzJhZTQxYzk2YTdlNTRlNWZmNWE1MTU4NjlkYyJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvODQxMmFmNjhlZGMzZWFkN2UzYWE5OWU5MjM4MTY2MzU5ZmVlNjE4OTA0ZWNlY2ZhYzNhYWJlNGIyNzc1M2VkMyJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNTBjZDc5NWViOTRlYmJlNDA1ZTZhNjAwYWVlOTVmZmZhZmMyYjhjNzQ0ODY1MGMwYmFhOTdmYzcwMjFjMzU0NCJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMmNiZWQ4YTgzMzU4NTQ0MDMyYzMxNGIzODFlYmJiMWVjNGY0MGZiNTI3M2Y0NWUxNTZhZWM3YjJjMDdlZGZkZCJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNWI5ZTZlMzRiNWI2MGZkNTNkNTdmZGE5OTgwZDdlOTk3YjUwNDY0Y2IxZjUxZGJjMzU3YTM3MmYzNjc2NTAzIn19fQ==", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZmQ1NWQ3Nzc0ZDFhN2Q2ZWQ0NTU2MDQxZTk2YmVhODIwYjI1ZGQ4ZjEzZmM1YTNlODI1NzYxZDBjMWZhNzZiYSJ9fX0=" + ) + + @Comment("Carnival 2024") + @CustomKey("clown-masks") + var clownMasks: List = listOf( + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvN2YyMzk1ZTg2MDE0YzE4NjQ0NjM0ZDc4ZDE1Mjg4NTI2N2Q3YzE5MDFjZDlhOGUxZDQ2MjRmNjM4MDYzN2U4MyJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTM4YmQxZmJmYTg3M2ZjZjcyYmFkNDg0MzI1NjQxNmNmNGIzZjU0ZjdiZDM5MmZkMWEwNDNjM2Q2MWFmZTdhMyJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZmIzNDQwYWI5MGE2OTBkNzNkZmEwNjhlYmJiNmM3ZWZhODhlODg5OGUzZDY0NjBlMmMwODg2ZWVhNjU4MzUyZCJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNjNjZjAyZWRkNTE1N2ZlYjUzZGU0OGNiZGYyZTIxZGI1YzkwMGIwZjk4NDlkYjRmY2MwYzNkZGNkNjBkMTljOCJ9fX0=", + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTY4NzgzY2FiMWNiMTUwMTdhNzQ2MTE4MTMyYWJmZTM2YThlOGYyNDI5YTI0NzY2YTcxMGNjYmQ2MzY1YjU2ZSJ9fX0=" + ) + +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/configuration/files/RelicsYml.kt b/src/main/java/dev/lumas/lumaitems/configuration/files/RelicsYml.kt new file mode 100644 index 00000000..aaa9caa2 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/files/RelicsYml.kt @@ -0,0 +1,425 @@ +package dev.lumas.lumaitems.configuration.files + +import dev.lumas.lumaitems.configuration.File +import dev.lumas.lumaitems.configuration.OkaeriFile +import eu.okaeri.configs.OkaeriConfig +import eu.okaeri.configs.annotation.CustomKey +import org.bukkit.Bukkit +import org.bukkit.Location +import org.bukkit.Material + +@File("relics.yml") +class RelicsYml : OkaeriFile() { + + var disassembler = DisassemblerSection() + @CustomKey("relic-materials") + var relicMaterials = RelicMaterialsSection() + var names = NamesSection() + + class DisassemblerSection : OkaeriConfig() { + var commands: Map = mapOf( + 5 to "lumaitems relic %player% core lunar", + 20 to "csap box rare %player%", + 29 to "points give %player% 5", + 39 to "repairtoken give %player% Repair3 1", + 41 to "csap box common %player%", + 60 to "give %player% experience_bottle 16", + 38 to "give %player% netherite_scrap 1", + 45 to "repairtoken give %player% Repair2 1", + 42 to "give %player% diamond 3", + 48 to "give %player% iron_ingot 5", + 47 to "repairtoken give %player% Repair1 1", + 43 to "give %player% gold_ingot 5", + 50 to "give %player% coal_block 4", + 44 to "lumaitems relic %player% shard 4" + ) + + var blocks: Map = mapOf( + "spawnDec" to Location(Bukkit.getWorld("spawn"), 199.0, 61.0, 215.0) + ) + } + + class RelicMaterialsSection : OkaeriConfig() { + var lunar: List = listOf( + Material.DIAMOND_HELMET, + Material.DIAMOND_CHESTPLATE, + Material.DIAMOND_LEGGINGS, + Material.DIAMOND_BOOTS, + Material.DIAMOND_SWORD, + Material.DIAMOND_PICKAXE, + Material.DIAMOND_AXE, + Material.DIAMOND_SHOVEL, + Material.DIAMOND_HOE + ) + + var nova: List = listOf( + Material.COPPER_HELMET, + Material.COPPER_CHESTPLATE, + Material.COPPER_LEGGINGS, + Material.COPPER_BOOTS, + Material.COPPER_SWORD, + Material.COPPER_PICKAXE, + Material.COPPER_AXE, + Material.COPPER_SHOVEL, + Material.COPPER_HOE, + Material.GOLDEN_HELMET, + Material.GOLDEN_CHESTPLATE, + Material.GOLDEN_LEGGINGS, + Material.GOLDEN_BOOTS, + Material.GOLDEN_SWORD, + Material.GOLDEN_PICKAXE, + Material.GOLDEN_AXE, + Material.GOLDEN_SHOVEL, + Material.GOLDEN_HOE, + Material.IRON_SWORD, + Material.IRON_PICKAXE, + Material.IRON_AXE, + Material.IRON_SHOVEL, + Material.IRON_HOE, + Material.CHAINMAIL_HELMET, + Material.CHAINMAIL_CHESTPLATE, + Material.CHAINMAIL_LEGGINGS, + Material.CHAINMAIL_BOOTS, + Material.LEATHER_HELMET, + Material.LEATHER_CHESTPLATE, + Material.LEATHER_LEGGINGS, + Material.LEATHER_BOOTS, + Material.STONE_SWORD, + Material.STONE_PICKAXE, + Material.STONE_AXE, + Material.STONE_SHOVEL, + Material.STONE_HOE, + Material.BOW + ) + + var pulsar: List = listOf( + Material.COPPER_HELMET, + Material.COPPER_CHESTPLATE, + Material.COPPER_LEGGINGS, + Material.COPPER_BOOTS, + Material.COPPER_SWORD, + Material.COPPER_PICKAXE, + Material.COPPER_AXE, + Material.COPPER_SHOVEL, + Material.COPPER_HOE, + Material.GOLDEN_HELMET, + Material.GOLDEN_CHESTPLATE, + Material.GOLDEN_LEGGINGS, + Material.GOLDEN_BOOTS, + Material.GOLDEN_SWORD, + Material.GOLDEN_PICKAXE, + Material.GOLDEN_AXE, + Material.GOLDEN_SHOVEL, + Material.GOLDEN_HOE, + Material.IRON_SWORD, + Material.IRON_PICKAXE, + Material.IRON_AXE, + Material.IRON_SHOVEL, + Material.IRON_HOE, + Material.CHAINMAIL_HELMET, + Material.CHAINMAIL_CHESTPLATE, + Material.CHAINMAIL_LEGGINGS, + Material.CHAINMAIL_BOOTS, + Material.LEATHER_HELMET, + Material.LEATHER_CHESTPLATE, + Material.LEATHER_LEGGINGS, + Material.LEATHER_BOOTS, + Material.STONE_SWORD, + Material.STONE_PICKAXE, + Material.STONE_AXE, + Material.STONE_HOE, + Material.WOODEN_PICKAXE, + Material.WOODEN_AXE, + Material.WOODEN_SHOVEL, + Material.BOW + ) + + var solar: List = listOf( + Material.CHAINMAIL_HELMET, + Material.CHAINMAIL_CHESTPLATE, + Material.CHAINMAIL_LEGGINGS, + Material.CHAINMAIL_BOOTS, + Material.LEATHER_HELMET, + Material.LEATHER_CHESTPLATE, + Material.LEATHER_LEGGINGS, + Material.LEATHER_BOOTS, + Material.STONE_SWORD, + Material.STONE_PICKAXE, + Material.STONE_AXE, + Material.STONE_SHOVEL, + Material.STONE_HOE, + Material.WOODEN_PICKAXE, + Material.WOODEN_AXE, + Material.WOODEN_SHOVEL, + Material.WOODEN_HOE, + Material.BOW + ) + + var delta: List = listOf( + Material.WOODEN_SPEAR, + Material.STONE_SPEAR, + Material.COPPER_SPEAR, + Material.LEATHER, + Material.CROSSBOW, + Material.CHAINMAIL_HELMET, + Material.CHAINMAIL_CHESTPLATE, + Material.CHAINMAIL_LEGGINGS, + Material.CHAINMAIL_BOOTS, + Material.LEATHER_HELMET, + Material.LEATHER_CHESTPLATE, + Material.LEATHER_LEGGINGS, + Material.LEATHER_BOOTS, + Material.STONE_SWORD, + Material.STONE_PICKAXE, + Material.STONE_AXE, + Material.STONE_SHOVEL, + Material.STONE_HOE, + Material.WOODEN_PICKAXE, + Material.WOODEN_AXE, + Material.WOODEN_SHOVEL, + Material.WOODEN_HOE + ) + } + + + class NamesSection : OkaeriConfig() { + var prefixes: List = listOf( + "Bleak", + "Spotlight", + "Liar's", + "Soul", + "Apple Slice", + "Imagination", + "Candy", + "White Wool", + "Lover's", + "Telephone", + "City Pop", + "Ice Cube", + "Yam", + "Circus", + "Carnival", + "Phoenix", + "Reflections", + "Opera House", + "Clouded Skies", + "Zodiac", + "Blonde", + "Cotton Candy", + "Sweet Soul", + "Egyptian", + "Utopian", + "Sakura", + "Cherry", + "Oak", + "Crew", + "Crimson", + "Forgotten", + "Boss'", + "Green Thumb", + "Trooper", + "Smash", + "Nameless", + "Soda", + "Beluga", + "J's", + "Witch's", + "Rats'", + "Saiyan's", + "Sugar Apple", + "Lightwater", + "Plastic", + "Lasting", + "Deni's", + "Kujo's", + "Kat's", + "Unreal", + "Didi's", + "Rat", + "Psycho", + "Dim's", + "Bayleaf's", + "Limz's", + "Kek's", + "Mystic", + "King's", + "Queen's", + "Pauper", + "PC's", + "Bjorn's", + "WitchBiscuit's", + "Nerdy", + "Potato", + "Winlo's", + "Drew's", + "Cobra", + "Magician's", + "Last", + "Nebula", + "Tidal Wave", + "Beach House", + "Saxaphone", + "Angelic", + "Friction", + "Party", + "Bounce House", + "Fruitful", + "Note", + "Fantasy Dream", + "Fantasia", + "Rojo", + "Diamond", + "Shadow", + "Material", + "Greek", + "Flagged", + "Luma", + "Luna", + "Jaunty", + "Janty", + "Lumin", + "Mayor's", + "Peasant", + "Snowy", + "Car", + "Breathing", + "Hot Air", + "Cold Sweat", + "Smiling", + "Happy Day", + "Cherry", + "Blossom", + "Lost", + "Insanity", + "Spotted", + "Spooder", + "Dotted", + "Caught", + "Soft Smile", + "Osh's", + "Lily's", + "Rose", + "Rock", + "Ugly Sweater", + "Tree", + "Stinky", + "Coffee's", + "Krox's", + "Prism's", + "Bailey's", + "Soda's", + "Legit's", + "Brand's", + "Tom's", + "Adora's", + "Oddi's", + "Bubbles'", + "Leah's", + "Tsui's", + "Sunni's", + "Slime's", + "Casper's", + "Autumn's", + "Ara's", + "Syielves'", + "Maddie's", + "Purple's", + "Diverse's", + "Bea's", + "Tisol's", + "Mlien's", + "Duck's", + "Corpes'", + "Daisy's", + "Lee's", + "Saph's", + "Fiellessi's", + "Mush's", + "Seiten's", + "Max's", + "yessir's", + "McArth's", + "Num's", + "Wetketchup's" + ) + + var suffixes: List = listOf( + "Vortex", + "Elegance", + "Apex", + "Serenity", + "Panorama", + "Silhouette", + "Opulence", + "Oracle", + "Muse", + "Mosaic", + "Chalice", + "Vestige", + "Paragon", + "Paradox", + "Grace", + "Tranquility", + "Horizon", + "Reverie", + "Echo", + "Enigma", + "Anomaly", + "Aberration", + "Exception", + "Unity", + "Solitude", + "Ascent", + "Mirage", + "Abyss", + "Remnant", + "Whisper", + "Revenant", + "Labyrinth", + "Synchrony", + "Nocturne", + "Nemesis", + "Crescendo", + "Incense", + "Resonance", + "Serenade", + "Calling", + "Brewing", + "Everlasting", + "Nest", + "Nexus", + "Package", + "Class", + "Junction", + "Methoding", + "Drink", + "Cheating", + "Fastening", + "Speed", + "Longevity", + "Vitality", + "Heart", + "Bently", + "LightSaber", + "Shinings", + "Savings", + "Forgetfulness", + "Happiness", + "Job", + "Feelings", + "Power", + "Might", + "Chance", + "Lumin", + "Smile", + "Monster", + "Eggs", + "Spider", + "Man", + "Bunny", + "Love", + "Joker", + "Hugs" + ) + } +} diff --git a/src/main/java/dev/lumas/lumaitems/configuration/model/AstralSetClass.kt b/src/main/java/dev/lumas/lumaitems/configuration/model/AstralSetClass.kt new file mode 100644 index 00000000..f3bf69fa --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/model/AstralSetClass.kt @@ -0,0 +1,17 @@ +package dev.lumas.lumaitems.configuration.model + +import dev.lumas.lumaitems.items.astral.AstralSet +import kotlin.reflect.KClass + +class AstralSetClass( + var setClass: Class<*> +) { + + constructor(setClass: KClass<*>) : this(setClass.java) + //dev.lumas.lumaitems.items.astral.sets.MistralSet + //dev.lumas.lumaitems.astral.sets.MistralSet + + fun getAstralSetClass(): Class { + return this.setClass as Class + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/configuration/model/PairedEnchantment.kt b/src/main/java/dev/lumas/lumaitems/configuration/model/PairedEnchantment.kt new file mode 100644 index 00000000..adfd1970 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/model/PairedEnchantment.kt @@ -0,0 +1,14 @@ +package dev.lumas.lumaitems.configuration.model + +import dev.lumas.lumaitems.enums.ToolType +import org.bukkit.enchantments.Enchantment + +class PairedEnchantment( + var enchantment: Enchantment, + var level: Int, + var apply: List = listOf() +) { + + constructor(enchantment: Enchantment, level: Int, vararg apply: ToolType) : this(enchantment, level, apply.toList()) + +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/configuration/serdes/AstralSetClassTransformer.kt b/src/main/java/dev/lumas/lumaitems/configuration/serdes/AstralSetClassTransformer.kt new file mode 100644 index 00000000..53c50ab2 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/serdes/AstralSetClassTransformer.kt @@ -0,0 +1,28 @@ +package dev.lumas.lumaitems.configuration.serdes + +import dev.lumas.lumaitems.configuration.model.AstralSetClass +import dev.lumas.lumaitems.items.astral.AstralSet +import eu.okaeri.configs.schema.GenericsPair +import eu.okaeri.configs.serdes.BidirectionalTransformer +import eu.okaeri.configs.serdes.SerdesContext + +class AstralSetClassTransformer : BidirectionalTransformer() { + override fun getPair(): GenericsPair { + return this.genericsPair(String::class.java, AstralSetClass::class.java) + } + + //TODO + override fun leftToRight(data: String, serdesContext: SerdesContext): AstralSetClass { + val className = "dev.lumas.lumaitems.items.astral.sets.$data" + val clazz = try { + Class.forName(className) + } catch (e: ClassNotFoundException) { + throw IllegalArgumentException("Astral set class $className not found", e) + } + return AstralSetClass(clazz) + } + + override fun rightToLeft(data: AstralSetClass, serdesContext: SerdesContext): String { + return data.setClass.simpleName + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/configuration/serdes/EnchantmentTransformer.kt b/src/main/java/dev/lumas/lumaitems/configuration/serdes/EnchantmentTransformer.kt new file mode 100644 index 00000000..984b8e60 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/serdes/EnchantmentTransformer.kt @@ -0,0 +1,24 @@ +package dev.lumas.lumaitems.configuration.serdes + +import eu.okaeri.configs.schema.GenericsPair +import eu.okaeri.configs.serdes.BidirectionalTransformer +import eu.okaeri.configs.serdes.SerdesContext +import io.papermc.paper.registry.RegistryAccess +import io.papermc.paper.registry.RegistryKey +import org.bukkit.NamespacedKey +import org.bukkit.enchantments.Enchantment + +class EnchantmentTransformer : BidirectionalTransformer() { + override fun getPair(): GenericsPair { + return this.genericsPair(String::class.java, Enchantment::class.java) + } + + override fun leftToRight(data: String, serdesContext: SerdesContext): Enchantment { + val enchantment = RegistryAccess.registryAccess().getRegistry(RegistryKey.ENCHANTMENT).get(NamespacedKey.minecraft(data)) + return enchantment ?: throw IllegalArgumentException("Enchantment with key $data not found") + } + + override fun rightToLeft(data: Enchantment, serdesContext: SerdesContext): String { + return data.key.key + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/configuration/serdes/LocationTransformer.kt b/src/main/java/dev/lumas/lumaitems/configuration/serdes/LocationTransformer.kt new file mode 100644 index 00000000..bb563f8a --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/serdes/LocationTransformer.kt @@ -0,0 +1,41 @@ +package dev.lumas.lumaitems.configuration.serdes + +import eu.okaeri.configs.schema.GenericsPair +import eu.okaeri.configs.serdes.BidirectionalTransformer +import eu.okaeri.configs.serdes.SerdesContext +import org.bukkit.Bukkit +import org.bukkit.Location +import org.bukkit.World + +class LocationTransformer : BidirectionalTransformer() { + override fun getPair(): GenericsPair { + return this.genericsPair(String::class.java, Location::class.java) + } + + override fun leftToRight(data: String, serdesContext: SerdesContext): Location { + val parts: Array = data.split(",".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray() + require(!(parts.size != 4 && parts.size != 6)) { "Invalid location format: $data" } + val world = Bukkit.getWorld(parts[0]) + val x = parts[1].toInt() + val y = parts[2].toInt() + val z = parts[3].toInt() + if (parts.size == 6) { + val yaw = parts[4].toFloat() + val pitch = parts[5].toFloat() + return Location(world, x.toDouble(), y.toDouble(), z.toDouble(), yaw, pitch) + } + return Location(world, x.toDouble(), y.toDouble(), z.toDouble()) + } + + override fun rightToLeft(data: Location, serdesContext: SerdesContext): String { + val world: World = if (data.world == null) { + Bukkit.getWorlds()[0] + } else { + data.world!! + } + if (data.yaw == 0f && data.pitch == 0f) { + return world.name + "," + data.blockX + "," + data.blockY + "," + data.blockZ + } + return world.name + "," + data.blockX + "," + data.blockY + "," + data.blockZ + "," + data.yaw + "," + data.pitch + } +} diff --git a/src/main/java/dev/lumas/lumaitems/configuration/serdes/PairedEnchantmentTransformer.kt b/src/main/java/dev/lumas/lumaitems/configuration/serdes/PairedEnchantmentTransformer.kt new file mode 100644 index 00000000..3ca90921 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/configuration/serdes/PairedEnchantmentTransformer.kt @@ -0,0 +1,54 @@ +package dev.lumas.lumaitems.configuration.serdes + +import dev.lumas.lumaitems.configuration.model.PairedEnchantment +import dev.lumas.lumaitems.enums.ToolType +import eu.okaeri.configs.schema.GenericsPair +import eu.okaeri.configs.serdes.BidirectionalTransformer +import eu.okaeri.configs.serdes.SerdesContext +import io.papermc.paper.registry.RegistryAccess +import io.papermc.paper.registry.RegistryKey +import org.bukkit.NamespacedKey + +class PairedEnchantmentTransformer : BidirectionalTransformer() { + override fun getPair(): GenericsPair { + return this.genericsPair(String::class.java, PairedEnchantment::class.java) + } + + override fun leftToRight(data: String, serdesContext: SerdesContext): PairedEnchantment { + val parts = data.split("/") + if (parts.size != 2) { + throw IllegalArgumentException("Invalid PairedEnchantment format: $data") + } + val enchantmentString = parts[0] + val levelString = parts[1] + val enchantment = RegistryAccess.registryAccess().getRegistry(RegistryKey.ENCHANTMENT).get(NamespacedKey.minecraft(enchantmentString)) + ?: throw IllegalArgumentException("Enchantment with key $enchantmentString not found") + val level = levelString.filter { it.isDigit() }.toIntOrNull() ?: throw IllegalArgumentException("Invalid level: $levelString") + + if (data.contains("-apply:", true)) { + val toolTypes: MutableList = mutableListOf() + val applyPart = data.substringAfter("-apply:").trim() + val applyTypes = applyPart.split(",") + for (type in applyTypes) { + val toolType = ToolType.entries.find { it.name.equals(type.trim(), ignoreCase = true) } + if (toolType != null) { + toolTypes.add(toolType) + } else { + throw IllegalArgumentException("Invalid ToolType: $type") + } + } + return PairedEnchantment(enchantment, level, toolTypes) + } + + return PairedEnchantment(enchantment, level) + } + + override fun rightToLeft(data: PairedEnchantment, serdesContext: SerdesContext): String { + if (data.apply.isEmpty()) { + return "${data.enchantment.key.key}/${data.level}" + } else { + val applyTypes = data.apply.joinToString(",") { it.name.lowercase() } + return "${data.enchantment.key.key}/${data.level} -apply:$applyTypes" + } + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/enums/Rarity.java b/src/main/java/dev/lumas/lumaitems/enums/Rarity.java index 038c42e7..ac68a6f0 100644 --- a/src/main/java/dev/lumas/lumaitems/enums/Rarity.java +++ b/src/main/java/dev/lumas/lumaitems/enums/Rarity.java @@ -1,19 +1,22 @@ package dev.lumas.lumaitems.enums; -import dev.lumas.lumaitems.util.Util; +import dev.lumas.lumaitems.configuration.files.RelicsYml; +import dev.lumas.lumaitems.registry.Registry; +import org.bukkit.Material; import java.util.List; public enum Rarity { - ASTRAL("&#AC87FB", 14, "Astral"), - LUNAR("ᡯfb", 7, "Lunar"), - NOVA("Kc3fb", 2, "Nova"), - PULSAR("&#c773fb", 1, "Pulsar"), - SOLAR("&#EEFB5F", 1, "Solar"); + ASTRAL("#AC87FB", 14, "Astral"), + LUNAR("#6255fb", 7, "Lunar"), + NOVA("#75c3fb", 2, "Nova"), + PULSAR("#c773fb", 1, "Pulsar"), + SOLAR("#EEFB5F", 1, "Solar"), + DELTA("#DE509D", 1, "Delta"); // Data - public static final List bossRarities = List.of(NOVA); - public static final List genericRarities = List.of(PULSAR, SOLAR); + public static final List BOSS = List.of(NOVA); + public static final List GENERIC = List.of(PULSAR, SOLAR, DELTA); public final String rgb; public final int algorithmWeight; @@ -39,6 +42,20 @@ public String getFriendlyName() { } public String getTier() { - return Util.colorcode(this.getRgb() + "&l" + this.getFriendlyName()); + return "<" + this.getRgb() + ">" + "" + this.getFriendlyName(); + } + + + public List getMaterials() { + RelicsYml.RelicMaterialsSection relicMaterialsSection = Registry.CONFIGS.getOrThrow(RelicsYml.class).getRelicMaterials(); + + return switch (this) { + case ASTRAL -> List.of(); + case LUNAR -> relicMaterialsSection.getLunar(); + case NOVA -> relicMaterialsSection.getNova(); + case PULSAR -> relicMaterialsSection.getPulsar(); + case SOLAR -> relicMaterialsSection.getSolar(); + case DELTA -> relicMaterialsSection.getDelta(); + }; } } diff --git a/src/main/java/dev/lumas/lumaitems/events/ExternalListeners.kt b/src/main/java/dev/lumas/lumaitems/events/ExternalListeners.kt index f31352ad..865db85e 100644 --- a/src/main/java/dev/lumas/lumaitems/events/ExternalListeners.kt +++ b/src/main/java/dev/lumas/lumaitems/events/ExternalListeners.kt @@ -4,18 +4,14 @@ import com.gamingmesh.jobs.api.JobsPrePaymentEvent import dev.lumas.lumacore.manager.modules.AutoRegister import dev.lumas.lumacore.manager.modules.RegisterType import dev.lumas.lumaitems.LumaItems -import dev.lumas.lumaitems.events.GeneralListeners.Companion.relicFile -import dev.lumas.lumaitems.enums.Rarity -import dev.lumas.lumaitems.relics.RelicCreator +import dev.lumas.lumaitems.items.astral.GrubbyRelicItem +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Util -import org.bukkit.Bukkit -import org.bukkit.Material +import kotlin.random.Random import org.bukkit.event.EventHandler import org.bukkit.event.Listener -import kotlin.random.Random -// todo: get rid of this shit -// Listeners that belong to external plugins +// General listeners that belong to external plugins @AutoRegister(RegisterType.LISTENER) class ExternalListeners : Listener { @@ -23,25 +19,10 @@ class ExternalListeners : Listener { @EventHandler fun onJobsPrePayment(event: JobsPrePaymentEvent) { - if (Random.nextInt(10000) > 2 || event.job.name == "Hunter") return + if (Random.nextInt(20_000) > 2 || event.job.name == "Hunter") return val player = event.player?.player ?: return - - Bukkit.getScheduler().runTaskAsynchronously(plugin, Runnable { - val rarity = Rarity.genericRarities.random() - val material: Material = - Material.valueOf(relicFile.getStringList("relic-materials.${rarity.name.lowercase()}").random()) - - val relic = RelicCreator( - rarity.algorithmWeight, - -1, - rarity, - material - ).getRelicItem() - - Bukkit.getScheduler().runTask(plugin, Runnable { - Util.giveItem(player, relic) - }) - }) + val grubby = Registry.CUSTOM_ITEMS.getOrThrow(GrubbyRelicItem::class).createItem().second + Util.giveItem(player, grubby) } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/events/GeneralListeners.kt b/src/main/java/dev/lumas/lumaitems/events/GeneralListeners.kt index 4b542a7b..c7c28ec5 100644 --- a/src/main/java/dev/lumas/lumaitems/events/GeneralListeners.kt +++ b/src/main/java/dev/lumas/lumaitems/events/GeneralListeners.kt @@ -2,21 +2,21 @@ package dev.lumas.lumaitems.events import dev.lumas.lumacore.manager.modules.AutoRegister import dev.lumas.lumacore.manager.modules.RegisterType -import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.enums.EntityArmor +import dev.lumas.lumaitems.enums.GenericToolType +import dev.lumas.lumaitems.enums.Rarity import dev.lumas.lumaitems.guis.AbstractGui import dev.lumas.lumaitems.guis.DisassemblerGui -import dev.lumas.lumaitems.manager.FileManager -import dev.lumas.lumaitems.manager.ItemManager -import dev.lumas.lumaitems.enums.Rarity +import dev.lumas.lumaitems.items.ItemFactory +import dev.lumas.lumaitems.registry.NamespacedIdentifier +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.relics.RelicCreator import dev.lumas.lumaitems.relics.RelicDisassembler -import dev.lumas.lumaitems.enums.EntityArmor -import dev.lumas.lumaitems.enums.GenericToolType -import dev.lumas.lumaitems.items.ItemFactory +import dev.lumas.lumaitems.util.Executors import dev.lumas.lumaitems.util.Util +import kotlin.random.Random import org.bukkit.Bukkit import org.bukkit.Material -import org.bukkit.NamespacedKey import org.bukkit.Sound import org.bukkit.entity.Enemy import org.bukkit.entity.EntityType @@ -33,17 +33,14 @@ import org.bukkit.event.inventory.InventoryType import org.bukkit.event.inventory.PrepareAnvilEvent import org.bukkit.event.player.PlayerInteractEvent import org.bukkit.persistence.PersistentDataType -import kotlin.random.Random // TODO: These listeners are a mess @AutoRegister(RegisterType.LISTENER) class GeneralListeners : Listener { - val plugin: LumaItems = LumaItems.getInstance() - companion object { - val relicFile = FileManager("relics.yml").generateYamlFile() - private val bosses: List = listOf( + private val LUMA_ITEM_KEY = Util.namespacedKey("lumaitem") + private val BOSSES: List = listOf( EntityType.ENDER_DRAGON, EntityType.WITHER, EntityType.ELDER_GUARDIAN, @@ -54,16 +51,15 @@ class GeneralListeners : Listener { @EventHandler fun onEntitySpawn(event: EntitySpawnEvent) { val livingEntity = event.entity as? LivingEntity ?: return - val isBoss = bosses.contains(livingEntity.type) + val isBoss = BOSSES.contains(livingEntity.type) - if (Random.nextInt(100) > 8 || livingEntity !is Enemy) return // 8% chance to spawn a relic + if (Random.nextInt(101) > 8 || livingEntity !is Enemy) return // 8% chance to spawn a relic - Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, Runnable { - if (livingEntity.hasMetadata("NO_RELIC")) return@Runnable + Executors.asyncDelayed(1) { + if (livingEntity.hasMetadata("NO_RELIC")) return@asyncDelayed - val rarity: Rarity = if (isBoss) Rarity.bossRarities[0] else Rarity.genericRarities.random() - val material: Material = - Material.valueOf(relicFile.getStringList("relic-materials.${rarity.name.lowercase()}").random()) + val rarity: Rarity = if (isBoss) Rarity.BOSS[0] else Rarity.GENERIC.random() + val material = rarity.materials.random() val relic = RelicCreator( rarity.algorithmWeight, @@ -72,7 +68,7 @@ class GeneralListeners : Listener { material ).getRelicItem() - Bukkit.getScheduler().runTask(plugin, Runnable { + Executors.sync { if (GenericToolType.getGenericToolType(relic.type) == GenericToolType.ARMOR) { val entityArmor = EntityArmor.getEquipmentSlotFromType(relic.type) entityArmor?.setEntityArmorSlot(livingEntity, relic) @@ -81,8 +77,10 @@ class GeneralListeners : Listener { } else { livingEntity.equipment?.setItemInOffHand(relic) } - }) - }, 1L) + } + + } + } @EventHandler @@ -104,7 +102,7 @@ class GeneralListeners : Listener { } - if (!RelicDisassembler.disassemblerBlocks.contains(event.clickedBlock ?: return)) return + if (!RelicDisassembler.DISASSEMBLER_BLOCKS.contains(event.clickedBlock ?: return)) return event.isCancelled = true @@ -160,11 +158,11 @@ class GeneralListeners : Listener { val meta = event.result!!.itemMeta var cancelEvent = false - if (meta.persistentDataContainer.has(NamespacedKey(plugin, "lumaitem"), PersistentDataType.SHORT)) { + if (meta.persistentDataContainer.has(LUMA_ITEM_KEY, PersistentDataType.SHORT)) { cancelEvent = true } else { - for (key in ItemManager.CUSTOM_ITEMS.keys) { - if (meta.persistentDataContainer.has(key, PersistentDataType.SHORT)) { + for (key in Registry.CUSTOM_ITEMS.keySet(NamespacedIdentifier::class)) { + if (meta.persistentDataContainer.has(key.key(), PersistentDataType.SHORT)) { cancelEvent = true break } diff --git a/src/main/java/dev/lumas/lumaitems/events/items/ItemListener.kt b/src/main/java/dev/lumas/lumaitems/events/items/ItemListener.kt index 379f317b..b89d4587 100644 --- a/src/main/java/dev/lumas/lumaitems/events/items/ItemListener.kt +++ b/src/main/java/dev/lumas/lumaitems/events/items/ItemListener.kt @@ -4,15 +4,15 @@ import com.gmail.nossr50.api.AbilityAPI as mcMMOAbilityAPI import dev.lumas.lumacore.utility.Logging import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.enums.Action +import dev.lumas.lumaitems.hooks.McMMOHook import dev.lumas.lumaitems.manager.CustomItem -import dev.lumas.lumaitems.manager.ItemManager +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Executors import dev.lumas.lumaitems.util.MiniMessageUtil import io.papermc.paper.persistence.PersistentDataContainerView import java.util.EnumMap import java.util.UUID import org.bukkit.Bukkit -import org.bukkit.NamespacedKey import org.bukkit.entity.Player import org.bukkit.event.Listener import org.bukkit.persistence.PersistentDataContainer @@ -47,11 +47,11 @@ abstract class ItemListener : Listener { // Paper added this, just makes it easier to look at the PDC fun fire(data: PersistentDataContainerView, action: Action, player: Player?, event: Any, withContainer: Boolean = false) { - for (customItem: MutableMap.MutableEntry in ItemManager.CUSTOM_ITEMS) { + for (customItem in Registry.CUSTOM_ITEMS) { val item = customItem.value val fireAnyways = item.fireAnyways(action) - if (!data.has(customItem.key) && !fireAnyways) { + if (!data.has(customItem.key.asNameSpacedKey()) && !fireAnyways) { continue } @@ -64,11 +64,11 @@ abstract class ItemListener : Listener { } fun fire(data: PersistentDataContainer, action: Action, player: Player?, event: Any, withContainer: Boolean = false) { - for (customItem: MutableMap.MutableEntry in ItemManager.CUSTOM_ITEMS) { + for (customItem in Registry.CUSTOM_ITEMS) { val item = customItem.value val fireAnyways = customItem.value.fireAnyways(action) - if (!data.has(customItem.key) && !fireAnyways) { + if (!data.has(customItem.key.asNameSpacedKey()) && !fireAnyways) { continue } @@ -84,10 +84,10 @@ abstract class ItemListener : Listener { fun fire(data: List, action: Action, player: Player?, event: Any, withContainer: Boolean = false) { for (itemData: PersistentDataContainer? in data.ifEmpty { listOf(null) }) { - for (customItem: MutableMap.MutableEntry in ItemManager.CUSTOM_ITEMS) { + for (customItem in Registry.CUSTOM_ITEMS) { val fireAnyways = customItem.value.fireAnyways(action) - if (!((itemData != null && itemData.has(customItem.key)) || fireAnyways)) { + if (!((itemData != null && itemData.has(customItem.key.asNameSpacedKey())) || fireAnyways)) { continue } @@ -105,8 +105,8 @@ abstract class ItemListener : Listener { // TODO: @FireAnyways fun fire(key: String, action: Action, player: Player?, event: Any, withContainer: Boolean = false) { - for (customItem in ItemManager.CUSTOM_ITEMS) { - if (key.equals(customItem.key.key, true)) { + for (customItem in Registry.CUSTOM_ITEMS) { + if (key.equals(customItem.key.asSimpleString(), true)) { val item = customItem.value if (player?.location?.let { item.isDisabled(it) } == true) { item.handleDisabled(player, event) @@ -136,7 +136,7 @@ abstract class ItemListener : Listener { fun isTreeFeller(player: Player): Boolean { try { - if (LumaItems.isWithmcMMO() && mcMMOAbilityAPI.treeFellerEnabled(player)) { + if (Registry.HOOKS.getOrThrow(McMMOHook::class).isWith() && mcMMOAbilityAPI.treeFellerEnabled(player)) { return true } } catch (throwable: Throwable) { diff --git a/src/main/java/dev/lumas/lumaitems/events/items/Listeners.kt b/src/main/java/dev/lumas/lumaitems/events/items/Listeners.kt index 5595de03..3bc01d7b 100644 --- a/src/main/java/dev/lumas/lumaitems/events/items/Listeners.kt +++ b/src/main/java/dev/lumas/lumaitems/events/items/Listeners.kt @@ -246,19 +246,8 @@ class Listeners : ItemListener() { if (!item.hasItemMeta() && !offHandItem.hasItemMeta()) return - val data: PersistentDataContainer? = item.itemMeta?.persistentDataContainer - val offHandData: PersistentDataContainer? = offHandItem.itemMeta?.persistentDataContainer - for (customItem in ItemManager.CUSTOM_ITEMS) { - if (data?.has(customItem.key, PersistentDataType.SHORT) == true) { - val customItemClass = customItem.value - customItemClass.executeActions(Action.FISH, player, event) - break - } else if (offHandData?.has(customItem.key, PersistentDataType.SHORT) == true) { - val customItemClass = customItem.value - customItemClass.executeActions(Action.FISH, player, event) - break - } - } + val data = Util.getHandNBT(player) + fire(data, Action.FISH, player, event) } @EventHandler diff --git a/src/main/java/dev/lumas/lumaitems/events/items/PassiveListeners.kt b/src/main/java/dev/lumas/lumaitems/events/items/PassiveListeners.kt index feda91ef..d0df14a4 100644 --- a/src/main/java/dev/lumas/lumaitems/events/items/PassiveListeners.kt +++ b/src/main/java/dev/lumas/lumaitems/events/items/PassiveListeners.kt @@ -2,7 +2,7 @@ package dev.lumas.lumaitems.events.items import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.enums.Action -import dev.lumas.lumaitems.manager.ItemManager +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Util import org.bukkit.Bukkit import org.bukkit.entity.Player @@ -22,16 +22,16 @@ class PassiveListeners(val plugin: LumaItems) { private fun fire(dataList: List, player: Player, action: Action) { for (data: PersistentDataContainer in dataList) { - for (customItem in ItemManager.CUSTOM_ITEMS) { - if (!data.has(customItem.key, PersistentDataType.SHORT)) continue + for (customItem in Registry.CUSTOM_ITEMS) { + if (!data.has(customItem.key.asNameSpacedKey(), PersistentDataType.SHORT)) continue customItem.value.executeActions(action, player, 0) } } } private fun fire(action: Action) { - for (customItem in ItemManager.CUSTOM_ITEMS) { - customItem.value.executeActions(action, ItemListener.getDummyPlayer() ?: return, 0) + for (customItem in Registry.CUSTOM_ITEMS.values()) { + customItem.executeActions(action, ItemListener.getDummyPlayer() ?: return, 0) } } @@ -49,8 +49,8 @@ class PassiveListeners(val plugin: LumaItems) { fun getGlobalTask(): BukkitRunnable { return object: BukkitRunnable() { override fun run() { - for (customItem in ItemManager.CUSTOM_ITEMS) { - customItem.value.asyncGlobalTask() + for (customItem in Registry.CUSTOM_ITEMS.values()) { + customItem.asyncGlobalTask() } } } diff --git a/src/main/java/dev/lumas/lumaitems/guis/AstralUpgradeGui.kt b/src/main/java/dev/lumas/lumaitems/guis/AstralUpgradeGui.kt index f71c515c..b3d4f1ad 100644 --- a/src/main/java/dev/lumas/lumaitems/guis/AstralUpgradeGui.kt +++ b/src/main/java/dev/lumas/lumaitems/guis/AstralUpgradeGui.kt @@ -2,7 +2,6 @@ package dev.lumas.lumaitems.guis import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.items.astral.upgrades.AstralSetUpgradeFactory -import dev.lumas.lumaitems.items.astral.upgrades.AstralSetUpgradeManager import dev.lumas.lumaitems.util.MiniMessageUtil import dev.lumas.lumaitems.util.Util import org.bukkit.Bukkit @@ -25,7 +24,7 @@ class AstralUpgradeGui : AbstractGui { } init { - AstralSetUpgradeManager().reloadUpgrades() + //AstralSetUpgradeManager().reloadUpgrades() } override fun onInventoryClick(event: InventoryClickEvent) { diff --git a/src/main/java/dev/lumas/lumaitems/hooks/CoreProtectHook.kt b/src/main/java/dev/lumas/lumaitems/hooks/CoreProtectHook.kt new file mode 100644 index 00000000..924d03a8 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/hooks/CoreProtectHook.kt @@ -0,0 +1,16 @@ +package dev.lumas.lumaitems.hooks + +import dev.lumas.lumaitems.registry.Identifier +import dev.lumas.lumaitems.registry.StringIdentifier +import net.coreprotect.CoreProtect +import net.coreprotect.CoreProtectAPI + +class CoreProtectHook : Hook { + override fun identifier(): Identifier { + return StringIdentifier.of("CoreProtect") + } + + fun getCoreProtectAPI(): CoreProtectAPI? { + return if (this.isWith()) CoreProtect.getInstance().api else null + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/hooks/Hook.kt b/src/main/java/dev/lumas/lumaitems/hooks/Hook.kt new file mode 100644 index 00000000..83f266d7 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/hooks/Hook.kt @@ -0,0 +1,9 @@ +package dev.lumas.lumaitems.hooks + +import dev.lumas.lumaitems.registry.RegistryItem +import org.bukkit.Bukkit + +interface Hook : RegistryItem { + + fun isWith(): Boolean = Bukkit.getPluginManager().getPlugin(this.identifier().asSimpleString()) != null +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/hooks/LumaGlowAPIHook.kt b/src/main/java/dev/lumas/lumaitems/hooks/LumaGlowAPIHook.kt new file mode 100644 index 00000000..c6e5a97b --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/hooks/LumaGlowAPIHook.kt @@ -0,0 +1,10 @@ +package dev.lumas.lumaitems.hooks + +import dev.lumas.lumaitems.registry.Identifier +import dev.lumas.lumaitems.registry.StringIdentifier + +class LumaGlowAPIHook : Hook { + override fun identifier(): Identifier { + return StringIdentifier.of("LumaGlowAPI") + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/hooks/McMMOHook.kt b/src/main/java/dev/lumas/lumaitems/hooks/McMMOHook.kt new file mode 100644 index 00000000..7ba703e8 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/hooks/McMMOHook.kt @@ -0,0 +1,10 @@ +package dev.lumas.lumaitems.hooks + +import dev.lumas.lumaitems.registry.Identifier +import dev.lumas.lumaitems.registry.StringIdentifier + +class McMMOHook : Hook { + override fun identifier(): Identifier { + return StringIdentifier.of("mcMMO") + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/hooks/MythicMobsHook.kt b/src/main/java/dev/lumas/lumaitems/hooks/MythicMobsHook.kt new file mode 100644 index 00000000..b4f3f1ad --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/hooks/MythicMobsHook.kt @@ -0,0 +1,19 @@ +package dev.lumas.lumaitems.hooks + +import dev.lumas.lumaitems.registry.Identifier +import dev.lumas.lumaitems.registry.StringIdentifier +import io.lumine.mythic.bukkit.MythicBukkit +import org.bukkit.entity.Entity + +class MythicMobsHook : Hook { + override fun identifier(): Identifier { + return StringIdentifier.of("MythicMobs") + } + + fun isMythicMob(bukkitEntity: Entity): Boolean { + if (!this.isWith()) { + return false + } + return MythicBukkit.inst().mobManager.isMythicMob(bukkitEntity) + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/hooks/ProtocolLibHook.kt b/src/main/java/dev/lumas/lumaitems/hooks/ProtocolLibHook.kt new file mode 100644 index 00000000..22800d5c --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/hooks/ProtocolLibHook.kt @@ -0,0 +1,16 @@ +package dev.lumas.lumaitems.hooks + +import com.comphenix.protocol.ProtocolLibrary +import com.comphenix.protocol.ProtocolManager +import dev.lumas.lumaitems.registry.Identifier +import dev.lumas.lumaitems.registry.StringIdentifier + +class ProtocolLibHook : Hook { + override fun identifier(): Identifier { + return StringIdentifier.of("ProtocolLib") + } + + fun getProtocolManager(): ProtocolManager? { + return if (this.isWith()) ProtocolLibrary.getProtocolManager() else null + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/ItemFactory.kt b/src/main/java/dev/lumas/lumaitems/items/ItemFactory.kt index 390c396f..8fa63661 100644 --- a/src/main/java/dev/lumas/lumaitems/items/ItemFactory.kt +++ b/src/main/java/dev/lumas/lumaitems/items/ItemFactory.kt @@ -30,13 +30,14 @@ import org.bukkit.persistence.PersistentDataType // - Our constructor takes in the parameters that generally most custom items always have and builds an item based off of them. // - Some other options are available outside the constructor. +//TODO clean up this disaster class ItemFactory( private val name: String, - private val customEnchants: MutableList, - private val lore: MutableList, + private val customEnchants: List, + private val lore: List, private val material: Material, - private val persistentData: MutableList, - private val vanillaEnchants: MutableMap, + private val persistentData: List, + private val vanillaEnchants: Map, var tier: String = "&#AC87FB&lAstral", @@ -82,13 +83,13 @@ class ItemFactory( private val tierFormat = listOf( "", "&#EEE1D5&m &r&#EEE1D5⋆⁺₊⋆ ★ ⋆⁺₊⋆&m ", - "&#EEE1D5Tier • ", + "&#EEE1D5Tier • %s", "&#EEE1D5&m &r&#EEE1D5⋆⁺₊⋆ ★ ⋆⁺₊⋆&m " ) private val miniMessageTierFormat = listOf( "", "<#EEE1D5> ⋆⁺₊⋆ ★ ⋆⁺₊⋆ ", - "<#EEE1D5>Tier • ", + "<#EEE1D5>Tier • %s", "<#EEE1D5> ⋆⁺₊⋆ ★ ⋆⁺₊⋆ " ) @JvmStatic @@ -189,17 +190,18 @@ class ItemFactory( } + if (!miniMessage) { combinedLore.addAll(lore.map { "&f$it" }) - combinedLore.addAll(tierFormat.map { it.replace("", tier) }) + if (tier.isNotEmpty()) combinedLore.addAll(tierFormat.map { it.format(tier) }) meta.setDisplayName(Util.colorcode(name)) meta.lore = Util.colorcodeList(combinedLore) } else { combinedLore.addAll(lore.map { it }) - combinedLore.addAll(miniMessageTierFormat.map { it.replace("", tier) }) + if (tier.isNotEmpty()) combinedLore.addAll(miniMessageTierFormat.map { it.format(tier) }) - meta.displayName(MiniMessageUtil.mm(name)/*.decorationIfAbsent(TextDecoration.BOLD, TextDecoration.State.TRUE)*/) + meta.displayName(MiniMessageUtil.mm(name)) meta.lore(MiniMessageUtil.mml(combinedLore).map { it.colorIfAbsent(NamedTextColor.WHITE) }) } @@ -260,7 +262,7 @@ class ItemFactory( private var lore: MutableList = mutableListOf() private var material: Material = Material.AIR private var persistentData: MutableList = mutableListOf() - private var vanillaEnchants: MutableMap = mutableMapOf() + private var vanillaEnchants: Map = mutableMapOf() private var tier: String = Tier.ASTRAL.toString() private var unbreakable: Boolean = false private var hideEnchants: Boolean = false @@ -294,7 +296,7 @@ class ItemFactory( fun persistentDataRecords(vararg persistentData: PersistentDataRecord<*, *>) = apply { this.persistentDataRecords = persistentData.toMutableList() } @SafeVarargs fun paperDataComponents(vararg paperDataComponents: PaperDataComponent) = apply { this.paperDataComponents = paperDataComponents.toMutableList() } - fun vanillaEnchants(vanillaEnchants: MutableMap) = apply { this.vanillaEnchants = vanillaEnchants } + fun vanillaEnchants(vanillaEnchants: Map) = apply { this.vanillaEnchants = vanillaEnchants } @SafeVarargs fun vanillaEnchants(vararg vanillaEnchants: Pair) = apply { this.vanillaEnchants = vanillaEnchants.toMap().toMutableMap() } fun tier(tier: String) = apply { this.tier = tier } diff --git a/src/main/java/dev/lumas/lumaitems/items/armor/ClownMaskItem.kt b/src/main/java/dev/lumas/lumaitems/items/armor/ClownMaskItem.kt index c00e2be7..0c923a88 100644 --- a/src/main/java/dev/lumas/lumaitems/items/armor/ClownMaskItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/armor/ClownMaskItem.kt @@ -1,10 +1,11 @@ package dev.lumas.lumaitems.items.armor +import dev.lumas.lumaitems.configuration.files.HeadsYml import dev.lumas.lumaitems.enums.DefaultAttributes import dev.lumas.lumaitems.util.tiers.Tier import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.manager.CustomItemFunctions -import dev.lumas.lumaitems.manager.FileManager +import dev.lumas.lumaitems.registry.Registry import org.bukkit.Material import org.bukkit.NamespacedKey import org.bukkit.attribute.Attribute @@ -19,13 +20,13 @@ import org.bukkit.persistence.PersistentDataType class ClownMaskItem : CustomItemFunctions() { companion object { - private val headTextures: List = FileManager("heads.yml").generateYamlFile().getStringList("clown-masks") private const val KEY = "clownmask" } private val namespacedKey = NamespacedKey(instance(), KEY) override fun createItem(): Pair { + val headTextures = Registry.CONFIGS.getOrThrow(HeadsYml::class).clownMasks return ItemFactory.builder() .name("<#FA909D>C<#F8C2AE>l<#F6F4BE>o<#F7CED4>w<#F7A8E9>n <#EBC1C9>M<#DDFF92>a<#C2ECC9>s<#A7D9FF>k") diff --git a/src/main/java/dev/lumas/lumaitems/items/armor/chestplate/YolkplaidYarweaveItem.kt b/src/main/java/dev/lumas/lumaitems/items/armor/chestplate/YolkplaidYarweaveItem.kt index d11828a2..fd7c0893 100644 --- a/src/main/java/dev/lumas/lumaitems/items/armor/chestplate/YolkplaidYarweaveItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/armor/chestplate/YolkplaidYarweaveItem.kt @@ -1,10 +1,12 @@ package dev.lumas.lumaitems.items.armor.chestplate +import dev.lumas.lumaitems.configuration.files.HeadsYml import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.enums.Action +import dev.lumas.lumaitems.hooks.MythicMobsHook import dev.lumas.lumaitems.manager.CustomItem -import dev.lumas.lumaitems.manager.FileManager import dev.lumas.lumaitems.manager.GlowManager +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.AbilityUtil import dev.lumas.lumaitems.util.Util import org.bukkit.ChatColor @@ -30,7 +32,6 @@ import kotlin.random.Random class YolkplaidYarweaveItem : CustomItem { companion object { - private val eggTextures: List = FileManager("heads.yml").generateYamlFile().getStringList("easter-egg") private val SLOWNESS = PotionEffect(PotionEffectType.SLOWNESS, 240, 200, false, false, false) } @@ -90,7 +91,8 @@ class YolkplaidYarweaveItem : CustomItem { } private fun encase(livingEntity: LivingEntity, attacker: Player) { - if (AbilityUtil.isMythicMob(livingEntity)) return + if (Registry.HOOKS.getOrThrow(MythicMobsHook::class).isMythicMob(livingEntity)) return + val eggTextures = Registry.CONFIGS.getOrThrow(HeadsYml::class).easterEgg val loc = livingEntity.eyeLocation.add(0.0, 0.5, 0.0); loc.yaw = 0.0f; loc.pitch = 0.0f val egg = livingEntity.world.spawnEntity(loc, EntityType.ITEM_DISPLAY) as ItemDisplay diff --git a/src/main/java/dev/lumas/lumaitems/items/armor/elytra/SnowySunsetWingsItem.kt b/src/main/java/dev/lumas/lumaitems/items/armor/elytra/SnowySunsetWingsItem.kt index b06f263f..473f21a9 100644 --- a/src/main/java/dev/lumas/lumaitems/items/armor/elytra/SnowySunsetWingsItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/armor/elytra/SnowySunsetWingsItem.kt @@ -9,6 +9,8 @@ import dev.lumas.lumaitems.util.Util import dev.lumas.lumaitems.util.Util.isItemInSlot import dev.lumas.lumaitems.util.tiers.Tier import dev.lumas.glowapi.colormanagers.ColorManager +import dev.lumas.lumaitems.hooks.McMMOHook +import dev.lumas.lumaitems.registry.Registry import org.bukkit.ChatColor import org.bukkit.Material import org.bukkit.enchantments.Enchantment @@ -73,13 +75,13 @@ class SnowySunsetWingsItem : CustomItemFunctions() { } fun addColor(player: Player) { - if (LumaItems.isWithLumaGlowAPI()) { + if (Registry.HOOKS.getOrThrow(McMMOHook::class).isWith()) { ColorManager.setTempPlayerColor(player, ChatColor.BLACK) } } fun removeColor(player: Player) { - if (LumaItems.isWithLumaGlowAPI()) { + if (Registry.HOOKS.getOrThrow(McMMOHook::class).isWith()) { ColorManager.updatePlayersColor(player) } } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/AstralOrbItem.kt b/src/main/java/dev/lumas/lumaitems/items/astral/AstralOrbItem.kt index e4026465..411e127b 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/AstralOrbItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/AstralOrbItem.kt @@ -1,11 +1,13 @@ package dev.lumas.lumaitems.items.astral import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.configuration.files.AstralYml import dev.lumas.lumaitems.enums.Action import dev.lumas.lumaitems.manager.CustomItem -import dev.lumas.lumaitems.manager.FileManager +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.relics.RelicCrafting import dev.lumas.lumaitems.util.Util +import kotlin.random.Random import org.bukkit.Bukkit import org.bukkit.NamespacedKey import org.bukkit.Sound @@ -13,7 +15,6 @@ import org.bukkit.entity.Player import org.bukkit.event.player.PlayerInteractEvent import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType -import kotlin.random.Random class AstralOrbItem : CustomItem { @@ -36,33 +37,22 @@ class AstralOrbItem : CustomItem { globalPlayer.sendMessage(Util.colorcode("${Util.legacyPrefix} &#F7FFC9${player.name}&#E2E2E2 has revealed a relic inside of a &#AC87FB&lAstral &#F7FFC9Orb&#E2E2E2!")) } - Util.giveItem(player, getAstralItem() ?: return false) + Util.giveItem(player, getAstralItem()) } else -> return false } return true } - private fun getAstralItem(): ItemStack? { - val file = FileManager("astral.yml").generateYamlFile() - - val itemClasses = file.getConfigurationSection("astral-orb-rarities")?.getKeys(true) - val setsAndWeight: MutableMap, Int> = mutableMapOf() + private fun getAstralItem(): ItemStack { + val setsWithWeights = Registry.CONFIGS.getOrThrow(AstralYml::class).astralOrbRarities - if (itemClasses == null) { - return null + var selectedSet = setsWithWeights.entries.random() + while (selectedSet.value < Random.nextInt(101)) { + selectedSet = setsWithWeights.entries.random() } - for (itemClass in itemClasses) { - val items = RelicCrafting.getItemsFromClass(itemClass) - val weight = file.getInt("astral-orb-rarities.$itemClass") - setsAndWeight[items] = weight - } - - var selectedSet = setsAndWeight.keys.toList().random() - while (setsAndWeight[selectedSet]!! < Random.nextInt(1, 100)) { - selectedSet = setsAndWeight.keys.toList().random() - } - return selectedSet.random() + val items = RelicCrafting.getItemsFromClass(selectedSet.key.getAstralSetClass()) + return items.random() } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/AstralSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/AstralSet.kt index 8819d63a..5195a1fb 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/AstralSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/AstralSet.kt @@ -15,7 +15,7 @@ interface AstralSet : CustomItem { * @see setItems */ override fun createItem(): Pair { - return Pair(identifier(), BLANK_ITEMSTACK) + return Pair(setIdentifier(), BLANK_ITEMSTACK) } /** @@ -28,6 +28,6 @@ interface AstralSet : CustomItem { * Set the identifier for the set * @return A string identifier */ - fun identifier(): String + fun setIdentifier(): String } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/AstralSetFunctions.kt b/src/main/java/dev/lumas/lumaitems/items/astral/AstralSetFunctions.kt index 8fbc523a..81db3efd 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/AstralSetFunctions.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/AstralSetFunctions.kt @@ -28,7 +28,7 @@ abstract class AstralSetFunctions(val identifier: String) : CustomItemFunctions( return "<#AC87FB>$this" } - override fun identifier(): String { + override fun setIdentifier(): String { return identifier } @@ -38,6 +38,6 @@ abstract class AstralSetFunctions(val identifier: String) : CustomItemFunctions( * @see setItems */ override fun createItem(): Pair { - return Pair(identifier(), AstralSet.BLANK_ITEMSTACK) + return Pair(setIdentifier(), AstralSet.BLANK_ITEMSTACK) } } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/GrubbyRelicItem.kt b/src/main/java/dev/lumas/lumaitems/items/astral/GrubbyRelicItem.kt new file mode 100644 index 00000000..158f4357 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/items/astral/GrubbyRelicItem.kt @@ -0,0 +1,67 @@ +package dev.lumas.lumaitems.items.astral + +import dev.lumas.lumaitems.enums.Rarity +import dev.lumas.lumaitems.items.ItemFactory +import dev.lumas.lumaitems.manager.CustomItemFunctions +import dev.lumas.lumaitems.relics.RelicCreator +import dev.lumas.lumaitems.util.tiers.Tier +import org.bukkit.Material +import org.bukkit.enchantments.Enchantment +import org.bukkit.entity.Player +import org.bukkit.event.player.PlayerInteractEvent +import org.bukkit.inventory.ItemStack + +class GrubbyRelicItem : CustomItemFunctions() { + + override fun createItem(): Pair { + return ItemFactory.builder() + .name("Grubby Relic") + .material(Material.CHARCOAL) + .tier(Tier.BLANK) + .hideEnchants(true) + .addSpace(false) + .vanillaEnchants(Enchantment.UNBREAKING to 1) + .lore("Right-click to open!") + .persistentData("grubby-relic") + .buildPair() + } + + override fun onRightClick(player: Player, event: PlayerInteractEvent) { + val item = event.item ?: return + item.amount -= 1 + + val rarity = GrubbyWeights.randomByTotalWeight().delegate + val material = rarity.materials.random() + + val relic = RelicCreator(rarity.algorithmWeight, -1, rarity, material).getRelicItem() + + val spawned = player.world.dropItem(player.eyeLocation, relic) + spawned.pickupDelay = 0 + } + + private enum class GrubbyWeights(val weight: Int, val delegate: Rarity) { + LUNAR(1, Rarity.LUNAR), + NOVA(10, Rarity.NOVA), + PULSAR(200, Rarity.PULSAR), + SOLAR(200, Rarity.SOLAR), + DELTA(200, Rarity.DELTA); + + companion object { + val TOTAL_WEIGHT = entries.toTypedArray().sumOf { it.weight } + + fun randomByTotalWeight(): GrubbyWeights { + val randomValue = (1..TOTAL_WEIGHT).random() + var cumulativeWeight = 0 + + for (percentChance in entries) { + cumulativeWeight += percentChance.weight + if (randomValue <= cumulativeWeight) { + return percentChance + } + } + return SOLAR // fallback + } + } + } + +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/LunarOrbItem.kt b/src/main/java/dev/lumas/lumaitems/items/astral/LunarOrbItem.kt index 893d4446..4b049abc 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/LunarOrbItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/LunarOrbItem.kt @@ -1,46 +1,51 @@ package dev.lumas.lumaitems.items.astral -import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.configuration.files.RelicsYml import dev.lumas.lumaitems.enums.Action -import dev.lumas.lumaitems.manager.CustomItem -import dev.lumas.lumaitems.manager.FileManager import dev.lumas.lumaitems.enums.Rarity +import dev.lumas.lumaitems.manager.CustomItemFunctions +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.relics.RelicCrafting import dev.lumas.lumaitems.relics.RelicCreator import dev.lumas.lumaitems.util.Util -import org.bukkit.Material -import org.bukkit.NamespacedKey import org.bukkit.Sound import org.bukkit.entity.Player import org.bukkit.event.player.PlayerInteractEvent import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType -class LunarOrbItem : CustomItem { +class LunarOrbItem : CustomItemFunctions() { + + companion object { + val LUNAR_ORB_KEY = Util.namespacedKey("lunarorb") + } override fun createItem(): Pair { return Pair("lunarorb", RelicCrafting.lunarOrb) } + override fun onRightClick(player: Player, event: PlayerInteractEvent) { + if (!player.inventory.itemInMainHand.itemMeta.persistentDataContainer.has(LUNAR_ORB_KEY, PersistentDataType.SHORT)) return + + event.isCancelled = true + + val materials = Registry.CONFIGS.getOrThrow(RelicsYml::class).relicMaterials.lunar + + val relicCreator = RelicCreator( + Rarity.LUNAR.algorithmWeight, + 7, + Rarity.LUNAR, + materials.random() + ) + player.inventory.itemInMainHand.amount -= 1 + Util.giveItem(player, relicCreator.getRelicItem()) + player.playSound(player.location, Sound.ENTITY_EVOKER_CAST_SPELL, 1f, 1f) + } + override fun executeActions(type: Action, player: Player, event: Any): Boolean { when (type) { Action.RIGHT_CLICK -> { - if (!player.inventory.itemInMainHand.itemMeta.persistentDataContainer.has(NamespacedKey(LumaItems.getInstance(), "lunarorb"), PersistentDataType.SHORT)) return false - - event as PlayerInteractEvent - event.isCancelled = true - - val materials = FileManager("relics.yml").getFileYaml().getStringList("relic-materials.lunar") - - val relicCreator = RelicCreator( - Rarity.LUNAR.algorithmWeight, - 7, - Rarity.LUNAR, - Material.valueOf(materials.random()) - ) - player.inventory.itemInMainHand.amount -= 1 - Util.giveItem(player, relicCreator.getRelicItem()) - player.playSound(player.location, Sound.ENTITY_EVOKER_CAST_SPELL, 1f, 1f) + } else -> { return false diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/ModernAstralSetFactory.kt b/src/main/java/dev/lumas/lumaitems/items/astral/ModernAstralSetFactory.kt index b7bf891b..b2d333dd 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/ModernAstralSetFactory.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/ModernAstralSetFactory.kt @@ -13,7 +13,7 @@ import org.bukkit.persistence.PersistentDataType class ModernAstralSetFactory(val identifier: String) { - constructor(caller: AstralSet) : this(caller.identifier()) + constructor(caller: AstralSet) : this(caller.setIdentifier()) companion object { private val ASTRAL_PDC = PersistentDataRecord.create("relic-rarity", PersistentDataType.STRING, Rarity.ASTRAL.name) diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/ArchaelSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/ArchaelSet.kt index 5c7ce184..6aaf84ae 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/ArchaelSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/ArchaelSet.kt @@ -32,7 +32,7 @@ class ArchaelSet : AstralSet { return false } - override fun identifier(): String { + override fun setIdentifier(): String { return "archael-set" } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/BlitzSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/BlitzSet.kt index 0ae36b12..853c4a49 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/BlitzSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/BlitzSet.kt @@ -63,7 +63,7 @@ class BlitzSet : AstralSet { return true } - override fun identifier(): String { + override fun setIdentifier(): String { return "blitz-set" } } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/FalterSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/FalterSet.kt index 1de365be..5b0f33c0 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/FalterSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/FalterSet.kt @@ -49,7 +49,7 @@ class FalterSet : AstralSet { return astralSetFactory.createdAstralItems } - override fun identifier(): String { + override fun setIdentifier(): String { return "falter-set" } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/KazkanSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/KazkanSet.kt index dce1421b..0bb1e6cb 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/KazkanSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/KazkanSet.kt @@ -78,7 +78,7 @@ class KazkanSet : AstralSet { return factory.createdAstralItems } - override fun identifier(): String { + override fun setIdentifier(): String { return "kazkan-set" } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/MagmaticSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/MagmaticSet.kt index f763cf2b..2bcea36f 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/MagmaticSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/MagmaticSet.kt @@ -66,7 +66,7 @@ class MagmaticSet : AstralSet { return factory.createdAstralItems } - override fun identifier(): String { + override fun setIdentifier(): String { return "magmatic-set" } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/MelukaSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/MelukaSet.kt index 476947fe..33bc5bb0 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/MelukaSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/MelukaSet.kt @@ -74,7 +74,7 @@ class MelukaSet : AstralSet { return true } - override fun identifier(): String { + override fun setIdentifier(): String { return "meluka-set" } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/MistralSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/MistralSet.kt index b514a84a..6204c82e 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/MistralSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/MistralSet.kt @@ -51,16 +51,16 @@ class MistralSet : AstralSet { when (genericMCToolType) { ToolType.SWORD -> { DefaultAttributes.NETHERITE_SWORD.appendThenGetAttributes( - Attribute.MOVEMENT_SPEED, identifier(), 0.025, AttributeModifier.Operation.ADD_NUMBER + Attribute.MOVEMENT_SPEED, setIdentifier(), 0.025, AttributeModifier.Operation.ADD_NUMBER ) } ToolType.PICKAXE -> { DefaultAttributes.NETHERITE_PICKAXE.appendThenGetAttributes( - Attribute.MOVEMENT_SPEED, identifier(), 0.025, AttributeModifier.Operation.ADD_NUMBER + Attribute.MOVEMENT_SPEED, setIdentifier(), 0.025, AttributeModifier.Operation.ADD_NUMBER ) } ToolType.FISHING_ROD -> { - DefaultAttributes.of(Attribute.MOVEMENT_SPEED, identifier(), 0.025, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlotGroup.ANY) + DefaultAttributes.of(Attribute.MOVEMENT_SPEED, setIdentifier(), 0.025, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlotGroup.ANY) } else -> null } @@ -70,7 +70,7 @@ class MistralSet : AstralSet { return astralSetFactory.createdAstralItems } - override fun identifier(): String { + override fun setIdentifier(): String { return "mistral-set" } override fun executeActions(type: Action, player: Player, event: Any): Boolean { diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/ValleySet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/ValleySet.kt index 3b70f77a..ab46f6cd 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/ValleySet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/ValleySet.kt @@ -59,7 +59,7 @@ class ValleySet : AstralSet { return astralSetFactory.createdAstralItems } - override fun identifier(): String { + override fun setIdentifier(): String { return "valley-set" } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/sets/VenomSet.kt b/src/main/java/dev/lumas/lumaitems/items/astral/sets/VenomSet.kt index 31fd536c..0b623d21 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/sets/VenomSet.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/sets/VenomSet.kt @@ -42,7 +42,7 @@ class VenomSet : AstralSet { return astralSetFactory.createdAstralItems } - override fun identifier(): String { + override fun setIdentifier(): String { return "venom-set" } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralSetUpgradeFactory.kt b/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralSetUpgradeFactory.kt index b9aa2b8e..d06cd3fa 100644 --- a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralSetUpgradeFactory.kt +++ b/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralSetUpgradeFactory.kt @@ -1,22 +1,25 @@ package dev.lumas.lumaitems.items.astral.upgrades +import dev.lumas.lumaitems.configuration.files.AstralYml import dev.lumas.lumaitems.enums.DefaultAttributes import dev.lumas.lumaitems.enums.ToolType +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.MiniMessageUtil +import dev.lumas.lumaitems.util.Util import dev.lumas.lumaitems.util.tiers.Tier import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer import org.bukkit.Material -import org.bukkit.NamespacedKey import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType // Notes: // Upgrade tier names should be the set's identifiers (e.g. mistral-set) and should have a short value of the actual tier. -class AstralSetUpgradeFactory (val item: ItemStack) : AstralSetUpgradeManager() { +class AstralSetUpgradeFactory (val item: ItemStack) { + fun upgrade(): Boolean { - val upgradeTier: AstralUpgradeTier = determineUpgradeTier() ?: return false + val upgradeTier: WrappedAstralUpgradeTier = determineUpgradeTier() ?: return false upgradeAstralItem(item, upgradeTier) if (upgradeTier.maxTier) { updateAstralItemTier(item) @@ -25,16 +28,23 @@ class AstralSetUpgradeFactory (val item: ItemStack) : AstralSetUpgradeManager() } - private fun determineUpgradeTier(): AstralUpgradeTier? { + private fun determineUpgradeTier(): WrappedAstralUpgradeTier? { val dataContainer = item.itemMeta?.persistentDataContainer ?: return null - for (upgrade in upgrades) { - val tierNumber = dataContainer.get(NamespacedKey(plugin, upgrade.key), PersistentDataType.SHORT) ?: continue - for (upgradeTier: AstralUpgradeTier in upgrade.value) { - if (upgradeTier.tierNumber == tierNumber.toInt() + 1) { - return upgradeTier + val upgradeTiers = Registry.CONFIGS.getOrThrow(AstralYml::class).astralUpgrades + for (entry in upgradeTiers) { + val setId = entry.key + val upgrades = entry.value + val currentTier = dataContainer.get(Util.namespacedKey(setId), PersistentDataType.SHORT) ?: continue + + for (upgradeTier: AstralYml.OkaeriAstralUpgradeTier in upgrades) { + val canUpgrade = upgradeTier.tier == currentTier.toInt() + 1 + if (canUpgrade) { + val isMaxTier = upgradeTier.tier >= upgrades.maxOf { it.tier } + return WrappedAstralUpgradeTier(setId, upgradeTier, isMaxTier) } } } + return null } @@ -55,20 +65,26 @@ class AstralSetUpgradeFactory (val item: ItemStack) : AstralSetUpgradeManager() } companion object { - fun upgradeAstralItem(item: ItemStack, upgradeTier: AstralUpgradeTier) { + val MODIFIABLE_MATERIALS: List = listOf( + ToolType.HELMET, ToolType.CHESTPLATE, ToolType.LEGGINGS, ToolType.BOOTS, + ToolType.SWORD, ToolType.PICKAXE, ToolType.AXE, ToolType.SHOVEL, ToolType.HOE + ) + + fun upgradeAstralItem(item: ItemStack, upgradeTier: WrappedAstralUpgradeTier) { val genericMCToolType = ToolType.getToolType(item) - if (modifiableMaterials.contains(genericMCToolType)) { + // TODO: Needs better logic + if (MODIFIABLE_MATERIALS.contains(genericMCToolType)) { val originalGearType = item.type.toString().split("_")[1] // FIXME: Deprecated method usage - item.type = Material.valueOf("${upgradeTier.newMaterial}_${originalGearType}") + item.type = Material.valueOf("${upgradeTier.material}_${originalGearType}") } val meta = item.itemMeta ?: return - for (astralUpgradeEnchant in upgradeTier.newEnchantments) { + for (astralUpgradeEnchant in upgradeTier.enchants) { val enchantment = astralUpgradeEnchant.enchantment - if (astralUpgradeEnchant.applyTo != null && astralUpgradeEnchant.applyTo.contains(genericMCToolType)) { + if (astralUpgradeEnchant.apply.isNotEmpty() && astralUpgradeEnchant.apply.contains(genericMCToolType)) { meta.addEnchant(enchantment, astralUpgradeEnchant.level, true) } else if (enchantment.canEnchantItem(item)) { meta.addEnchant(enchantment, astralUpgradeEnchant.level, true) @@ -85,7 +101,7 @@ class AstralSetUpgradeFactory (val item: ItemStack) : AstralSetUpgradeManager() } } - meta.persistentDataContainer.set(NamespacedKey(plugin, upgradeTier.tierName), PersistentDataType.SHORT, upgradeTier.tierNumber.toShort()) + meta.persistentDataContainer.set(Util.namespacedKey(upgradeTier.setId), PersistentDataType.SHORT, upgradeTier.tier.toShort()) item.itemMeta = meta } } diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralSetUpgradeManager.kt b/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralSetUpgradeManager.kt deleted file mode 100644 index d35abdcb..00000000 --- a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralSetUpgradeManager.kt +++ /dev/null @@ -1,75 +0,0 @@ -package dev.lumas.lumaitems.items.astral.upgrades - -import dev.lumas.lumaitems.LumaItems -import dev.lumas.lumaitems.manager.FileManager -import dev.lumas.lumaitems.enums.ToolType -import org.bukkit.NamespacedKey -import org.bukkit.enchantments.Enchantment - -open class AstralSetUpgradeManager { - companion object { - val modifiableMaterials: List = listOf( - ToolType.HELMET, ToolType.CHESTPLATE, ToolType.LEGGINGS, ToolType.BOOTS, - ToolType.SWORD, ToolType.PICKAXE, ToolType.AXE, ToolType.SHOVEL, ToolType.HOE - ) - - @JvmStatic val upgrades: MutableMap> = mutableMapOf() - val plugin: LumaItems = LumaItems.getInstance() - } - - init { - //reloadUpgrades() - } - - fun reloadUpgrades() { - val fileManager = FileManager("astral.yml").generateYamlFile() - - for (setKey in fileManager.getConfigurationSection("astral-upgrades")?.getKeys(false) ?: throw NullPointerException("Section does not exist")) { - val setTierSection = fileManager.getConfigurationSection("astral-upgrades.$setKey") ?: continue - val setTierSectionList = setTierSection.getKeys(false) - for (setTier in setTierSectionList) { - val astralMaterial = AstralMaterial.valueOf(setTierSection.getString("$setTier.material") ?: "IRON") - val enchantsListString = setTierSection.getStringList("$setTier.enchants") - val setTierNumber = setTier.replace("tier-", "").trim().toInt() - - val astralUpgradeTier = AstralUpgradeTier( - setKey, - astralMaterial, - getEnchantsFromStringList(enchantsListString), - setTierNumber, - setTierSectionList.last() == setTier - ) - - if (upgrades.contains(setKey)) { - upgrades[setKey]?.add(astralUpgradeTier) - } else { - upgrades[setKey] = mutableListOf(astralUpgradeTier) - } - } - } - } - - private fun getEnchantsFromStringList(stringEnchants: MutableList): List { - val enchants: MutableList = mutableListOf() - for (stringEnchant in stringEnchants) { - val pair = AstralUpgradeEnchantment.deserializeAndRemoveApplyTo(stringEnchant) - - val toolsToApplyTo: List? = pair.first - val finalStringEnchant = pair.second - - val split = finalStringEnchant.split("/") - if (split.size != 2) { - plugin.logger.severe("Invalid enchantment! $finalStringEnchant") - continue - } - - val enchantment: Enchantment? = Enchantment.getByKey(NamespacedKey.minecraft(split[0].lowercase())) - if (enchantment == null) { - plugin.logger.severe("Invalid enchantment! ${split[0]}") - continue - } - enchants.add(AstralUpgradeEnchantment(enchantment, split[1].toInt(), toolsToApplyTo)) - } - return enchants - } -} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralUpgradeEnchantment.kt b/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralUpgradeEnchantment.kt deleted file mode 100644 index fe912baa..00000000 --- a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralUpgradeEnchantment.kt +++ /dev/null @@ -1,50 +0,0 @@ -package dev.lumas.lumaitems.items.astral.upgrades - -import dev.lumas.lumaitems.enums.ToolType -import org.bukkit.enchantments.Enchantment - -data class AstralUpgradeEnchantment ( - val enchantment: Enchantment, - val level: Int, - val applyTo: List? -) { - companion object { - - fun deserializeAndRemoveApplyTo(string: String): Pair?, String> { - if (!string.contains("-apply:")) return Pair(null, string) - - val split = string.split("-apply:") - - val tools = split[1].split(",") - val toolsToApplyTo: MutableList = mutableListOf() - for (tool in tools) { - toolsToApplyTo.add(ToolType.valueOf(tool.uppercase())) - } - - val newString = split[0].replace(" ", "").trim() - - return Pair(toolsToApplyTo, newString) - } - - fun deserializeToolsToApplyTo(string: String?): List? { - if (string == null) return null - if (!string.contains("-apply:")) return null - - val tools = string.split("-apply:")[1].split(",") - val toolsToApplyTo: MutableList = mutableListOf() - for (tool in tools) { - toolsToApplyTo.add(ToolType.valueOf(tool)) - } - return toolsToApplyTo - } - - fun serializeToolsToApplyTo(tools: List?): String? { - if (tools == null) return null - val toolsToApplyTo: MutableList = mutableListOf() - for (tool in tools) { - toolsToApplyTo.add(tool.name) - } - return "-apply:${toolsToApplyTo.joinToString(",")}" - } - } -} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralUpgradeTier.kt b/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralUpgradeTier.kt deleted file mode 100644 index cae9cec8..00000000 --- a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/AstralUpgradeTier.kt +++ /dev/null @@ -1,13 +0,0 @@ -package dev.lumas.lumaitems.items.astral.upgrades - -data class AstralUpgradeTier( - val tierName: String, - val newMaterial: AstralMaterial, - val newEnchantments: List, - val tierNumber: Int, - val maxTier: Boolean -) { - override fun toString(): String { - return "AstralUpgradeTier(tierName='$tierName', newMaterial=$newMaterial, newEnchantments=$newEnchantments, tierNumber=$tierNumber, maxTier=$maxTier)" - } -} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/WrappedAstralUpgradeTier.kt b/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/WrappedAstralUpgradeTier.kt new file mode 100644 index 00000000..b355b154 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/items/astral/upgrades/WrappedAstralUpgradeTier.kt @@ -0,0 +1,14 @@ +package dev.lumas.lumaitems.items.astral.upgrades + +import dev.lumas.lumaitems.configuration.files.AstralYml + +class WrappedAstralUpgradeTier( + val setId: String, + val upgradeTier: AstralYml.OkaeriAstralUpgradeTier, + val maxTier: Boolean +) { + + val tier = upgradeTier.tier + val material = upgradeTier.material + val enchants = upgradeTier.enchants +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/misc/jobs/ArchiveOfAstralisItemNest.kt b/src/main/java/dev/lumas/lumaitems/items/misc/jobs/ArchiveOfAstralisItemNest.kt index 3155336b..da6c6cc9 100644 --- a/src/main/java/dev/lumas/lumaitems/items/misc/jobs/ArchiveOfAstralisItemNest.kt +++ b/src/main/java/dev/lumas/lumaitems/items/misc/jobs/ArchiveOfAstralisItemNest.kt @@ -6,8 +6,10 @@ import com.gmail.nossr50.api.AbilityAPI as MCMMOAbilityAPI import dev.lumas.lumacore.utility.Logging import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.enums.Action +import dev.lumas.lumaitems.hooks.McMMOHook import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.manager.CustomItemFunctions +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Util import dev.lumas.lumaitems.util.tiers.Tier import io.papermc.paper.persistence.PersistentDataContainerView @@ -62,7 +64,7 @@ abstract class ArchiveOfAstralisItemNest(private val jobType: JobType) : CustomI override fun executeWithContainer(type: Action, player: Player, event: Any, container: PersistentDataContainerView): Boolean { try { - if (LumaItems.isWithmcMMO() && MCMMOAbilityAPI.treeFellerEnabled(player)) { + if (Registry.HOOKS.getOrThrow(McMMOHook::class).isWith() && MCMMOAbilityAPI.treeFellerEnabled(player)) { // Patched, but leaving disabled for now. return false } diff --git a/src/main/java/dev/lumas/lumaitems/items/nests/InfiniteBucketsItemNest.kt b/src/main/java/dev/lumas/lumaitems/items/nests/InfiniteBucketsItemNest.kt index a555e54e..b2727aad 100644 --- a/src/main/java/dev/lumas/lumaitems/items/nests/InfiniteBucketsItemNest.kt +++ b/src/main/java/dev/lumas/lumaitems/items/nests/InfiniteBucketsItemNest.kt @@ -32,7 +32,7 @@ class InfiniteWaterBucketItem : CustomItemFunctions() { override fun onPlayerEmptyBucket(player: Player, event: PlayerBucketEmptyEvent) { event.itemStack = infiniteWaterBucket - player.updateInventory() + //player.updateInventory() Currently unnecessary - any reports on this? } } @@ -60,7 +60,7 @@ class InfiniteLavaBucketItem : CustomItemFunctions() { override fun onPlayerEmptyBucket(player: Player, event: PlayerBucketEmptyEvent) { event.itemStack = infiniteLavaBucket - player.updateInventory() + //player.updateInventory() Currently unnecessary - any reports on this? } } diff --git a/src/main/java/dev/lumas/lumaitems/items/tools/hatchet/StellarisTomahawkItem.kt b/src/main/java/dev/lumas/lumaitems/items/tools/hatchet/StellarisTomahawkItem.kt index f822381c..2e50e3d3 100644 --- a/src/main/java/dev/lumas/lumaitems/items/tools/hatchet/StellarisTomahawkItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/tools/hatchet/StellarisTomahawkItem.kt @@ -1,15 +1,13 @@ package dev.lumas.lumaitems.items.tools.hatchet -import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.enums.Action +import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.manager.CustomItem -import dev.lumas.lumaitems.util.AbilityUtil import dev.lumas.lumaitems.util.disabling.Disable import dev.lumas.lumaitems.util.disabling.WorldName import org.bukkit.Material import org.bukkit.enchantments.Enchantment import org.bukkit.entity.Player -import org.bukkit.event.block.BlockBreakEvent import org.bukkit.inventory.ItemStack @Disable(WorldName.EVENT_NEW) @@ -27,14 +25,6 @@ class StellarisTomahawkItem : CustomItem { } override fun executeActions(type: Action, player: Player, event: Any): Boolean { - val blockBreakEvent: BlockBreakEvent? = event as? BlockBreakEvent - when (type) { - Action.BREAK_BLOCK -> { - AbilityUtil.pinataAbility(blockBreakEvent!!.block) - } - - else -> return false - } return true } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/tools/mattock/StellarisMattockItem.kt b/src/main/java/dev/lumas/lumaitems/items/tools/mattock/StellarisMattockItem.kt index 85145129..08a3fa49 100644 --- a/src/main/java/dev/lumas/lumaitems/items/tools/mattock/StellarisMattockItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/tools/mattock/StellarisMattockItem.kt @@ -37,14 +37,6 @@ class StellarisMattockItem : CustomItem { } override fun executeActions(type: Action, player: Player, event: Any): Boolean { - val blockBreakEvent: BlockBreakEvent? = event as? BlockBreakEvent - when (type) { - Action.BREAK_BLOCK -> { - AbilityUtil.pinataAbility(blockBreakEvent!!.block) - } - - else -> return false - } return true } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/tools/mattock/VigilanceMattockItem.kt b/src/main/java/dev/lumas/lumaitems/items/tools/mattock/VigilanceMattockItem.kt index 4bfd5016..e14703dd 100644 --- a/src/main/java/dev/lumas/lumaitems/items/tools/mattock/VigilanceMattockItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/tools/mattock/VigilanceMattockItem.kt @@ -6,9 +6,11 @@ import com.comphenix.protocol.events.PacketAdapter import com.comphenix.protocol.events.PacketEvent import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.enums.BlockConstants +import dev.lumas.lumaitems.hooks.ProtocolLibHook import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.manager.CustomItemFunctions import dev.lumas.lumaitems.manager.GlowManager +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.shapes.Cuboid import dev.lumas.lumaitems.util.extensions.BlockUtil.getOreColor import dev.lumas.lumaitems.util.Executors @@ -47,7 +49,7 @@ class VigilanceMattockItem : CustomItemFunctions() { init { - LumaItems.getProtocolManager()?.addPacketListener( + Registry.HOOKS.getOrThrow(ProtocolLibHook::class).getProtocolManager()?.addPacketListener( object: PacketAdapter(LumaItems.getInstance(), ListenerPriority.NORMAL, PacketType.Play.Server.NAMED_SOUND_EFFECT, PacketType.Play.Server.ENTITY_SOUND) { override fun onPacketSending(event: PacketEvent) { if (event.player.inventory.itemInMainHand.itemMeta?.persistentDataContainer?.has(KEY) == true) { diff --git a/src/main/java/dev/lumas/lumaitems/items/tools/rod/FrostedAlluringItem.kt b/src/main/java/dev/lumas/lumaitems/items/tools/rod/FrostedAlluringItem.kt index cc8893b0..013b5bdf 100644 --- a/src/main/java/dev/lumas/lumaitems/items/tools/rod/FrostedAlluringItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/tools/rod/FrostedAlluringItem.kt @@ -3,8 +3,10 @@ package dev.lumas.lumaitems.items.tools.rod import com.comphenix.protocol.PacketType import com.comphenix.protocol.wrappers.EnumWrappers import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.hooks.ProtocolLibHook import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.manager.CustomItemFunctions +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Util import dev.lumas.lumaitems.util.tiers.Tier import org.bukkit.Bukkit @@ -37,7 +39,7 @@ class FrostedAlluringItem : CustomItemFunctions() { } Bukkit.getScheduler().runTaskLaterAsynchronously(instance(), Runnable { - val protocolManager = LumaItems.getProtocolManager() ?: return@Runnable + val protocolManager = Registry.HOOKS.getOrThrow(ProtocolLibHook::class).getProtocolManager() ?: return@Runnable val hand = if (Util.isItemInSlot("frosted-alluring", EquipmentSlot.OFF_HAND, player)) { EnumWrappers.Hand.OFF_HAND diff --git a/src/main/java/dev/lumas/lumaitems/items/tools/rod/LoversAlluringItem.kt b/src/main/java/dev/lumas/lumaitems/items/tools/rod/LoversAlluringItem.kt index c4e41f79..2132d363 100644 --- a/src/main/java/dev/lumas/lumaitems/items/tools/rod/LoversAlluringItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/tools/rod/LoversAlluringItem.kt @@ -5,7 +5,9 @@ import com.comphenix.protocol.events.PacketContainer import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.enums.Action +import dev.lumas.lumaitems.hooks.ProtocolLibHook import dev.lumas.lumaitems.manager.CustomItem +import dev.lumas.lumaitems.registry.Registry import org.bukkit.Bukkit import org.bukkit.Material import org.bukkit.enchantments.Enchantment @@ -37,7 +39,7 @@ class LoversAlluringItem : CustomItem { when (event.state) { PlayerFishEvent.State.BITE -> { Bukkit.getScheduler().runTaskLaterAsynchronously(instance(), Runnable { - LumaItems.getProtocolManager()?.receiveClientPacket(player, PacketContainer(PacketType.Play.Client.USE_ITEM)) + Registry.HOOKS.getOrThrow(ProtocolLibHook::class).getProtocolManager()?.receiveClientPacket(player, PacketContainer(PacketType.Play.Client.USE_ITEM)) }, 1L) } PlayerFishEvent.State.CAUGHT_FISH -> { diff --git a/src/main/java/dev/lumas/lumaitems/items/tools/spade/StellarisSpadeItem.kt b/src/main/java/dev/lumas/lumaitems/items/tools/spade/StellarisSpadeItem.kt index 9f1cb968..189e3a40 100644 --- a/src/main/java/dev/lumas/lumaitems/items/tools/spade/StellarisSpadeItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/tools/spade/StellarisSpadeItem.kt @@ -27,14 +27,6 @@ class StellarisSpadeItem : CustomItem { } override fun executeActions(type: Action, player: Player, event: Any): Boolean { - val blockBreakEvent: BlockBreakEvent? = event as? BlockBreakEvent - when (type) { - Action.BREAK_BLOCK -> { - AbilityUtil.pinataAbility(blockBreakEvent!!.block) - } - - else -> return false - } return true } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/items/weapons/bow/VigilanceDriverItem.kt b/src/main/java/dev/lumas/lumaitems/items/weapons/bow/VigilanceDriverItem.kt index f304ee44..b783449c 100644 --- a/src/main/java/dev/lumas/lumaitems/items/weapons/bow/VigilanceDriverItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/weapons/bow/VigilanceDriverItem.kt @@ -6,9 +6,11 @@ import com.comphenix.protocol.events.PacketAdapter import com.comphenix.protocol.events.PacketEvent import com.comphenix.protocol.wrappers.EnumWrappers import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.hooks.ProtocolLibHook import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.manager.CustomItemFunctions import dev.lumas.lumaitems.manager.GlowManager +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Executors import dev.lumas.lumaitems.util.Util import dev.lumas.lumaitems.util.tiers.Tier @@ -36,12 +38,12 @@ class VigilanceDriverItem : CustomItemFunctions() { private val referencedEntities: ConcurrentHashMap> = ConcurrentHashMap() private val KEY = Util.namespacedKey("vigilance-driver") private val BLINDNESS = PotionEffect(PotionEffectType.BLINDNESS, 300, 0, true, false, false) - private val COLORS = GlowManager.PACKET_COLORS.filter { it != EnumWrappers.ChatFormatting.WHITE } + private val COLORS by lazy { GlowManager.PACKET_COLORS.filter { it != EnumWrappers.ChatFormatting.WHITE } } private const val RANGE = 80.0 init { - LumaItems.getProtocolManager()?.addPacketListener( + Registry.HOOKS.getOrThrow(ProtocolLibHook::class).getProtocolManager()?.addPacketListener( object: PacketAdapter(LumaItems.getInstance(), ListenerPriority.NORMAL, PacketType.Play.Server.NAMED_SOUND_EFFECT, PacketType.Play.Server.ENTITY_SOUND) { override fun onPacketSending(event: PacketEvent) { if (Util.isItemInSlot(KEY, EquipmentSlot.HAND, event.player)) { diff --git a/src/main/java/dev/lumas/lumaitems/items/weapons/cutlass/YolkPlaidYataghanItem.kt b/src/main/java/dev/lumas/lumaitems/items/weapons/cutlass/YolkPlaidYataghanItem.kt index bd8136f9..4e012600 100644 --- a/src/main/java/dev/lumas/lumaitems/items/weapons/cutlass/YolkPlaidYataghanItem.kt +++ b/src/main/java/dev/lumas/lumaitems/items/weapons/cutlass/YolkPlaidYataghanItem.kt @@ -1,9 +1,10 @@ package dev.lumas.lumaitems.items.weapons.cutlass +import dev.lumas.lumaitems.configuration.files.HeadsYml import dev.lumas.lumaitems.items.ItemFactory import dev.lumas.lumaitems.manager.CustomItemFunctions -import dev.lumas.lumaitems.manager.FileManager import dev.lumas.lumaitems.manager.GlowManager +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.AbilityUtil import dev.lumas.lumaitems.util.Util import dev.lumas.lumaitems.util.tiers.Tier @@ -28,7 +29,6 @@ import org.joml.Vector3f class YolkPlaidYataghanItem : CustomItemFunctions() { companion object { - private val eggTextures: List = FileManager("heads.yml").generateYamlFile().getStringList("easter-egg") private val coolingDownEggs: MutableMap = mutableMapOf() private val SLOWNESS = PotionEffect(PotionEffectType.SLOWNESS, 240, 150, false, false, false) } @@ -75,6 +75,7 @@ class YolkPlaidYataghanItem : CustomItemFunctions() { } private fun trapMobInEgg(livingEntity: LivingEntity, attacker: Player) { + val eggTextures = Registry.CONFIGS.getOrThrow(HeadsYml::class).easterEgg val loc = livingEntity.eyeLocation.add(0.0, 0.5, 0.0); loc.yaw = 0.0f; loc.pitch = 0.0f val boundingBox = livingEntity.boundingBox val egg = livingEntity.world.spawnEntity(loc, EntityType.ITEM_DISPLAY) as ItemDisplay diff --git a/src/main/java/dev/lumas/lumaitems/manager/CustomItem.kt b/src/main/java/dev/lumas/lumaitems/manager/CustomItem.kt index 5255949c..bc4a4aed 100644 --- a/src/main/java/dev/lumas/lumaitems/manager/CustomItem.kt +++ b/src/main/java/dev/lumas/lumaitems/manager/CustomItem.kt @@ -3,6 +3,9 @@ package dev.lumas.lumaitems.manager import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.enums.Action import dev.lumas.lumaitems.events.items.ItemListener +import dev.lumas.lumaitems.registry.Identifier +import dev.lumas.lumaitems.registry.NamespacedIdentifier +import dev.lumas.lumaitems.registry.RegistryItem import dev.lumas.lumaitems.util.Executors import dev.lumas.lumaitems.util.disabling.Disable import io.papermc.paper.persistence.PersistentDataContainerView @@ -15,7 +18,7 @@ import org.bukkit.event.player.PlayerMoveEvent import org.bukkit.inventory.ItemStack import org.bukkit.scheduler.BukkitTask -interface CustomItem { +interface CustomItem : RegistryItem { fun instance(): LumaItems { return LumaItems.getInstance() @@ -86,4 +89,8 @@ interface CustomItem { fun tabCompleteName(): String? { return null } + + override fun identifier(): NamespacedIdentifier { + return NamespacedIdentifier.lumaitems(this.createItem().first) + } } \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/manager/FileManager.kt b/src/main/java/dev/lumas/lumaitems/manager/FileManager.kt deleted file mode 100644 index f6842446..00000000 --- a/src/main/java/dev/lumas/lumaitems/manager/FileManager.kt +++ /dev/null @@ -1,103 +0,0 @@ -package dev.lumas.lumaitems.manager - -import dev.lumas.lumaitems.LumaItems -import org.bukkit.configuration.file.YamlConfiguration -import java.io.File -import java.io.IOException -import java.nio.file.Files - -class FileManager(val fileName: String) { - - companion object { - private val plugin: LumaItems = LumaItems.getInstance() - private val defaultFiles: List = listOf("relics.yml", "astral.yml", "heads.yml") - - @JvmStatic fun generateFolder(folder: String) { - if (!File(plugin.dataFolder, folder).exists()) { - File(plugin.dataFolder, folder).mkdir() - } - } - - @JvmStatic fun generateDefaultFiles() { - if (!plugin.dataFolder.exists()) { - plugin.dataFolder.mkdir() - } - generateFolder("saves") - for (fileName in defaultFiles) { - FileManager(fileName).generateFile() - } - } - } - - val file: File = File(plugin.dataFolder, fileName) - private var yamlConfiguration: YamlConfiguration? = null - - - fun generateYamlFile(): YamlConfiguration { - generateFile() - return getFileYaml() - } - - fun generateFile() { - try { - if (!file.exists()) { - file.createNewFile() - - val inputStream = plugin.getResource(fileName) - if (inputStream != null) { - val outputStream = Files.newOutputStream(file.toPath()) - val buffer = ByteArray(1024) - var bytesRead: Int - while (inputStream.read(buffer).also { bytesRead = it } != -1) { - outputStream.write(buffer, 0, bytesRead) - } - inputStream.close() - outputStream.flush() - outputStream.close() - } - } - } catch (ex: IOException) { - plugin.logger.warning("Could not generate file: ${file.name} \n $ex") - } - } - - fun overrideFile() { - try { - if (!file.exists()) return - - val inputStream = plugin.getResource(fileName) - if (inputStream != null) { - val outputStream = Files.newOutputStream(file.toPath()) - val buffer = ByteArray(1024) - var bytesRead: Int - while (inputStream.read(buffer).also { bytesRead = it } != -1) { - outputStream.write(buffer, 0, bytesRead) - } - inputStream.close() - outputStream.flush() - outputStream.close() - } - } catch (ex: IOException) { - plugin.logger.warning("Could not override file: ${file.name} \n $ex") - } - } - - fun deleteFile() { - if (file.exists()) { - file.delete() - } - } - - fun getFileYaml(): YamlConfiguration { - yamlConfiguration = YamlConfiguration.loadConfiguration(file) - return yamlConfiguration!! - } - - fun saveFileYaml() { - yamlConfiguration?.save(file) - } - - fun reloadFileYaml() { - yamlConfiguration?.load(file) - } -} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/manager/GlowManager.kt b/src/main/java/dev/lumas/lumaitems/manager/GlowManager.kt index cfac8142..d7e03d70 100644 --- a/src/main/java/dev/lumas/lumaitems/manager/GlowManager.kt +++ b/src/main/java/dev/lumas/lumaitems/manager/GlowManager.kt @@ -9,6 +9,8 @@ import com.comphenix.protocol.wrappers.WrappedTeamParameters import com.comphenix.protocol.wrappers.WrappedWatchableObject import com.google.common.collect.Lists import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.hooks.ProtocolLibHook +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Executors import java.lang.reflect.Type import java.util.Optional @@ -166,7 +168,7 @@ object GlowManager { } fun removeProtocolTeam(player: Player, entity: Entity) { - val protocolManager = LumaItems.getProtocolManager() ?: return + val protocolManager = Registry.HOOKS.getOrThrow(ProtocolLibHook::class).getProtocolManager() ?: return val teamName = "glow_${entity.entityId}" val removePacket = protocolManager.createPacket(PacketType.Play.Server.SCOREBOARD_TEAM) @@ -177,7 +179,7 @@ object GlowManager { } fun setProtocolTeamColor(player: Player, entity: Entity, color: EnumWrappers.ChatFormatting) { - val protocolManager = LumaItems.getProtocolManager() ?: return + val protocolManager = Registry.HOOKS.getOrThrow(ProtocolLibHook::class).getProtocolManager() ?: return val teamName = "glow_${entity.entityId}" val entry = if (entity is Player) entity.name else entity.uniqueId.toString() val teamParams = WrappedTeamParameters.newBuilder() @@ -207,7 +209,7 @@ object GlowManager { // liberally borrowed from: https://www.spigotmc.org/threads/i-want-to-use-protocollib-to-make-fake-entity-glow.589919/ fun setProtocolGlowPacket(player: Player, entity: Entity, glow: Boolean) { - val protocolManager = LumaItems.getProtocolManager() ?: return + val protocolManager = Registry.HOOKS.getOrThrow(ProtocolLibHook::class).getProtocolManager() ?: return val packet = protocolManager.createPacket(PacketType.Play.Server.ENTITY_METADATA) // metadata packet packet.integers.write(0, entity.entityId) //Set entity id from packet above diff --git a/src/main/java/dev/lumas/lumaitems/manager/ItemManager.java b/src/main/java/dev/lumas/lumaitems/manager/ItemManager.java index 9b044e4d..6cadcf41 100644 --- a/src/main/java/dev/lumas/lumaitems/manager/ItemManager.java +++ b/src/main/java/dev/lumas/lumaitems/manager/ItemManager.java @@ -3,10 +3,10 @@ import com.google.common.reflect.ClassPath; import dev.lumas.lumaitems.LumaItems; import dev.lumas.lumaitems.items.astral.AstralSet; -import dev.lumas.lumaitems.util.NeedsEdits; +import dev.lumas.lumaitems.registry.NamespacedIdentifier; +import dev.lumas.lumaitems.registry.Registry; +import dev.lumas.lumaitems.registry.StringIdentifier; import dev.lumas.lumaitems.util.disabling.Ignore; -import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; -import org.bukkit.NamespacedKey; import org.bukkit.inventory.ItemStack; import org.jetbrains.annotations.Nullable; @@ -15,22 +15,25 @@ import java.lang.reflect.Modifier; import java.net.URL; import java.net.URLClassLoader; -import java.util.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.Set; import java.util.stream.Collectors; public final class ItemManager { - private final LumaItems plugin; + //private final LumaItems plugin; /** * Map of all LumaItems Custom Items * Key: Custom Item NBT Key * Value: Custom Item Class */ - public final static Map CUSTOM_ITEMS = new HashMap<>(); + //public final static Map CUSTOM_ITEMS = new HashMap<>(); - public final static Map CUSTOM_ITEMS_BY_NAME = new HashMap<>(); + //public final static Map CUSTOM_ITEMS_BY_NAME = new HashMap<>(); public final static String BASE_PACKAGE = "dev.lumas.lumaitems.items"; @@ -44,16 +47,16 @@ public final class ItemManager { */ @Nullable public static ItemStack getItemByName(String name) { - var customItem = CUSTOM_ITEMS_BY_NAME.get(name.replace(" ", "_").toLowerCase()); + var customItem = Registry.NAMED_CUSTOM_ITEMS.get(StringIdentifier.normalized(name)); if (customItem == null) { return null; } - return customItem.createItem().component2(); + return customItem.getCustomItem().createItem().component2(); } @Nullable public static ItemStack getItemByKey(String key) { - var customItem = CUSTOM_ITEMS.get(new NamespacedKey(LumaItems.getInstance(), key)); + var customItem = Registry.CUSTOM_ITEMS.get(NamespacedIdentifier.lumaitems(key)); if (customItem == null) { return null; } @@ -67,7 +70,7 @@ public static ItemStack getItemByKey(String key) { */ @Nullable public static CustomItem getCustomItem(String key) { - return CUSTOM_ITEMS.get(new NamespacedKey(LumaItems.getInstance(), key)); + return Registry.CUSTOM_ITEMS.get(NamespacedIdentifier.lumaitems(key)); } /** @@ -75,7 +78,7 @@ public static CustomItem getCustomItem(String key) { */ public static List getAllItems() { List list = new ArrayList<>(); - for (CustomItem item : CUSTOM_ITEMS.values()) { + for (CustomItem item : Registry.CUSTOM_ITEMS.values()) { try { list.add(item.createItem().component2()); } catch (Exception e) { @@ -86,9 +89,9 @@ public static List getAllItems() { } - public ItemManager(LumaItems plugin) { - this.plugin = plugin; - } +// public ItemManager(LumaItems plugin) { +// this.plugin = plugin; +// } /** @@ -103,7 +106,7 @@ public void registerItems() throws IOException { for (String pack : packages) { registerForPackage(pack, classPath); } - LumaItems.log("Registered &6" + CUSTOM_ITEMS.size() + " &2classes through reflection"); + LumaItems.log("Registered &6" + Registry.CUSTOM_ITEMS.size() + " &2classes through reflection"); } } @@ -126,45 +129,17 @@ public void registerForPackage(String pack, ClassPath classPath) { } public void registerItem(CustomItem item) { - CUSTOM_ITEMS.put(new NamespacedKey(plugin, item.createItem().component1()), item); - registerForName(item); - Class clazz = item.getClass(); - NeedsEdits edits = clazz.getAnnotation(NeedsEdits.class); - if (edits != null) { - if (!edits.review()) { - LumaItems.log("&cClass &6" + clazz.getSimpleName() + " &cneeds edits!"); - } else { - LumaItems.log("&aClass &6" + clazz.getSimpleName() + " &ais ready for review!"); - } - } - } + Registry.CUSTOM_ITEMS.put(item); - public void registerForName(CustomItem item) { - String customTabName = item.tabCompleteName(); - if (customTabName != null) { - CUSTOM_ITEMS_BY_NAME.put(customTabName, item); - return; + if (!AstralSet.class.isAssignableFrom(item.getClass())) { + String customTabName = item.tabCompleteName(); + NamedCustomItem namedCustomItem = new NamedCustomItem(item, customTabName); + Registry.NAMED_CUSTOM_ITEMS.put(namedCustomItem); } - - ItemStack itemStack; - try { - itemStack = item.createItem().component2(); - } catch (Exception e) { - LumaItems.log("Failed to create item for " + item.getClass().getSimpleName(), e); - return; - } - if (AstralSet.class.isAssignableFrom(item.getClass())) { - return; - } else if (!itemStack.hasItemMeta() || !itemStack.getItemMeta().hasDisplayName()) { - LumaItems.log("Item " + itemStack.getType() + " does not have a display name or meta!"); - return; - } - String formattedName = PlainTextComponentSerializer.plainText().serialize(itemStack.getItemMeta().displayName()) - .replace(" ", "_").toLowerCase(); - CUSTOM_ITEMS_BY_NAME.put(formattedName, item); } + /** * Recursively finds all packages in a base package * @param basePackage Base package to search diff --git a/src/main/java/dev/lumas/lumaitems/manager/NamedCustomItem.kt b/src/main/java/dev/lumas/lumaitems/manager/NamedCustomItem.kt new file mode 100644 index 00000000..3f43ebea --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/manager/NamedCustomItem.kt @@ -0,0 +1,45 @@ +package dev.lumas.lumaitems.manager + +import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.registry.RegistryItem +import dev.lumas.lumaitems.registry.StringIdentifier +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer + +class NamedCustomItem( + val customItem: CustomItem, + val forcedIdentifier: String? = null +) : RegistryItem { + + constructor(customItem: CustomItem) : this(customItem, null) + + override fun identifier(): StringIdentifier { + return if (forcedIdentifier != null) { + StringIdentifier.of(forcedIdentifier) + } else { + StringIdentifier.of(this.normalizedName()) + } + } + + fun normalizedName(): String? { + val itemStack = try { + customItem.createItem().second + } catch (e: Exception) { + LumaItems.log("Failed to create item for " + customItem.javaClass.getSimpleName(), e) + return null + } + val meta = itemStack.itemMeta + if (!meta.hasCustomName()) { + LumaItems.log("Item " + itemStack.type + " does not have a display name or meta!") + return "${itemStack.type}-${randomString(3)}" + } + return PlainTextComponentSerializer.plainText().serialize(meta.customName()!!) + .replace(" ", "_").lowercase() + } + + private fun randomString(length: Int): String { + val allowedChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" + return (1..length) + .map { allowedChars.random() } + .joinToString("") + } +} \ No newline at end of file diff --git a/src/main/java/dev/lumas/lumaitems/registry/Identifier.java b/src/main/java/dev/lumas/lumaitems/registry/Identifier.java new file mode 100644 index 00000000..bfc7f7d3 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/registry/Identifier.java @@ -0,0 +1,12 @@ +package dev.lumas.lumaitems.registry; + +import org.bukkit.NamespacedKey; +import org.jetbrains.annotations.NotNull; + +public interface Identifier { + @NotNull + NamespacedKey asNameSpacedKey(); + + @NotNull + String asSimpleString(); +} diff --git a/src/main/java/dev/lumas/lumaitems/registry/NamespacedIdentifier.java b/src/main/java/dev/lumas/lumaitems/registry/NamespacedIdentifier.java new file mode 100644 index 00000000..c6da7523 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/registry/NamespacedIdentifier.java @@ -0,0 +1,25 @@ +package dev.lumas.lumaitems.registry; + +import dev.lumas.lumaitems.LumaItems; +import org.bukkit.NamespacedKey; +import org.jetbrains.annotations.NotNull; + +@SuppressWarnings("unused") +public record NamespacedIdentifier(NamespacedKey key) implements Identifier { + + public static NamespacedIdentifier lumaitems(String key) { + return new NamespacedIdentifier(new NamespacedKey(LumaItems.getInstance(), key)); + } + + @NotNull + @Override + public NamespacedKey asNameSpacedKey() { + return key; + } + + @NotNull + @Override + public String asSimpleString() { + return key.getKey(); + } +} diff --git a/src/main/java/dev/lumas/lumaitems/registry/Registry.java b/src/main/java/dev/lumas/lumaitems/registry/Registry.java new file mode 100644 index 00000000..cf3eb5bd --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/registry/Registry.java @@ -0,0 +1,232 @@ +package dev.lumas.lumaitems.registry; + +import dev.lumas.lumaitems.configuration.ConfigManager; +import dev.lumas.lumaitems.configuration.OkaeriFile; +import dev.lumas.lumaitems.configuration.files.AstralYml; +import dev.lumas.lumaitems.configuration.files.HeadsYml; +import dev.lumas.lumaitems.configuration.files.RelicsYml; +import dev.lumas.lumaitems.hooks.CoreProtectHook; +import dev.lumas.lumaitems.hooks.Hook; +import dev.lumas.lumaitems.hooks.LumaGlowAPIHook; +import dev.lumas.lumaitems.hooks.McMMOHook; +import dev.lumas.lumaitems.hooks.MythicMobsHook; +import dev.lumas.lumaitems.hooks.ProtocolLibHook; +import dev.lumas.lumaitems.manager.CustomItem; +import dev.lumas.lumaitems.manager.NamedCustomItem; +import kotlin.jvm.JvmClassMappingKt; +import kotlin.reflect.KClass; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.stream.Stream; + +public final class Registry implements Iterable> { + + public static final Registry CUSTOM_ITEMS = new Registry<>(); + public static final Registry NAMED_CUSTOM_ITEMS = new Registry<>(); + public static final Registry CONFIGS = fromClassesWithCrafter(new ConfigManager(), RelicsYml.class, AstralYml.class, HeadsYml.class); + public static final Registry HOOKS = fromClasses(ProtocolLibHook.class, MythicMobsHook.class, McMMOHook.class, CoreProtectHook.class, LumaGlowAPIHook.class); + + private final Map map; + + public Registry(Collection values) { + this.map = new HashMap<>(); + values.forEach(item -> { + map.put(item.identifier(), item); + }); + } + + public Registry() { + this.map = new HashMap<>(); + } + + @Nullable + public T get(Identifier identifier) { + return map.get(identifier); + } + + @Nullable + public A get(KClass kClass) { + return get(JvmClassMappingKt.getJavaClass(kClass)); + } + + @SuppressWarnings("unchecked") + @Nullable + public A get(Class clazz) { + return (A) map.values().stream() + .filter(it -> it.getClass().equals(clazz)) + .findFirst() + .orElse(null); + } + + @NotNull + public A getOrThrow(KClass kClass) { + return getOrThrow(JvmClassMappingKt.getJavaClass(kClass)); + } + + @NotNull + public A getOrThrow(Class clazz) { + A item = get(clazz); + if (item == null) { + throw new IllegalStateException("No registry item found for class " + clazz.getName()); + } + return item; + } + + public T put(T item) { + return map.put(item.identifier(), item); + } + + public Collection values() { + return map.values(); + } + + public Collection keySet() { + return map.keySet(); + } + + public Collection keySet(KClass kClass) { + return keySet(JvmClassMappingKt.getJavaClass(kClass)); + } + + public Collection keySet(Class clazz) { + List keys = new ArrayList<>(); + for (Identifier id : map.keySet()) { + if (clazz.isInstance(id)) { + keys.add(clazz.cast(id)); + } + } + return keys; + } + + public int size() { + return map.size(); + } + + public Stream> stream() { + return map.entrySet().stream(); + } + + @Override + public @NotNull Iterator> iterator() { + return map.entrySet().iterator(); + } + + public @NotNull Iterator> iterator(Class clazz) { + List> entries = new ArrayList<>(); + for (Map.Entry entry : map.entrySet()) { + if (clazz.isInstance(entry.getKey())) { + entries.add(Map.entry(clazz.cast(entry.getKey()), entry.getValue())); + } + } + return entries.iterator(); + } + + public boolean exists(Identifier identifier) { + return map.containsKey(identifier); + } + + public boolean exists(T item) { + return exists(item, true); + } + + public boolean exists(T item, boolean useIdentity) { + if (useIdentity) { + return map.containsKey(item.identifier()); + } + return map.containsValue(item); + } + + @SuppressWarnings({"unchecked", "RedundantCast"}) + @SafeVarargs + public static Registry fromClassesWithCrafter(RegistryCrafter crafter, Class... classes) { + List eClasses = new ArrayList<>(); + for (Class clazz : classes) { + if (crafter instanceof RegistryCrafter.Extension crafter1) { + eClasses.add((E) crafter1.craft(clazz)); + } else if (crafter instanceof RegistryCrafter.NoExtension crafter2) { + eClasses.add((E) crafter2.craft(clazz)); + } else { + throw new IllegalArgumentException("Unknown crafter type"); + } + } + return new Registry<>(eClasses.stream().filter(Objects::nonNull).toList()); + } + + @SafeVarargs + public static Registry fromClasses(Class... classes) { + return ConstructableClassBuilder.builder().addClasses(classes).build(); + } + + public static Registry fromClasses(Collection> constructorParamTypes, Collection constructorParams, Collection> classes) { + return ConstructableClassBuilder.builder().addConstructorParameters(constructorParamTypes, constructorParams).addClasses(classes).build(); + } + + + public static class ConstructableClassBuilder { + private final List> constructorClassTypes = new ArrayList<>(); + private final List constructorClassValues = new ArrayList<>(); + private final List> classes = new ArrayList<>(); + + public static ConstructableClassBuilder builder() { + return new ConstructableClassBuilder(); + } + + public ConstructableClassBuilder addConstructorParameter(Class type, Object value) { + constructorClassTypes.add(type); + constructorClassValues.add(value); + return this; + } + + public ConstructableClassBuilder addConstructorParameters(Collection> types, Collection values) { + constructorClassTypes.addAll(types); + constructorClassValues.addAll(values); + return this; + } + + public ConstructableClassBuilder addClass(Class clazz) { + classes.add(clazz); + return this; + } + + public ConstructableClassBuilder addClasses(Class... clazz) { + classes.addAll(List.of(clazz)); + return this; + } + + public ConstructableClassBuilder addClasses(Collection> clazz) { + classes.addAll(clazz); + return this; + } + + + public Registry build() { + Class[] constructorTypes = constructorClassTypes.toArray(new Class[0]); + Object[] constructorValues = constructorClassValues.toArray(new Object[0]); + + List tClasses = new ArrayList<>(); + for (Class clazz : classes) { + if (!RegistryItem.class.isAssignableFrom(clazz)) { + throw new IllegalArgumentException("Class " + clazz.getName() + " does not implement RegistryItem"); + } + + try { + tClasses.add((T) clazz.getConstructor(constructorTypes).newInstance(constructorValues)); + } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | + InvocationTargetException e) { + throw new RuntimeException("No constructor found for " + clazz.getName(), e); + } + } + return new Registry<>(tClasses); + } + + } +} diff --git a/src/main/java/dev/lumas/lumaitems/registry/RegistryCrafter.java b/src/main/java/dev/lumas/lumaitems/registry/RegistryCrafter.java new file mode 100644 index 00000000..22eb2185 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/registry/RegistryCrafter.java @@ -0,0 +1,10 @@ +package dev.lumas.lumaitems.registry; + +public interface RegistryCrafter { + interface Extension extends RegistryCrafter { + T craft(Class clazz); + } + interface NoExtension extends RegistryCrafter { + T craft(Class clazz); + } +} diff --git a/src/main/java/dev/lumas/lumaitems/registry/RegistryItem.java b/src/main/java/dev/lumas/lumaitems/registry/RegistryItem.java new file mode 100644 index 00000000..f45b1de9 --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/registry/RegistryItem.java @@ -0,0 +1,8 @@ +package dev.lumas.lumaitems.registry; + +import org.jetbrains.annotations.NotNull; + +public interface RegistryItem { + @NotNull + Identifier identifier(); +} diff --git a/src/main/java/dev/lumas/lumaitems/registry/StringIdentifier.java b/src/main/java/dev/lumas/lumaitems/registry/StringIdentifier.java new file mode 100644 index 00000000..59e3ab8d --- /dev/null +++ b/src/main/java/dev/lumas/lumaitems/registry/StringIdentifier.java @@ -0,0 +1,29 @@ +package dev.lumas.lumaitems.registry; + +import dev.lumas.lumaitems.LumaItems; +import org.bukkit.NamespacedKey; +import org.jetbrains.annotations.NotNull; + +@SuppressWarnings("unused") +public record StringIdentifier(String key) implements Identifier { + + public static StringIdentifier of(String key) { + return new StringIdentifier(key); + } + + public static StringIdentifier normalized(String key) { + return new StringIdentifier(key.toLowerCase().replace(" ", "_")); + } + + @NotNull + @Override + public NamespacedKey asNameSpacedKey() { + return new NamespacedKey(LumaItems.getInstance(), key); + } + + @NotNull + @Override + public String asSimpleString() { + return key; + } +} diff --git a/src/main/java/dev/lumas/lumaitems/relics/RelicCrafting.kt b/src/main/java/dev/lumas/lumaitems/relics/RelicCrafting.kt index 7018919a..6b9acaf5 100644 --- a/src/main/java/dev/lumas/lumaitems/relics/RelicCrafting.kt +++ b/src/main/java/dev/lumas/lumaitems/relics/RelicCrafting.kt @@ -103,6 +103,7 @@ object RelicCrafting { Bukkit.addRecipe(upgradeCoreRecipe) } + //TODO fun getItemsFromClass(className: String): List { val clazz = try { Class.forName("dev.lumas.lumaitems.items.astral.sets.$className") @@ -121,6 +122,11 @@ object RelicCrafting { } } + fun getItemsFromClass(clazz: Class): List { + val astralSet = clazz.getDeclaredConstructor().newInstance() as AstralSet + return astralSet.setItems() + } + fun hasFullSet(key: String, player: Player): Boolean { for (equipment in player.equipment?.armorContents ?: return false) { if (equipment == null || equipment.type == Material.AIR || !equipment.hasItemMeta()) return false diff --git a/src/main/java/dev/lumas/lumaitems/relics/RelicCreator.kt b/src/main/java/dev/lumas/lumaitems/relics/RelicCreator.kt index 0a761784..1a456f54 100644 --- a/src/main/java/dev/lumas/lumaitems/relics/RelicCreator.kt +++ b/src/main/java/dev/lumas/lumaitems/relics/RelicCreator.kt @@ -1,16 +1,17 @@ package dev.lumas.lumaitems.relics -import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.configuration.files.RelicsYml import dev.lumas.lumaitems.enums.Rarity import dev.lumas.lumaitems.items.ItemFactory -import dev.lumas.lumaitems.manager.FileManager import dev.lumas.lumaitems.obj.PersistentDataRecord -import dev.lumas.lumaitems.util.Util +import dev.lumas.lumaitems.registry.Registry +import io.papermc.paper.registry.RegistryAccess +import io.papermc.paper.registry.RegistryKey +import kotlin.random.Random import org.bukkit.Material import org.bukkit.enchantments.Enchantment import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType -import kotlin.random.Random class RelicCreator ( private val algorithmWeight: Int, @@ -19,8 +20,6 @@ class RelicCreator ( private val material: Material ) { companion object { - private val plugin: LumaItems = LumaItems.getInstance() - private const val RELIC_SUFFIX_RGB = "&f" private val blackListedEnchants: List = listOf(Enchantment.BINDING_CURSE, Enchantment.VANISHING_CURSE, Enchantment.FROST_WALKER, Enchantment.SWIFT_SNEAK, Enchantment.SOUL_SPEED, Enchantment.LUCK_OF_THE_SEA, Enchantment.LURE, Enchantment.IMPALING, Enchantment.RIPTIDE, Enchantment.CHANNELING, Enchantment.LOYALTY, Enchantment.MULTISHOT, Enchantment.PIERCING, Enchantment.QUICK_CHARGE, Enchantment.PUNCH, Enchantment.FLAME, Enchantment.INFINITY, Enchantment.POWER) @@ -38,17 +37,17 @@ class RelicCreator ( ) } - private val file = FileManager("relics.yml").generateYamlFile() - private val relicPrefixes: List = file.getStringList("names.prefixes") - private val relicSuffixes: List = file.getStringList("names.suffixes") + private val file = Registry.CONFIGS.getOrThrow(RelicsYml::class) + private val relicPrefixes: List = file.names.prefixes + private val relicSuffixes: List = file.names.suffixes private val compatibleEnchants: MutableList = mutableListOf() - private val itemCreator: ItemFactory + private val itemFactory: ItemFactory init { if (forcedMaxEnchantLevel < 1) forcedMaxEnchantLevel = algorithmWeight val itemMaterial = ItemStack(material) - for (enchantment in Enchantment.values()) { + for (enchantment in RegistryAccess.registryAccess().getRegistry(RegistryKey.ENCHANTMENT)) { if (enchantment.canEnchantItem(itemMaterial) && !blackListedEnchants.contains(enchantment)) { compatibleEnchants.add(enchantment) } @@ -57,17 +56,20 @@ class RelicCreator ( val enchantments: Map = determineEnchants() val name: String = determineName() - itemCreator = ItemFactory( - name, - if (rarity != Rarity.LUNAR) mutableListOf("&7Relic I") else mutableListOf(), - mutableListOf(), - material, - mutableListOf("relic-item"), - enchantments.toMutableMap() - ) - itemCreator.persistentDataRecords.add(PersistentDataRecord.create("relic-rarity", PersistentDataType.STRING, rarity.name)) - itemCreator.tier = rarity.tier - itemCreator.addSpace = false + this.itemFactory = ItemFactory.builder() + .name(name) + .material(material) + .persistentData("relic-item") + .vanillaEnchants(enchantments) + .persistentDataRecords(PersistentDataRecord.create("relic-rarity", PersistentDataType.STRING, rarity.name)) + .tier(rarity.tier) + .addSpace(false) + .apply { + if (rarity != Rarity.LUNAR) { + lore("Relic I") + } + } + .build() } @@ -114,12 +116,13 @@ class RelicCreator ( return enchantments } + private fun determineName(): String { - return Util.colorcode("${rarity.getRgb()}&l${relicPrefixes.random()} $RELIC_SUFFIX_RGB${relicSuffixes.random()}") + return "<${rarity.getRgb()}>${relicPrefixes.random()} ${relicSuffixes.random()}" } fun getRelicItem(): ItemStack { - return itemCreator.createItem() + return itemFactory.createItem() } } diff --git a/src/main/java/dev/lumas/lumaitems/relics/RelicDisassembler.kt b/src/main/java/dev/lumas/lumaitems/relics/RelicDisassembler.kt index e9330c77..2f366d69 100644 --- a/src/main/java/dev/lumas/lumaitems/relics/RelicDisassembler.kt +++ b/src/main/java/dev/lumas/lumaitems/relics/RelicDisassembler.kt @@ -1,109 +1,89 @@ package dev.lumas.lumaitems.relics import dev.lumas.lumacore.utility.Logging +import dev.lumas.lumacore.utility.Text import dev.lumas.lumaitems.LumaItems +import dev.lumas.lumaitems.configuration.files.RelicsYml import dev.lumas.lumaitems.enums.Rarity -import dev.lumas.lumaitems.manager.FileManager +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Util +import java.util.UUID +import kotlin.random.Random import org.bukkit.Bukkit -import org.bukkit.Location -import org.bukkit.NamespacedKey import org.bukkit.block.Block import org.bukkit.entity.Player import org.bukkit.event.block.Action import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType -import java.util.* -import kotlin.random.Random + object RelicDisassembler { - val disassemblerBlocks: MutableList = mutableListOf() - private val file = FileManager("relics.yml").generateYamlFile() + + val RELIC_RARITY_KEY = Util.namespacedKey("relic-rarity") + val DISASSEMBLER_BLOCKS: MutableList = mutableListOf() private val confirmCooldownTasks: MutableMap = mutableMapOf() - private val plugin: LumaItems = LumaItems.getInstance() - @JvmStatic fun setupDisassemblerBlocks() { - if (file.getConfigurationSection("disassembler.blocks") == null) { - plugin.logger.warning("disassembler.blocks config section is null!") - return - } - for (key in file.getConfigurationSection("disassembler.blocks")?.getKeys(false) ?: return) { - val world = Bukkit.getWorld(file.getString("disassembler.blocks.$key.world") ?: continue) - if (world == null) { - Logging.warningLog("World for disassembler block $key is null!") - continue - } - val loc = Location( - world, - file.getDouble("disassembler.blocks.$key.x"), - file.getDouble("disassembler.blocks.$key.y"), - file.getDouble("disassembler.blocks.$key.z") - ).toCenterLocation() + @JvmStatic + fun setupDisassemblerBlocks() { + Registry.CONFIGS.getOrThrow(RelicsYml::class).disassembler.blocks.entries + .forEach { + val key = it.key + val location = it.value + try { + if (location.world == null) { + Logging.warningLog("World for disassembler block $key is null!") + return@forEach + } + } catch (ignored: IllegalArgumentException) { + Logging.warningLog("World for disassembler block $key is unloaded!") + return@forEach + } - disassemblerBlocks.add(loc.block) - } + DISASSEMBLER_BLOCKS.add(location.toCenterLocation().block) + } } fun getCommandToExecute(itemStack: ItemStack, player: Player): String? { val rarity = Rarity.valueOf( itemStack.itemMeta?.persistentDataContainer?.get( - NamespacedKey(plugin, "relic-rarity"), + RELIC_RARITY_KEY, PersistentDataType.STRING ) ?: return null ) - val commands: MutableMap = mutableMapOf() - val configSec = file.getConfigurationSection("disassembler.commands")?.getKeys(false) ?: return null - for (key in configSec) { - val chance = Integer.parseInt(key) - if (chance == 0) continue - commands[file.getString("disassembler.commands.$key") ?: "non"] = chance - } + val commands: MutableMap = Registry.CONFIGS.getOrThrow(RelicsYml::class).disassembler.commands.toMutableMap() + if (rarity == Rarity.ASTRAL) { - commands["lumaitems relic %player% core astral"] = 100 + commands[100] = "lumaitems relic %player% core astral" } - var selectedCommand = commands.keys.random() - while (commands[selectedCommand]!! < Random.nextInt(100)) { - selectedCommand = commands.keys.random() + var selectedCommand = commands.entries.random() + while (selectedCommand.key < Random.nextInt(101)) { + selectedCommand = commands.entries.random() } - return selectedCommand.replace("%player%", player.name) + return selectedCommand.value.replace("%player%", player.name) } // returns a command to be executed fun getCommandToExecute(itemStack: ItemStack, action: Action, player: Player): String? { val rarity = Rarity.valueOf( itemStack.itemMeta?.persistentDataContainer?.get( - NamespacedKey(plugin, "relic-rarity"), + RELIC_RARITY_KEY, PersistentDataType.STRING ) ?: return null ) if (!rescheduleCooldownTask(player)) { return null } else if (rarity == Rarity.ASTRAL && action.isLeftClick) { - player.sendMessage(Util.colorcode("${Util.legacyPrefix} You must left click to disassemble &#F7FFC9Astral &#E2E2E2Relics")) + Text.msg(player, "You must left click to disassemble <#F7FFC9>Astral relics") return null } - val commands: MutableMap = mutableMapOf() - val configSec = file.getConfigurationSection("disassembler.commands")?.getKeys(false) ?: return null - for (key in configSec) { - val chance = Integer.parseInt(key) - if (chance == 0) continue - commands[file.getString("disassembler.commands.$key") ?: "non"] = chance - } - if (rarity == Rarity.ASTRAL) { - commands["lumaitems relic %player% core astral"] = 100 - } - - var selectedCommand = commands.keys.random() - while (commands[selectedCommand]!! < Random.nextInt(100)) { - selectedCommand = commands.keys.random() - } - return selectedCommand.replace("%player%", player.name) + return getCommandToExecute(itemStack, player) } + // TODO: Rewrite private fun rescheduleCooldownTask(player: Player): Boolean { var returnValue = false if (confirmCooldownTasks.contains(player.uniqueId)) { @@ -113,7 +93,7 @@ object RelicDisassembler { player.sendMessage("${Util.legacyPrefix} Are you sure you want to disassemble this item? Click again to confirm.") } - confirmCooldownTasks[player.uniqueId] = Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, { + confirmCooldownTasks[player.uniqueId] = Bukkit.getScheduler().scheduleSyncDelayedTask(LumaItems.getInstance(), { confirmCooldownTasks.remove(player.uniqueId) }, 200L) return returnValue diff --git a/src/main/java/dev/lumas/lumaitems/util/AbilityUtil.kt b/src/main/java/dev/lumas/lumaitems/util/AbilityUtil.kt index 4f5a18d6..39a6a726 100644 --- a/src/main/java/dev/lumas/lumaitems/util/AbilityUtil.kt +++ b/src/main/java/dev/lumas/lumaitems/util/AbilityUtil.kt @@ -1,7 +1,6 @@ package dev.lumas.lumaitems.util import dev.lumas.lumaitems.LumaItems -import dev.lumas.lumaitems.manager.FileManager import dev.lumas.lumaitems.util.extensions.BlockUtil.breakNaturallyWithLog import io.lumine.mythic.bukkit.MythicBukkit import org.bukkit.Bukkit @@ -42,7 +41,7 @@ object AbilityUtil { fun noDamagePermission(attacker: Player, victim: Entity): Boolean { val event = EntityDamageByEntityEvent(attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 0.1) Bukkit.getPluginManager().callEvent(event) - return event.isCancelled || isMythicMob(victim) + return event.isCancelled } @JvmStatic // TODO: Replace this with proper towny and worldguard integration @@ -58,15 +57,6 @@ object AbilityUtil { return event.isCancelled } - @JvmStatic - fun isMythicMob(bukkitEntity: Entity): Boolean { - if (!LumaItems.isWithMythicMobs()) { - return false - } - return MythicBukkit.inst().mobManager.isMythicMob(bukkitEntity) - } - - fun getDirectionBetweenLocations(start: Location, end: Location): Vector { val from = start.toVector() val to = end.toVector() @@ -131,32 +121,6 @@ object AbilityUtil { } } - // Usage: Stellaris' Set - fun pinataAbility(block: Block) { - if (Random.nextInt(32000) >= 14) return - - val pinataFile = FileManager("saves/pinata.yml").getFileYaml() - val items = pinataFile.getConfigurationSection("items")!!.getKeys(false) - val rareItems = pinataFile.getConfigurationSection("rare-items")!!.getKeys(false) - - val item = if (Random.nextInt(20) <= 5) { - val item = rareItems.random() - val itemStack = pinataFile.getItemStack("rare-items.$item") - itemStack - } else { - val item = items.random() - val itemStack = pinataFile.getItemStack("items.$item") - itemStack - } - - if (item != null) { - block.world.dropItemNaturally(block.location, item) - } - block.world.spawnParticle(Particle.DUST, block.location, 50, 0.5, 0.5, 0.5, 0.1, DustOptions(Color.fromRGB(106, 219, 255), 2f)) - block.world.spawnParticle(Particle.DUST, block.location, 50, 0.5, 0.5, 0.5, 0.1, DustOptions(Color.fromRGB(255, 121, 209), 2f)) - block.world.playSound(block.location, Sound.ENTITY_FIREWORK_ROCKET_TWINKLE, 1f, 1f) - - } fun spawnSpell(player: Player, particle: Particle?, key: NamespacedKey, ticksAlive: Long): Snowball { return spawnSpell(player, particle, key, ticksAlive, null) diff --git a/src/main/java/dev/lumas/lumaitems/util/Executors.kt b/src/main/java/dev/lumas/lumaitems/util/Executors.kt index 7c31a398..a1c3e85c 100644 --- a/src/main/java/dev/lumas/lumaitems/util/Executors.kt +++ b/src/main/java/dev/lumas/lumaitems/util/Executors.kt @@ -47,6 +47,7 @@ object Executors { }.runTaskTimer(LumaItems.getInstance(), delay, period) } + @JvmStatic fun syncDelayed(delay: Long, runnable: Consumer): BukkitTask { return object : BukkitRunnable() { override fun run() { @@ -59,6 +60,7 @@ object Executors { }.runTaskLater(LumaItems.getInstance(), delay) } + @JvmStatic fun async(runnable: Consumer): ScheduledTask { return Bukkit.getAsyncScheduler().runNow(LumaItems.getInstance()) { task -> try { diff --git a/src/main/java/dev/lumas/lumaitems/util/extensions/BlockUtil.kt b/src/main/java/dev/lumas/lumaitems/util/extensions/BlockUtil.kt index 751de513..e3e7c0cb 100644 --- a/src/main/java/dev/lumas/lumaitems/util/extensions/BlockUtil.kt +++ b/src/main/java/dev/lumas/lumaitems/util/extensions/BlockUtil.kt @@ -2,6 +2,9 @@ package dev.lumas.lumaitems.util.extensions import dev.lumas.lumaitems.LumaItems import dev.lumas.lumaitems.enums.BlockConstants +import dev.lumas.lumaitems.hooks.CoreProtectHook +import dev.lumas.lumaitems.hooks.ProtocolLibHook +import dev.lumas.lumaitems.registry.Registry import dev.lumas.lumaitems.util.Util import org.bukkit.Color import org.bukkit.Material @@ -31,20 +34,20 @@ object BlockUtil { } fun Block.breakNaturallyWithLog(player: Player, itemStack: ItemStack? = null, triggerEffects: Boolean = false, dropExp: Boolean = false) { - LumaItems.getCoreProtectAPI()?.logRemoval(player.name, this.location, this.type, this.blockData) + Registry.HOOKS.getOrThrow(CoreProtectHook::class).getCoreProtectAPI()?.logRemoval(player.name, this.location, this.type, this.blockData) itemStack?.let { this.breakNaturally(it, triggerEffects, dropExp) } ?: this.breakNaturally() } fun Block.breakNaturallyWithLog(player: Player, triggerEffects: Boolean, dropExp: Boolean) { - LumaItems.getCoreProtectAPI()?.logRemoval(player.name, this.location, this.type, this.blockData) + Registry.HOOKS.getOrThrow(CoreProtectHook::class).getCoreProtectAPI()?.logRemoval(player.name, this.location, this.type, this.blockData) this.breakNaturally(triggerEffects, dropExp) } fun Block.setAirWithLog(player: Player) { - LumaItems.getCoreProtectAPI()?.logRemoval(player.name, this.location, this.type, this.blockData) + Registry.HOOKS.getOrThrow(CoreProtectHook::class).getCoreProtectAPI()?.logRemoval(player.name, this.location, this.type, this.blockData) this.type = Material.AIR } fun Block.setBlockDataWithLog(player: Player, material: Material) { - LumaItems.getCoreProtectAPI()?.logPlacement(player.name, this.location, material, material.createBlockData()) + Registry.HOOKS.getOrThrow(CoreProtectHook::class).getCoreProtectAPI()?.logPlacement(player.name, this.location, material, material.createBlockData()) this.blockData = material.createBlockData() } diff --git a/src/main/java/dev/lumas/lumaitems/util/tiers/Tier.java b/src/main/java/dev/lumas/lumaitems/util/tiers/Tier.java index 9934a13a..70da62f3 100644 --- a/src/main/java/dev/lumas/lumaitems/util/tiers/Tier.java +++ b/src/main/java/dev/lumas/lumaitems/util/tiers/Tier.java @@ -5,6 +5,7 @@ public class Tier { + public static final Tier BLANK = new Tier(""); public static final Tier DEPRECATED = new Tier("Deprecated"); public static final Tier DEBUG = new Tier("Debug"); public static final Tier ASTRAL = new Tier("<#AC87FB>Astral"); diff --git a/src/main/resources/astral.yml b/src/main/resources/astral.yml index ba554909..eb7c0679 100644 --- a/src/main/resources/astral.yml +++ b/src/main/resources/astral.yml @@ -1,3 +1,4 @@ +# TODO: Remove, unused astral-orb-rarities: # Class name and then chance of item MistralSet: 35 @@ -47,12 +48,14 @@ astral-upgrades: tier-3: material: DIAMOND enchants: + - 'efficiency/6' - 'mending/1' - 'unbreaking/6' - 'respiration/5' tier-4: material: NETHERITE enchants: + - 'efficiency/7' - 'unbreaking/7' - 'respiration/6' - 'protection/7' diff --git a/src/main/resources/heads.yml b/src/main/resources/heads.yml index ab1ebfea..63996762 100644 --- a/src/main/resources/heads.yml +++ b/src/main/resources/heads.yml @@ -1,3 +1,4 @@ +# TODO: Remove, unused # Easter 2024 easter-egg: - "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNDY0MmFmYTM5Njg1M2I4MWIxN2JlZjVjOGQ3YTQ0YzEyZGU2ODlhNTZhZjQ3NDg0NjY3OTgzOTlkYTNjZmVhZSJ9fX0=" diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml index 93d14106..f1ca2643 100644 --- a/src/main/resources/plugin.yml +++ b/src/main/resources/plugin.yml @@ -6,14 +6,11 @@ author: 'Jsinco' depend: - LumaCore softdepend: -- PlaceHolderAPI -- EvenMoreFish # Softdepending EMF to register listeners after it -- ProtocolLib -- MythicMobs -- Jobs -- mcMMO -- CoreProtect -- LumaGlowAPI + - ProtocolLib + - EvenMoreFish # Softdepending EMF to register listeners after it + - Jobs + - CoreProtect + - LumaGlowAPI permissions: lumaitems.disassemblergui: description: Permission to open the disassembler GUI diff --git a/src/main/resources/relics.yml b/src/main/resources/relics.yml index 6b5943f7..0e0ba9bc 100644 --- a/src/main/resources/relics.yml +++ b/src/main/resources/relics.yml @@ -1,3 +1,4 @@ +# TODO: Remove, unused disassembler: commands: '5': 'lumaitems relic %player% core lunar'