fixed some lints and some bugs in the teams implementation

probably a job for tomorrow

.classpath

@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="optional" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+			<attribute name="optional" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="target/generated-sources/annotations">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="ignore_optional_problems" value="true"/>
+			<attribute name="m2e-apt" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="target/generated-test-sources/test-annotations">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="ignore_optional_problems" value="true"/>
+			<attribute name="m2e-apt" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

.gitea/workflows/main.yml

@@ -2,22 +2,28 @@ name: Java CI with Maven
 
 on:
   push:
-    branches: [ "master" ]
+    branches:
+      - "main"
   pull_request:
-    branches: [ "master" ]
+    branches:
+      - "*"
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
-
     steps:
-    - uses: actions/checkout@v4
-    - name: Set up JDK 21
-      uses: actions/setup-java@v4
-      with:
-        java-version: '21'
-        distribution: 'temurin'
-        cache: maven
-    - name: Build with Maven
-      run: mvn -B package --file pom.xml
+      - uses: actions/checkout@v4
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: "21"
+          distribution: "temurin"
+          cache: maven
+      - uses: stCarolas/setup-maven@v5
+      - name: Build with Maven
+        run: mvn -B package --file pom.xml
+      - name: Release
+        uses: akkuman/gitea-release-action@v1
+        with:
+          files: ./target/fantasysmp*.jar
+          token: "${{secrets.RELEASE_TOKEN}}"

.project

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>fantasysmp</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1756828330981</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>

.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,4 @@
+eclipse.preferences.version=1
+encoding//src/main/java=UTF-8
+encoding//src/main/resources=UTF-8
+encoding/<project>=UTF-8

.settings/org.eclipse.jdt.apt.core.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.apt.aptEnabled=false

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,9 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
+org.eclipse.jdt.core.compiler.compliance=21
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
+org.eclipse.jdt.core.compiler.processAnnotations=disabled
+org.eclipse.jdt.core.compiler.release=disabled
+org.eclipse.jdt.core.compiler.source=21

.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

.zed/tasks.json

@@ -0,0 +1,37 @@
+// Project tasks configuration. See https://zed.dev/docs/tasks for documentation.
+[
+  {
+    "label": "Maven Compile",
+    "command": "mvn",
+    "args": ["compile"],
+    "shell": "system",
+    "use_new_terminal": false
+  },
+  {
+    "label": "Maven Clean Package",
+    "command": "mvn",
+    "args": ["clean", "package"],
+    "shell": "system",
+    "use_new_terminal": false
+  },
+  {
+    "label": "Maven Test",
+    "command": "mvn",
+    "args": ["test"],
+    "shell": "system",
+    "use_new_terminal": false
+  },
+  {
+    "label": "Run Project",
+    "command": "./run.sh",
+    "shell": "system",
+    "use_new_terminal": false
+  },
+  {
+    "label": "Maven Package (Skip Tests)",
+    "command": "mvn",
+    "args": ["clean", "package", "-DskipTests"],
+    "shell": "system",
+    "use_new_terminal": false
+  }
+]

run.sh

@@ -0,0 +1,4 @@
+mkdir -p ./run/plugins/
+cp ./target/fantasysmp*.jar run/plugins/fantasysmp.jar
+cd run/
+java -jar ./paper.jar nogui

src/main/java/dev/zxq5/fantasysmp/Fantasysmp.java

@@ -1,10 +1,9 @@
 package dev.zxq5.fantasysmp;
 
-import dev.zxq5.fantasysmp.events.HereticWarner;
-import dev.zxq5.fantasysmp.events.StevenKillCheck;
-import dev.zxq5.fantasysmp.items.GenericGearSet;
-import dev.zxq5.fantasysmp.items.Items;
-import dev.zxq5.fantasysmp.items.Witherite;
+import dev.zxq5.fantasysmp.events.*;
+import dev.zxq5.fantasysmp.groups.Commands;
+import dev.zxq5.fantasysmp.groups.Team;
+import dev.zxq5.fantasysmp.items.*;
 import dev.zxq5.fantasysmp.warps.Warp;
 import dev.zxq5.fantasysmp.warps.Warper;
 import org.bukkit.plugin.java.JavaPlugin;
@@ -13,39 +12,47 @@ public final class Fantasysmp extends JavaPlugin {
 
     @Override
     public void onEnable() {
-
         Items items = new Items(this);
         getCommand("items").setExecutor(items);
         // Plugin startup logic
 
         try {
             Warp.loadWarps();
+            Team.loadTeams();
         } catch (Exception e) {
             e.printStackTrace();
         }
 
         getCommand("home").setExecutor(new Warper());
         getCommand("sethome").setExecutor(new Warper());
-
         getCommand("setwarp").setExecutor(new Warper());
+        getCommand("delwarp").setExecutor(new Warper());
         getCommand("warp").setExecutor(new Warper());
+        getCommand("rewarps").setExecutor(new Warper());
+        getCommand("warps").setExecutor(new Warper());
+        getCommand("team").setExecutor(new Commands());
 
-        getCommand("reloadwarps").setExecutor(new Warper());
+        getServer().getPluginManager().registerEvents(new Chat(), this);
 
-        getServer().broadcastMessage("registered commands + \n /home \n /sethome \n /warp \n /setwarp");
+        HeresyChecker heresyChecker = new HeresyChecker();
+        heresyChecker.scheduleHeresyChecker();
+        getServer().getPluginManager().registerEvents(heresyChecker, this);
 
-        GenericGearSet witherite = new Witherite();
-        witherite.registerRecipes();
-
-        getServer().getPluginManager().registerEvents(new StevenKillCheck(), this);
-
-        HereticWarner hereticWarner = new HereticWarner();
-        hereticWarner.checkHereticInventory();
+        getServer()
+            .getPluginManager()
+            .registerEvents(new DeathMessageCustomiser(), this);
 
+        XrayDetector xrayDetector = new XrayDetector();
+        getServer().getPluginManager().registerEvents(xrayDetector, this);
     }
 
     @Override
     public void onDisable() {
-        // Plugin shutdown logic
+        try {
+            Warp.saveWarps();
+            Team.saveTeams();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
     }
 }

src/main/java/dev/zxq5/fantasysmp/chatutils/Chat.java

@@ -0,0 +1,22 @@
+package dev.zxq5.fantasysmp.chatutils;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+public class Chat {
+    public static final String EVENT_PREFIX = ChatColor.WHITE + "<" + ChatColor.AQUA + "Server" + ChatColor.WHITE + "> " + ChatColor.RESET;
+
+    private Chat() {}
+
+    public static void success(Player player, String message) {
+        player.sendMessage(EVENT_PREFIX + ChatColor.GREEN + message);
+    }
+
+    public static void error(Player player, String message) {
+        player.sendMessage(EVENT_PREFIX + ChatColor.RED + message);
+    }
+
+    public static void info(Player player, String message) {
+        player.sendMessage(EVENT_PREFIX + message);
+    }
+}

src/main/java/dev/zxq5/fantasysmp/events/Chat.java

@@ -0,0 +1,16 @@
+package dev.zxq5.fantasysmp.events;
+
+import dev.zxq5.fantasysmp.groups.Team;
+import org.bukkit.ChatColor;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+public class Chat implements Listener {
+    @EventHandler
+    public void onChat(org.bukkit.event.player.AsyncPlayerChatEvent event) {
+        Team team = Team.fromMember(event.getPlayer());
+        if (team != null) {
+            event.setFormat(ChatColor.WHITE + "[" + team.getTag() + ChatColor.WHITE + "]" + ChatColor.RESET + " <%s> %s");
+        }
+    }
+}

src/main/java/dev/zxq5/fantasysmp/events/DeathMessageCustomiser.java

@@ -0,0 +1,39 @@
+package dev.zxq5.fantasysmp.events;
+
+import org.bukkit.damage.DamageType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+
+import java.util.Random;
+
+public class DeathMessageCustomiser implements Listener {
+    private static final Random random = new Random();
+    private static final String[] FALL_MESSAGES = new String[] {
+            "%p Forgot to use chalk.",
+            "%p Tried to free solo.",
+            "%p Tried lead climbing.",
+            "%p Discovered it was not in fact a jug.",
+            "It was not a v1 in %p's gym.",
+            "%p slipped on a sloper",
+            "%p thought the ravine was a boulder problem",
+            "%p's fingers were not cut out for crack climbing",
+            "%p got a leg cramp",
+            "%p forgot to check their harness",
+            "%p didn't send the dyno",
+            "%p tried to static a 4 block jump",
+            "%p's climbing shoes didn't fit",
+            "%p wasn't flexible enough"
+    };
+
+    @EventHandler
+    public void onPlayerDeath(PlayerDeathEvent event) {
+        int randomIndex = random.nextInt(FALL_MESSAGES.length);
+        Player player = event.getEntity();
+
+        if (event.getDamageSource().getDamageType() == DamageType.FALL) {
+            event.setDeathMessage(FALL_MESSAGES[randomIndex].replace("%p", player.getName()));
+        }
+    }
+}

src/main/java/dev/zxq5/fantasysmp/events/HeresyChecker.java

@@ -0,0 +1,146 @@
+package dev.zxq5.fantasysmp.events;
+
+import org.bukkit.*;
+import org.bukkit.entity.Chicken;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.player.PlayerItemConsumeEvent;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.bukkit.Bukkit.*;
+
+public class HeresyChecker implements Listener {
+    private final HashMap<Player, Integer> heretics;
+    private final HashMap<Player, Integer> formerHeretics;
+
+    public HeresyChecker() {
+        this.heretics = new HashMap<>();
+        this.formerHeretics = new HashMap<>();
+    }
+
+    @EventHandler
+    public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
+        if (event.getEntity() instanceof Chicken) {
+            event.setCancelled(true);
+
+            if (event.getDamager() instanceof Player heretic) {
+                executeHeretic(heretic);
+            }
+        }
+    }
+
+    @EventHandler
+    public void onEntityDamage(EntityDamageEvent event) {
+        if (event.getEntity() instanceof Chicken) {
+            event.setCancelled(true);
+
+            if ( event.getDamageSource().getCausingEntity() instanceof Player heretic) {
+                executeHeretic(heretic);
+            }
+        }
+    }
+
+    @EventHandler
+    public void onProjectileHit(ProjectileHitEvent event) {
+        if (event.getHitEntity() instanceof Chicken && event.getEntity().getShooter() instanceof Player heretic) {
+            if (event.getEntity().getType() == EntityType.EGG) return;
+            if (event.getEntity().getType() == EntityType.SNOWBALL) return;
+
+            event.setCancelled(true);
+            executeHeretic(heretic);
+        }
+    }
+
+    @EventHandler
+    public void onEntitySpawn(org.bukkit.event.entity.EntitySpawnEvent event) {
+        if (event.getEntity() instanceof Chicken steven) {
+            steven.setCustomName("Steven");
+        }
+    }
+
+    @EventHandler
+    public void onPlayerEatChicken(PlayerItemConsumeEvent event) {
+        Material type = event.getItem().getType();
+
+        if (type == Material.COOKED_CHICKEN || type == Material.CHICKEN) {
+            this.executeHeretic(event.getPlayer());
+        }
+    }
+
+    public void scheduleHeresyChecker() {
+        Bukkit.getScheduler().scheduleSyncRepeatingTask(getPluginManager().getPlugin("fantasysmp"), this::checkHeretics, 0, 20);
+        Bukkit.getScheduler().scheduleSyncRepeatingTask(getPluginManager().getPlugin("fantasysmp"), () -> {
+            for (Player heretic : this.formerHeretics.keySet() ) {
+                this.formerHeretics.put(heretic, this.formerHeretics.get(heretic) - 1);
+            }
+        }, 0, 200);
+    }
+
+    public void checkHeretics() {
+        for ( Player player : Bukkit.getServer().getOnlinePlayers() ) {
+            if (player.getInventory().contains(Material.CHICKEN) || player.getInventory().contains(Material.COOKED_CHICKEN)) {
+                if (!this.heretics.containsKey(player)) {
+                    this.heretics.put(player, this.formerHeretics.getOrDefault(player, 0));
+                }
+            } else if (this.heretics.containsKey(player)) {
+                this.formerHeretics.put(player, this.heretics.get(player));
+                this.heretics.remove(player);
+            }
+        }
+
+        for (Map.Entry<Player, Integer> entry : this.heretics.entrySet() ) {
+            entry.setValue(entry.getValue() + 1);
+            warnHeretic(entry.getKey());
+            if ( entry.getValue() >= 5 ) {
+                punishHeretic(entry.getKey());
+            }
+        }
+    }
+
+    public void punishHeretic(Player heretic) {
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 20 * 2, 0));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, 20 * 2, 0));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, 20 * 2, 3));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.MINING_FATIGUE, 20 * 2, 3));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, 20 * 2, 3));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.DARKNESS, 20 * 2, 3));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.NAUSEA, 20 * 2, 3));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.HUNGER, 20 * 2, 3));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.WEAKNESS, 20 * 2, 3));
+        heretic.addPotionEffect(new PotionEffect(PotionEffectType.INSTANT_DAMAGE, 20 * 2, 0));
+    }
+
+    public void warnHeretic(Player heretic) {
+        heretic.sendTitle(ChatColor.DARK_RED + "HOLDING CHICKEN IS HERESY!", ChatColor.YELLOW + "DROP IT IMMEDIATELY!", 5, 10, 5);
+    }
+
+    public void executeHeretic(Player heretic) {
+        Location coords = heretic.getLocation();
+        World world = coords.getWorld();
+        Plugin plugin = getPluginManager().getPlugin("fantasysmp");
+
+        heretic.sendTitle(ChatColor.DARK_RED + "HERESY!", ChatColor.YELLOW + "YOU SHALL PAY FOR YOUR CRIMES.", 5, 10, 5);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 0);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 1);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 2);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 3);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 4);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 5);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 6);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 7);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 8);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 9);
+        Bukkit.getScheduler().runTaskLater(plugin, () -> heretic.setHealth(0), 10);
+    }
+}
+

src/main/java/dev/zxq5/fantasysmp/events/HereticWarner.java

@@ -1,40 +0,0 @@
-package dev.zxq5.fantasysmp.events;
-
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-
-import static org.bukkit.Bukkit.getPluginManager;
-
-public class HereticWarner {
-    int task;
-
-    public void checkHereticInventory() {
-        Bukkit.getScheduler().scheduleSyncRepeatingTask(getPluginManager().getPlugin("fantasysmp"), () -> {
-            for ( Player heretic : Bukkit.getServer().getOnlinePlayers() ) {
-                if (heretic.getInventory().contains(Material.CHICKEN) || heretic.getInventory().contains(Material.COOKED_CHICKEN)) {
-                    warnHeretic(heretic);
-                }
-            }
-        }, 0, 20);
-    }
-
-    public void warnHeretic(Player heretic) {
-        // apply poison to player
-        heretic.sendMessage(ChatColor.DARK_RED + "HOLDING CHICKEN IS HERESY!");
-        heretic.sendMessage(ChatColor.DARK_RED + "DROP IT IMMEDIATELY!");
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 20 * 2, 10));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, 20 * 2, 10));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, 20 * 2, 3));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.MINING_FATIGUE, 20 * 2, 3));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, 20 * 2, 3));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.DARKNESS, 20 * 2, 3));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.NAUSEA, 20 * 2, 3));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.HUNGER, 20 * 2, 3));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.WEAKNESS, 20 * 2, 3));
-        heretic.addPotionEffect(new PotionEffect(PotionEffectType.INSTANT_DAMAGE, 20 * 2, 0));
-    }
-}

src/main/java/dev/zxq5/fantasysmp/events/StevenKillCheck.java

@@ -1,81 +0,0 @@
-package dev.zxq5.fantasysmp.events;
-
-import org.bukkit.*;
-import org.bukkit.entity.Chicken;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Wither;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.event.entity.ProjectileHitEvent;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-import org.bukkit.scheduler.BukkitRunnable;
-
-import static org.bukkit.Bukkit.*;
-
-public class StevenKillCheck implements Listener {
-
-    @EventHandler
-    public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
-        if (event.getEntity() instanceof Chicken) {
-            event.setCancelled(true);
-
-            if (event.getDamager() instanceof Player player) {
-                destroyHeretic(player);
-            }
-        }
-    }
-
-    @EventHandler
-    public void onEntityDamage(EntityDamageEvent event) {
-        if (event.getEntity() instanceof Chicken) {
-            event.setCancelled(true);
-
-            if ( event.getDamageSource().getCausingEntity() instanceof Player player) {
-                destroyHeretic(player);
-            }
-        }
-    }
-
-    @EventHandler
-    public void onProjectileHit(ProjectileHitEvent event) {
-        if (event.getHitEntity() instanceof Chicken && event.getEntity().getShooter() instanceof Player player) {
-            if (event.getEntity().getType() == EntityType.EGG) return;
-            if (event.getEntity().getType() == EntityType.SNOWBALL) return;
-
-            event.setCancelled(true);
-            destroyHeretic(player);
-        }
-    }
-
-    @EventHandler
-    public void onEntitySpawn(org.bukkit.event.entity.EntitySpawnEvent event) {
-        if (event.getEntity() instanceof Chicken steven) {
-            steven.setCustomName("Steven");
-        }
-    }
-
-    public void destroyHeretic(Player heretic) {
-        Location coords = heretic.getLocation();
-        World world = getServer().getWorlds().getFirst();
-        Plugin plugin = getPluginManager().getPlugin("fantasysmp");
-
-        broadcastMessage(ChatColor.DARK_RED + "HERESY!!!!");
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 0);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 1);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 2);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 3);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 4);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 5);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 6);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 7);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 8);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> world.strikeLightning(coords), 9);
-        Bukkit.getScheduler().runTaskLater(plugin, () -> heretic.setHealth(0), 10);
-    }
-}
-

src/main/java/dev/zxq5/fantasysmp/events/XrayDetector.java

@@ -0,0 +1,131 @@
+package dev.zxq5.fantasysmp.events;
+
+import static org.bukkit.Bukkit.*;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.plugin.Plugin;
+
+public class XrayDetector implements Listener {
+
+    private final HashMap<Player, HashMap<Material, Integer>> players =
+        new HashMap<>();
+    private String token;
+
+    private final ArrayList<Material> trackedBlocks = new ArrayList<>(
+        Arrays.asList(
+            Material.ANCIENT_DEBRIS,
+            Material.DIAMOND_ORE,
+            Material.EMERALD_ORE,
+            Material.GOLD_ORE,
+            Material.IRON_ORE,
+            Material.LAPIS_ORE,
+            Material.REDSTONE_ORE
+        )
+    );
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent event) {
+        Player player = event.getPlayer();
+        HashMap<Material, Integer> blocks;
+        Material block = event.getBlock().getType();
+        Plugin plugin = getPluginManager().getPlugin("fantasysmp");
+
+        if (!this.players.containsKey(player)) this.players.put(
+            player,
+            new HashMap<>()
+        );
+        blocks = this.players.get(player);
+
+        if (this.trackedBlocks.contains(block)) {
+            if (!(blocks.containsKey(block))) blocks.put(block, 0);
+            blocks.put(block, blocks.get(block) + 1);
+
+            Bukkit.getScheduler().runTaskLater(
+                    plugin,
+                    () -> {
+                        blocks.put(block, blocks.get(block) - 1);
+                    },
+                    1200
+                );
+        }
+    }
+
+    private void uploadData() {
+        HashMap<String, HashMap<String, Integer>> data = new HashMap<>();
+        for (Map.Entry<
+            Player,
+            HashMap<Material, Integer>
+        > entry : players.entrySet()) {
+            HashMap<String, Integer> materials = new HashMap<>();
+
+            for (Map.Entry<Material, Integer> materialEntry : entry
+                .getValue()
+                .entrySet()) {
+                materials.put(
+                    materialEntry.getKey().toString(),
+                    materialEntry.getValue()
+                );
+            }
+
+            data.put(entry.getKey().getName(), materials);
+        }
+
+        Gson gson = new GsonBuilder().setPrettyPrinting().create();
+
+        HttpClient client = HttpClient.newHttpClient();
+        HttpRequest request = HttpRequest.newBuilder(
+            URI.create("https://mcapi.zxq5.dev/xray?token=" + token)
+        )
+            .header("Content-Type", "application/json")
+            .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(data)))
+            .build();
+
+        client
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString())
+            .thenApply(HttpResponse::body)
+            .join();
+    }
+
+    public XrayDetector() {
+        File dataFolder = getServer()
+            .getPluginManager()
+            .getPlugin("Fantasysmp")
+            .getDataFolder();
+        File file = new File(dataFolder, "token.txt");
+
+        BufferedReader reader;
+        try {
+            reader = new BufferedReader(new FileReader(file));
+            this.token = reader.readLine();
+            reader.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return;
+        }
+
+        Bukkit.getScheduler().runTaskTimerAsynchronously(
+            getPluginManager().getPlugin("fantasysmp"),
+            this::uploadData,
+            0,
+            20 * 60
+        );
+    }
+}

src/main/java/dev/zxq5/fantasysmp/groups/Commands.java

@@ -0,0 +1,274 @@
+package dev.zxq5.fantasysmp.groups;
+
+import static org.bukkit.Bukkit.getServer;
+
+import dev.zxq5.fantasysmp.chatutils.Chat;
+import dev.zxq5.fantasysmp.warps.Warp;
+import dev.zxq5.fantasysmp.warps.WarpType;
+import java.util.ArrayList;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.entity.Player;
+
+/*
+ * Commands:
+ *
+ *   ** PLAYER **
+ *
+ *   team list                       => DONE
+ *   team create <name>              => DONE
+ *   team rename <new name>          => TODO TEST
+ *   team transfer <player>          => TODO
+ *   team join <name>                => TODO
+ *   team invite <player>            => TODO
+ *   team leave                      => TODO
+ *   team disband                    => DONE
+ *   team setwarp                    => DONE
+ *   team delwarp                    => TODO
+ *   team warp <name>                => TODO TEST
+ *   team kick                       => TODO
+ *   team log                        => TODO
+ *
+ *   ** ADMIN ONLY **
+ *
+ *   rank create <name>              => TODO
+ *   rank <name> rename <new name>   => TODO
+ *   rank <name> delete              => TODO
+ *   rank add <player> <name>        => TODO
+ *   rank remove <player> <name>     => TODO
+ * */
+
+public class Commands implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        if (!(sender instanceof Player player)) return false;
+
+        if (command.getName().equals("team")) handleTeamCommands(player, args);
+        if (command.getName().equals("rank")) handleRankCommands(player, args);
+        return true;
+    }
+
+    public void handleTeamCommands(Player player, String[] args) {
+        switch (args[0]) {
+            case "list" -> this.handleList(player, args);
+            case "create" -> this.handleCreate(player, args);
+            case "rename" -> this.handleRename(player, args);
+            case "tag" -> this.handleSetTag(player, args);
+            case "transfer" -> this.handleTransfer(player, args);
+            case "join" -> this.handleJoin(player, args);
+            case "invite" -> this.handleInvite(player, args);
+            case "leave" -> this.handleLeave(player, args);
+            case "disband" -> this.handleDisband(player, args);
+            case "setwarp" -> this.handleSetWarp(player, args);
+            case "delwarp" -> this.handleDelWarp(player, args);
+            case "colour" -> this.handleSetColour(player, args);
+            case "warp" -> this.handleWarp(player, args);
+            case "kick" -> this.handleKick(player, args);
+            case "log" -> this.handleLog(player, args);
+        }
+    }
+
+    public void handleRankCommands(Player player, String[] args) {
+        // check perms
+        if (!(player.hasPermission("fantasysmp.ranks"))) {
+            Chat.error(
+                player,
+                "You do not have permission to use this command."
+            );
+            return;
+        }
+
+        switch (args[0]) {
+            case "create" -> this.handleCreateRank(player, args);
+            case "rename" -> this.handleRenameRank(player, args);
+            case "delete" -> this.handleDeleteRank(player, args);
+            case "add" -> this.handleAddRank(player, args);
+            case "remove" -> this.handleRemoveRank(player, args);
+        }
+    }
+
+    public void handleList(Player player, String[] args) {
+        String[] teams = Team.getTeams();
+        Chat.info(player, String.join(" ", teams));
+    }
+
+    public void handleCreate(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team create <name>");
+            return;
+        }
+
+        Team.createTeam(caller, args[1]);
+    }
+
+    public void handleSetColour(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team colour <color>");
+            return;
+        }
+
+        Team team = Team.fromMember(caller);
+        if (team == null) return;
+
+        team.setColour(caller, args[1]);
+    }
+
+    public void handleRename(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team rename <new name>");
+            return;
+        }
+
+        if (
+            args[1].isEmpty() || args[1].contains(" ") || args[1].contains("\t")
+        ) {
+            Chat.error(caller, "Invalid name!");
+            return;
+        }
+
+        Team team = Team.fromMember(caller);
+        if (team == null) return;
+
+        team.renameTeam(caller, args[1]);
+    }
+
+    public void handleSetTag(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team tag <tag>");
+            return;
+        }
+
+        if (
+            args[1].length() < 3 ||
+            args[1].contains(" ") ||
+            args[1].contains("\t") ||
+            args[1].length() > 8
+        ) {
+            Chat.error(caller, "Invalid tag!");
+            Chat.error(
+                caller,
+                "tags should be 3-8 chars, alphanumeric and have no spaces"
+            );
+            return;
+        }
+
+        Team team = Team.fromMember(caller);
+        if (team == null) return;
+
+        team.changeTeamTag(caller, args[1]);
+        Chat.success(caller, "Changed tag to " + args[1] + "!");
+    }
+
+    public void handleTransfer(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team transfer <player>");
+            return;
+        }
+        Team.fromMember(caller).transferTeam(caller, args[1]);
+
+        // Chat.success(caller, "Transferred ownership to: " + args[1] + "!");
+    }
+
+    public void handleJoin(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team join <name>");
+            return;
+        }
+        // Chat.success(caller, "Joined team: " + args[1] + "!");
+    }
+
+    public void handleInvite(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team invite <player>");
+            return;
+        }
+        // Chat.success(caller, "Changed tag to: " + args[1] + "!");
+    }
+
+    public void handleLeave(Player caller, String[] args) {
+        if (args.length != 1) {
+            Chat.error(caller, "Usage: /team leave");
+            return;
+        }
+        Team team = Team.fromMember(caller);
+        if (team == null) return;
+
+        team.leaveTeam(caller);
+    }
+
+    public void handleDisband(Player caller, String[] args) {
+        if (args.length != 1) {
+            Chat.error(caller, "Usage: /team disband");
+            return;
+        }
+        Team team = Team.fromMember(caller);
+        if (team == null) return;
+
+        team.disbandTeam(caller);
+    }
+
+    public void handleSetWarp(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team setwarp <name>");
+            return;
+        }
+
+        Warp.setWarp(args[1], caller, WarpType.TEAM);
+    }
+
+    public void handleDelWarp(Player caller, String[] args) {}
+
+    public void handleWarp(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team warp <name>");
+            return;
+        }
+        Team team = Team.fromMember(caller);
+        if (team == null) return;
+
+        Warp warp = Warp.getTeamWarp(team, caller, args[1]);
+        warp.execute(caller);
+    }
+
+    public void handleKick(Player caller, String[] args) {
+        if (args.length != 2) {
+            Chat.error(caller, "Usage: /team kick <player>");
+            return;
+        }
+        Team team = Team.fromMember(caller);
+        if (team == null) return;
+
+        team.removePlayer(caller, args[1]);
+    }
+
+    public void handleLog(Player caller, String[] args) {
+        if (args.length != 1) {
+            Chat.error(caller, "Usage: /team log");
+            return;
+        }
+
+        Team team = Team.fromMember(caller);
+        if (team == null) return;
+
+        ArrayList<String> logs = team.getLogs(caller);
+        String result = "Logs: [\n  " + String.join("\n  ", logs) + "\n]";
+        Chat.info(caller, result);
+    }
+
+    public void handleCreateRank(Player caller, String[] args) {}
+
+    public void handleRenameRank(Player caller, String[] args) {}
+
+    public void handleDeleteRank(Player caller, String[] args) {}
+
+    public void handleAddRank(Player caller, String[] args) {}
+
+    public void handleRemoveRank(Player caller, String[] args) {}
+
+    public Commands() {}
+}

src/main/java/dev/zxq5/fantasysmp/groups/Ranks.java

@@ -0,0 +1,4 @@
+package dev.zxq5.fantasysmp.groups;
+
+public class Ranks {
+}

src/main/java/dev/zxq5/fantasysmp/groups/Team.java

@@ -0,0 +1,372 @@
+package dev.zxq5.fantasysmp.groups;
+
+import static org.bukkit.Bukkit.broadcastMessage;
+import static org.bukkit.Bukkit.getServer;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+import dev.zxq5.fantasysmp.chatutils.Chat;
+import java.io.*;
+import java.util.ArrayList;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+public class Team {
+
+    private static ArrayList<Team> teams;
+    private static final String FILENAME = "teams.json";
+
+    private String name;
+    private String ownerUUID;
+    private ArrayList<String> members;
+    private ArrayList<String> invites;
+    private ArrayList<String> logs;
+    private String teamUUID;
+    private String tag;
+    private ChatColor color;
+
+    public Team(Player creator, String name, String tag) {
+        this.name = name;
+        this.tag = tag;
+        this.teamUUID = UUID.randomUUID().toString();
+        this.ownerUUID = creator.getUniqueId().toString();
+        this.members = new ArrayList<>();
+        this.logs = new ArrayList<>();
+        members.add(creator.getUniqueId().toString());
+    }
+
+    public static Team createTeam(Player creator, String name) {
+        if (Team.fromMember(creator) != null) {
+            Team.error(creator, Error.SELF_IN_TEAM);
+            return null;
+        }
+
+        Team team = new Team(creator, name, name);
+        team.logs.add(creator.getName() + " created the team.");
+        teams.add(team);
+
+        Chat.success(creator, "You created " + team.name + ".");
+        return team;
+    }
+
+    public static Team fromMember(Player member) {
+        for (Team team : teams) {
+            if (
+                team.members.contains(member.getUniqueId().toString())
+            ) return team;
+        }
+
+        Team.error(member, Error.TEAM_NOT_FOUND);
+        return null;
+    }
+
+    public static String[] getTeams() {
+        String[] names = new String[teams.size()];
+        for (int i = 0; i < teams.size(); i++) {
+            names[i] = teams.get(i).name;
+        }
+        return names;
+    }
+
+    public void renameTeam(Player player, String newName) {
+        if (!this.ownerUUID.equals(player.getUniqueId().toString())) {
+            Team.error(player, Error.NO_PERMISSION);
+            return;
+        }
+
+        String oldName = this.name;
+        this.name = newName;
+        this.log(player.getName() + " renamed the team to " + newName + ".");
+
+        Chat.success(player, "You renamed " + oldName + " to " + newName + ".");
+    }
+
+    public void changeTeamTag(Player player, String newTag) {
+        if (!this.ownerUUID.equals(player.getUniqueId().toString())) {
+            Team.error(player, Error.NO_PERMISSION);
+            return;
+        }
+
+        this.tag = newTag;
+        this.log(player.getName() + " changed the team tag to " + newTag + ".");
+
+        Chat.success(
+            player,
+            "You changed the tag of " + this.name + " to " + newTag + "."
+        );
+    }
+
+    public void setColour(Player player, String colour) {
+        if (!this.ownerUUID.equals(player.getUniqueId().toString())) {
+            Team.error(player, Error.NO_PERMISSION);
+            return;
+        }
+
+        this.color = switch (colour) {
+            case "red" -> ChatColor.RED;
+            case "green" -> ChatColor.GREEN;
+            case "blue" -> ChatColor.BLUE;
+            case "yellow" -> ChatColor.YELLOW;
+            case "aqua" -> ChatColor.AQUA;
+            case "dark_aqua" -> ChatColor.DARK_AQUA;
+            case "dark_blue" -> ChatColor.DARK_BLUE;
+            case "dark_gray" -> ChatColor.DARK_GRAY;
+            case "dark_green" -> ChatColor.DARK_GREEN;
+            case "dark_purple" -> ChatColor.DARK_PURPLE;
+            case "gold" -> ChatColor.GOLD;
+            case "gray" -> ChatColor.GRAY;
+            case "light_purple" -> ChatColor.LIGHT_PURPLE;
+            case "white" -> ChatColor.WHITE;
+            case "black" -> ChatColor.BLACK;
+            default -> ChatColor.WHITE;
+        };
+
+        this.log(
+            player.getName() + " changed the team colour to " + colour + "."
+        );
+        Chat.success(
+            player,
+            "You changed the colour of " + this.name + " to " + colour + "."
+        );
+    }
+
+    public void transferTeam(Player player, String playerName) {
+        if (!this.ownerUUID.equals(player.getUniqueId().toString())) {
+            Team.error(player, Error.NO_PERMISSION);
+            return;
+        }
+
+        Player newOwner = getServer().getPlayer(playerName);
+        if (newOwner == null) {
+            Team.error(player, Error.PLAYER_NOT_FOUND);
+            return;
+        }
+
+        String newUUID = newOwner.getUniqueId().toString();
+        if (!this.members.contains(newUUID)) {
+            Team.error(player, Error.PLAYER_NOT_FOUND);
+            return;
+        }
+
+        this.ownerUUID = newUUID;
+        this.log(
+            player.getName() +
+            " transferred ownership to " +
+            newOwner.getName() +
+            "."
+        );
+
+        Chat.success(
+            player,
+            "You transferred ownership of " +
+            this.name +
+            " to " +
+            newOwner.getName() +
+            "."
+        );
+    }
+
+    public void removePlayer(Player remover, String playerName) {
+        Player removedPlayer = getServer().getPlayer(playerName);
+
+        if (removedPlayer == null) {
+            Team.error(remover, Error.PLAYER_NOT_FOUND);
+            return;
+        }
+
+        String removerUUID = remover.getUniqueId().toString();
+        String removedPlayerUUID = removedPlayer.getUniqueId().toString();
+
+        if (removedPlayerUUID.equals(this.ownerUUID)) {
+            Team.error(remover, Error.TEAM_OWNER);
+            return;
+        }
+
+        if (!this.ownerUUID.equals(removerUUID)) {
+            Team.error(remover, Error.NO_PERMISSION);
+            return;
+        }
+
+        if (!this.members.contains(removedPlayerUUID)) {
+            Team.error(remover, Error.PLAYER_NOT_FOUND);
+            return;
+        }
+
+        this.members.remove(removedPlayerUUID);
+        this.log(
+            remover.getName() +
+            " removed " +
+            removedPlayer.getName() +
+            " from the team."
+        );
+
+        Chat.success(
+            remover,
+            "You removed " +
+            removedPlayer.getName() +
+            " from " +
+            this.name +
+            "."
+        );
+    }
+
+    public void leaveTeam(Player member) {
+        if (this.ownerUUID.equals(member.getUniqueId().toString())) {
+            Team.error(member, Error.TEAM_OWNER);
+            return;
+        }
+
+        this.members.remove(member.getUniqueId().toString());
+        this.log(member.getName() + " left the team.");
+
+        Chat.success(member, "You left " + this.name + ".");
+    }
+
+    public void disbandTeam(Player member) {
+        if (!this.ownerUUID.equals(member.getUniqueId().toString())) {
+            Team.error(member, Error.NO_PERMISSION);
+            return;
+        }
+
+        teams.remove(this);
+        this.log(member.getName() + " disbanded the team.");
+
+        Chat.success(member, "You disbanded " + this.name + ".");
+    }
+
+    public void addMember(Player member) {
+        if (!this.ownerUUID.equals(member.getUniqueId().toString())) {
+            Team.error(member, Error.NO_PERMISSION);
+            return;
+        }
+
+        this.members.add(member.getUniqueId().toString());
+        this.log(member.getName() + " joined the team.");
+
+        Chat.success(member, "You joined " + this.name + ".");
+    }
+
+    public ArrayList<String> getLogs(Player member) {
+        if (
+            this.ownerUUID.equals(member.getUniqueId().toString())
+        ) return this.logs;
+
+        Team.error(member, Error.NO_PERMISSION);
+        return null;
+    }
+
+    public void log(String message) {
+        this.logs.add(message);
+        Team.saveTeams();
+    }
+
+    public static void loadTeams() throws Exception {
+        File dataFolder = getServer()
+            .getPluginManager()
+            .getPlugin("Fantasysmp")
+            .getDataFolder();
+        File file = new File(dataFolder, FILENAME);
+
+        if (!file.exists()) {
+            createTeamsFile();
+        }
+
+        BufferedReader reader;
+        reader = new BufferedReader(new FileReader(file));
+
+        Gson gson = new GsonBuilder().setPrettyPrinting().create();
+        teams = gson.fromJson(
+            reader,
+            new TypeToken<ArrayList<Team>>() {}.getType()
+        );
+
+        reader.close();
+    }
+
+    public static void saveTeams() {
+        File dataFolder = getServer()
+            .getPluginManager()
+            .getPlugin("Fantasysmp")
+            .getDataFolder();
+        File file = new File(dataFolder, FILENAME);
+
+        Gson gson = new GsonBuilder().setPrettyPrinting().create();
+        String json = gson.toJson(teams);
+
+        try {
+            Writer writer = new FileWriter(file);
+            writer.write(json);
+            writer.close();
+        } catch (Exception e) {
+            broadcastMessage("Error saving teams. Please contact an admin.");
+            e.printStackTrace();
+        }
+    }
+
+    public static void createTeamsFile() {
+        File dataFolder = getServer()
+            .getPluginManager()
+            .getPlugin("Fantasysmp")
+            .getDataFolder();
+        File file = new File(dataFolder, FILENAME);
+
+        if (!file.exists()) {
+            try {
+                Team[] t = new Team[0];
+                Gson gson = new GsonBuilder().setPrettyPrinting().create();
+                String json = gson.toJson(t);
+                Writer writer = new FileWriter(file);
+                writer.write(json);
+                writer.close();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    // utility methods
+    public boolean hasMember(Player player) {
+        for (String uuid : this.members) {
+            if (player.getUniqueId().toString() == uuid) return true;
+        }
+
+        return false;
+    }
+
+    public String getUUID() {
+        return this.teamUUID;
+    }
+
+    public String getTag() {
+        return this.color + this.tag;
+    }
+
+    public static void error(Player player, Error error) {
+        Chat.error(
+            player,
+            switch (error) {
+                case NO_PERMISSION -> "You do not have permission to do that!";
+                case SELF_IN_TEAM -> "You are already in a team!";
+                case NOT_IN_TEAM -> "You are not in a team!";
+                case TEAM_NOT_FOUND -> "Team not found!";
+                case PLAYER_NOT_FOUND -> "Player not found!";
+                case ALREADY_TAKEN -> "That name is already taken!";
+                case PLAYER_IN_TEAM -> "That player is already in a team!";
+                case TEAM_OWNER -> "You cannot do this to/as the owner!";
+            }
+        );
+    }
+}
+
+enum Error {
+    NO_PERMISSION,
+    TEAM_OWNER,
+    SELF_IN_TEAM,
+    NOT_IN_TEAM,
+    TEAM_NOT_FOUND,
+    PLAYER_NOT_FOUND,
+    ALREADY_TAKEN,
+    PLAYER_IN_TEAM,
+}

src/main/java/dev/zxq5/fantasysmp/items/Food.java

@@ -0,0 +1,4 @@
+package dev.zxq5.fantasysmp.items;
+
+public class Food {
+}

src/main/java/dev/zxq5/fantasysmp/items/GenericGearSet.java

@@ -1,184 +1,169 @@
 package dev.zxq5.fantasysmp.items;
 
+import dev.zxq5.fantasysmp.util.LoreChecker;
+import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
 import org.bukkit.attribute.Attribute;
 import org.bukkit.attribute.AttributeModifier;
-import org.bukkit.inventory.EquipmentSlotGroup;
-import org.bukkit.inventory.ItemFlag;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.RecipeChoice;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.bukkit.inventory.*;
 import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.components.EquippableComponent;
+import org.bukkit.plugin.Plugin;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
-public abstract class GenericGearSet implements HasRecipes {
-    protected int swordAttackDamage = 0;
-    protected float swordAttackSpeed = 0;
-    protected int swordDurability = 0;
-    protected String swordName = "wooden sword";
-    protected String swordLore = "";
+public abstract class GenericGearSet implements HasRecipes, Listener {
 
-    protected int helmetArmour = 0;
-    protected int helmetArmourToughness = 0;
-    protected double helmetKnockbackResistance = 0;
-    protected int helmetDurability = 0;
-    protected String helmetName = "leather cap";
-    protected String helmetLore = "";
-
-    protected int chestplateArmour = 0;
-    protected int chestplateArmourToughness = 0;
-    protected double chestplateKnockbackResistance = 0;
-    protected int chestplateDurability = 0;
-    protected String chestplateName = "leather tunic";
-    protected String chestplateLore = "";
-
-    protected int leggingsArmour = 0;
-    protected int leggingsArmourToughness = 0;
-    protected double leggingsKnockbackResistance = 0;
-    protected int leggingsDurability = 0;
-    protected String leggingsName = "leather pants";
-    protected String leggingsLore = "";
-
-    protected int bootsArmour = 0;
-    protected int bootsArmourToughness = 0;
-    protected double bootsKnockbackResistance = 0;
-    protected int bootsDurability = 0;
-    protected String bootsName = "leather boots";
-    protected String bootsLore = "";
-
-    protected ItemStack helmetMaterial = new ItemStack(Material.LEATHER_HELMET);
-    protected ItemStack chestplateMaterial = new ItemStack(Material.LEATHER_CHESTPLATE);
-    protected ItemStack leggingsMaterial = new ItemStack(Material.LEATHER_LEGGINGS);
-    protected ItemStack bootsMaterial = new ItemStack(Material.LEATHER_BOOTS);
-    protected ItemStack swordMaterial = new ItemStack(Material.WOODEN_SWORD);
+    protected ItemStats sword = new ItemStats();
+    protected ItemStats helmet = new ItemStats();
+    protected ItemStats chestplate = new ItemStats();
+    protected ItemStats leggings = new ItemStats();
+    protected ItemStats boots = new ItemStats();
 
     protected static RecipeChoice NETHERITE_UPGRADE = new RecipeChoice.MaterialChoice(Material.NETHERITE_UPGRADE_SMITHING_TEMPLATE);
     protected static RecipeChoice WITHER_SKULL = new RecipeChoice.MaterialChoice(Material.WITHER_SKELETON_SKULL);
 
-    public void setTier1() {
-        swordAttackDamage = 4;
-        swordAttackSpeed = 1.6f;
+    public void registerEvents(Plugin plugin) {
+        Bukkit.getServer().getPluginManager().registerEvents(this, plugin);
+    }
 
-        // todo: idk
+    public void setTier1() {
+        sword.setMaterial(Material.WOODEN_SWORD);
+        helmet.setMaterial(Material.LEATHER_HELMET);
+        chestplate.setMaterial(Material.LEATHER_CHESTPLATE);
+        leggings.setMaterial(Material.LEATHER_LEGGINGS);
+        boots.setMaterial(Material.LEATHER_BOOTS);
     }
 
     public void setTier3() {
-        helmetMaterial = new ItemStack(Material.IRON_HELMET);
-        chestplateMaterial = new ItemStack(Material.IRON_CHESTPLATE);
-        leggingsMaterial = new ItemStack(Material.IRON_LEGGINGS);
-        ItemStack bootsMaterial = new ItemStack(Material.IRON_BOOTS);
-        swordMaterial = new ItemStack(Material.IRON_SWORD);
+        helmet.setMaterial(Material.IRON_HELMET);
+        chestplate.setMaterial(Material.IRON_CHESTPLATE);
+        leggings.setMaterial(Material.IRON_LEGGINGS);
+        boots.setMaterial(Material.IRON_BOOTS);
+        sword.setMaterial(Material.IRON_SWORD);
 
-        swordAttackDamage = 6;
-        swordAttackSpeed = 1.6f;
-        helmetArmour = 2;
-        helmetArmourToughness = 0;
-        chestplateArmour = 6;
-        chestplateArmourToughness = 0;
-        leggingsArmour = 5;
-        leggingsArmourToughness = 0;
-        bootsArmour = 2;
-        bootsArmourToughness = 0;
+        sword.attackDamage = 6;
+        sword.attackSpeed = 1.6f;
+        helmet.armour = 2;
+        helmet.armourToughness = 0;
+        chestplate.armour = 6;
+        chestplate.armourToughness = 0;
+        leggings.armour = 5;
+        leggings.armourToughness = 0;
+        boots.armour = 2;
+        boots.armourToughness = 0;
     }
 
     public void setTier4() {
-        helmetMaterial = new ItemStack(Material.DIAMOND_HELMET);
-        chestplateMaterial = new ItemStack(Material.DIAMOND_CHESTPLATE);
-        leggingsMaterial = new ItemStack(Material.DIAMOND_LEGGINGS);
-        bootsMaterial = new ItemStack(Material.DIAMOND_BOOTS);
-        swordMaterial = new ItemStack(Material.DIAMOND_SWORD);
+        helmet.setMaterial(Material.DIAMOND_HELMET);
+        chestplate.setMaterial(Material.DIAMOND_CHESTPLATE);
+        leggings.setMaterial(Material.DIAMOND_LEGGINGS);
+        boots.setMaterial(Material.DIAMOND_BOOTS);
+        sword.setMaterial(Material.DIAMOND_SWORD);
 
-        swordAttackDamage = 7;
-        swordAttackSpeed = 1.6f;
-        helmetArmour = 3;
-        helmetArmourToughness = 2;
-        chestplateArmour = 8;
-        chestplateArmourToughness = 2;
-        leggingsArmour = 6;
-        leggingsArmourToughness = 2;
-        bootsArmour = 3;
-        bootsArmourToughness = 2;
+        sword.attackDamage = 7;
+        sword.attackSpeed = 1.6f;
+        helmet.armour = 3;
+        helmet.armourToughness = 2;
+        chestplate.armour = 8;
+        chestplate.armourToughness = 2;
+        leggings.armour = 6;
+        leggings.armourToughness = 2;
+        boots.armour = 3;
+        boots.armourToughness = 2;
     }
 
     public void setTier5() {
-        helmetMaterial = new ItemStack(Material.NETHERITE_HELMET);
-        chestplateMaterial = new ItemStack(Material.NETHERITE_CHESTPLATE);
-        leggingsMaterial = new ItemStack(Material.NETHERITE_LEGGINGS);
-        bootsMaterial = new ItemStack(Material.NETHERITE_BOOTS);
-        swordMaterial = new ItemStack(Material.NETHERITE_SWORD);
+        helmet.setMaterial(Material.NETHERITE_HELMET);
+        chestplate.setMaterial(Material.NETHERITE_CHESTPLATE);
+        leggings.setMaterial(Material.NETHERITE_LEGGINGS);
+        boots.setMaterial(Material.NETHERITE_BOOTS);
+        sword.setMaterial(Material.NETHERITE_SWORD);
 
-        swordAttackDamage = 8;
-        swordAttackSpeed = 1.6f;
-        helmetArmour = 3;
-        helmetArmourToughness = 3;
-        helmetKnockbackResistance = 0.1;
-        chestplateArmour = 8;
-        chestplateArmourToughness = 3;
-        chestplateKnockbackResistance = 0.1;
-        leggingsArmour = 6;
-        leggingsArmourToughness = 3;
-        leggingsKnockbackResistance = 0.1;
-        bootsArmour = 3;
-        bootsArmourToughness = 3;
-        bootsKnockbackResistance = 0.1;
+        sword.attackDamage = 8;
+        sword.attackSpeed = 1.6f;
+        helmet.armour = 3;
+        helmet.armourToughness = 3;
+        helmet.knockbackResistance = 0.1;
+        chestplate.armour = 8;
+        chestplate.armourToughness = 3;
+        chestplate.knockbackResistance = 0.1;
+        leggings.armour = 6;
+        leggings.armourToughness = 3;
+        leggings.knockbackResistance = 0.1;
+        boots.armour = 3;
+        boots.armourToughness = 3;
+        boots.knockbackResistance = 0.1;
     }
 
     public void setTier6() {
-        helmetMaterial = new ItemStack(Material.NETHERITE_HELMET);
-        chestplateMaterial = new ItemStack(Material.NETHERITE_CHESTPLATE);
-        leggingsMaterial = new ItemStack(Material.NETHERITE_LEGGINGS);
-        bootsMaterial = new ItemStack(Material.NETHERITE_BOOTS);
-        swordMaterial = new ItemStack(Material.NETHERITE_SWORD);
+        helmet.setMaterial(Material.NETHERITE_HELMET);
+        chestplate.setMaterial(Material.NETHERITE_CHESTPLATE);
+        leggings.setMaterial(Material.NETHERITE_LEGGINGS);
+        boots.setMaterial(Material.NETHERITE_BOOTS);
+        sword.setMaterial(Material.NETHERITE_SWORD);
 
-        swordAttackDamage = 10;
-        swordAttackSpeed = 1.6f;
-        helmetArmour = 3;
-        helmetArmourToughness = 5;
-        helmetKnockbackResistance = 0.1;
-        chestplateArmour = 8;
-        chestplateArmourToughness = 5;
-        chestplateKnockbackResistance = 0.1;
-        leggingsArmour = 6;
-        leggingsArmourToughness = 5;
-        leggingsKnockbackResistance = 0.1;
-        bootsArmour = 3;
-        bootsArmourToughness = 5;
-        bootsKnockbackResistance = 0.1;
+        sword.attackDamage = 10;
+        sword.attackSpeed = 1.6f;
+        helmet.armour = 3;
+        helmet.armourToughness = 5;
+        helmet.knockbackResistance = 0.1;
+        chestplate.armour = 8;
+        chestplate.armourToughness = 5;
+        chestplate.knockbackResistance = 0.1;
+        leggings.armour = 6;
+        leggings.armourToughness = 5;
+        leggings.knockbackResistance = 0.1;
+        boots.armour = 3;
+        boots.armourToughness = 5;
+        boots.knockbackResistance = 0.1;
+    }
+
+    public boolean hasGear(Player player) {
+        return (LoreChecker.itemLoreContains(player.getInventory().getHelmet(), this.helmet.lore)
+            && LoreChecker.itemLoreContains(player.getInventory().getChestplate(), this.chestplate.lore)
+            && LoreChecker.itemLoreContains(player.getInventory().getLeggings(), this.leggings.lore)
+            && LoreChecker.itemLoreContains(player.getInventory().getBoots(), this.boots.lore)
+        );
     }
 
     // this must be overridden by the child class.
     public static void init() {}
 
     public ItemStack getSword() {
-        ItemStack item = swordMaterial;
+        ItemStack item = sword.material;
         ItemMeta meta = item.getItemMeta();
 
         meta.addAttributeModifier(Attribute.ATTACK_DAMAGE, new AttributeModifier(
                 NamespacedKey.minecraft("generic.attack_damage"),
-                swordAttackDamage,
+                sword.attackDamage,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.HAND
         ));
 
         meta.addAttributeModifier(Attribute.ATTACK_SPEED, new AttributeModifier(
                 NamespacedKey.minecraft("generic.attack_speed"),
-                swordAttackSpeed - 4,
+                sword.attackSpeed - 4,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.HAND
         ));
 
         meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES);
-        meta.setDisplayName(this.swordName);
+        meta.setDisplayName(sword.name);
 
-        ArrayList<String> lore = new ArrayList<>(List.of(this.swordLore));
+        if (!sword.customItemModel.isEmpty()) meta.setItemModel(NamespacedKey.fromString("fantasysmp:" + sword.customItemModel));
+
+        ArrayList<String> lore = new ArrayList<>(List.of(sword.lore));
         lore.add("\n");
         lore.add(ChatColor.GRAY + "When in Main Hand:" + ChatColor.RESET);
-        if (swordAttackDamage > 0) lore.add(ChatColor.GREEN + " " + swordAttackDamage + " Attack Damage" + ChatColor.RESET);
-        if (swordAttackSpeed > 0) lore.add(ChatColor.GREEN + " " + swordAttackSpeed + " Attack Speed" + ChatColor.RESET);
+        if (sword.attackDamage > 0) lore.add(ChatColor.GREEN + String.format(" %.1f Attack Damage", sword.attackDamage) + ChatColor.RESET);
+        if (sword.attackSpeed > 0) lore.add(ChatColor.GREEN + String.format(" %.1f Attack Speed", sword.attackSpeed) + ChatColor.RESET);
 
         meta.setLore(lore);
         item.setItemMeta(meta);
@@ -186,16 +171,17 @@ public abstract class GenericGearSet implements HasRecipes {
     }
 
     public ItemStack getHelmet() {
-        ItemStack item = helmetMaterial;
+        ItemStack item = helmet.material;
 
         ItemMeta meta = item.getItemMeta();
-        meta.setDisplayName(this.helmetName);
-        meta.setLore(new ArrayList<>(List.of(this.helmetLore)));
+        meta.setDisplayName(helmet.name);
+        meta.setLore(new ArrayList<>(List.of(helmet.lore)));
+
 
         meta.addAttributeModifier(Attribute.ARMOR, new AttributeModifier(
                 UUID.randomUUID(),
                 "armour",
-                (double) helmetArmour,
+                (double) helmet.armour,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.HEAD
         ));
@@ -203,36 +189,41 @@ public abstract class GenericGearSet implements HasRecipes {
         meta.addAttributeModifier(Attribute.ARMOR_TOUGHNESS, new AttributeModifier(
                 UUID.randomUUID(),
                 "armour_toughness",
-                helmetArmourToughness,
+                helmet.armourToughness,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.HEAD
         ));
 
-        if (helmetKnockbackResistance != 0) {
+        if (helmet.knockbackResistance != 0) {
             meta.addAttributeModifier(Attribute.KNOCKBACK_RESISTANCE, new AttributeModifier(
                     UUID.randomUUID(),
                     "knockback_resistance",
-                    helmetKnockbackResistance,
+                    helmet.knockbackResistance,
                     AttributeModifier.Operation.ADD_NUMBER,
                     EquipmentSlotGroup.HEAD
             ));
         }
+        if (!helmet.customItemModel.isEmpty()) meta.setItemModel(NamespacedKey.fromString("fantasysmp:" + helmet.customItemModel));
+        EquippableComponent equippable = meta.getEquippable();
+        equippable.setModel(NamespacedKey.fromString("fantasysmp:" + helmet.customEquipmentModel));
+        equippable.setSlot(EquipmentSlot.HEAD);
+        meta.setEquippable(equippable);
 
         item.setItemMeta(meta);
         return item;
     }
 
     public ItemStack getChestplate() {
-        ItemStack item = chestplateMaterial;
+        ItemStack item = chestplate.material;
 
         ItemMeta meta = item.getItemMeta();
-        meta.setDisplayName(this.chestplateName);
-        meta.setLore(new ArrayList<>(List.of(this.chestplateLore)));
+        meta.setDisplayName(chestplate.name);
+        meta.setLore(new ArrayList<>(List.of(chestplate.lore)));
 
         meta.addAttributeModifier(Attribute.ARMOR, new AttributeModifier(
                 UUID.randomUUID(),
                 "armour",
-                (double) chestplateArmour,
+                (double) chestplate.armour,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.CHEST
         ));
@@ -240,36 +231,42 @@ public abstract class GenericGearSet implements HasRecipes {
         meta.addAttributeModifier(Attribute.ARMOR_TOUGHNESS, new AttributeModifier(
                 UUID.randomUUID(),
                 "armour_toughness",
-                chestplateArmourToughness,
+                chestplate.armourToughness,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.CHEST
         ));
 
-        if (chestplateKnockbackResistance != 0) {
+        if (chestplate.knockbackResistance != 0) {
             meta.addAttributeModifier(Attribute.KNOCKBACK_RESISTANCE, new AttributeModifier(
                     UUID.randomUUID(),
                     "knockback_resistance",
-                    chestplateKnockbackResistance,
+                    chestplate.knockbackResistance,
                     AttributeModifier.Operation.ADD_NUMBER,
                     EquipmentSlotGroup.CHEST
             ));
         }
 
+        if (!chestplate.customItemModel.isEmpty()) meta.setItemModel(NamespacedKey.fromString("fantasysmp:" + chestplate.customItemModel));
+        EquippableComponent equippable = meta.getEquippable();
+        equippable.setModel(NamespacedKey.fromString("fantasysmp:" + chestplate.customEquipmentModel));
+        equippable.setSlot(EquipmentSlot.CHEST);
+        meta.setEquippable(equippable);
+
         item.setItemMeta(meta);
         return item;
     }
 
     public ItemStack getLeggings() {
-        ItemStack item = leggingsMaterial;
+        ItemStack item = leggings.material;
 
         ItemMeta meta = item.getItemMeta();
-        meta.setDisplayName(this.leggingsName);
-        meta.setLore(new ArrayList<>(List.of(this.leggingsLore)));
+        meta.setDisplayName(leggings.name);
+        meta.setLore(new ArrayList<>(List.of(leggings.lore)));
 
         meta.addAttributeModifier(Attribute.ARMOR, new AttributeModifier(
                 UUID.randomUUID(),
                 "armour",
-                (double) leggingsArmour,
+                (double) leggings.armour,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.LEGS
         ));
@@ -277,36 +274,42 @@ public abstract class GenericGearSet implements HasRecipes {
         meta.addAttributeModifier(Attribute.ARMOR_TOUGHNESS, new AttributeModifier(
                 UUID.randomUUID(),
                 "armour_toughness",
-                leggingsArmourToughness,
+                leggings.armourToughness,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.LEGS
         ));
 
-        if (leggingsKnockbackResistance != 0) {
+        if (leggings.knockbackResistance != 0) {
             meta.addAttributeModifier(Attribute.KNOCKBACK_RESISTANCE, new AttributeModifier(
                     UUID.randomUUID(),
                     "knockback_resistance",
-                    leggingsKnockbackResistance,
+                    leggings.knockbackResistance,
                     AttributeModifier.Operation.ADD_NUMBER,
                     EquipmentSlotGroup.LEGS
             ));
         }
 
+        if (!leggings.customItemModel.isEmpty()) meta.setItemModel(NamespacedKey.fromString("fantasysmp:" + leggings.customItemModel));
+        EquippableComponent equippable = meta.getEquippable();
+        equippable.setModel(NamespacedKey.fromString("fantasysmp:" + leggings.customEquipmentModel));
+        equippable.setSlot(EquipmentSlot.LEGS);
+        meta.setEquippable(equippable);
+
         item.setItemMeta(meta);
         return item;
     }
 
     public ItemStack getBoots() {
-        ItemStack item = bootsMaterial;
+        ItemStack item = boots.material;
 
         ItemMeta meta = item.getItemMeta();
-        meta.setDisplayName(this.bootsName);
-        meta.setLore(new ArrayList<>(List.of(this.bootsLore)));
+        meta.setDisplayName(boots.name);
+        meta.setLore(new ArrayList<>(List.of(boots.lore)));
 
         meta.addAttributeModifier(Attribute.ARMOR, new AttributeModifier(
                 UUID.randomUUID(),
                 "armour",
-                (double) bootsArmour,
+                (double) boots.armour,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.FEET
         ));
@@ -314,21 +317,27 @@ public abstract class GenericGearSet implements HasRecipes {
         meta.addAttributeModifier(Attribute.ARMOR_TOUGHNESS, new AttributeModifier(
                 UUID.randomUUID(),
                 "armour_toughness",
-                bootsArmourToughness,
+                boots.armourToughness,
                 AttributeModifier.Operation.ADD_NUMBER,
                 EquipmentSlotGroup.FEET
         ));
 
-        if (bootsKnockbackResistance != 0) {
+        if (boots.knockbackResistance != 0) {
             meta.addAttributeModifier(Attribute.KNOCKBACK_RESISTANCE, new AttributeModifier(
                     UUID.randomUUID(),
                     "knockback_resistance",
-                    bootsKnockbackResistance,
+                    boots.knockbackResistance,
                     AttributeModifier.Operation.ADD_NUMBER,
                     EquipmentSlotGroup.FEET
             ));
         }
 
+        if (!boots.customItemModel.isEmpty()) meta.setItemModel(NamespacedKey.fromString("fantasysmp:" + boots.customItemModel));
+        EquippableComponent equippable = meta.getEquippable();
+        equippable.setModel(NamespacedKey.fromString("fantasysmp:" + boots.customEquipmentModel));
+        equippable.setSlot(EquipmentSlot.FEET);
+        meta.setEquippable(equippable);
+
         item.setItemMeta(meta);
         return item;
     }
@@ -346,5 +355,3 @@ public abstract class GenericGearSet implements HasRecipes {
 
 
 
-
-

src/main/java/dev/zxq5/fantasysmp/items/ItemStats.java

@@ -0,0 +1,36 @@
+package dev.zxq5.fantasysmp.items;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+public class ItemStats {
+    public double attackDamage;
+    public double attackSpeed;
+    public int durability;
+    public int armour;
+    public int armourToughness;
+    public double knockbackResistance ;
+    public String name;
+    public String lore;
+    public String customItemModel;
+    public String customEquipmentModel;
+    public ItemStack material;
+
+    public ItemStats() {
+        this.attackDamage = 0;
+        this.attackSpeed = 0;
+        this.durability = 0;
+        this.armour = 0;
+        this.armourToughness = 0;
+        this.knockbackResistance = 0;
+        this.name = "";
+        this.lore = "";
+        this.customItemModel = "";
+        this.customEquipmentModel = "";
+        this.material = new ItemStack(Material.AIR);
+    }
+
+    public void setMaterial(Material material) {
+        this.material = new ItemStack(material);
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/Items.java

@@ -1,14 +1,12 @@
 package dev.zxq5.fantasysmp.items;
 
-import org.bukkit.Bukkit;
+import dev.zxq5.fantasysmp.items.food.AppleCider;
+import dev.zxq5.fantasysmp.items.food.AppleJuice;
+import dev.zxq5.fantasysmp.items.gear.*;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Wither;
-import org.bukkit.event.EventHandler;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import static org.bukkit.Bukkit.getServer;
-
 public class Items implements CommandExecutor {
 
     @Override
@@ -35,7 +33,15 @@ public class Items implements CommandExecutor {
 
         CommandExecutor handler;
         switch (args[0]) {
-            case "witherite" -> handler = new Witherite();
+            case "witherite" -> handler = new WitheriteGear();
+            case "lightning" -> handler = new LightningSword();
+            case "steven" -> handler = new StevensWrath();
+            case "blazing" -> handler = new BlazingGear();
+            case "dragon" -> handler = new DragonGear();
+            case "trueneth" -> handler = new TrueNetheriteGear();
+            case "ender" -> handler = new EnderGear();
+            case "poseidon" -> handler = new PoseidonGear();
+            case "crimson" -> handler = new CrimsonGear();
             default -> { return false; }
         }
 
@@ -45,8 +51,47 @@ public class Items implements CommandExecutor {
     }
 
     public Items(JavaPlugin plugin) {
-        Witherite.init();
-        getServer().getPluginManager().registerEvents(new Witherite(), plugin);
 
+        WitheriteGear witherite = new WitheriteGear();
+        witherite.registerRecipes();
+        witherite.registerEvents(plugin);
+
+        LightningSword lightning = new LightningSword();
+        lightning.registerRecipes();
+        lightning.registerEvents(plugin);
+
+        StevensWrath stevensWrath = new StevensWrath();
+        stevensWrath.registerRecipes();
+        stevensWrath.registerEvents(plugin);
+
+        BlazingGear blazing = new BlazingGear();
+        blazing.registerRecipes();
+        blazing.registerEvents(plugin);
+
+        DragonGear dragon = new DragonGear();
+        dragon.registerRecipes();
+        dragon.registerEvents(plugin);
+
+        EnderGear ender = new EnderGear();
+        ender.registerRecipes();
+        ender.registerEvents(plugin);
+
+        TrueNetheriteGear trueNetherite = new TrueNetheriteGear();
+        trueNetherite.registerRecipes();
+        trueNetherite.registerEvents(plugin);
+
+        PoseidonGear poseidon = new PoseidonGear();
+        poseidon.registerRecipes();
+        poseidon.registerEvents(plugin);
+
+        CrimsonGear crimson = new CrimsonGear();
+        crimson.registerRecipes();
+        crimson.registerEvents(plugin);
+
+        AppleJuice appleJuice = new AppleJuice();
+        appleJuice.registerEvents(plugin);
+
+        AppleCider appleCider = new AppleCider();
+        appleCider.registerEvents(plugin);
     }
 }

src/main/java/dev/zxq5/fantasysmp/items/Witherite.java

@@ -1,179 +0,0 @@
-package dev.zxq5.fantasysmp.items;
-
-import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.RecipeChoice;
-import org.bukkit.inventory.SmithingTransformRecipe;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.inventory.meta.components.CustomModelDataComponent;
-import org.bukkit.inventory.meta.components.EquippableComponent;
-import org.bukkit.potion.PotionEffect;
-
-import static org.bukkit.Bukkit.getServer;
-
-public class Witherite extends GenericGearSet implements Listener, CommandExecutor {
-
-    @Override
-    public boolean onCommand(org.bukkit.command.CommandSender sender, org.bukkit.command.Command command, String label, String[] args) {
-        if (!(args[0].equals("witherite"))) {
-            return false;
-        }
-
-        Player player = (Player) sender;
-
-        player.getInventory().addItem(new Witherite().getSword());
-        player.getInventory().addItem(new Witherite().getHelmet());
-        player.getInventory().addItem(new Witherite().getChestplate());
-        player.getInventory().addItem(new Witherite().getLeggings());
-        player.getInventory().addItem(new Witherite().getBoots());
-
-        return true;
-    }
-
-    @Override
-    public void registerRecipes() {
-        ItemStack sword = this.getSword();
-        NamespacedKey swordKey = new NamespacedKey("fantasysmp.items", "witherite_sword");
-        RecipeChoice swordChoice = new RecipeChoice.MaterialChoice(Material.NETHERITE_SWORD);
-        SmithingTransformRecipe swordRecipe = new SmithingTransformRecipe(swordKey, sword, NETHERITE_UPGRADE, swordChoice, WITHER_SKULL);
-        getServer().addRecipe(swordRecipe);
-
-        ItemStack helmet = this.getHelmet();
-        NamespacedKey helmetKey = new NamespacedKey("fantasysmp.items", "witherite_helmet");
-        RecipeChoice helmetChoice = new RecipeChoice.MaterialChoice(Material.NETHERITE_HELMET);
-        SmithingTransformRecipe helmetRecipe = new SmithingTransformRecipe(helmetKey, helmet, NETHERITE_UPGRADE, helmetChoice, WITHER_SKULL);
-        getServer().addRecipe(helmetRecipe);
-
-        ItemStack chestplate = this.getChestplate();
-        NamespacedKey chestplateKey = new NamespacedKey("fantasysmp.items", "witherite_chestplate");
-        RecipeChoice chestplateChoice = new RecipeChoice.MaterialChoice(Material.NETHERITE_CHESTPLATE);
-        SmithingTransformRecipe chestplateRecipe = new SmithingTransformRecipe(chestplateKey, chestplate, NETHERITE_UPGRADE, chestplateChoice, WITHER_SKULL);
-        getServer().addRecipe(chestplateRecipe);
-
-        ItemStack leggings = this.getLeggings();
-        NamespacedKey leggingsKey = new NamespacedKey("fantasysmp.items", "witherite_leggings");
-        RecipeChoice leggingsChoice = new RecipeChoice.MaterialChoice(Material.NETHERITE_LEGGINGS);
-        SmithingTransformRecipe leggingsRecipe = new SmithingTransformRecipe(leggingsKey, leggings, NETHERITE_UPGRADE, leggingsChoice, WITHER_SKULL);
-        getServer().addRecipe(leggingsRecipe);
-
-        ItemStack boots = this.getBoots();
-        NamespacedKey bootsKey = new NamespacedKey("fantasysmp.items", "witherite_boots");
-        RecipeChoice bootsChoice = new RecipeChoice.MaterialChoice(Material.NETHERITE_BOOTS);
-        SmithingTransformRecipe bootsRecipe = new SmithingTransformRecipe(bootsKey, boots, NETHERITE_UPGRADE, bootsChoice, WITHER_SKULL);
-        getServer().addRecipe(bootsRecipe);
-    }
-
-    @EventHandler
-    public void onEntityDamageByEntity(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
-
-        // checks that it is a player that is performing the attack.
-        if (!(event.getDamager() instanceof org.bukkit.entity.Player player)) {
-            return;
-        }
-
-        try {
-            if (!player.getInventory().getItemInMainHand().getItemMeta().getLore().toString().contains(this.swordLore)) {
-                return;
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-            return;
-        }
-
-        PotionEffect effect = new PotionEffect(
-                org.bukkit.potion.PotionEffectType.WITHER,
-                20 * 5,
-                1
-        );
-        effect.apply((LivingEntity) event.getEntity());
-
-    }
-
-    @EventHandler
-    public void onEntityPotionEffectEvent(org.bukkit.event.entity.EntityPotionEffectEvent event) {
-        if (event.getEntity() instanceof Player player) {
-            if (event.getNewEffect().getType() != org.bukkit.potion.PotionEffectType.WITHER) {
-                return;
-            }
-
-            try {
-                if (player.getInventory().getHelmet().getItemMeta().getLore().toString().contains(this.helmetLore)
-                        && player.getInventory().getChestplate().getItemMeta().getLore().toString().contains(this.chestplateLore)
-                        && player.getInventory().getLeggings().getItemMeta().getLore().toString().contains(this.leggingsLore)
-                        && player.getInventory().getBoots().getItemMeta().getLore().toString().contains(this.bootsLore)) {
-                    event.setCancelled(true);
-                }
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    @Override
-    public ItemStack getSword() {
-        ItemStack item = super.getSword();
-        ItemMeta meta = item.getItemMeta();
-        meta.setItemModel(NamespacedKey.fromString("fantasysmp:witherite_sword"));
-        item.setItemMeta(meta);
-        return item;
-    }
-
-    @Override
-    public ItemStack getHelmet() {
-        ItemStack item = super.getHelmet();
-        ItemMeta meta = item.getItemMeta();
-        meta.setItemModel(NamespacedKey.fromString("fantasysmp:witherite_helmet"));
-        item.setItemMeta(meta);
-        return item;
-    }
-
-    @Override
-    public ItemStack getChestplate() {
-        ItemStack item = super.getChestplate();
-        ItemMeta meta = item.getItemMeta();
-        meta.setItemModel(NamespacedKey.fromString("fantasysmp:witherite_chestplate"));
-        item.setItemMeta(meta);
-        return item;
-    }
-
-    @Override
-    public ItemStack getLeggings() {
-        ItemStack item = super.getLeggings();
-        ItemMeta meta = item.getItemMeta();
-        meta.setItemModel(NamespacedKey.fromString("fantasysmp:witherite_leggings"));
-        item.setItemMeta(meta);
-        return item;
-    }
-
-    @Override
-    public ItemStack getBoots() {
-        ItemStack item = super.getBoots();
-        ItemMeta meta = item.getItemMeta();
-        meta.setItemModel(NamespacedKey.fromString("fantasysmp:witherite_boots"));
-        item.setItemMeta(meta);
-        return item;
-    }
-
-    public static void init() {}
-
-    public Witherite() {
-        this.setTier5();
-        this.swordName = "Witherite Sword";
-        this.helmetName = "Witherite Helmet";
-        this.chestplateName = "Witherite Chestplate";
-        this.leggingsName = "Witherite Leggings";
-        this.bootsName = "Witherite Boots";
-
-        this.swordLore = "A sword forged with the skulls of wither skeletons.";
-        this.helmetLore = "A helmet forged with the skulls of wither skeletons.";
-        this.chestplateLore = "A chestplate forged with the skulls of wither skeletons.";
-        this.leggingsLore = "A leggings forged with the skulls of wither skeletons.";
-        this.bootsLore = "A boots forged with the skulls of wither skeletons.";
-    }
-}

src/main/java/dev/zxq5/fantasysmp/items/food/AppleCider.java

@@ -0,0 +1,85 @@
+package dev.zxq5.fantasysmp.items.food;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.inventory.meta.components.FoodComponent;
+import org.bukkit.potion.PotionEffectType;
+
+public class AppleCider extends GenericDrink {
+
+    public boolean onCommand(org.bukkit.command.CommandSender sender, org.bukkit.command.Command command, String label, String[] args) {
+        Player player = (Player) sender;
+        player.getInventory().addItem(this.getDrink());
+        return true;
+    }
+
+    public AppleCider() {
+        this.name = "Apple Cider";
+        this.lore = "A stronger drink";
+
+        this.ingredients.put(new ItemStack(Material.APPLE, 1), 1);
+        this.ingredients.put(new AppleJuice().getDrink(), 1);
+        this.ingredients.put(new ItemStack(Material.SUGAR, 1), 1);
+    }
+
+    @Override
+    public ItemStack getDrink() {
+        ItemStack item = super.getDrink();
+        PotionMeta meta = (PotionMeta) item.getItemMeta();
+
+        if (meta == null) {
+            Bukkit.getConsoleSender().sendMessage("Meta is null on a drink!!!!! this should not happen!!!!");
+            return item;
+        }
+
+        meta.addCustomEffect(new org.bukkit.potion.PotionEffect(
+            PotionEffectType.SATURATION, 20, 5
+        ), true);
+        meta.addCustomEffect(new org.bukkit.potion.PotionEffect(
+            PotionEffectType.SPEED, 10 * 20, 1
+        ), true);
+
+        meta.setColor(org.bukkit.Color.fromRGB(255, 255, 0));
+        meta.setMaxStackSize(16);
+        FoodComponent food = meta.getFood();
+        food.setNutrition(8);
+        food.setSaturation(8);
+        food.setCanAlwaysEat(true);
+        meta.setFood(food);
+
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    @Override
+    public void registerRecipes() {}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/main/java/dev/zxq5/fantasysmp/items/food/AppleJuice.java

@@ -0,0 +1,70 @@
+package dev.zxq5.fantasysmp.items.food;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.inventory.meta.components.FoodComponent;
+
+public class AppleJuice extends GenericDrink {
+
+    public boolean onCommand(org.bukkit.command.CommandSender sender, org.bukkit.command.Command command, String label, String[] args) {
+        Player player = (Player) sender;
+        player.getInventory().addItem(this.getDrink());
+        return true;
+    }
+
+    public AppleJuice() {
+        this.name = "Apple Juice";
+        this.lore = "A refreshing drink";
+
+        this.ingredients.put(new ItemStack(Material.APPLE, 1), 1);
+        this.ingredients.put(GenericDrink.WATER_BOTTLE, 1);
+    }
+
+    @Override
+    public ItemStack getDrink() {
+        ItemStack item = super.getDrink();
+        PotionMeta meta = (PotionMeta) item.getItemMeta();
+
+        meta.setColor(org.bukkit.Color.fromRGB(255, 255, 0));
+        meta.setMaxStackSize(16);
+        FoodComponent food = meta.getFood();
+        food.setNutrition(6);
+        food.setSaturation(6);
+        food.setCanAlwaysEat(true);
+        meta.setFood(food);
+
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    @Override
+    public void registerRecipes() {}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/main/java/dev/zxq5/fantasysmp/items/food/GenericDrink.java

@@ -0,0 +1,67 @@
+package dev.zxq5.fantasysmp.items.food;
+
+import dev.zxq5.fantasysmp.items.HasRecipes;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.plugin.Plugin;
+
+import java.util.*;
+
+public abstract class GenericDrink implements Listener, CommandExecutor, HasRecipes {
+    protected static ItemStack WATER_BOTTLE = new ItemStack(Material.GLASS_BOTTLE, 1);
+    protected HashMap<ItemStack, Integer> ingredients = new HashMap<>();
+
+    protected String name;
+    protected String lore;
+
+    public void registerEvents(Plugin plugin) {
+        Bukkit.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler
+    public void itemCraftingHandler(org.bukkit.event.inventory.PrepareItemCraftEvent event) {
+        ItemStack item = getDrink();
+        int sum = ingredients
+                .values()
+                .stream()
+                .mapToInt(Integer::intValue)
+                .sum();
+
+        long count = Arrays
+                .stream(event.getInventory().getMatrix())
+                .filter(Objects::nonNull)
+                .mapToInt(ItemStack::getAmount)
+                .sum();
+
+        if (sum != count) return;
+        for (ItemStack ingredient : ingredients.keySet()) {
+            if (!event.getInventory().containsAtLeast(ingredient, ingredients.get(ingredient))) return;
+        }
+        event.getInventory().setResult(item);
+    }
+
+    @Override
+    public abstract boolean onCommand(org.bukkit.command.CommandSender csender, org.bukkit.command.Command command, String label, String[] args);
+
+    public abstract void registerRecipes();
+
+    public ItemStack getDrink() {
+        ItemStack item = new ItemStack(Material.POTION, 1);
+
+        PotionMeta pm = (PotionMeta) item.getItemMeta();
+        pm.setBasePotionType(org.bukkit.potion.PotionType.WATER);
+
+        List<String> lore = new ArrayList<>();
+        lore.add(this.lore);
+        pm.setLore(lore);
+        pm.setDisplayName(this.name);
+        item.setItemMeta(pm);
+        return item;
+    }
+
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/BlazingGear.java

@@ -0,0 +1,184 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import static org.bukkit.Bukkit.*;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import dev.zxq5.fantasysmp.util.LoreChecker;
+import java.util.ArrayList;
+import java.util.List;
+import org.bukkit.*;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.damage.DamageType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.SmallFireball;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+public class BlazingGear extends GenericGearSet implements CommandExecutor {
+
+    private ArrayList<Player> cooldown = new ArrayList<>();
+
+    private final ArrayList<DamageType> damageTypes = new ArrayList<>(
+        List.of(
+            DamageType.HOT_FLOOR,
+            DamageType.ON_FIRE,
+            DamageType.IN_FIRE,
+            DamageType.LAVA
+        )
+    );
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+        player.getInventory().addItem(this.getSword());
+        player.getInventory().addItem(this.getHelmet());
+        player.getInventory().addItem(this.getChestplate());
+        player.getInventory().addItem(this.getLeggings());
+        player.getInventory().addItem(this.getBoots());
+
+        return true;
+    }
+
+    @Override
+    public void registerRecipes() {}
+
+    @EventHandler
+    public void onPlayerSetOnFire(
+        org.bukkit.event.entity.EntityDamageEvent event
+    ) {
+        if (!(event.getEntity() instanceof Player player)) return;
+
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getHelmet(),
+                    this.helmet.lore
+                ))
+        ) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getChestplate(),
+                    this.chestplate.lore
+                ))
+        ) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getLeggings(),
+                    this.leggings.lore
+                ))
+        ) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getBoots(),
+                    this.boots.lore
+                ))
+        ) return;
+
+        if (
+            damageTypes.contains(event.getDamageSource().getDamageType())
+        ) event.setCancelled(true);
+
+        player.setFireTicks(0);
+    }
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        ItemStack item = event.getItem(); // Get the item the player interacted with
+
+        if (
+            !(event.getAction() == Action.RIGHT_CLICK_AIR ||
+                event.getAction() == Action.RIGHT_CLICK_BLOCK)
+        ) {
+            return;
+        }
+
+        if (!(LoreChecker.itemLoreContains(item, this.sword.lore))) return;
+        if (cooldown.contains(player)) return;
+
+        Plugin plugin = getPluginManager().getPlugin("fantasysmp");
+
+        cooldown.add(player);
+        Bukkit.getScheduler().runTaskLater(
+            plugin,
+            () -> cooldown.remove(player),
+            25
+        );
+
+        shootFireball(player);
+        Bukkit.getScheduler().runTaskLater(
+            plugin,
+            () -> shootFireball(player),
+            4
+        );
+        Bukkit.getScheduler().runTaskLater(
+            plugin,
+            () -> shootFireball(player),
+            8
+        );
+    }
+
+    @EventHandler
+    public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Player player)) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInMainHand(),
+                    this.sword.lore
+                ))
+        ) return;
+        if (event.getEntity().getFireTicks() < 240) event
+            .getEntity()
+            .setFireTicks(240);
+    }
+
+    public void shootFireball(Player player) {
+        Location location = player.getLocation();
+        World world = player.getWorld();
+        player.launchProjectile(SmallFireball.class);
+        player.playSound(location, Sound.ENTITY_BLAZE_SHOOT, 1.0f, 1.0f);
+        world.spawnParticle(Particle.FLAME, location, 1);
+    }
+
+    public static void init() {}
+
+    public BlazingGear() {
+        this.setTier4();
+        this.sword.name = ChatColor.GOLD + "Blazing Sword" + ChatColor.RESET;
+        this.sword.customItemModel = "blazing_sword";
+
+        this.helmet.name = ChatColor.GOLD + "Blazing Helmet" + ChatColor.RESET;
+        this.helmet.customItemModel = "blazing_helmet";
+        this.helmet.customEquipmentModel = "blazing";
+
+        this.chestplate.name =
+            ChatColor.GOLD + "Blazing Chestplate" + ChatColor.RESET;
+        this.chestplate.customItemModel = "blazing_chestplate";
+        this.chestplate.customEquipmentModel = "blazing";
+
+        this.leggings.name =
+            ChatColor.GOLD + "Blazing Leggings" + ChatColor.RESET;
+        this.leggings.customItemModel = "blazing_leggings";
+        this.leggings.customEquipmentModel = "blazing";
+
+        this.boots.name = ChatColor.GOLD + "Blazing Boots" + ChatColor.RESET;
+        this.boots.customItemModel = "blazing_boots";
+        this.boots.customEquipmentModel = "blazing";
+
+        this.sword.lore = "Forged from molten lava and the essence of blazes";
+        this.helmet.lore = "Forged from molten lava and the essence of blazes";
+        this.chestplate.lore =
+            "Forged from molten lava and the essence of blazes";
+        this.leggings.lore =
+            "Forged from molten lava and the essence of blazes";
+        this.boots.lore = "Forged from molten lava and the essence of blazes";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/CrimsonGear.java

@@ -0,0 +1,112 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import dev.zxq5.fantasysmp.util.LoreChecker;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+
+public class CrimsonGear extends GenericGearSet implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+
+        player.getInventory().addItem(this.getSword());
+        player.getInventory().addItem(this.getHelmet());
+        player.getInventory().addItem(this.getChestplate());
+        player.getInventory().addItem(this.getLeggings());
+        player.getInventory().addItem(this.getBoots());
+        return true;
+    }
+
+    @EventHandler
+    public void onEntityDamageByEntity(
+        org.bukkit.event.entity.EntityDamageByEntityEvent event
+    ) {
+        if (!(event.getDamager() instanceof Player player)) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInMainHand(),
+                    this.sword.lore
+                ))
+        ) return;
+
+        player.setHealth(
+            Math.min(player.getHealth() + 1, player.getMaxHealth())
+        );
+
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getHelmet(),
+                    this.helmet.lore
+                ))
+        ) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getChestplate(),
+                    this.chestplate.lore
+                ))
+        ) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getLeggings(),
+                    this.leggings.lore
+                ))
+        ) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getBoots(),
+                    this.boots.lore
+                ))
+        ) return;
+
+        player.setHealth(
+            Math.min(player.getHealth() + 1, player.getMaxHealth())
+        );
+        player.setFoodLevel(Math.min(player.getFoodLevel() + 1, 20));
+    }
+
+    @Override
+    public void registerRecipes() {}
+
+    public CrimsonGear() {
+        this.setTier5();
+        this.sword.name = ChatColor.DARK_RED + "Bloodlust" + ChatColor.RESET;
+        this.sword.customItemModel = "crimson_sword";
+        this.sword.lore = "Live off the blood of your enemies.";
+
+        this.helmet.name =
+            ChatColor.DARK_RED + "Crimson Helmet" + ChatColor.RESET;
+        this.helmet.customItemModel = "crimson_helmet";
+        this.helmet.customEquipmentModel = "crimson";
+        this.helmet.lore = "A helmet that grants its wearer vampiric senses.";
+
+        this.chestplate.name =
+            ChatColor.DARK_RED + "Crimson Chestplate" + ChatColor.RESET;
+        this.chestplate.customItemModel = "crimson_chestplate";
+        this.chestplate.customEquipmentModel = "crimson";
+        this.chestplate.lore =
+            "A chestplate that strengthens the heart of the wearer.";
+
+        this.leggings.name =
+            ChatColor.DARK_RED + "Crimson Leggings" + ChatColor.RESET;
+        this.leggings.customItemModel = "crimson_leggings";
+        this.leggings.customEquipmentModel = "crimson";
+        this.leggings.lore =
+            "Leggings that enhance the wearer's speed and agility.";
+
+        this.boots.name =
+            ChatColor.DARK_RED + "Crimson Boots" + ChatColor.RESET;
+        this.boots.customItemModel = "crimson_boots";
+        this.boots.customEquipmentModel = "crimson";
+        this.boots.lore =
+            "Boots that allow the wearer to move silently and swiftly.";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/DragonGear.java

@@ -0,0 +1,221 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import static org.bukkit.Bukkit.broadcastMessage;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import dev.zxq5.fantasysmp.util.LoreChecker;
+import java.util.ArrayList;
+import java.util.Objects;
+import org.bukkit.*;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.damage.DamageType;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.*;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.util.Vector;
+
+public class DragonGear extends GenericGearSet implements CommandExecutor {
+
+    private ArrayList<Player> cooldown = new ArrayList<>();
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+        player.getInventory().addItem(this.getSword());
+        player.getInventory().addItem(this.getHelmet());
+        player.getInventory().addItem(this.getChestplate());
+        player.getInventory().addItem(this.getLeggings());
+        player.getInventory().addItem(this.getBoots());
+
+        return true;
+    }
+
+    @Override
+    public void registerRecipes() {}
+
+    @EventHandler
+    public void onEntityPotionEffectEvent(
+        org.bukkit.event.entity.EntityPotionEffectEvent event
+    ) {
+        if (event.getEntity() instanceof Player player) {
+            if (event.getNewEffect() == null) return;
+
+            if (event.getNewEffect().getType() != PotionEffectType.LEVITATION) {
+                return;
+            }
+
+            try {
+                if (
+                    LoreChecker.itemLoreContains(
+                        player.getInventory().getHelmet(),
+                        this.helmet.lore
+                    ) &&
+                    LoreChecker.itemLoreContains(
+                        player.getInventory().getChestplate(),
+                        this.chestplate.lore
+                    ) &&
+                    LoreChecker.itemLoreContains(
+                        player.getInventory().getLeggings(),
+                        this.leggings.lore
+                    ) &&
+                    LoreChecker.itemLoreContains(
+                        player.getInventory().getBoots(),
+                        this.boots.lore
+                    )
+                ) {
+                    event.setCancelled(true);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @EventHandler
+    public void onEntityDamage(
+        org.bukkit.event.entity.EntityDamageEvent event
+    ) {
+        // check if fall damage
+        if (!(event.getEntity() instanceof Player player)) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getHelmet(),
+                    this.helmet.lore
+                ) &&
+                LoreChecker.itemLoreContains(
+                    player.getInventory().getChestplate(),
+                    this.chestplate.lore
+                ) &&
+                LoreChecker.itemLoreContains(
+                    player.getInventory().getLeggings(),
+                    this.leggings.lore
+                ) &&
+                LoreChecker.itemLoreContains(
+                    player.getInventory().getBoots(),
+                    this.boots.lore
+                ))
+        ) return;
+        if (
+            !(event.getDamageSource().getDamageType() ==
+                DamageType.FLY_INTO_WALL)
+        ) return;
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onEntityDamageByEntity(
+        org.bukkit.event.entity.EntityDamageByEntityEvent event
+    ) {
+        if (!(event.getDamager() instanceof Player player)) return;
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInMainHand(),
+                    this.sword.lore
+                ))
+        ) return;
+        if (!(player.isFlying() || player.isGliding())) return;
+
+        double baseDamage = event.getDamage();
+        double newDamage =
+            baseDamage *
+            Math.min(Math.max(player.getVelocity().length(), 1.0), 2.0);
+
+        broadcastMessage("damage " + baseDamage);
+        broadcastMessage("velocity " + player.getVelocity().length());
+        broadcastMessage("new damage " + newDamage);
+
+        event.setDamage(newDamage);
+    }
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        ItemStack item = event.getItem(); // Get the item the player interacted with
+
+        if (
+            !(event.getAction() == Action.RIGHT_CLICK_AIR ||
+                event.getAction() == Action.RIGHT_CLICK_BLOCK)
+        ) {
+            return;
+        }
+
+        if (!(LoreChecker.itemLoreContains(item, this.sword.lore))) return;
+        if (cooldown.contains(player)) return;
+
+        Location location = player.getLocation();
+        Vector direction = location.getDirection();
+
+        player.setVelocity(direction.multiply(2.0));
+        player.playSound(location, Sound.ENTITY_ENDER_DRAGON_FLAP, 1.0f, 1.0f);
+        World world = player.getWorld();
+        world.spawnParticle(Particle.DRAGON_BREATH, location, 100);
+
+        cooldown.add(player);
+        Bukkit.getScheduler().scheduleSyncDelayedTask(
+            Objects.requireNonNull(
+                Bukkit.getPluginManager().getPlugin("fantasysmp")
+            ),
+            () -> cooldown.remove(player),
+            25
+        );
+    }
+
+    @Override
+    public ItemStack getHelmet() {
+        //        helmet.setMaterial(Material.DRAGON_HEAD);
+        return super.getHelmet();
+    }
+
+    @Override
+    public ItemStack getChestplate() {
+        chestplate.setMaterial(Material.ELYTRA);
+        ItemStack item = super.getChestplate();
+        item.addUnsafeEnchantment(Enchantment.PROTECTION, 4);
+        return item;
+    }
+
+    public static void init() {}
+
+    public DragonGear() {
+        this.setTier5();
+        this.sword.name =
+            ChatColor.DARK_PURPLE + "Dragon Sword" + ChatColor.RESET;
+        this.sword.customItemModel = "dragon_sword";
+
+        this.helmet.name =
+            ChatColor.DARK_PURPLE + "Dragon Helmet" + ChatColor.RESET;
+        this.helmet.customItemModel = "dragon_helmet";
+        this.helmet.customEquipmentModel = "dragon";
+
+        this.chestplate.name =
+            ChatColor.DARK_PURPLE + "Dragon Chestplate" + ChatColor.RESET;
+        this.chestplate.customItemModel = "dragon_chestplate";
+        this.chestplate.customEquipmentModel = "dragon";
+
+        this.leggings.name =
+            ChatColor.DARK_PURPLE + "Dragon Leggings" + ChatColor.RESET;
+        this.leggings.customItemModel = "dragon_leggings";
+        this.leggings.customEquipmentModel = "dragon";
+
+        this.boots.name =
+            ChatColor.DARK_PURPLE + "Dragon Boots" + ChatColor.RESET;
+        this.boots.customItemModel = "dragon_boots";
+        this.boots.customEquipmentModel = "dragon";
+
+        this.sword.lore = "A blade forged from dragon scales and chorus fruit";
+        this.helmet.lore = "Forged from dragon scales and chorus fruit";
+        this.chestplate.lore = "Forged from dragon scales and chorus fruit";
+        this.leggings.lore = "Forged from dragon scales and chorus fruit";
+        this.boots.lore = "Forged from dragon scales and chorus fruit";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/EnderGear.java

@@ -0,0 +1,141 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import dev.zxq5.fantasysmp.util.LoreChecker;
+import java.util.ArrayList;
+import java.util.Objects;
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.*;
+import org.bukkit.util.Vector;
+
+public class EnderGear extends GenericGearSet implements CommandExecutor {
+
+    private ArrayList<Player> cooldown = new ArrayList<>();
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+        player.getInventory().addItem(this.getSword());
+        player.getInventory().addItem(this.getHelmet());
+        player.getInventory().addItem(this.getChestplate());
+        player.getInventory().addItem(this.getLeggings());
+        player.getInventory().addItem(this.getBoots());
+
+        return true;
+    }
+
+    @Override
+    public void registerRecipes() {}
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        ItemStack item = event.getItem(); // Get the item the player interacted with
+
+        if (
+            !(event.getAction() == Action.RIGHT_CLICK_AIR ||
+                event.getAction() == Action.RIGHT_CLICK_BLOCK)
+        ) {
+            return;
+        }
+
+        if (!(LoreChecker.itemLoreContains(item, this.sword.lore))) return;
+        if (cooldown.contains(player)) return;
+
+        Location old_location = player.getLocation();
+        World world = player.getWorld();
+        // find nearest block in that direction
+
+        Block block = player.getTargetBlock(null, 64);
+
+        if (
+            block.getType() == Material.AIR ||
+            block.getType() == Material.CAVE_AIR
+        ) {
+            return;
+        }
+
+        player.playSound(
+            old_location,
+            Sound.ENTITY_ENDERMAN_TELEPORT,
+            1.0f,
+            1.0f
+        );
+        world.spawnParticle(Particle.PORTAL, old_location, 100);
+
+        Location new_location = block.getLocation();
+        new_location.setPitch(old_location.getPitch());
+        new_location.setYaw(old_location.getYaw());
+        player.setVelocity(
+            new Vector(
+                player.getVelocity().getX(),
+                0,
+                player.getVelocity().getZ()
+            )
+        );
+        player.teleport(new_location);
+
+        player.playSound(
+            new_location,
+            Sound.ENTITY_ENDERMAN_TELEPORT,
+            1.0f,
+            1.0f
+        );
+        world.spawnParticle(Particle.PORTAL, new_location, 100);
+
+        cooldown.add(player);
+        Bukkit.getScheduler().scheduleSyncDelayedTask(
+            Objects.requireNonNull(
+                Bukkit.getPluginManager().getPlugin("fantasysmp")
+            ),
+            () -> cooldown.remove(player),
+            25
+        );
+    }
+
+    public static void init() {}
+
+    public EnderGear() {
+        this.setTier4();
+        this.sword.name = ChatColor.DARK_AQUA + "Ender Sword" + ChatColor.RESET;
+        this.sword.customItemModel = "ender_sword";
+
+        this.helmet.name =
+            ChatColor.DARK_AQUA + "Ender Helmet" + ChatColor.RESET;
+        this.helmet.customItemModel = "ender_helmet";
+        this.helmet.customEquipmentModel = "ender";
+
+        this.chestplate.name =
+            ChatColor.DARK_AQUA + "Ender Chestplate" + ChatColor.RESET;
+        this.chestplate.customItemModel = "ender_chestplate";
+        this.chestplate.customEquipmentModel = "ender";
+
+        this.leggings.name =
+            ChatColor.DARK_AQUA + "Ender Leggings" + ChatColor.RESET;
+        this.leggings.customItemModel = "ender_leggings";
+        this.leggings.customEquipmentModel = "ender";
+
+        this.boots.name = ChatColor.DARK_AQUA + "Ender Boots" + ChatColor.RESET;
+        this.boots.customItemModel = "ender_boots";
+        this.boots.customEquipmentModel = "ender";
+
+        this.sword.lore = "A sword forged from the essence of ender pearls,";
+        this.helmet.lore = "A helmet forged from the essence of ender pearls,";
+        this.chestplate.lore =
+            "A chestplate forged from the essence of ender pearls,";
+        this.leggings.lore =
+            "Leggings forged from the essence of ender pearls,";
+        this.boots.lore = "Boots forged from the essence of ender pearls,";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/LightningSword.java

@@ -0,0 +1,142 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import static org.bukkit.Bukkit.getServer;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import dev.zxq5.fantasysmp.util.LoreChecker;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.World;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.entity.*;
+import org.bukkit.event.EventHandler;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.potion.PotionEffectType;
+
+public class LightningSword extends GenericGearSet implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+        player.getInventory().addItem(this.getSword());
+        return true;
+    }
+
+    @Override
+    public void registerRecipes() {
+        ItemStack sword = this.getSword();
+        NamespacedKey swordKey = new NamespacedKey(
+            "fantasysmp.items",
+            "lightning_sword"
+        );
+        ShapedRecipe swordRecipe = new ShapedRecipe(swordKey, sword);
+        swordRecipe.shape(" N ", " N ", " R ");
+        swordRecipe.setIngredient('N', Material.NETHER_STAR);
+        swordRecipe.setIngredient('R', Material.LIGHTNING_ROD);
+        getServer().addRecipe(swordRecipe);
+    }
+
+    @EventHandler
+    public void onEntityDamageByEntity(
+        org.bukkit.event.entity.EntityDamageByEntityEvent event
+    ) {
+        // checks that it is a player that is performing the attack.
+        if (!(event.getDamager() instanceof org.bukkit.entity.Player player)) {
+            return;
+        }
+
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInMainHand(),
+                    this.sword.lore
+                ))
+        ) return;
+
+        if (
+            player.isOnGround() ||
+            player.getVelocity().getY() >= 0 ||
+            player.isClimbing() ||
+            player.isInWater() ||
+            player.isInsideVehicle() ||
+            player.hasPotionEffect(PotionEffectType.BLINDNESS)
+        ) return;
+
+        Location location = event.getEntity().getLocation();
+        World world = location.getWorld();
+
+        if (world == null) return;
+
+        world.strikeLightning(location);
+    }
+
+    @EventHandler
+    public void onEntityDamage(
+        org.bukkit.event.entity.EntityDamageEvent event
+    ) {
+        if (event.getEntity() instanceof Player player) {
+            if (
+                !(event
+                        .getDamageSource()
+                        .getDamageType()
+                        .getKey()
+                        .toString()
+                        .equals("minecraft:lightning_bolt"))
+            ) return;
+
+            if (
+                LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInMainHand(),
+                    this.sword.lore
+                )
+            ) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    @EventHandler
+    public void onEntityDeath(org.bukkit.event.entity.EntityDeathEvent event) {
+        if (event.getEntity() instanceof Mob) {
+            if (
+                event
+                    .getDamageSource()
+                    .getDamageType()
+                    .getKey()
+                    .toString()
+                    .equals("minecraft:lightning_bolt") ||
+                event
+                    .getDamageSource()
+                    .getDamageType()
+                    .getKey()
+                    .toString()
+                    .equals("minecraft:on_fire")
+            ) {
+                Entity e = event.getEntity();
+                ((ExperienceOrb) e
+                        .getLocation()
+                        .getWorld()
+                        .spawn(
+                            e.getLocation(),
+                            ExperienceOrb.class
+                        )).setExperience(10);
+            }
+        }
+    }
+
+    public static void init() {}
+
+    public LightningSword() {
+        this.setTier5();
+        this.sword.name = "Lightning Sword";
+        this.sword.customItemModel = "lightning_sword";
+        this.sword.lore = "All who oppose shall be smitten.";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/PoseidonGear.java

@@ -0,0 +1,109 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import static org.bukkit.Bukkit.getPluginManager;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class PoseidonGear extends GenericGearSet implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+
+        player.getInventory().addItem(this.getTrident());
+        player.getInventory().addItem(this.getHelmet());
+        player.getInventory().addItem(this.getChestplate());
+        player.getInventory().addItem(this.getLeggings());
+        player.getInventory().addItem(this.getBoots());
+        return true;
+    }
+
+    public ItemStack getTrident() {
+        ItemStack item = super.getSword();
+        item.addUnsafeEnchantment(Enchantment.RIPTIDE, 5);
+        return item;
+    }
+
+    public ItemStack getHelmet() {
+        ItemStack item = super.getHelmet();
+        item.addUnsafeEnchantment(Enchantment.AQUA_AFFINITY, 3);
+        return item;
+    }
+
+    public ItemStack getBoots() {
+        ItemStack item = super.getBoots();
+        item.addUnsafeEnchantment(Enchantment.DEPTH_STRIDER, 5);
+        return item;
+    }
+
+    @Override
+    public void registerRecipes() {
+        Bukkit.getScheduler().scheduleSyncRepeatingTask(
+            getPluginManager().getPlugin("fantasysmp"),
+            this::checkPlayerAir,
+            0,
+            20
+        );
+    }
+
+    public void checkPlayerAir() {
+        // any players wearing the armour will never run out of breath
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            if (this.hasGear(player)) {
+                if (player.getRemainingAir() < player.getMaximumAir()) {
+                    player.setRemainingAir(player.getMaximumAir());
+                }
+            }
+        }
+    }
+
+    public PoseidonGear() {
+        this.setTier5();
+        this.sword.setMaterial(Material.TRIDENT);
+        this.sword.attackDamage = 10;
+        this.sword.attackSpeed = 1.2f;
+        this.sword.name = ChatColor.AQUA + "Poseidon's Fury" + ChatColor.RESET;
+        this.sword.lore =
+            "A powerful trident imbued with the power of the ocean.";
+        this.sword.customItemModel = "poseidons_trident";
+
+        this.helmet.name =
+            ChatColor.AQUA + "Poseidon's Crown" + ChatColor.RESET;
+        this.helmet.lore =
+            "A helmet granted to those who harness the power of the ocean.";
+        this.helmet.customItemModel = "poseidons_helmet";
+        this.helmet.customEquipmentModel = "poseidon";
+
+        this.chestplate.name =
+            ChatColor.AQUA + "Poseidon's Chestplate" + ChatColor.RESET;
+        this.chestplate.lore =
+            "A chestplate granted to those who harness the power of the ocean.";
+        this.chestplate.customItemModel = "poseidons_chestplate";
+        this.chestplate.customEquipmentModel = "poseidon";
+
+        this.leggings.name =
+            ChatColor.AQUA + "Poseidon's Leggings" + ChatColor.RESET;
+        this.leggings.lore =
+            "Leggings granted to those who harness the power of the ocean.";
+        this.leggings.customItemModel = "poseidons_leggings";
+        this.leggings.customEquipmentModel = "poseidon";
+
+        this.boots.name = ChatColor.AQUA + "Poseidon's Boots" + ChatColor.RESET;
+        this.boots.lore =
+            "Boots granted to those who harness the power of the ocean.";
+        this.boots.customItemModel = "poseidons_boots";
+        this.boots.customEquipmentModel = "poseidon";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/StevensWrath.java

@@ -0,0 +1,106 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import dev.zxq5.fantasysmp.util.LoreChecker;
+import org.bukkit.*;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+
+public class StevensWrath extends GenericGearSet implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+        player.getInventory().addItem(this.getSword());
+        return true;
+    }
+
+    @EventHandler
+    public void onCraft(
+        org.bukkit.event.inventory.PrepareItemCraftEvent event
+    ) {
+        if (!event.getInventory().contains(Material.NETHERITE_BLOCK)) return;
+        if (
+            !event.getInventory().contains(new LightningSword().getSword())
+        ) return;
+        event.getInventory().setResult(new StevensWrath().getSword());
+    }
+
+    @Override
+    public void registerRecipes() {}
+
+    @EventHandler
+    public void onEntityDamageByEntity(
+        org.bukkit.event.entity.EntityDamageByEntityEvent event
+    ) {
+        // checks that it is a player that is performing the attack.
+        if (!(event.getDamager() instanceof org.bukkit.entity.Player player)) {
+            return;
+        }
+
+        if (
+            !(LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInMainHand(),
+                    this.sword.lore
+                ) ||
+                LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInOffHand(),
+                    this.sword.lore
+                ))
+        ) return;
+
+        Location location = event.getEntity().getLocation();
+        World world = location.getWorld();
+
+        if (world == null) return;
+
+        world.strikeLightning(location);
+    }
+
+    @EventHandler
+    public void onEntityDamage(
+        org.bukkit.event.entity.EntityDamageEvent event
+    ) {
+        if (event.getEntity() instanceof Player player) {
+            if (
+                !(event
+                        .getDamageSource()
+                        .getDamageType()
+                        .getKey()
+                        .toString()
+                        .equals("minecraft:lightning_bolt"))
+            ) return;
+
+            if (
+                LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInMainHand(),
+                    this.sword.lore
+                ) ||
+                LoreChecker.itemLoreContains(
+                    player.getInventory().getItemInOffHand(),
+                    this.sword.lore
+                )
+            ) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    public static void init() {}
+
+    public StevensWrath() {
+        this.setTier6();
+        this.sword.name =
+            ChatColor.LIGHT_PURPLE + "Stevens Wrath" + ChatColor.RESET;
+        this.sword.customItemModel = "stevens_wrath";
+        this.sword.lore =
+            ChatColor.LIGHT_PURPLE +
+            "All who oppose the mighty Steven shall face his wrath of lightning.";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/TrueNetheriteGear.java

@@ -0,0 +1,67 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.entity.Player;
+
+public class TrueNetheriteGear
+    extends GenericGearSet
+    implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+
+        player.getInventory().addItem(this.getSword());
+        player.getInventory().addItem(this.getHelmet());
+        player.getInventory().addItem(this.getChestplate());
+        player.getInventory().addItem(this.getLeggings());
+        player.getInventory().addItem(this.getBoots());
+        return true;
+    }
+
+    @Override
+    public void registerRecipes() {}
+
+    public TrueNetheriteGear() {
+        this.setTier6();
+        this.sword.name =
+            ChatColor.WHITE + "True Netherite Sword" + ChatColor.RESET;
+        this.sword.lore = "A sword forged with the skulls of wither skeletons.";
+        this.sword.customItemModel = "true_netherite_sword";
+        this.sword.lore = "Destruction awaits.";
+
+        this.helmet.name =
+            ChatColor.WHITE + "True Netherite Helmet" + ChatColor.RESET;
+        this.helmet.lore =
+            "A helmet forged with the skulls of wither skeletons.";
+        this.helmet.customItemModel = "true_netherite_helmet";
+        this.helmet.customEquipmentModel = "true_netherite";
+
+        this.chestplate.name =
+            ChatColor.WHITE + "True Netherite Chestplate" + ChatColor.RESET;
+        this.chestplate.lore =
+            "A chestplate forged with the skulls of wither skeletons.";
+        this.chestplate.customItemModel = "true_netherite_chestplate";
+        this.chestplate.customEquipmentModel = "true_netherite";
+
+        this.leggings.name =
+            ChatColor.WHITE + "True Netherite Leggings" + ChatColor.RESET;
+        this.leggings.lore =
+            "Leggings forged with the skulls of wither skeletons.";
+        this.leggings.customItemModel = "true_netherite_leggings";
+        this.leggings.customEquipmentModel = "true_netherite";
+
+        this.boots.name =
+            ChatColor.WHITE + "True Netherite Boots" + ChatColor.RESET;
+        this.boots.lore = "Boots forged with the skulls of wither skeletons.";
+        this.boots.customItemModel = "true_netherite_boots";
+        this.boots.customEquipmentModel = "true_netherite";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/items/gear/WitheriteGear.java

@@ -0,0 +1,263 @@
+package dev.zxq5.fantasysmp.items.gear;
+
+import static org.bukkit.Bukkit.getServer;
+
+import dev.zxq5.fantasysmp.items.GenericGearSet;
+import dev.zxq5.fantasysmp.util.LoreChecker;
+import java.util.ArrayList;
+import java.util.Objects;
+import org.bukkit.*;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.WitherSkull;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.RecipeChoice;
+import org.bukkit.inventory.SmithingTransformRecipe;
+import org.bukkit.potion.PotionEffect;
+
+public class WitheriteGear extends GenericGearSet implements CommandExecutor {
+
+    private ArrayList<Player> cooldown = new ArrayList<>();
+
+    @Override
+    public boolean onCommand(
+        org.bukkit.command.CommandSender sender,
+        org.bukkit.command.Command command,
+        String label,
+        String[] args
+    ) {
+        Player player = (Player) sender;
+        player.getInventory().addItem(this.getSword());
+        player.getInventory().addItem(this.getHelmet());
+        player.getInventory().addItem(this.getChestplate());
+        player.getInventory().addItem(this.getLeggings());
+        player.getInventory().addItem(this.getBoots());
+
+        return true;
+    }
+
+    @Override
+    public void registerRecipes() {
+        ItemStack sword = this.getSword();
+        NamespacedKey swordKey = new NamespacedKey(
+            "fantasysmp.items",
+            "witherite_sword"
+        );
+        RecipeChoice swordChoice = new RecipeChoice.MaterialChoice(
+            Material.NETHERITE_SWORD
+        );
+        SmithingTransformRecipe swordRecipe = new SmithingTransformRecipe(
+            swordKey,
+            sword,
+            NETHERITE_UPGRADE,
+            swordChoice,
+            WITHER_SKULL
+        );
+        getServer().addRecipe(swordRecipe);
+
+        ItemStack helmet = this.getHelmet();
+        NamespacedKey helmetKey = new NamespacedKey(
+            "fantasysmp.items",
+            "witherite_helmet"
+        );
+        RecipeChoice helmetChoice = new RecipeChoice.MaterialChoice(
+            Material.NETHERITE_HELMET
+        );
+        SmithingTransformRecipe helmetRecipe = new SmithingTransformRecipe(
+            helmetKey,
+            helmet,
+            NETHERITE_UPGRADE,
+            helmetChoice,
+            WITHER_SKULL
+        );
+        getServer().addRecipe(helmetRecipe);
+
+        ItemStack chestplate = this.getChestplate();
+        NamespacedKey chestplateKey = new NamespacedKey(
+            "fantasysmp.items",
+            "witherite_chestplate"
+        );
+        RecipeChoice chestplateChoice = new RecipeChoice.MaterialChoice(
+            Material.NETHERITE_CHESTPLATE
+        );
+        SmithingTransformRecipe chestplateRecipe = new SmithingTransformRecipe(
+            chestplateKey,
+            chestplate,
+            NETHERITE_UPGRADE,
+            chestplateChoice,
+            WITHER_SKULL
+        );
+        getServer().addRecipe(chestplateRecipe);
+
+        ItemStack leggings = this.getLeggings();
+        NamespacedKey leggingsKey = new NamespacedKey(
+            "fantasysmp.items",
+            "witherite_leggings"
+        );
+        RecipeChoice leggingsChoice = new RecipeChoice.MaterialChoice(
+            Material.NETHERITE_LEGGINGS
+        );
+        SmithingTransformRecipe leggingsRecipe = new SmithingTransformRecipe(
+            leggingsKey,
+            leggings,
+            NETHERITE_UPGRADE,
+            leggingsChoice,
+            WITHER_SKULL
+        );
+        getServer().addRecipe(leggingsRecipe);
+
+        ItemStack boots = this.getBoots();
+        NamespacedKey bootsKey = new NamespacedKey(
+            "fantasysmp.items",
+            "witherite_boots"
+        );
+        RecipeChoice bootsChoice = new RecipeChoice.MaterialChoice(
+            Material.NETHERITE_BOOTS
+        );
+        SmithingTransformRecipe bootsRecipe = new SmithingTransformRecipe(
+            bootsKey,
+            boots,
+            NETHERITE_UPGRADE,
+            bootsChoice,
+            WITHER_SKULL
+        );
+        getServer().addRecipe(bootsRecipe);
+    }
+
+    @EventHandler
+    public void onEntityDamageByEntity(
+        org.bukkit.event.entity.EntityDamageByEntityEvent event
+    ) {
+        // checks that it is a player that is performing the attack.
+        if (!(event.getDamager() instanceof org.bukkit.entity.Player player)) {
+            return;
+        }
+
+        if (
+            !LoreChecker.itemLoreContains(
+                player.getInventory().getItemInMainHand(),
+                this.sword.lore
+            )
+        ) {
+            return;
+        }
+
+        PotionEffect effect = new PotionEffect(
+            org.bukkit.potion.PotionEffectType.WITHER,
+            20 * 5,
+            1
+        );
+        effect.apply((LivingEntity) event.getEntity());
+    }
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        ItemStack item = event.getItem(); // Get the item the player interacted with
+
+        if (
+            !(event.getAction() == Action.RIGHT_CLICK_AIR ||
+                event.getAction() == Action.RIGHT_CLICK_BLOCK)
+        ) {
+            return;
+        }
+
+        if (!(LoreChecker.itemLoreContains(item, this.sword.lore))) return;
+        if (cooldown.contains(player)) return;
+
+        Location location = player.getLocation();
+        player.launchProjectile(WitherSkull.class);
+        player.playSound(location, Sound.ENTITY_WITHER_SHOOT, 1.0f, 1.0f);
+        World world = player.getWorld();
+        world.spawnParticle(Particle.SOUL_FIRE_FLAME, location, 1);
+
+        cooldown.add(player);
+        Bukkit.getScheduler().scheduleSyncDelayedTask(
+            Objects.requireNonNull(
+                Bukkit.getPluginManager().getPlugin("fantasysmp")
+            ),
+            () -> cooldown.remove(player),
+            25
+        );
+    }
+
+    @EventHandler
+    public void onEntityPotionEffectEvent(
+        org.bukkit.event.entity.EntityPotionEffectEvent event
+    ) {
+        if (event.getEntity() instanceof Player player) {
+            if (event.getNewEffect() == null) return;
+
+            if (
+                event.getNewEffect().getType() !=
+                org.bukkit.potion.PotionEffectType.WITHER
+            ) {
+                return;
+            }
+
+            try {
+                if (
+                    LoreChecker.itemLoreContains(
+                        player.getInventory().getHelmet(),
+                        this.helmet.lore
+                    ) &&
+                    LoreChecker.itemLoreContains(
+                        player.getInventory().getChestplate(),
+                        this.chestplate.lore
+                    ) &&
+                    LoreChecker.itemLoreContains(
+                        player.getInventory().getLeggings(),
+                        this.leggings.lore
+                    ) &&
+                    LoreChecker.itemLoreContains(
+                        player.getInventory().getBoots(),
+                        this.boots.lore
+                    )
+                ) {
+                    event.setCancelled(true);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static void init() {}
+
+    public WitheriteGear() {
+        this.setTier5();
+        this.sword.name = ChatColor.BLACK + "Witherite Sword" + ChatColor.RESET;
+        this.sword.lore = "A sword forged with the skulls of wither skeletons.";
+        this.sword.customItemModel = "witherite_sword";
+
+        this.helmet.name =
+            ChatColor.BLACK + "Witherite Helmet" + ChatColor.RESET;
+        this.helmet.lore =
+            "A helmet forged with the skulls of wither skeletons.";
+        this.helmet.customItemModel = "witherite_helmet";
+        this.helmet.customEquipmentModel = "witherite";
+
+        this.chestplate.name =
+            ChatColor.BLACK + "Witherite Chestplate" + ChatColor.RESET;
+        this.chestplate.lore =
+            "A chestplate forged with the skulls of wither skeletons.";
+        this.chestplate.customItemModel = "witherite_chestplate";
+        this.chestplate.customEquipmentModel = "witherite";
+
+        this.leggings.name =
+            ChatColor.BLACK + "Witherite Leggings" + ChatColor.RESET;
+        this.leggings.lore =
+            "Leggings forged with the skulls of wither skeletons.";
+        this.leggings.customItemModel = "witherite_leggings";
+        this.leggings.customEquipmentModel = "witherite";
+
+        this.boots.name = ChatColor.BLACK + "Witherite Boots" + ChatColor.RESET;
+        this.boots.lore = "Boots forged with the skulls of wither skeletons.";
+        this.boots.customItemModel = "witherite_boots";
+        this.boots.customEquipmentModel = "witherite";
+    }
+}

src/main/java/dev/zxq5/fantasysmp/util/LoreChecker.java

@@ -0,0 +1,20 @@
+package dev.zxq5.fantasysmp.util;
+
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.List;
+
+public class LoreChecker {
+    public static boolean itemLoreContains(ItemStack item, String content) {
+        if (item == null) return false;
+
+        ItemMeta meta = item.getItemMeta();
+        if (meta == null) return false;
+
+        List<String> lore = meta.getLore();
+        if (lore == null) return false;
+
+        return lore.toString().contains(content);
+    }
+}

src/main/java/dev/zxq5/fantasysmp/warps/Warp.java

@@ -1,32 +1,37 @@
 package dev.zxq5.fantasysmp.warps;
 
-import com.google.gson.Gson;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.entity.Player;
-
-import java.io.*;
-import java.util.UUID;
-
-import static org.bukkit.Bukkit.broadcastMessage;
 import static org.bukkit.Bukkit.getServer;
 
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import dev.zxq5.fantasysmp.groups.Team;
+import java.io.*;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
 
 public class Warp {
 
+    private static final String FILENAME = "warps.json";
     private static Warp[] warps;
 
     private String name;
     private String setby;
     private String world;
+    private String teamUUID;
     private WarpType type;
     private int x;
     private int y;
     private int z;
 
     public boolean execute(Player player) {
-        Location location = new Location(getServer().getWorld(world), this.x, this.y, this.z);
+        Location location = new Location(
+            getServer().getWorld(world),
+            this.x,
+            this.y,
+            this.z
+        );
         location.setPitch(player.getLocation().getPitch());
         location.setYaw(player.getLocation().getYaw());
         player.teleport(location);
@@ -34,8 +39,11 @@ public class Warp {
     }
 
     public static void loadWarps() throws Exception {
-        File dataFolder = getServer().getPluginManager().getPlugin("Fantasysmp").getDataFolder();
-        File file = new File(dataFolder, "warps.json");
+        File dataFolder = getServer()
+            .getPluginManager()
+            .getPlugin("Fantasysmp")
+            .getDataFolder();
+        File file = new File(dataFolder, FILENAME);
 
         if (!file.exists()) {
             createWarpFile();
@@ -44,17 +52,20 @@ public class Warp {
         BufferedReader reader;
         reader = new BufferedReader(new FileReader(file));
 
-        Gson gson = new Gson();
+        Gson gson = new GsonBuilder().setPrettyPrinting().create();
         warps = gson.fromJson(reader, Warp[].class);
 
         reader.close();
     }
 
     public static void saveWarps() throws Exception {
-        File dataFolder = getServer().getPluginManager().getPlugin("Fantasysmp").getDataFolder();
-        File file = new File(dataFolder, "warps.json");
+        File dataFolder = getServer()
+            .getPluginManager()
+            .getPlugin("Fantasysmp")
+            .getDataFolder();
+        File file = new File(dataFolder, FILENAME);
 
-        Gson gson = new Gson();
+        Gson gson = new GsonBuilder().setPrettyPrinting().create();
         String json = gson.toJson(warps);
         Writer writer = new FileWriter(file);
         writer.write(json);
@@ -62,13 +73,16 @@ public class Warp {
     }
 
     public static void createWarpFile() {
-        File dataFolder = getServer().getPluginManager().getPlugin("Fantasysmp").getDataFolder();
-        File file = new File(dataFolder, "warps.json");
+        File dataFolder = getServer()
+            .getPluginManager()
+            .getPlugin("Fantasysmp")
+            .getDataFolder();
+        File file = new File(dataFolder, FILENAME);
 
         if (!file.exists()) {
             try {
                 Warp[] w = new Warp[0];
-                Gson gson = new Gson();
+                Gson gson = new GsonBuilder().setPrettyPrinting().create();
                 String json = gson.toJson(w);
                 Writer writer = new FileWriter(file);
                 writer.write(json);
@@ -104,6 +118,35 @@ public class Warp {
         return null;
     }
 
+    public static Warp getTeamWarp(Team team, Player player, String name) {
+        for (Warp warp : warps) {
+            if (warp.type.equals(WarpType.TEAM)) {
+                if (
+                    warp.name.equals(name) &&
+                    warp.setby.equals(player.getUniqueId().toString())
+                ) {
+                    return warp;
+                }
+            }
+        }
+        return null;
+    }
+
+    public static String listWarps(UUID player) {
+        String message = ChatColor.WHITE + "All Warps: [\n" + ChatColor.GREEN;
+
+        for (Warp warp : warps) {
+            if (
+                warp.type.equals(WarpType.PUBLIC) ||
+                warp.setby.equals(player.toString())
+            ) {
+                message += "  " + warp.name + "\n";
+            }
+        }
+
+        return message + ChatColor.WHITE + "]";
+    }
+
     public static void setHome(Player player) {
         setWarp("Home (" + player.getName() + ")", player, WarpType.HOME);
     }
@@ -148,23 +191,3 @@ public class Warp {
         }
     }
 }
-
-enum WarpType {
-    HOME,
-    PUBLIC,
-    DEATH,
-    TEAM,
-}
-
-
-
-
-
-
-
-
-
-
-
-
-

src/main/java/dev/zxq5/fantasysmp/warps/WarpType.java

@@ -0,0 +1,8 @@
+package dev.zxq5.fantasysmp.warps;
+
+public enum WarpType {
+    HOME,
+    PUBLIC,
+    DEATH,
+    TEAM,
+}

src/main/java/dev/zxq5/fantasysmp/warps/Warper.java

@@ -1,73 +1,121 @@
 package dev.zxq5.fantasysmp.warps;
 
+import dev.zxq5.fantasysmp.chatutils.Chat;
+import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.entity.Player;
 
+/*
+* Commands:
+*
+*   ** PLAYER **
+*
+*   home                => DONE
+*   sethome             => DONE
+*   warp <name>         => DONE
+*
+*   ** ADMIN ONLY **
+*
+*   rewarps             => DONE
+*   setwarp <name>      => DONE
+*   delwarp <name>      => TODO
+* */
+
 public class Warper implements CommandExecutor {
     @Override
-    public boolean onCommand(org.bukkit.command.CommandSender sender, org.bukkit.command.Command command, String label, String[] args) {
+    public boolean onCommand(org.bukkit.command.CommandSender sender, Command command, String label, String[] args) {
         if (!(sender instanceof Player player)) {
             return false;
         }
 
-        if (command.getName().equals("reloadwarps")) {
-            // reply
-            try {
-                Warp.loadWarps();
-            } catch (Exception e) {
-                player.sendMessage("Failed to reload warps. please contact an admin.");
-                e.printStackTrace();
-            }
+        switch (command.getName()) {
+            case "home" -> this.handleHome(player, args);
+            case "sethome" -> this.handleSetHome(player, args);
+            case "warp" -> this.handleWarp(player, args);
+            case "setwarp" -> this.handleSetWarp(player, args);
+            case "delwarp" -> this.handleDelWarp(player, args);
+            case "rewarps" -> this.handleReWarps(player, args);
+            case "warps" -> this.handleWarpsOther(player, args);
         }
 
-        if (command.getName().equals("home")) {
-            if (args.length != 0) {
-                player.sendMessage("Usage: /home");
-                return true;
-            }
-
-            Warp warp = Warp.getHome(player.getUniqueId());
-
-            if (warp != null) {
-                warp.execute(player);
-            }
-        }
-
-        if (command.getName().equals("sethome")) {
-            if (args.length != 0) {
-                player.sendMessage("Usage: /sethome");
-                return true;
-            }
-
-            Warp.setHome(player);
-        }
-
-        if (command.getName().equals("warp")) {
-            if (args.length != 1) {
-                player.sendMessage("Usage: /warp <name>");
-                return true;
-            }
-
-            Warp warp = Warp.getWarp(args[0]);
-
-            if (warp != null) {
-                warp.execute(player);
-            }
-        }
-
-        if (command.getName().equals("setwarp")) {
-            if (!(player.hasPermission("fantasysmp.manage_warps"))) {
-                player.sendMessage("You do not have permission to use this command.");
-                return false;
-            }
-
-            if (args.length != 1) {
-                player.sendMessage("Usage: /setwarp <name>");
-                return true;
-            }
-
-            Warp.setWarp(args[0], player, WarpType.PUBLIC);
-        }
         return true;
     }
+
+    public void handleHome(Player player, String[] args) {
+        if (args.length != 0) {
+            Chat.error(player,"Usage: /home");
+            return;
+        }
+
+        Warp warp = Warp.getHome(player.getUniqueId());
+
+        if (warp == null) {
+            Chat.error(player,"No home set! use /sethome to set one.");
+            return;
+        }
+
+        warp.execute(player);
+        Chat.success(player,"Warped Home!");
+    }
+
+    public void handleSetHome(Player player, String[] args) {
+        if (args.length != 0) {
+            Chat.error(player,"Usage: /sethome");
+            return;
+        }
+
+        Warp.setHome(player);
+        Chat.success(player,"Home set Successfully!");
+    }
+
+    public void handleWarp(Player player, String[] args) {
+        if (args.length != 1) {
+            Chat.error(player, "Usage: /warp <name>");
+            return;
+        }
+
+        Warp warp = Warp.getWarp(args[0]);
+
+        if (warp == null) {
+            Chat.error(player, "Location [" + args[0] + "] does not exist or is not accessible to you!");
+            return;
+        };
+        warp.execute(player);
+        Chat.success(player, "Warped!");
+    }
+
+    public void handleSetWarp(Player player, String[] args) {
+        if (!(player.hasPermission("fantasysmp.manage_warps"))) {
+            Chat.error(player, "You do not have permission to use this command.");
+            return;
+        }
+
+        if (args.length != 1) {
+            Chat.error(player, "Usage: /setwarp <name>");
+            return;
+        }
+
+        Warp.setWarp(args[0], player, WarpType.PUBLIC);
+        Chat.success(player, "Warp [" + args[0] + "] set Successfully!");
+    }
+
+    public void handleDelWarp(Player player, String[] args) {
+
+    }
+
+    public void handleReWarps(Player player, String[] args) {
+        try {
+            Warp.loadWarps();
+        } catch (Exception e) {
+            Chat.error(player, "Failed to reload warps. please contact zxq5.");
+            e.printStackTrace();
+        }
+        Chat.success(player, "Successfully reloaded warps from warps.json");
+    }
+
+    public void handleWarpsOther(Player player, String[] args) {
+        if (args.length == 0) {
+            Chat.info(player, Warp.listWarps(player.getUniqueId()));
+        }
+    }
 }

src/main/resources/plugin.yml

@@ -9,7 +9,7 @@ website: https://zxq5.dev
 commands:
   items:
     description: create custom items from plugin
-    usage: /items <set name>
+    usage: /items <name>
     permission: fantasysmp.admin
 
   home:
@@ -27,36 +27,60 @@ commands:
     usage: /setwarp <warp name>
     permission: fantasysmp.manage_warps
 
-  reloadwarps:
+  delwarp:
+    description: delete a warp
+    usage: /delwarp <warp name>
+    permission: fantasysmp.manage_warps
+
+  warps:
+    description: list all warps
+    usage: /warps
+    permission: fantasysmp.warps
+
+  rewarps:
     description: reload warps
-    usage: /reloadwarps
-    permission: fantasysmp.admin
+    usage: /rewarps
+    permission: fantasysmp.manage_warps
 
   warp:
     description: teleport to a warp
     usage: /warp <warp name>
     permission: fantasysmp.warps
 
+  team:
+    description: team commands
+    usage: /team <subcommand>
+    permission: fantasysmp.teams
+
 
 permissions:
-  fantasysmp.admin:
-    description: Manage plugin
-    default: op
-    children:
-      fantasysmp.*: true
-
   fantasysmp.items:
     description: create custom items from plugin
     default: false
 
+  fantasysmp.teams:
+    description: team commands
+    default: true
+
   fantasysmp.warps:
     description: teleport to custom warps
     default: true
 
   fantasysmp.manage_warps:
     description: commands for managing warps
-    default: true
+    default: false
 
   fantasysmp.home:
     description: commands for teleporting home
     default: true
+
+  fantasysmp.admin:
+    description: Manage plugin
+    default: op
+    children:
+      fantasysmp.items: true
+      fantasysmp.manage_warps: true
+      fantasysmp.home: true
+      fantasysmp.warps: true
+      fantasysmp.teams: true
+