entity type gui + command

src/main/java/me/unurled/sacredrealms/sr/commands/CommandManager.java

@@ -6,6 +6,7 @@ import java.lang.reflect.InvocationTargetException;
 import me.unurled.sacredrealms.sr.SR;
 import me.unurled.sacredrealms.sr.commands.admin.AttributeCommand;
 import me.unurled.sacredrealms.sr.commands.admin.ClientBuildCommand;
+import me.unurled.sacredrealms.sr.commands.admin.EntityTypeCommand;
 import me.unurled.sacredrealms.sr.commands.admin.LevelCommand;
 import me.unurled.sacredrealms.sr.commands.player.ResetAdventureCommand;
 import me.unurled.sacredrealms.sr.managers.Manager;
@@ -38,6 +39,7 @@ public class CommandManager extends Manager {
     registerCommand("attributes", AttributeCommand.class);
     registerCommand("clientbuild", ClientBuildCommand.class);
     registerCommand("level", LevelCommand.class);
+    registerCommand("entitytype", EntityTypeCommand.class);
 
     registerCommand("resetadventure", ResetAdventureCommand.class);
   }

src/main/java/me/unurled/sacredrealms/sr/commands/admin/EntityTypeCommand.java

@@ -0,0 +1,171 @@
+package me.unurled.sacredrealms.sr.commands.admin;
+
+import java.util.Arrays;
+import java.util.List;
+import me.unurled.sacredrealms.sr.components.entity.EntityManager;
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import me.unurled.sacredrealms.sr.gui.entitytype.EntityTypeGUI;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityTypeCommand implements TabExecutor {
+
+  /**
+   * Executes the given command, returning its success. <br>
+   * If false is returned, then the "usage" plugin.yml entry for this command (if defined) will be
+   * sent to the player.
+   *
+   * @param sender Source of the command
+   * @param command Command which was executed
+   * @param label Alias of the command which was used
+   * @param args Passed command arguments
+   * @return true if a valid command, otherwise false
+   */
+  @Override
+  public boolean onCommand(
+      @NotNull CommandSender sender,
+      @NotNull Command command,
+      @NotNull String label,
+      @NotNull String[] args) {
+    if (!sender.hasPermission("sr.entitytype")) {
+      sender.sendMessage("You do not have permission to use this command.");
+      return true;
+    }
+
+    if (args.length == 0) {
+      sender.sendMessage("Usage: /entitytype <create|delete|edit|list>");
+      return true;
+    }
+
+    switch (args[0].toLowerCase()) {
+      case "create":
+        if (args.length < 2) {
+          sender.sendMessage("Usage: /entitytype create <ID>");
+          return true;
+        }
+        if (!(sender instanceof Player p)) {
+          sender.sendMessage("You must be a player to use this command.");
+          return true;
+        }
+        break;
+      case "delete":
+        if (args.length < 2) {
+          sender.sendMessage("Usage: /entitytype delete <ID>");
+          return true;
+        }
+        break;
+      case "edit":
+        if (args.length < 2) {
+          sender.sendMessage("Usage: /entitytype edit <ID>");
+          return true;
+        }
+        if (!(sender instanceof Player p)) {
+          sender.sendMessage("You must be a player to use this command.");
+          return true;
+        }
+        if (args.length < 3) {
+          EntityManager em = EntityManager.getInstance(EntityManager.class);
+          if (!em.getTypes().stream().map(SREntityType::getID).toList().contains(args[1])) {
+            sender.sendMessage("Invalid entity type.");
+            return true;
+          }
+          SREntityType type = em.getType(args[1]);
+          Window window =
+              Window.single()
+                  .setViewer(p)
+                  .setTitle(args[1])
+                  .setGui(EntityTypeGUI.createGui(type))
+                  .build();
+          return true;
+        }
+        if (args.length < 4) {
+          sender.sendMessage(
+              "Usage: /entitytype edit <ID> <type|behavior|loot|item|stats|name|level>");
+          return true;
+        }
+        if (args[2].equalsIgnoreCase("type")) {
+          if (args.length < 5) {
+            sender.sendMessage("Usage: /entitytype edit <ID> type <type>");
+            return true;
+          }
+          try {
+            EntityType type = EntityType.valueOf(args[4]);
+            EntityManager em = EntityManager.getInstance(EntityManager.class);
+            try {
+              em.getType(args[1]).setType(type);
+            } catch (Exception e) {
+              sender.sendMessage("An error occurred while setting the entity type.");
+              return true;
+            }
+          } catch (IllegalArgumentException e) {
+            sender.sendMessage("Invalid entity type.");
+            return true;
+          }
+        }
+        break;
+      case "list":
+        if (!(sender instanceof Player p)) {
+          sender.sendMessage("You must be a player to use this command.");
+          return true;
+        }
+        Window window =
+            Window.single().setViewer(p).setTitle(args[1]).setGui(EntityTypeGUI.listGui()).build();
+        window.open();
+        break;
+    }
+    return true;
+  }
+
+  /**
+   * Requests a list of possible completions for a command argument.
+   *
+   * @param sender Source of the command. For players tab-completing a command inside of a command
+   *     block, this will be the player, not the command block.
+   * @param command Command which was executed
+   * @param label Alias of the command which was used
+   * @param args The arguments passed to the command, including final partial argument to be
+   *     completed
+   * @return A List of possible completions for the final argument, or null to default to the
+   *     command executor
+   */
+  @Override
+  public @Nullable List<String> onTabComplete(
+      @NotNull CommandSender sender,
+      @NotNull Command command,
+      @NotNull String label,
+      @NotNull String[] args) {
+    if (sender.hasPermission("sr.entitytype")) {
+      if (args.length == 1) {
+        return List.of("create", "delete", "edit", "list");
+      }
+      if (args.length == 2) {
+        return EntityManager.getInstance(EntityManager.class).getTypes().stream()
+            .map(SREntityType::getID)
+            .toList();
+      }
+      if (args.length == 3) {
+        if (args[0].equalsIgnoreCase("edit")) {
+          return List.of("type", "behavior", "loot", "item", "stats", "name", "level");
+        }
+      }
+      if (args.length == 4) {
+        if (args[0].equalsIgnoreCase("edit")) {
+          if (args[2].equalsIgnoreCase("type")) {
+            return List.of(
+                Arrays.stream(EntityType.values())
+                    .filter(EntityType::isAlive)
+                    .map(EntityType::name)
+                    .toString());
+          }
+        }
+      }
+    }
+    return null;
+  }
+}

src/main/java/me/unurled/sacredrealms/sr/components/entity/EntityManager.java

@@ -1,13 +1,26 @@
 package me.unurled.sacredrealms.sr.components.entity;
 
+import static me.unurled.sacredrealms.sr.utils.Logger.error;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.UUID;
+import me.unurled.sacredrealms.sr.data.DataHandler;
+import me.unurled.sacredrealms.sr.data.DataManager;
+import me.unurled.sacredrealms.sr.data.gson.ItemStackDeserializer;
+import me.unurled.sacredrealms.sr.data.gson.ItemStackSerializer;
+import me.unurled.sacredrealms.sr.data.gson.PotionEffectDeserializer;
 import me.unurled.sacredrealms.sr.managers.Manager;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Mob;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.entity.EntitySpawnEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -15,11 +28,67 @@ public class EntityManager extends Manager {
 
   @NotNull private final HashMap<UUID, SREntity> entities;
 
+  private final List<SREntityType> types;
+
   public EntityManager() {
     super();
+    this.types = new ArrayList<>();
     entities = new HashMap<>();
   }
 
+  /** Load the data */
+  @Override
+  public void loadData() {
+    // loads all types
+    DataManager dm = DataManager.getInstance(DataManager.class);
+    if (dm == null) {
+      error("DataManager is null, Can't load entity data.");
+      return;
+    }
+    DataHandler dh = dm.getDataHandler();
+    if (dh == null) {
+      error("DataHandler is null, Can't load entity data.");
+      return;
+    }
+
+    Gson gson =
+        new GsonBuilder()
+            .registerTypeAdapter(PotionEffect.class, new PotionEffectDeserializer())
+            .registerTypeAdapter(ItemStack.class, new ItemStackDeserializer())
+            .excludeFieldsWithoutExposeAnnotation()
+            .create();
+
+    dh.getKeysAll("sr.entities")
+        .forEach(
+            key -> {
+              SREntityType type = gson.fromJson(dh.get(key), SREntityType.class);
+              if (type != null) {
+                types.add(type);
+              }
+            });
+  }
+
+  public void saveType(@NotNull SREntityType type) {
+    // save type
+    DataManager dm = DataManager.getInstance(DataManager.class);
+    if (dm == null) {
+      error("DataManager is null, Can't save entity data.");
+      return;
+    }
+    DataHandler dh = dm.getDataHandler();
+    if (dh == null) {
+      error("DataHandler is null, Can't save entity data.");
+      return;
+    }
+    Gson gson =
+        new GsonBuilder()
+            .registerTypeAdapter(PotionEffect.class, new PotionEffectDeserializer())
+            .registerTypeAdapter(ItemStack.class, new ItemStackSerializer())
+            .excludeFieldsWithoutExposeAnnotation()
+            .create();
+    dh.set("sr.entities." + type.getID(), gson.toJson(type));
+  }
+
   @Nullable
   public SREntity getEntity(@NotNull UUID uuid) {
     return entities.get(uuid);
@@ -37,6 +106,21 @@ public class EntityManager extends Manager {
     return entities.containsKey(uuid);
   }
 
+  public void addEntityType(@NotNull SREntityType type) {
+    types.add(type);
+  }
+
+  public List<SREntityType> getTypes() {
+    return types;
+  }
+
+  public SREntityType getType(@NotNull String ID) {
+    for (SREntityType type : types) {
+      if (type.getID().equals(ID)) return type;
+    }
+    return null;
+  }
+
   @EventHandler
   public void onEntitySpawn(@NotNull EntitySpawnEvent e) {
     if (e.getEntity() instanceof Player) return;

src/main/java/me/unurled/sacredrealms/sr/components/entity/SREntityType.java

@@ -0,0 +1,165 @@
+package me.unurled.sacredrealms.sr.components.entity;
+
+import com.google.gson.annotations.Expose;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import me.unurled.sacredrealms.sr.components.attributes.Attribute;
+import org.bukkit.entity.EntityType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+
+public class SREntityType {
+
+  @Expose private final String ID;
+  @Expose private String name;
+  @Expose private Integer level = 1;
+  @Expose private Long experience = 0L;
+  @Expose private HashMap<Attribute, Double> attributes = new HashMap<>();
+  @Expose private List<ItemStack> armor = new ArrayList<>();
+  private HashMap<Attribute, HashMap<ItemStack, Double>> itemAttributes = new HashMap<>();
+  @Expose private List<PotionEffect> potionEffects = new ArrayList<>();
+  @Expose private HashMap<ItemStack, Double> lootTable = new HashMap<>();
+  @Expose private EntityType type;
+  @Expose private ItemStack item;
+  @Expose private ItemStack handItem;
+  @Expose private ItemStack secondHandItem;
+
+  public SREntityType(String name, String ID) {
+    this.name = name;
+    this.ID = ID;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getID() {
+    return ID;
+  }
+
+  public int getLevel() {
+    return level;
+  }
+
+  public void setLevel(int level) {
+    this.level = level;
+  }
+
+  public Long getExperience() {
+    return experience;
+  }
+
+  public void setExperience(Long experience) {
+    this.experience = experience;
+  }
+
+  public HashMap<Attribute, Double> getAttributes() {
+    return attributes;
+  }
+
+  public void setAttributes(HashMap<Attribute, Double> attributes) {
+    this.attributes = attributes;
+  }
+
+  public HashMap<Attribute, HashMap<ItemStack, Double>> getItemAttributes() {
+    return itemAttributes;
+  }
+
+  public void setItemAttributes(HashMap<Attribute, HashMap<ItemStack, Double>> itemAttributes) {
+    this.itemAttributes = itemAttributes;
+  }
+
+  public List<PotionEffect> getPotionEffects() {
+    return potionEffects;
+  }
+
+  public void setPotionEffects(List<PotionEffect> potionEffects) {
+    this.potionEffects = potionEffects;
+  }
+
+  public HashMap<ItemStack, Double> getLootTable() {
+    return lootTable;
+  }
+
+  public void setLootTable(HashMap<ItemStack, Double> lootTable) {
+    this.lootTable = lootTable;
+  }
+
+  public void setItemAttributes(Attribute attribute, ItemStack item, Double value) {
+    if (itemAttributes.containsKey(attribute)) {
+      itemAttributes.get(attribute).put(item, value);
+    } else {
+      HashMap<ItemStack, Double> map = new HashMap<>();
+      map.put(item, value);
+      itemAttributes.put(attribute, map);
+    }
+  }
+
+  public void removeItemAttributes(Attribute attribute, ItemStack item) {
+    if (itemAttributes.containsKey(attribute)) {
+      itemAttributes.get(attribute).remove(item);
+    }
+  }
+
+  public Double getItemAttributes(Attribute attribute, ItemStack item) {
+    if (itemAttributes.containsKey(attribute)) {
+      return itemAttributes.get(attribute).get(item);
+    }
+    return null;
+  }
+
+  public HashMap<ItemStack, Double> getItemAttributes(Attribute attribute) {
+    return itemAttributes.getOrDefault(attribute, new HashMap<>());
+  }
+
+  public Double getTotalItemAttribute(Attribute attribute) {
+    if (itemAttributes == null) itemAttributes = new HashMap<>();
+    return itemAttributes.getOrDefault(attribute, new HashMap<>()).values().stream()
+        .reduce(0.0, Double::sum);
+  }
+
+  public EntityType getType() {
+    return type;
+  }
+
+  public void setType(EntityType type) {
+    this.type = type;
+  }
+
+  public ItemStack getItem() {
+    return item;
+  }
+
+  public void setItem(ItemStack item) {
+    this.item = item;
+  }
+
+  public List<ItemStack> getArmor() {
+    return armor;
+  }
+
+  public void setArmor(List<ItemStack> armor) {
+    this.armor = armor;
+  }
+
+  public ItemStack getHandItem() {
+    return handItem;
+  }
+
+  public void setHandItem(ItemStack handItem) {
+    this.handItem = handItem;
+  }
+
+  public ItemStack getSecondHandItem() {
+    return secondHandItem;
+  }
+
+  public void setSecondHandItem(ItemStack secondHandItem) {
+    this.secondHandItem = secondHandItem;
+  }
+}

src/main/java/me/unurled/sacredrealms/sr/data/gson/ItemStackSerializer.java

@@ -0,0 +1,32 @@
+package me.unurled.sacredrealms.sr.data.gson;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import org.bukkit.inventory.ItemStack;
+
+public class ItemStackSerializer implements JsonSerializer<ItemStack> {
+
+  /**
+   * Gson invokes this call-back method during serialization when it encounters a field of the
+   * specified type.
+   *
+   * <p>In the implementation of this call-back method, you should consider invoking {@link
+   * JsonSerializationContext#serialize(Object, Type)} method to create JsonElements for any
+   * non-trivial field of the {@code src} object. However, you should never invoke it on the {@code
+   * src} object itself since that will cause an infinite loop (Gson will call your call-back method
+   * again).
+   *
+   * @param src the object that needs to be converted to Json.
+   * @param typeOfSrc the actual type (fully genericized version) of the source object.
+   * @param context
+   * @return a JsonElement corresponding to the specified object.
+   */
+  @Override
+  public JsonElement serialize(ItemStack src, Type typeOfSrc, JsonSerializationContext context) {
+    return new JsonPrimitive(Arrays.toString(src.serializeAsBytes()));
+  }
+}

src/main/java/me/unurled/sacredrealms/sr/gui/BackItem.java

@@ -0,0 +1,26 @@
+package me.unurled.sacredrealms.sr.gui;
+
+import org.bukkit.Material;
+import xyz.xenondevs.invui.gui.PagedGui;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.controlitem.PageItem;
+
+public class BackItem extends PageItem {
+
+  public BackItem() {
+    super(false);
+  }
+
+  @Override
+  public ItemProvider getItemProvider(PagedGui<?> gui) {
+    ItemBuilder builder = new ItemBuilder(Material.RED_STAINED_GLASS_PANE);
+    builder
+        .setDisplayName("$7Previous Page")
+        .addLoreLines(
+            gui.hasPreviousPage()
+                ? "§7Go to page §e" + gui.getCurrentPage() + "§7/§e" + gui.getPageAmount()
+                : "§cYou can't go further back");
+    return builder;
+  }
+}

src/main/java/me/unurled/sacredrealms/sr/gui/ForwardItem.java

@@ -0,0 +1,27 @@
+package me.unurled.sacredrealms.sr.gui;
+
+import org.bukkit.Material;
+import xyz.xenondevs.invui.gui.PagedGui;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.controlitem.PageItem;
+
+public class ForwardItem extends PageItem {
+
+  public ForwardItem() {
+    super(true);
+  }
+
+  @Override
+  public ItemProvider getItemProvider(PagedGui<?> gui) {
+    ItemBuilder builder = new ItemBuilder(Material.GREEN_STAINED_GLASS_PANE);
+    builder
+        .setDisplayName("§7Next page")
+        .addLoreLines(
+            gui.hasNextPage()
+                ? "§7Go to page §e" + (gui.getCurrentPage() + 2) + "§7/§e" + gui.getPageAmount()
+                : "§cThere are no more pages");
+
+    return builder;
+  }
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityArmorItem.java

@@ -0,0 +1,51 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityArmorItem extends AbstractItem {
+
+  private final ItemStack stack;
+
+  public EntityArmorItem(SREntityType type, int armorSlot) {
+    if (armorSlot == 4) {
+      stack = type.getHandItem();
+    } else if (armorSlot == 5) {
+      stack = type.getSecondHandItem();
+    } else {
+      stack = type.getArmor().get(armorSlot);
+    }
+  }
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    return new ItemBuilder(stack);
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {}
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityBehaviorItem.java

@@ -0,0 +1,46 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityBehaviorItem extends AbstractItem {
+
+  String behavior;
+
+  public EntityBehaviorItem(SREntityType type) {
+    //    behavior = type.getBehavior();
+  }
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    return new ItemBuilder(Material.NETHERITE_SWORD).setDisplayName("Behavior: " + behavior);
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {}
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityExpItem.java

@@ -0,0 +1,46 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityExpItem extends AbstractItem {
+
+  private final Long exp;
+
+  public EntityExpItem(SREntityType type) {
+    exp = type.getExperience();
+  }
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    return new ItemBuilder(Material.EXPERIENCE_BOTTLE).setDisplayName("Experience: " + exp);
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {}
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityItemDisplay.java

@@ -0,0 +1,46 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityItemDisplay extends AbstractItem {
+
+  private final String name;
+
+  public EntityItemDisplay(SREntityType type) {
+    name = type.getItem().getType().name();
+  }
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    return new ItemBuilder(Material.CREEPER_SPAWN_EGG).setDisplayName("Item Display: " + name);
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {}
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityLevelItem.java

@@ -0,0 +1,46 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityLevelItem extends AbstractItem {
+
+  private final int level;
+
+  public EntityLevelItem(SREntityType type) {
+    level = type.getLevel();
+  }
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    return new ItemBuilder(Material.DIAMOND).setDisplayName("Level: " + level);
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {}
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityLootItem.java

@@ -0,0 +1,39 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityLootItem extends AbstractItem {
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    return new ItemBuilder(Material.SKELETON_SKULL).setDisplayName("Death Loot");
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {}
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityNameItem.java

@@ -0,0 +1,46 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityNameItem extends AbstractItem {
+
+  private final String name;
+
+  public EntityNameItem(SREntityType type) {
+    name = type.getName();
+  }
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    return new ItemBuilder(Material.NAME_TAG).setDisplayName(name);
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {}
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityStatsItem.java

@@ -0,0 +1,52 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import java.util.HashMap;
+import me.unurled.sacredrealms.sr.components.attributes.Attribute;
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityStatsItem extends AbstractItem {
+
+  private final HashMap<Attribute, Double> attributes;
+
+  public EntityStatsItem(SREntityType type) {
+    attributes = type.getAttributes();
+  }
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    ItemBuilder builder = new ItemBuilder(Material.APPLE).setDisplayName("Add Stats");
+    for (Attribute attribute : attributes.keySet()) {
+      builder.addLoreLines(attribute.getName() + ": " + attributes.get(attribute));
+    }
+    return builder;
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {}
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityTypeGUI.java

@@ -0,0 +1,73 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import me.unurled.sacredrealms.sr.components.entity.EntityManager;
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import me.unurled.sacredrealms.sr.gui.BackItem;
+import me.unurled.sacredrealms.sr.gui.ForwardItem;
+import org.bukkit.Material;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.gui.Gui;
+import xyz.xenondevs.invui.gui.PagedGui;
+import xyz.xenondevs.invui.gui.structure.Markers;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.SimpleItem;
+
+public class EntityTypeGUI {
+  public static @NotNull Gui listGui() {
+    EntityManager em = EntityManager.getInstance(EntityManager.class);
+    List<Item> items =
+        em.getTypes().stream()
+            .map(type -> new SimpleItem(new ItemBuilder(type.getItem())))
+            .collect(Collectors.toList());
+
+    Gui gui =
+        PagedGui.items()
+            .setStructure(
+                "# # # # # # # # #",
+                "# X X X X X X X #",
+                "# X X X X X X X #",
+                "# X X X X X X X #",
+                "# # # < # > # # #")
+            .addIngredient('X', Markers.CONTENT_LIST_SLOT_HORIZONTAL)
+            .addIngredient('<', new BackItem())
+            .addIngredient('>', new ForwardItem())
+            .setContent(items)
+            .build();
+    return gui;
+  }
+
+  public static @NotNull Gui createGui(SREntityType type) {
+
+    Item border =
+        new SimpleItem(new ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setDisplayName("§r"));
+
+    Gui gui =
+        Gui.normal()
+            .setStructure(
+                "# # # # # # # # #",
+                "# T B O I S N L #", // Type, Behavior, lOot, Item display, Stats, Name, Level
+                "# X X X P X X X #", // exPerience
+                "# H C E B X M A #", // Helmet, Chestplate, lEgging, Boots, Main hand, second hAnd
+                "# # # # # # # # #")
+            .addIngredient('#', border)
+            .addIngredient('T', new EntityTypeItem(type))
+            .addIngredient('B', new EntityBehaviorItem(type))
+            .addIngredient('O', new EntityLootItem())
+            .addIngredient('I', new EntityItemDisplay(type))
+            .addIngredient('S', new EntityStatsItem(type))
+            .addIngredient('N', new EntityNameItem(type))
+            .addIngredient('L', new EntityLevelItem(type))
+            .addIngredient('P', new EntityExpItem(type))
+            .addIngredient('H', new EntityArmorItem(type, 0))
+            .addIngredient('C', new EntityArmorItem(type, 1))
+            .addIngredient('E', new EntityArmorItem(type, 2))
+            .addIngredient('B', new EntityArmorItem(type, 3))
+            .addIngredient('M', new EntityArmorItem(type, 4))
+            .addIngredient('A', new EntityArmorItem(type, 5))
+            .build();
+    return gui;
+  }
+}

src/main/java/me/unurled/sacredrealms/sr/gui/entitytype/EntityTypeItem.java

@@ -0,0 +1,58 @@
+package me.unurled.sacredrealms.sr.gui.entitytype;
+
+import static me.unurled.sacredrealms.sr.utils.Component.comp;
+
+import me.unurled.sacredrealms.sr.components.entity.SREntityType;
+import org.bukkit.Material;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.xenondevs.invui.item.Item;
+import xyz.xenondevs.invui.item.ItemProvider;
+import xyz.xenondevs.invui.item.builder.ItemBuilder;
+import xyz.xenondevs.invui.item.impl.AbstractItem;
+import xyz.xenondevs.invui.window.Window;
+
+public class EntityTypeItem extends AbstractItem {
+
+  private final EntityType type;
+
+  public EntityTypeItem(SREntityType type) {
+    this.type = type.getType();
+  }
+
+  /**
+   * Gets the {@link ItemProvider}. This method gets called every time a {@link Window} is notified
+   * ({@link #notifyWindows()}).
+   *
+   * @return The {@link ItemProvider}
+   */
+  @Override
+  public ItemProvider getItemProvider() {
+    return new ItemBuilder(Material.ZOMBIE_SPAWN_EGG).setDisplayName(type.name());
+  }
+
+  /**
+   * A method called if the {@link ItemStack} associated to this {@link Item} has been clicked by a
+   * player.
+   *
+   * @param clickType The {@link ClickType} the {@link Player} performed.
+   * @param player The {@link Player} who clicked on the {@link ItemStack}.
+   * @param event The {@link InventoryClickEvent} associated with this click.
+   */
+  @Override
+  public void handleClick(
+      @NotNull ClickType clickType, @NotNull Player player, @NotNull InventoryClickEvent event) {
+    player.closeInventory();
+    player.sendMessage(
+        comp(
+            "<click:suggest_command:/entitytype edit "
+                + event.getView().title()
+                + " type > entitytype edit "
+                + event.getView().title()
+                + "type"));
+  }
+}