3.11.0 update

Xemorr · May 11, 2023 · af042a7 · af042a7
1 parent 1bf3846
commit af042a7
Show file tree

Hide file tree

Showing 11 changed files with 215 additions and 32 deletions.
diff --git a/.gradle/file-system.probe b/.gradle/file-system.probe
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -1,5 +1,5 @@
 group = "me.xemor"
-version = "3.10.0"
+version = "3.11.0"
 description = "superheroes"
 java.sourceCompatibility = JavaVersion.VERSION_17
 
@@ -24,7 +24,7 @@ dependencies {
     shadow("de.themoep:minedown-adventure:1.7.1-SNAPSHOT")
     shadow("me.xemor:configurationdata:1.19.2-SNAPSHOT")
     shadow("org.bstats:bstats-bukkit:1.7")
-    shadow("me.xemor:UserInterface:1.6.5-SNAPSHOT")
+    shadow("me.xemor:UserInterface:1.6.6-SNAPSHOT")
     shadow("dev.dbassett:skullcreator:3.0.1")
     shadow("org.jetbrains:annotations:20.1.0")
     shadow("net.kyori:adventure-platform-bukkit:4.1.0")

diff --git a/src/main/java/me/xemor/superheroes/Superhero.java b/src/main/java/me/xemor/superheroes/Superhero.java
@@ -3,6 +3,8 @@
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
 import me.xemor.superheroes.skills.skilldata.SkillData;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -12,6 +14,10 @@ public class Superhero {
     protected String name;
     protected String colouredName;
     protected String description;
+    private String base64Skin;
+    private String signature;
+
+    private ItemStack icon;
     protected Multimap<Integer, SkillData> skillToData = HashMultimap.create();
 
     public Superhero(String name, String colouredName, String description) {
@@ -20,6 +26,14 @@ public Superhero(String name, String colouredName, String description) {
         this.description = description;
     }
 
+    public ItemStack getIcon() {
+        return icon;
+    }
+
+    public void setIcon(ItemStack icon) {
+        this.icon = icon;
+    }
+
     public void addSkill(SkillData skill) {
         skillToData.put(skill.getSkill(), skill);
     }
@@ -55,6 +69,22 @@ public String getName() {
         return name;
     }
 
+    public String getBase64Skin() {
+        return base64Skin == null ? "" : base64Skin;
+    }
+
+    public void setBase64Skin(String base64Skin) {
+        this.base64Skin = base64Skin;
+    }
+
+    public String getSignature() {
+        return signature == null ? "" : signature;
+    }
+
+    public void setSignature(String signature) {
+        this.signature = signature;
+    }
+
     public String getPermission() { return "superheroes.hero." + getName().toLowerCase();}
 
     @Override

diff --git a/src/main/java/me/xemor/superheroes/Superheroes.java b/src/main/java/me/xemor/superheroes/Superheroes.java
@@ -9,10 +9,12 @@
 import me.xemor.superheroes.data.HeroHandler;
 import me.xemor.superheroes.skills.Skill;
 import me.xemor.superheroes.skills.implementations.*;
+import me.xemor.userinterface.ChestHandler;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.apache.commons.io.FileUtils;
 import org.bstats.bukkit.Metrics;
 import org.bukkit.Bukkit;
+import org.bukkit.block.Chest;
 import org.bukkit.command.CommandMap;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.PluginCommand;
@@ -67,6 +69,11 @@ public void onEnable() {
         hasSkillsLibrary = Bukkit.getPluginManager().isPluginEnabled("SkillsLibrary2");
         if (hasSkillsLibrary) runSkillsLibraryChanges();
         handleAliases(heroCommand, command);
+        registerUserInterfaces();
+    }
+
+    public void registerUserInterfaces() {
+        this.getServer().getPluginManager().registerEvents(new ChestHandler(), this);
     }
 
     public void convertFromSuperheroes2Folder() {

diff --git a/src/main/java/me/xemor/superheroes/commands/HeroSelect.java b/src/main/java/me/xemor/superheroes/commands/HeroSelect.java
@@ -35,10 +35,7 @@ public void onCommand(CommandSender sender, String[] args) {
         }
         if (args.length <= 1) {
             if (sender instanceof Player player) {
-                Superhero superhero = heroHandler.getSuperhero(player);
-                audience.sendMessage(MiniMessage.miniMessage().deserialize(configHandler.getCurrentHeroMessage(),
-                                Placeholder.unparsed("player", player.getName()),
-                                Placeholder.unparsed("hero", superhero.getName())));
+                heroHandler.openHeroGUI(player);
             }
             return;
         }
@@ -54,16 +51,9 @@ public void onCommand(CommandSender sender, String[] args) {
             audience.sendMessage(MiniMessage.miniMessage().deserialize(configHandler.getNoPermissionMessage(), Placeholder.unparsed("player", sender.getName())));
             return;
         }
-        if (!sender.hasPermission("superheroes.hero.bypasscooldown") && sender instanceof Player) {
-            Player senderPlayer = (Player) sender;
+        if (sender instanceof Player senderPlayer) {
             SuperheroPlayer superheroPlayer = heroHandler.getSuperheroPlayer(senderPlayer);
-            long seconds = getCooldownLeft(superheroPlayer) / 1000;
-            if (!isCooldownOver(superheroPlayer)) {
-                Component message = MiniMessage.miniMessage().deserialize(configHandler.getHeroCooldownMessage(),
-                        Placeholder.unparsed("player", senderPlayer.getDisplayName()),
-                        Placeholder.unparsed("currentcooldown", String.valueOf(Math.round(seconds))),
-                        Placeholder.unparsed("cooldown", String.valueOf(configHandler.getHeroCommandCooldown())));
-                audience.sendMessage(message);
+            if (!superheroPlayer.handleCooldown(senderPlayer, audience)) {
                 return;
             }
         }
@@ -106,13 +96,4 @@ public List<String> tabComplete(CommandSender sender, String[] args) {
         return null;
     }
 
-    public boolean isCooldownOver(SuperheroPlayer superheroPlayer) {
-        return getCooldownLeft(superheroPlayer) <= 0;
-    }
-
-    public long getCooldownLeft(SuperheroPlayer superheroPlayer) {
-        long cooldown = configHandler.getHeroCommandCooldown() * 1000;
-        return cooldown - (System.currentTimeMillis() - superheroPlayer.getHeroCommandTimestamp());
-    }
-
 }
diff --git a/src/main/java/me/xemor/superheroes/data/ConfigHandler.java b/src/main/java/me/xemor/superheroes/data/ConfigHandler.java
@@ -1,17 +1,27 @@
 package me.xemor.superheroes.data;
 
+import dev.dbassett.skullcreator.SkullCreator;
+import me.xemor.configurationdata.ItemStackData;
 import me.xemor.configurationdata.comparison.ItemComparisonData;
 import me.xemor.superheroes.Superhero;
 import me.xemor.superheroes.Superheroes;
 import me.xemor.superheroes.events.SuperheroLoadEvent;
 import me.xemor.superheroes.events.SuperheroesReloadEvent;
 import me.xemor.superheroes.skills.Skill;
 import me.xemor.superheroes.skills.skilldata.SkillData;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.TextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.Bukkit;
+import org.bukkit.DyeColor;
+import org.bukkit.Material;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
 
 import java.io.File;
 import java.io.IOException;
@@ -24,6 +34,8 @@
 
 public class ConfigHandler {
 
+    private static final LegacyComponentSerializer legacySerializer = LegacyComponentSerializer.builder().useUnusualXRepeatedCharacterHexFormat().hexColors().build();
+
     private File dataFolder;
     private File superpowersFolder;
     private File languageFile;
@@ -128,7 +140,12 @@ public void loadSuperheroes(HeroHandler heroHandler) {
                 String superheroName = superheroSection.getName();
                 String colouredSuperheroName = superheroSection.getString("colouredName", superheroName);
                 String superheroDescription = superheroSection.getString("description", superheroName + " description");
+                String base64Skin = superheroSection.getString("skin.value");
+                String signature = superheroSection.getString("skin.signature");
                 Superhero superhero = new Superhero(superheroName, colouredSuperheroName, superheroDescription);
+                superhero.setBase64Skin(base64Skin);
+                superhero.setSignature(signature);
+                calculateIcon(superhero, superheroSection);
                 loadSkills(superhero, superheroSection);
                 SuperheroLoadEvent superheroLoadEvent = new SuperheroLoadEvent(superhero, superheroSection);
                 Bukkit.getServer().getPluginManager().callEvent(superheroLoadEvent);
@@ -140,6 +157,48 @@ public void loadSuperheroes(HeroHandler heroHandler) {
         heroHandler.registerHeroes(nameToSuperhero);
     }
 
+    // Used in loadSuperheroes for working out the icon for the GUI
+    private void calculateIcon(Superhero hero, ConfigurationSection heroSection) {
+        ItemStack icon;
+        ConfigurationSection section = heroSection.getConfigurationSection("icon");
+        Component colouredName = MiniMessage.miniMessage().deserialize(hero.getColouredName());
+        if (section != null) {
+            icon = new ItemStackData(heroSection.getConfigurationSection("icon")).getItem();
+        }
+        else {
+            if (hero.getBase64Skin().equals("")) { // approximate wool colour based on coloured name
+                TextColor color = colouredName.color();
+                if (color == null) icon = new ItemStack(Material.BLACK_WOOL);
+                else icon = new ItemStack(woolFromColor(color.red(), color.green(), color.blue()));
+            }
+            else {
+                icon = SkullCreator.itemFromBase64(hero.getBase64Skin());
+            }
+            ItemMeta meta = icon.getItemMeta();
+            meta.setDisplayName(legacySerializer.serialize(colouredName));
+            Component description = MiniMessage.miniMessage().deserialize(hero.getDescription());
+            description = description.colorIfAbsent(TextColor.color(255, 255, 255));
+            meta.setLore(List.of(legacySerializer.serialize(description)));
+            icon.setItemMeta(meta);
+        }
+        hero.setIcon(icon);
+    }
+
+    public Material woolFromColor(int red, int green, int blue) {
+        int distance = Integer.MAX_VALUE;
+        org.bukkit.DyeColor closest = DyeColor.BLACK;
+        for (org.bukkit.DyeColor dye : org.bukkit.DyeColor.values()) {
+            org.bukkit.Color color = dye.getColor();
+            int dist = Math.abs(color.getRed() - red) + Math.abs(color.getGreen() - green) + Math.abs(color.getBlue() - blue);
+            if (dist < distance) {
+                distance = dist;
+                closest = dye;
+            }
+        }
+        // You might want to add a try here - I'm not sure how it worked back in 1.14 (it may produce a NullPointerException)
+        return Material.getMaterial((closest.name() + "_WOOL").toUpperCase());
+    }
+
     public void reloadConfig(HeroHandler heroHandler) {
         SuperheroesReloadEvent superheroesReloadEvent = new SuperheroesReloadEvent();
         Bukkit.getServer().getPluginManager().callEvent(superheroesReloadEvent);
@@ -178,15 +237,27 @@ public boolean isRerollEnabled() {
     }
 
     public boolean isPowerOnStartEnabled() {
-        return config.getBoolean("powerOnStart.isEnabled", true);
+        return config.getBoolean("powerOnStart.isEnabled", false);
+    }
+
+    public boolean openGUIOnStart() {
+        return config.getBoolean("gui.onStart", true);
+    }
+
+    public String getGUIName() {
+        return language.getString("GUI.name", "Pick your hero!");
+    }
+
+    public boolean canCloseGUI() {
+        return config.getBoolean("gui.canClose", false);
     }
 
     public List<String> getDisabledWorlds() {
         return config.getStringList("disabledWorlds");
     }
 
     public boolean shouldShowHeroOnStart() {
-        return config.getBoolean("powerOnStart.showHero", true);
+        return config.getBoolean("powerOnStart.showHero", false);
     }
 
     public String getHeroGainedMessage() {
@@ -205,7 +276,14 @@ public Superhero getDefaultHero() {
         String name = config.getString("defaultHero.name", "Powerless");
         String colouredName = config.getString("defaultHero.colouredName", "<yellow><b>Powerless");
         String description = config.getString("defaultHero.description", "You have no power");
-        return new Superhero(name, colouredName, description);
+        Superhero hero = new Superhero(name, colouredName, description);
+        ItemStack icon = new ItemStack(Material.BARRIER);
+        ItemMeta meta = icon.getItemMeta();
+        meta.setDisplayName(legacySerializer.serialize(MiniMessage.miniMessage().deserialize(colouredName)));
+        meta.setLore(List.of(legacySerializer.serialize(MiniMessage.miniMessage().deserialize("<white>" + description))));
+        icon.setItemMeta(meta);
+        hero.setIcon(icon);
+        return hero;
     }
 
     public String getHeroCooldownMessage() {

diff --git a/src/main/java/me/xemor/superheroes/data/HeroHandler.java b/src/main/java/me/xemor/superheroes/data/HeroHandler.java
@@ -1,20 +1,28 @@
 package me.xemor.superheroes.data;
 
+import dev.dbassett.skullcreator.SkullCreator;
 import me.xemor.superheroes.Superhero;
 import me.xemor.superheroes.Superheroes;
 import me.xemor.superheroes.events.PlayerGainedSuperheroEvent;
 import me.xemor.superheroes.events.PlayerLostSuperheroEvent;
 import me.xemor.superheroes.events.SuperheroPlayerJoinEvent;
 import me.xemor.superheroes.skills.Skill;
+import me.xemor.userinterface.ChestInterface;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import net.kyori.adventure.title.Title;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
+import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.bukkit.scheduler.BukkitRunnable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -129,6 +137,40 @@ public void setHero(Player player, Superhero hero, boolean show) {
         heroIOHandler.saveSuperheroPlayerAsync(getSuperheroPlayer(player));
     }
 
+    public void openHeroGUI(Player player) {
+        List<Superhero> allowedSuperheroes = nameToSuperhero.values().stream().filter((hero) -> !configHandler.areHeroPermissionsRequired() || player.hasPermission(hero.getPermission())).toList();
+        if (allowedSuperheroes.isEmpty()) return;
+        // without the subtract one from the size it always has one more row than it should
+        // the + 1 is so you don't get silliness like 0 rows
+        int numberOfRows = ((allowedSuperheroes.size() - 1) / 9) + 1;
+        if (numberOfRows > 6) {
+            Superheroes.getInstance().getLogger().severe("The hero GUI does not support more than 54 heroes.");
+            return;
+        }
+        ChestInterface<boolean[]> chestInterface = new ChestInterface<>(configHandler.getGUIName(), numberOfRows, new boolean[]{false});
+        for (Superhero superhero : allowedSuperheroes) {
+            if (superhero.getIcon() == null) continue;
+            chestInterface.getInventory().addItem(superhero.getIcon());
+            chestInterface.getInteractions().addSimpleInteraction(superhero.getIcon(), (p) -> {
+                if (getSuperheroPlayer(player).handleCooldown(player, Superheroes.getBukkitAudiences().player(player))) {
+                    setHero(p, superhero);
+                }
+                chestInterface.getInteractions().getData()[0] = true;
+            });
+            if (!configHandler.canCloseGUI()) {
+                chestInterface.getInteractions().addCloseInteraction((p) -> new BukkitRunnable() {
+                    @Override
+                    public void run() {
+                        if (!chestInterface.getInteractions().getData()[0]) {
+                            openHeroGUI(player);
+                        }
+                    }
+                }.runTaskLater(superheroes, 1L));
+            }
+        }
+        player.openInventory(chestInterface.getInventory());
+    }
+
     public void loadSuperheroPlayer(@NotNull Player player) {
         CompletableFuture<SuperheroPlayer> future = heroIOHandler.loadSuperHeroPlayerAsync(player.getUniqueId());
         future.thenAccept((superheroPlayer) -> Bukkit.getScheduler().runTask(superheroes, () -> {
@@ -143,6 +185,9 @@ public void loadSuperheroPlayer(@NotNull Player player) {
                 } else {
                     superhero = noPower;
                 }
+                if (configHandler.openGUIOnStart()) {
+                    openHeroGUI(player);
+                }
                 setHero(player, superhero, configHandler.shouldShowHeroOnStart());
             }
             SuperheroPlayerJoinEvent playerJoinEvent = new SuperheroPlayerJoinEvent(superhero, player);