Removed SpawnPointContext and centralized everything into SpawnPoints directly.

MMOCore-API/src/main/java/net/Indyuce/mmocore/MMOCore.java

@@ -49,6 +49,7 @@ import net.Indyuce.mmocore.script.mechanic.ManaMechanic;
 import net.Indyuce.mmocore.script.mechanic.StaminaMechanic;
 import net.Indyuce.mmocore.script.mechanic.StelliumMechanic;
 import net.Indyuce.mmocore.skill.cast.SkillCastingMode;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
 import org.apache.commons.lang.Validate;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
@@ -80,6 +81,10 @@ public class MMOCore extends JavaPlugin {
     public final MMOLoadManager loadManager = new MMOLoadManager();
     public final RestrictionManager restrictionManager = new RestrictionManager();
     public final SkillTreeManager skillTreeManager = new SkillTreeManager();
+
+    public final SpawnPointManager spawnPointManager = new SpawnPointManager();
+
+    public final PluginMessageManager pluginMessageManager = new PluginMessageManager();
     public final StatManager statManager = new StatManager();
     public final GuildDataManager nativeGuildManager = new YAMLGuildDataManager();
     public final PlayerDataManager playerDataManager = new PlayerDataManager(this);
@@ -181,6 +186,10 @@ public class MMOCore extends JavaPlugin {
             MMOCore.plugin.getLogger().log(Level.INFO, "Hooked onto MythicMobs");
         }
 
+        //Registers plugin message channel to teleport players to other servers.
+        MMOCore.plugin.getServer().getMessenger().registerOutgoingPluginChannel(MMOCore.plugin, "BungeeCord");
+
+
         /*
          * Resource regeneration. Must check if entity is dead otherwise regen
          * will make the 'respawn' button glitched plus HURT entity effect bug
@@ -197,6 +206,21 @@ public class MMOCore extends JavaPlugin {
             }
         }.runTaskTimer(MMOCore.plugin, 100, 20);
 
+
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                for (PlayerData playerData : PlayerData.getAll()) {
+                    for (SpawnPoint spawnPoint : spawnPointManager.getAll()) {
+                        if (!playerData.hasUnlocked(spawnPoint) && spawnPoint.matchesCondition(playerData)) {
+                            playerData.unlock(spawnPoint);
+                        }
+                    }
+                }
+            }
+        }.runTaskTimer(this, 5*20L, 5 * 20L);
+
+
         /*
          * For the sake of the lord, make sure they aren't using MMOItems Mana and
          * Stamina Addon...This should prevent a couple error reports produced by people
@@ -329,6 +353,8 @@ public class MMOCore extends JavaPlugin {
         requestManager.initialize(clearBefore);
         soundManager.initialize(clearBefore);
         configItems.initialize(clearBefore);
+        spawnPointManager.initialize(clearBefore);
+        pluginMessageManager.initialize(clearBefore);
         //Needs to be loaded after the class manager.
         InventoryManager.load();
 

MMOCore-API/src/main/java/net/Indyuce/mmocore/api/load/DefaultMMOLoader.java

@@ -11,6 +11,9 @@ import net.Indyuce.mmocore.api.quest.trigger.*;
 import net.Indyuce.mmocore.experience.source.*;
 import net.Indyuce.mmocore.loot.chest.condition.*;
 import net.Indyuce.mmocore.loot.droptable.dropitem.*;
+import net.Indyuce.mmocore.spawnpoint.def.DefaultSpawnOption;
+import net.Indyuce.mmocore.spawnpoint.def.LastOption;
+import net.Indyuce.mmocore.spawnpoint.def.SpawnPointOption;
 import org.bukkit.configuration.ConfigurationSection;
 
 public class DefaultMMOLoader extends MMOLoader {
@@ -23,9 +26,12 @@ public class DefaultMMOLoader extends MMOLoader {
         if (config.getKey().equals("stat"))
             return new StatTrigger(config);
 
-        if(config.getKey().equals("unlock_slot"))
+        if (config.getKey().equals("unlock_slot"))
             return new UnlockSlotTrigger(config);
 
+        if (config.getKey().equals("unlock_spawn_point"))
+            return new UnlockSpawnPointTrigger(config);
+
         if (config.getKey().equals("unlock_skill"))
             return new UnlockSkillTrigger(config);
 
@@ -35,7 +41,7 @@ public class DefaultMMOLoader extends MMOLoader {
         if (config.getKey().equals("levelup_skill"))
             return new LevelUpSkillTrigger(config);
 
-        if (config.getKey().equals("skill_buff")||config.getKey().equals("skill_modifier"))
+        if (config.getKey().equals("skill_buff") || config.getKey().equals("skill_modifier"))
             return new SkillModifierTrigger(config);
 
         if (config.getKey().equals("message"))
@@ -204,4 +210,13 @@ public class DefaultMMOLoader extends MMOLoader {
 
         return null;
     }
+
+    @Override
+    public DefaultSpawnOption loadDefaultSpawnOption(MMOLineConfig config) {
+        if (config.getKey().equals("last"))
+            return new LastOption(config);
+        if (config.getKey().equals("spawnpoint"))
+            return new SpawnPointOption(config);
+        return null;
+    }
 }

MMOCore-API/src/main/java/net/Indyuce/mmocore/api/load/MMOLoader.java

@@ -8,6 +8,7 @@ import net.Indyuce.mmocore.experience.source.type.ExperienceSource;
 import net.Indyuce.mmocore.loot.chest.condition.Condition;
 import net.Indyuce.mmocore.loot.droptable.dropitem.DropItem;
 import net.Indyuce.mmocore.api.block.BlockType;
+import net.Indyuce.mmocore.spawnpoint.def.DefaultSpawnOption;
 import org.bukkit.configuration.ConfigurationSection;
 
 /**
@@ -40,4 +41,9 @@ public class MMOLoader {
     public BlockType loadBlockType(MMOLineConfig config) {
         return null;
     }
+
+    public DefaultSpawnOption loadDefaultSpawnOption(MMOLineConfig config) {
+        return null;
+    }
+
 }

MMOCore-API/src/main/java/net/Indyuce/mmocore/api/player/PlayerData.java

@@ -49,6 +49,7 @@ import net.Indyuce.mmocore.skill.cast.SkillCastingMode;
 import net.Indyuce.mmocore.skilltree.SkillTreeNode;
 import net.Indyuce.mmocore.skilltree.SkillTreeStatus;
 import net.Indyuce.mmocore.skilltree.tree.SkillTree;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
 import net.Indyuce.mmocore.waypoint.Waypoint;
 import net.Indyuce.mmocore.waypoint.WaypointOption;
 import net.md_5.bungee.api.ChatMessageType;
@@ -84,6 +85,9 @@ public class PlayerData extends SynchronizedDataHolder implements OfflinePlayerD
      */
     private double health;
     private Guild guild;
+
+    private SpawnPoint lastSpawnPoint;
+    private SpawnPoint lastUsedSpawnPoint;
     private SkillCastingInstance skillCasting;
     private final PlayerQuests questData;
     private final PlayerStats playerStats;
@@ -128,6 +132,8 @@ public class PlayerData extends SynchronizedDataHolder implements OfflinePlayerD
      */
     private final Map<String, Integer> tableItemClaims = new HashMap<>();
 
+    private boolean shouldTeleportWhenJoin;
+
     // NON-FINAL player data stuff made public to facilitate field change
     public boolean noCooldown;
 
@@ -191,6 +197,19 @@ public class PlayerData extends SynchronizedDataHolder implements OfflinePlayerD
                 node.getExperienceTable().claimRemovableTrigger(this, node);
     }
 
+    /**
+     * This method is called when a player connects to a server and has shouldTeleportWhenJoin set to true.
+     * If the player is alive it means that he has been teleported to this server because of spawnpoints.
+     * If he is dead this will be done when he respawns.
+     */
+    public void setupSpawnPoint() {
+        if (lastSpawnPoint != null && isOnline() && shouldTeleportWhenJoin && !lastSpawnPoint.isOtherServer()
+                && !getPlayer().isDead()) {
+            MMOCore.plugin.spawnPointManager.getSpawnPoint(lastSpawnPoint.getId()).whenRespawn(this);
+            shouldTeleportWhenJoin = false;
+        }
+    }
+
     public int getPointSpent(SkillTree skillTree) {
         return pointSpent.getOrDefault(skillTree, 0);
     }
@@ -351,7 +370,7 @@ public class PlayerData extends SynchronizedDataHolder implements OfflinePlayerD
 
     /**
      * @return If the item is unlocked by the player
-     *         This is used for skills that can be locked & unlocked.
+     * This is used for skills that can be locked & unlocked.
      */
     public boolean hasUnlocked(Unlockable unlockable) {
         return unlockable.isUnlockedByDefault() || unlockedItems.contains(unlockable.getUnlockNamespacedKey());
@@ -454,6 +473,27 @@ public class PlayerData extends SynchronizedDataHolder implements OfflinePlayerD
         this.lastActivity.put(activity, timestamp);
     }
 
+    public SpawnPoint getLastSpawnPoint() {
+        return lastSpawnPoint;
+    }
+
+    public SpawnPoint getLastUsedSpawnPoint() {
+        return lastUsedSpawnPoint;
+    }
+
+
+    public void setLastSpawnPoint(SpawnPoint lastSpawnPoint) {
+        this.lastSpawnPoint = lastSpawnPoint;
+    }
+
+    public void setLastUsedSpawnPoint(SpawnPoint lastUsedSpawnPoint) {
+        this.lastUsedSpawnPoint = this.lastUsedSpawnPoint;
+    }
+
+    public void setShouldTeleportWhenJoin(boolean shouldTeleport) {
+        this.shouldTeleportWhenJoin = shouldTeleport;
+    }
+
     @Override
     public long getLastLogin() {
         return getMMOPlayerData().getLastLogActivity();
@@ -1221,7 +1261,7 @@ public class PlayerData extends SynchronizedDataHolder implements OfflinePlayerD
      * checks if they could potentially upgrade to one of these
      *
      * @return If the player can change its current class to
-     *         a subclass
+     * a subclass
      */
     @Deprecated
     public boolean canChooseSubclass() {

MMOCore-API/src/main/java/net/Indyuce/mmocore/api/player/attribute/PlayerAttributes.java

@@ -1,8 +1,8 @@
 package net.Indyuce.mmocore.api.player.attribute;
 
-import com.google.gson.Gson;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
+import io.lumine.mythic.lib.gson.Gson;
+import io.lumine.mythic.lib.gson.JsonElement;
+import io.lumine.mythic.lib.gson.JsonObject;
 import io.lumine.mythic.lib.UtilityMethods;
 import io.lumine.mythic.lib.api.player.EquipmentSlot;
 import io.lumine.mythic.lib.player.modifier.Closeable;

MMOCore-API/src/main/java/net/Indyuce/mmocore/api/quest/PlayerQuests.java

@@ -1,8 +1,8 @@
 package net.Indyuce.mmocore.api.quest;
 
-import com.google.gson.Gson;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
+import io.lumine.mythic.lib.gson.Gson;
+import io.lumine.mythic.lib.gson.JsonElement;
+import io.lumine.mythic.lib.gson.JsonObject;
 import io.lumine.mythic.lib.util.Closeable;
 import net.Indyuce.mmocore.MMOCore;
 import net.Indyuce.mmocore.api.player.PlayerData;

MMOCore-API/src/main/java/net/Indyuce/mmocore/api/quest/trigger/UnlockSpawnPointTrigger.java

@@ -0,0 +1,33 @@
+package net.Indyuce.mmocore.api.quest.trigger;
+
+import io.lumine.mythic.lib.api.MMOLineConfig;
+import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.skill.binding.SkillSlot;
+import net.Indyuce.mmocore.api.quest.trigger.api.Removable;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
+import org.apache.commons.lang.Validate;
+
+
+public class UnlockSpawnPointTrigger extends Trigger implements Removable {
+    private final SpawnPoint spawnPoint;
+
+    public UnlockSpawnPointTrigger(MMOLineConfig config) {
+        super(config);
+        config.validateKeys("spawn-point");
+        Validate.isTrue(MMOCore.plugin.spawnPointManager.isSpawnPoint(config.getString("spawn-point")), config.getString("spawn-point") + " is not a valid spawn point");
+        spawnPoint = MMOCore.plugin.spawnPointManager.getSpawnPoint(config.getString("spawn-point"));
+    }
+
+    @Override
+    public void apply(PlayerData player) {
+        if (!player.hasUnlocked(spawnPoint))
+            player.unlock(spawnPoint);
+    }
+
+    @Override
+    public void remove(PlayerData player) {
+        if (player.hasUnlocked(spawnPoint))
+            player.lock(spawnPoint);
+    }
+}

MMOCore-API/src/main/java/net/Indyuce/mmocore/api/util/MMOCoreUtils.java

@@ -1,7 +1,7 @@
 package net.Indyuce.mmocore.api.util;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
+import io.lumine.mythic.lib.gson.JsonArray;
+import io.lumine.mythic.lib.gson.JsonObject;
 import io.lumine.mythic.lib.MythicLib;
 import io.lumine.mythic.lib.hologram.Hologram;
 import io.lumine.mythic.lib.version.VersionMaterial;

MMOCore-API/src/main/java/net/Indyuce/mmocore/command/api/CommandVerbose.java

@@ -58,7 +58,8 @@ public class CommandVerbose {
         SKILL_TREE_POINTS,
         RESET,
         RESOURCE,
-        WAYPOINT;
+        WAYPOINT,
+        SPAWN_POINT;
     }
 
     private enum VerboseValue {

MMOCore-API/src/main/java/net/Indyuce/mmocore/command/rpg/admin/AdminCommandTreeNode.java

@@ -30,6 +30,7 @@ public class AdminCommandTreeNode extends CommandTreeNode {
         addChild(new PointsCommandTreeNode("skill-realloc", this, PlayerData::setSkillReallocationPoints, PlayerData::giveSkillReallocationPoints, PlayerData::getSkillReallocationPoints));
         addChild(new PointsCommandTreeNode("skill-tree-realloc", this, PlayerData::setSkillTreeReallocationPoints, PlayerData::giveSkillTreeReallocationPoints, PlayerData::getSkillTreeReallocationPoints));
         addChild(new SkillTreePointsCommandTreeNode(this, (playerData, integer, s) -> playerData.setSkillTreePoints(s, integer), (playerData, integer, s) -> playerData.giveSkillTreePoints(s, integer), ((playerData, s) -> playerData.getSkillTreePoint(s))));
+        addChild(new SpawnPointCommandTreeNode(this));
         for (PlayerResource res : PlayerResource.values())
             addChild(new ResourceCommandTreeNode(res.name().toLowerCase(), this, res));
     }

MMOCore-API/src/main/java/net/Indyuce/mmocore/command/rpg/admin/SpawnPointCommandTreeNode.java

@@ -0,0 +1,81 @@
+package net.Indyuce.mmocore.command.rpg.admin;
+
+import io.lumine.mythic.lib.command.api.CommandTreeNode;
+import io.lumine.mythic.lib.command.api.Parameter;
+import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.skill.binding.SkillSlot;
+import net.Indyuce.mmocore.command.api.CommandVerbose;
+import net.Indyuce.mmocore.skill.ClassSkill;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+
+public class SpawnPointCommandTreeNode extends CommandTreeNode {
+    public SpawnPointCommandTreeNode(CommandTreeNode parent) {
+        super(parent, "slot");
+        addChild(new LockSpawnPointCommand(this, "lock", true));
+        addChild(new LockSpawnPointCommand(this, "unlock", false));
+    }
+
+    public class LockSpawnPointCommand extends CommandTreeNode {
+        private final boolean lock;
+
+        public LockSpawnPointCommand(CommandTreeNode parent, String id, boolean lock) {
+            super(parent, id);
+            this.lock = lock;
+            addParameter(Parameter.PLAYER);
+            addParameter(new Parameter("spawnpoint",
+                    (explorer, list) -> MMOCore.plugin.spawnPointManager.getAll().stream().map(spawnPoint -> spawnPoint.getId()).forEach(list::add)));
+
+        }
+
+        @Override
+        public CommandResult execute(CommandSender sender, String[] args) {
+            if (args.length < 5)
+                return CommandResult.THROW_USAGE;
+            Player player = Bukkit.getPlayer(args[3]);
+            if (player == null) {
+                sender.sendMessage(ChatColor.RED + "Could not find the player called " + args[3] + ".");
+                return CommandResult.FAILURE;
+            }
+            PlayerData playerData = PlayerData.get(player);
+
+            if (!MMOCore.plugin.spawnPointManager.isSpawnPoint(args[4])) {
+                sender.sendMessage(ChatColor.RED + "Could not find the spawnpoint called " + args[4] + ".");
+                return CommandResult.FAILURE;
+            }
+            SpawnPoint spawnPoint = MMOCore.plugin.spawnPointManager.getSpawnPoint(args[4]);
+            if (lock) {
+                if (!playerData.hasUnlocked(spawnPoint)) {
+                    CommandVerbose.verbose(sender, CommandVerbose.CommandType.SKILL, ChatColor.RED + "The spawn point " +
+                            spawnPoint.getId() + " is already locked for " + player.getName());
+                    return CommandResult.SUCCESS;
+                }
+                playerData.lock(spawnPoint);
+
+            } else {
+                if (playerData.hasUnlocked(spawnPoint)) {
+                    CommandVerbose.verbose(sender, CommandVerbose.CommandType.SKILL, ChatColor.RED + "The spawn point " +
+                            spawnPoint.getId() + " is already unlocked for " + player.getName());
+                    return CommandResult.SUCCESS;
+                }
+                playerData.unlock(spawnPoint);
+            }
+            CommandVerbose.verbose(sender, CommandVerbose.CommandType.SPAWN_POINT, ChatColor.GOLD + "The spawn point " +
+                    spawnPoint.getId() + " is now " + (lock ? "locked" : "unlocked  for " + player.getName()));
+            return CommandResult.SUCCESS;
+        }
+    }
+
+
+    @Override
+    public CommandResult execute(CommandSender sender, String[] args) {
+        return CommandResult.THROW_USAGE;
+    }
+}
+
+

MMOCore-API/src/main/java/net/Indyuce/mmocore/comp/profile/MMOCoreProfileDataModule.java

@@ -34,7 +34,7 @@ public class MMOCoreProfileDataModule implements ProfileDataModule, Listener {
     @Override
     public void processPlaceholderRequest(PlaceholderRequest placeholderRequest) {
         final PlayerData fictiveData = new PlayerData(new MMOPlayerData(placeholderRequest.getProfile().getUniqueId()));
-        MMOCore.plugin.playerDataManager.getDataHandler().loadData(fictiveData).thenRun(() -> {
+        MMOCore.plugin.playerDataManager.loadData(fictiveData).thenRun(() -> {
             placeholderRequest.addPlaceholder("class", fictiveData.getProfess().getName());
             placeholderRequest.addPlaceholder("level", fictiveData.getLevel());
 

MMOCore-API/src/main/java/net/Indyuce/mmocore/experience/PlayerProfessions.java

@@ -1,10 +1,10 @@
 package net.Indyuce.mmocore.experience;
 
-import com.google.gson.Gson;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
 import io.lumine.mythic.lib.MythicLib;
 import io.lumine.mythic.lib.UtilityMethods;
+import io.lumine.mythic.lib.gson.Gson;
+import io.lumine.mythic.lib.gson.JsonElement;
+import io.lumine.mythic.lib.gson.JsonObject;
 import net.Indyuce.mmocore.MMOCore;
 import net.Indyuce.mmocore.api.ConfigMessage;
 import net.Indyuce.mmocore.api.SoundEvent;

MMOCore-API/src/main/java/net/Indyuce/mmocore/manager/ConfigManager.java

@@ -104,6 +104,7 @@ public class ConfigManager {
         loadDefaultFile("triggers.yml");
         loadDefaultFile("conditions.yml");
         loadDefaultFile("guilds.yml");
+        loadDefaultFile("spawn-points.yml");
 
         final ConfigurationSection config = MMOCore.plugin.getConfig();
         commandVerbose.reload(MMOCore.plugin.getConfig().getConfigurationSection("command-verbose"));

MMOCore-API/src/main/java/net/Indyuce/mmocore/manager/MMOLoadManager.java

@@ -1,6 +1,6 @@
 package net.Indyuce.mmocore.manager;
 
-import com.google.gson.JsonParseException;
+import io.lumine.mythic.lib.gson.JsonParseException;
 import io.lumine.mythic.lib.api.MMOLineConfig;
 import net.Indyuce.mmocore.experience.source.type.ExperienceSource;
 import net.Indyuce.mmocore.api.block.BlockType;
@@ -11,6 +11,7 @@ import net.Indyuce.mmocore.api.quest.trigger.Trigger;
 import net.Indyuce.mmocore.experience.dispenser.ExperienceDispenser;
 import net.Indyuce.mmocore.loot.chest.condition.Condition;
 import net.Indyuce.mmocore.loot.droptable.dropitem.DropItem;
+import net.Indyuce.mmocore.spawnpoint.def.DefaultSpawnOption;
 import org.apache.commons.lang.Validate;
 import org.bukkit.configuration.ConfigurationSection;
 
@@ -60,6 +61,11 @@ public class MMOLoadManager {
         return load("block type", config, loader -> loader.loadBlockType(config));
     }
 
+    public DefaultSpawnOption loadDefaultSpawnOption(MMOLineConfig config) {
+        return load("default spawn", config, loader -> loader.loadDefaultSpawnOption(config));
+    }
+
+
     private <T> T load(String objName, MMOLineConfig config, Function<MMOLoader, T> func) {
 
         for (MMOLoader loader : loaders)

MMOCore-API/src/main/java/net/Indyuce/mmocore/manager/PluginMessageManager.java

@@ -0,0 +1,58 @@
+package net.Indyuce.mmocore.manager;
+
+import com.google.common.io.ByteArrayDataInput;
+import com.google.common.io.ByteArrayDataOutput;
+import com.google.common.io.ByteStreams;
+import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class PluginMessageManager implements MMOCoreManager, PluginMessageListener {
+    private String serverName;
+    private List<String> allServerNames;
+    public final String BUNGEECORD_CHANNEL = "BungeeCord";
+
+    @Override
+    public void initialize(boolean clearBefore) {
+        if (!clearBefore) {
+            //Setup the channels.
+            MMOCore.plugin.getServer().getMessenger().registerOutgoingPluginChannel(MMOCore.plugin, BUNGEECORD_CHANNEL);
+            MMOCore.plugin.getServer().getMessenger().registerIncomingPluginChannel(MMOCore.plugin, BUNGEECORD_CHANNEL, this);
+
+        }
+    }
+
+    public void teleportToOtherServer(PlayerData playerData, String server) {
+        ByteArrayDataOutput out = ByteStreams.newDataOutput();
+        out.writeUTF("Connect");
+        out.writeUTF(server);
+        playerData.getPlayer().sendPluginMessage(MMOCore.plugin, BUNGEECORD_CHANNEL, out.toByteArray());
+    }
+
+
+    @Override
+    public void onPluginMessageReceived(@NotNull String channel, @NotNull Player player, @NotNull byte[] bytes) {
+        if (!channel.equals(BUNGEECORD_CHANNEL)) return;
+        ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
+        String subchannel = in.readUTF();
+        if (subchannel.equals("GetServer")) {
+            serverName = in.readUTF();
+        } else if (subchannel.equals("GetServers")) {
+            allServerNames = Arrays.asList(in.readUTF().split(", "));
+        }
+    }
+
+    public String getServerName() {
+        return serverName;
+    }
+
+    public List<String> getAllServerNames() {
+        return new ArrayList(allServerNames);
+    }
+}

MMOCore-API/src/main/java/net/Indyuce/mmocore/manager/SpawnPointManager.java

@@ -0,0 +1,107 @@
+package net.Indyuce.mmocore.manager;
+
+import io.lumine.mythic.lib.MythicLib;
+import io.lumine.mythic.lib.api.MMOLineConfig;
+import io.lumine.mythic.lib.script.Script;
+import io.lumine.mythic.lib.script.condition.Condition;
+import io.lumine.mythic.lib.skill.SimpleSkill;
+import io.lumine.mythic.lib.skill.Skill;
+import io.lumine.mythic.lib.skill.handler.MythicLibSkillHandler;
+import io.lumine.mythic.lib.skill.trigger.TriggerType;
+import io.lumine.mythic.lib.util.ConfigFile;
+import io.lumine.mythic.lib.util.configobject.ConfigSectionObject;
+import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
+import net.Indyuce.mmocore.spawnpoint.def.DefaultSpawnOption;
+import org.bukkit.configuration.file.FileConfiguration;
+
+import javax.swing.text.html.Option;
+import java.util.*;
+import java.util.logging.Level;
+
+public class SpawnPointManager implements MMOCoreManager {
+
+    private Optional<Condition> globalUnlockCondition;
+    private Optional<Skill> globalUnlockScript;
+    private Optional<Skill> globalRespawnScript;
+
+    private final Map<String, SpawnPoint> spawnPoints = new HashMap<>();
+
+    private List<DefaultSpawnOption> defaultSpawnOptions = new ArrayList<>();
+
+
+    public SpawnPoint getSpawnPoint(String id) {
+        return spawnPoints.get(id);
+    }
+
+    public boolean isSpawnPoint(String id) {
+        return spawnPoints.containsKey(id);
+    }
+
+    public Collection<SpawnPoint> getAll() {
+        return spawnPoints.values();
+    }
+
+    @Override
+    public void initialize(boolean clearBefore) {
+        FileConfiguration config = new ConfigFile(MMOCore.plugin, "", "spawn-points").getConfig();
+
+        if (config.isConfigurationSection("spawn-points"))
+            for (String key : config.getConfigurationSection("spawn-points").getKeys(false)) {
+                try {
+                    SpawnPoint spawnPoint = new SpawnPoint(config.getConfigurationSection("spawn-points." + key));
+                    spawnPoints.put(spawnPoint.getId(), spawnPoint);
+                } catch (Exception e) {
+                    MMOCore.log(Level.WARNING, "An error occured while loading spawnpoint " + key + ": " + e.getMessage());
+                }
+
+            }
+        for (String defaultSpawnOption : config.getStringList("default-spawn")) {
+            defaultSpawnOptions.add(MMOCore.plugin.loadManager.loadDefaultSpawnOption(new MMOLineConfig(defaultSpawnOption)));
+        }
+
+
+        Skill globalUnlockScript = null;
+        if (config.isConfigurationSection("global.unlock-script"))
+            try {
+                final Script script = MythicLib.plugin.getSkills().loadScript(config.getConfigurationSection("global.unlock-script"));
+                globalUnlockScript = new SimpleSkill(TriggerType.CAST, new MythicLibSkillHandler(script));
+            } catch (RuntimeException exception) {
+                MMOCore.plugin.getLogger().log(Level.WARNING, "Could not load unlock script: " + exception.getMessage());
+            }
+        this.globalUnlockScript = Optional.ofNullable(globalUnlockScript);
+
+        Skill globalRespawnScript = null;
+        if (config.isConfigurationSection("global.respawn-script"))
+            try {
+                final Script script = MythicLib.plugin.getSkills().loadScript(config.getConfigurationSection("global.respawn-script"));
+                globalRespawnScript = new SimpleSkill(TriggerType.CAST, new MythicLibSkillHandler(script));
+            } catch (RuntimeException exception) {
+                MMOCore.plugin.getLogger().log(Level.WARNING, "Could not load respawn script: " + exception.getMessage());
+            }
+        this.globalRespawnScript = Optional.ofNullable(globalRespawnScript);
+
+        Condition globalUnlockCondition = null;
+        if (config.isConfigurationSection("global.unlock-condition"))
+            globalUnlockCondition = MythicLib.plugin.getSkills().loadCondition(new ConfigSectionObject(config.getConfigurationSection("global.unlock-condition")));
+        this.globalUnlockCondition = Optional.ofNullable(globalUnlockCondition);
+
+
+    }
+
+    public Optional<Condition> getUnlockCondition() {
+        return globalUnlockCondition;
+    }
+
+    public Optional<Skill> getUnlockScript() {
+        return globalUnlockScript;
+    }
+
+    public Optional<Skill> getRespawnScript() {
+        return globalRespawnScript;
+    }
+
+    public List<DefaultSpawnOption> getDefaultSpawnOptions() {
+        return new ArrayList(defaultSpawnOptions);
+    }
+}

MMOCore-API/src/main/java/net/Indyuce/mmocore/manager/data/sql/MMOCoreDataSynchronizer.java

@@ -89,6 +89,15 @@ public class MMOCoreDataSynchronizer extends SQLDataSynchronizer<PlayerData> {
             getData().getWaypoints().addAll(MMOCoreUtils.jsonArrayToList(result.getString("waypoints")));
         if (!isEmpty(result.getString("friends")))
             MMOCoreUtils.jsonArrayToList(result.getString("friends")).forEach(str -> getData().getFriends().add(UUID.fromString(str)));
+        if (!isEmpty(result.getString("last_spawn_point")))
+            getData().setLastSpawnPoint(MMOCore.plugin.spawnPointManager.getSpawnPoint(result.getString("last_spawn_point")));
+
+        if (!isEmpty(result.getString("last_used_spawn_point")))
+            getData().setLastUsedSpawnPoint(MMOCore.plugin.spawnPointManager.getSpawnPoint(result.getString("last_spawn_point")));
+
+        getData().setShouldTeleportWhenJoin(result.getBoolean("should_teleport_when_join"));
+        getData().setupSpawnPoint();
+
         if (!isEmpty(result.getString("skills"))) {
             JsonObject object = MythicLib.plugin.getGson().fromJson(result.getString("skills"), JsonObject.class);
             for (Map.Entry<String, JsonElement> entry : object.entrySet())

MMOCore-API/src/main/java/net/Indyuce/mmocore/manager/data/sql/PlayerDataTableUpdater.java

@@ -1,7 +1,7 @@
 package net.Indyuce.mmocore.manager.data.sql;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
+import io.lumine.mythic.lib.gson.JsonArray;
+import io.lumine.mythic.lib.gson.JsonObject;
 import io.lumine.mythic.lib.data.sql.SQLDataSource;
 import net.Indyuce.mmocore.MMOCore;
 import net.Indyuce.mmocore.api.player.PlayerData;

MMOCore-API/src/main/java/net/Indyuce/mmocore/manager/data/sql/SQLDataHandler.java

@@ -1,24 +1,22 @@
 package net.Indyuce.mmocore.manager.data.sql;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
+import io.lumine.mythic.lib.gson.JsonArray;
+import io.lumine.mythic.lib.gson.JsonObject;
 import io.lumine.mythic.lib.UtilityMethods;
 import io.lumine.mythic.lib.data.sql.SQLDataSource;
 import io.lumine.mythic.lib.data.sql.SQLSynchronizedDataHandler;
 import net.Indyuce.mmocore.MMOCore;
-import net.Indyuce.mmocore.manager.data.OfflinePlayerData;
 import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.api.player.profess.PlayerClass;
 import net.Indyuce.mmocore.api.player.profess.SavedClassInformation;
+import net.Indyuce.mmocore.manager.data.OfflinePlayerData;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.sql.SQLException;
-import java.util.List;
 import java.util.UUID;
 import java.util.stream.Collectors;
 
-public class SQLDataHandler extends SQLSynchronizedDataHandler<PlayerData, OfflinePlayerData, MMOCoreDataSynchronizer> {
+public class SQLDataHandler extends SQLSynchronizedDataHandler<PlayerData, OfflinePlayerData> {
     public SQLDataHandler(SQLDataSource dataSource) {
         super(dataSource);
     }
@@ -34,7 +32,10 @@ public class SQLDataHandler extends SQLSynchronizedDataHandler<PlayerData, Offli
             "health", "FLOAT",
             "mana", "FLOAT",
             "stamina", "FLOAT",
-            "stellium", "FLOAT"};
+            "stellium", "FLOAT",
+            "last_spawn_point", "LONGTEXT",
+            "last_used_spawn_point", "LONGTEXT",
+            "spawn_when_join", "TINYINT"};
 
     @Override
     public void setup() {
@@ -67,6 +68,9 @@ public class SQLDataHandler extends SQLSynchronizedDataHandler<PlayerData, Offli
                 "stellium FLOAT," +
                 "unlocked_items LONGTEXT," +
                 "class_info LONGTEXT," +
+                "last_spawn_point LONGTEXT," +
+                "last_used_spawn_point LONGTEXT," +
+                "spawn_when_join TINYINT," +
                 "is_saved TINYINT," +
                 "PRIMARY KEY (uuid));");
 
@@ -122,6 +126,8 @@ public class SQLDataHandler extends SQLSynchronizedDataHandler<PlayerData, Offli
         updater.addData("professions", data.getCollectionSkills().toJsonString());
         updater.addData("quests", data.getQuestData().toJsonString());
         updater.addData("class_info", createClassInfoData(data).toString());
+        updater.addData("last_spawn_point", data.getLastSpawnPoint().getId());
+        updater.addData("last_used_spawn_point", data.getLastUsedSpawnPoint().getId());
         updater.addJSONArray("unlocked_items", data.getUnlockedItems());
         if (!autosave)
             updater.addData("is_saved", 1);

MMOCore-API/src/main/java/net/Indyuce/mmocore/manager/data/yaml/YAMLPlayerDataHandler.java

@@ -17,6 +17,7 @@ import org.bukkit.plugin.Plugin;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
+import java.util.Optional;
 import java.util.UUID;
 import java.util.logging.Level;
 import java.util.stream.Collectors;
@@ -133,14 +134,20 @@ public class YAMLPlayerDataHandler extends YAMLSynchronizedDataHandler<PlayerDat
         data.setMana(config.contains("mana") ? config.getDouble("mana") : data.getStats().getStat("MAX_MANA"));
         data.setStamina(config.contains("stamina") ? config.getDouble("stamina") : data.getStats().getStat("MAX_STAMINA"));
         data.setStellium(config.contains("stellium") ? config.getDouble("stellium") : data.getStats().getStat("MAX_STELLIUM"));
+        if (config.contains("last-spawn-point"))
+            data.setLastSpawnPoint(MMOCore.plugin.spawnPointManager.getSpawnPoint(config.getString("last-spawn-point")));
 
+        if (config.contains("last-used-spawn-point"))
+            data.setLastUsedSpawnPoint(MMOCore.plugin.spawnPointManager.getSpawnPoint(config.getString("last-used-spawn-point")));
+
+        data.setShouldTeleportWhenJoin(config.getBoolean("should-teleport-when-join", false));
+        data.setupSpawnPoint();
         if (data.isOnline() && !data.getPlayer().isDead())
             data.getPlayer().setHealth(MMOCoreUtils.fixResource(config.getDouble("health"), data.getPlayer().getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue()));
     }
 
     @Override
     public void saveInSection(PlayerData data, ConfigurationSection config) {
-
         config.set("class-points", data.getClassPoints());
         config.set("skill-points", data.getSkillPoints());
         config.set("skill-reallocation-points", data.getSkillReallocationPoints());
@@ -172,7 +179,10 @@ public class YAMLPlayerDataHandler extends YAMLSynchronizedDataHandler<PlayerDat
         config.set("attribute", null);
         config.createSection("attribute");
         data.getAttributes().save(config.getConfigurationSection("attribute"));
-
+        if (data.getLastSpawnPoint() != null)
+            config.set("last-spawn-point", data.getLastSpawnPoint().getId());
+        if (data.getLastUsedSpawnPoint() != null)
+            config.set("last-used-spawn-point", data.getLastUsedSpawnPoint().getId());
         config.set("profession", null);
         config.createSection("profession");
         data.getCollectionSkills().save(config.getConfigurationSection("profession"));
@@ -202,6 +212,7 @@ public class YAMLPlayerDataHandler extends YAMLSynchronizedDataHandler<PlayerDat
             info.mapBoundSkills().forEach((slot, skill) -> config.set("class-info." + key + ".bound-skills." + slot, skill));
             config.set("class-info." + key + ".unlocked-items", new ArrayList<>(info.getUnlockedItems()));
         }
+
     }
 
     @NotNull

MMOCore-API/src/main/java/net/Indyuce/mmocore/skilltree/SkillTreePath.java

@@ -12,7 +12,7 @@ public record SkillTreePath(SkillTree tree, IntegerCoordinates coordinates, Skil
         SkillTreeStatus toStatus = playerData.getNodeStatus(to);
         if (fromStatus == SkillTreeStatus.UNLOCKED && toStatus == SkillTreeStatus.UNLOCKED)
             return PathStatus.UNLOCKED;
-        if ((fromStatus == SkillTreeStatus.UNLOCKABLE && toStatus == SkillTreeStatus.LOCKED) || (fromStatus == SkillTreeStatus.LOCKED && toStatus == SkillTreeStatus.UNLOCKABLE))
+        if ((fromStatus == SkillTreeStatus.UNLOCKABLE && toStatus == SkillTreeStatus.UNLOCKED) || (fromStatus == SkillTreeStatus.UNLOCKED && toStatus == SkillTreeStatus.UNLOCKABLE))
             return PathStatus.UNLOCKABLE;
         if (fromStatus == SkillTreeStatus.FULLY_LOCKED || toStatus == SkillTreeStatus.FULLY_LOCKED)
             return PathStatus.FULLY_LOCKED;

MMOCore-API/src/main/java/net/Indyuce/mmocore/spawnpoint/SpawnPoint.java

@@ -0,0 +1,129 @@
+package net.Indyuce.mmocore.spawnpoint;
+
+import io.lumine.mythic.lib.MythicLib;
+import io.lumine.mythic.lib.UtilityMethods;
+import io.lumine.mythic.lib.api.player.EquipmentSlot;
+import io.lumine.mythic.lib.script.Script;
+import io.lumine.mythic.lib.script.condition.Condition;
+import io.lumine.mythic.lib.skill.SimpleSkill;
+import io.lumine.mythic.lib.skill.Skill;
+import io.lumine.mythic.lib.skill.SkillMetadata;
+import io.lumine.mythic.lib.skill.handler.MythicLibSkillHandler;
+import io.lumine.mythic.lib.skill.trigger.TriggerMetadata;
+import io.lumine.mythic.lib.skill.trigger.TriggerType;
+import io.lumine.mythic.lib.util.configobject.ConfigSectionObject;
+import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.player.Unlockable;
+import org.apache.commons.lang.Validate;
+import org.bukkit.Location;
+import org.bukkit.configuration.ConfigurationSection;
+
+import java.util.Optional;
+import java.util.logging.Level;
+
+public class SpawnPoint implements Unlockable {
+    private final String id;
+
+    private final Optional<String> server;
+    private final Location location;
+    private final Condition unlockCondition;
+    private final double strength;
+
+    private final Optional<Skill> unlockScript;
+    private final Optional<Skill> respawnScript;
+
+    private final boolean overridesUnlockCondition, overridesRespawnScript, overridesUnlockScript;
+
+    public SpawnPoint(ConfigurationSection section) {
+        id = section.getName();
+        server = Optional.ofNullable(section.getString("server"));
+        location = UtilityMethods.readLocation(new ConfigSectionObject(section.getConfigurationSection("location")));
+        Validate.isTrue(section.isConfigurationSection("unlock-condition"), "You must specify an unlock condition.");
+        unlockCondition = MythicLib.plugin.getSkills().loadCondition(
+                new ConfigSectionObject(section.getConfigurationSection("unlock-condition")));
+
+        strength = section.getDouble("strength", 1);
+        overridesRespawnScript = section.getBoolean("override-respawn-script", false);
+        overridesUnlockScript = section.getBoolean("override-unlock-script", false);
+        overridesUnlockCondition = section.getBoolean("override-unlock-condition", false);
+        Skill unlockScript = null;
+        if (section.isConfigurationSection("unlock-script"))
+            try {
+                final Script script = MythicLib.plugin.getSkills().loadScript(section.getConfigurationSection("unlock-script"));
+                unlockScript = new SimpleSkill(TriggerType.CAST, new MythicLibSkillHandler(script));
+            } catch (RuntimeException exception) {
+                MMOCore.log(Level.WARNING, "Could not load unlock script: " + exception.getMessage());
+            }
+        this.unlockScript = Optional.ofNullable(unlockScript);
+
+        Skill respawnScript = null;
+        if (section.isConfigurationSection("respawn-script"))
+            try {
+                final Script script = MythicLib.plugin.getSkills().loadScript(section.getConfigurationSection("respawn-script"));
+                respawnScript = new SimpleSkill(TriggerType.CAST, new MythicLibSkillHandler(script));
+            } catch (RuntimeException exception) {
+                MMOCore.log(Level.WARNING, "Could not load respawn script: " + exception.getMessage());
+            }
+        this.respawnScript = Optional.ofNullable(respawnScript);
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public Location getLocation() {
+        return location;
+    }
+
+    @Override
+    public String getUnlockNamespacedKey() {
+        return "spawnpoint:" + id;
+    }
+
+    public double getStrength() {
+        return strength;
+    }
+
+    @Override
+    public boolean isUnlockedByDefault() {
+        return false;
+    }
+
+    @Override
+    public void whenLocked(PlayerData playerData) {
+    }
+
+    @Override
+    public void whenUnlocked(PlayerData playerData) {
+        TriggerMetadata triggerMetadata = new TriggerMetadata(playerData.getMMOPlayerData().getStatMap().cache(EquipmentSlot.MAIN_HAND));
+        if (!overridesUnlockScript)
+            MMOCore.plugin.spawnPointManager.getUnlockScript().ifPresent(skill -> skill.cast(triggerMetadata));
+        unlockScript.ifPresent(skill -> skill.cast(triggerMetadata));
+    }
+
+    public boolean isOtherServer() {
+        return !server.isEmpty() && server.get() != MMOCore.plugin.pluginMessageManager.getServerName();
+    }
+
+    public boolean matchesCondition(PlayerData playerData) {
+        SkillMetadata metadata = new SkillMetadata(null, playerData.getMMOPlayerData());
+        if (!overridesUnlockCondition && !MMOCore.plugin.spawnPointManager.getUnlockCondition()
+                .map((condition) -> condition.isMet(metadata)).orElse(true))
+            return false;
+        return unlockCondition.isMet(metadata);
+    }
+
+    public void whenRespawn(PlayerData playerData) {
+        if (isOtherServer()) {
+            MMOCore.plugin.pluginMessageManager.teleportToOtherServer(playerData, server.get());
+        } else {
+            playerData.setLastUsedSpawnPoint(this);
+            TriggerMetadata triggerMetadata = new TriggerMetadata(playerData.getMMOPlayerData().getStatMap().cache(EquipmentSlot.MAIN_HAND));
+            if (!overridesRespawnScript)
+                MMOCore.plugin.spawnPointManager.getRespawnScript().ifPresent(skill -> skill.cast(triggerMetadata));
+            respawnScript.ifPresent(skill -> skill.cast(triggerMetadata));
+        }
+
+    }
+}

MMOCore-API/src/main/java/net/Indyuce/mmocore/spawnpoint/def/DefaultSpawnOption.java

@@ -0,0 +1,32 @@
+package net.Indyuce.mmocore.spawnpoint.def;
+
+import io.lumine.mythic.lib.api.MMOLineConfig;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
+import org.bukkit.World;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public abstract class DefaultSpawnOption {
+
+    protected final String worldExpression;
+
+    public DefaultSpawnOption() {
+        this.worldExpression = "true";
+    }
+
+    public DefaultSpawnOption(MMOLineConfig config) {
+        this.worldExpression = config.getString("world-expression");
+    }
+
+    public boolean matches(World world) {
+        String worldName = world.getName();
+        Pattern pattern = Pattern.compile(this.worldExpression);
+        Matcher matcher = pattern.matcher(worldName);
+        return matcher.matches();
+    }
+
+    public abstract SpawnPoint getSpawnPoint(PlayerData playerData);
+
+}

MMOCore-API/src/main/java/net/Indyuce/mmocore/spawnpoint/def/LastOption.java

@@ -0,0 +1,18 @@
+package net.Indyuce.mmocore.spawnpoint.def;
+
+import io.lumine.mythic.lib.api.MMOLineConfig;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
+
+public class LastOption extends DefaultSpawnOption {
+
+    public LastOption(MMOLineConfig config) {
+        super(config);
+    }
+
+    @Override
+    public SpawnPoint getSpawnPoint(PlayerData playerData) {
+        return playerData.getLastSpawnPoint();
+    }
+
+}

MMOCore-API/src/main/java/net/Indyuce/mmocore/spawnpoint/def/LastUsedOption.java

@@ -0,0 +1,18 @@
+package net.Indyuce.mmocore.spawnpoint.def;
+
+import io.lumine.mythic.lib.api.MMOLineConfig;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
+
+public class LastUsedOption extends DefaultSpawnOption {
+
+    public LastUsedOption(MMOLineConfig config) {
+        super(config);
+    }
+
+    @Override
+    public SpawnPoint getSpawnPoint(PlayerData playerData) {
+        return playerData.getLastSpawnPoint();
+    }
+
+}

MMOCore-API/src/main/java/net/Indyuce/mmocore/spawnpoint/def/SpawnPointOption.java

@@ -0,0 +1,24 @@
+package net.Indyuce.mmocore.spawnpoint.def;
+
+import io.lumine.mythic.lib.api.MMOLineConfig;
+import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
+import org.apache.commons.lang.Validate;
+
+import java.util.Optional;
+
+public class SpawnPointOption extends DefaultSpawnOption {
+    private final SpawnPoint spawnPoint;
+
+    public SpawnPointOption(MMOLineConfig config) {
+        super(config);
+        Validate.isTrue(MMOCore.plugin.spawnPointManager.isSpawnPoint(config.getString("id")));
+        spawnPoint = MMOCore.plugin.spawnPointManager.getSpawnPoint(config.getString("id"));
+    }
+
+    @Override
+    public SpawnPoint getSpawnPoint(PlayerData playerData) {
+        return spawnPoint;
+    }
+}

MMOCore-Dist/src/main/java/net/Indyuce/mmocore/MMOCoreBukkit.java

@@ -45,6 +45,7 @@ public class MMOCoreBukkit {
         Bukkit.getPluginManager().registerEvents(new FishingListener(), plugin);
         Bukkit.getPluginManager().registerEvents(new PlayerCollectStats(), plugin);
         Bukkit.getPluginManager().registerEvents(new PlayerPressKeyListener(), plugin);
+        Bukkit.getPluginManager().registerEvents(new SpawnPointsListener(), plugin);
         // Bukkit.getPluginManager().registerEvents(new ClassTriggers(), plugin);
     }
 }

MMOCore-Dist/src/main/java/net/Indyuce/mmocore/listener/SpawnPointsListener.java

@@ -0,0 +1,83 @@
+package net.Indyuce.mmocore.listener;
+
+import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.spawnpoint.SpawnPoint;
+import net.Indyuce.mmocore.spawnpoint.def.DefaultSpawnOption;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+
+import java.util.List;
+import java.util.Optional;
+
+public class SpawnPointsListener implements Listener {
+
+    @EventHandler
+    public void onTeleport(PlayerTeleportEvent event) {
+        if (!event.getFrom().getWorld().equals(event.getTo().getWorld())) {
+            PlayerData playerData = PlayerData.get(event.getPlayer());
+            getLastSpawnPoint(event.getFrom(), playerData).ifPresent(playerData::setLastSpawnPoint);
+        }
+    }
+
+    @EventHandler
+    public void onDeath(PlayerDeathEvent event) {
+        PlayerData playerData = PlayerData.get(event.getEntity());
+        //TODO: Only when module enabled
+        getLastSpawnPoint(playerData).ifPresent((spawnPoint) -> playerData.setLastSpawnPoint(spawnPoint));
+
+    }
+
+    @EventHandler
+    public void onSpawn(PlayerRespawnEvent event) {
+        PlayerData playerData = PlayerData.get(event.getPlayer());
+        getLastSpawnPoint(playerData).ifPresent((spawnPoint) ->
+        {
+            if (!spawnPoint.isOtherServer())
+                event.setRespawnLocation(spawnPoint.getLocation());
+
+            spawnPoint.whenRespawn(playerData);
+        });
+    }
+
+    public Optional<SpawnPoint> getLastSpawnPoint(Location location, PlayerData playerData) {
+        World world = location.getWorld();
+        List<SpawnPoint> reachableSpawnPoints = MMOCore.plugin.spawnPointManager.
+                getAll()
+                .stream()
+                .filter(spawnPoint -> spawnPoint.getLocation().getWorld().equals(world) && playerData.hasUnlocked(spawnPoint))
+                .toList();
+        if (!reachableSpawnPoints.isEmpty()) {
+
+            double minDistance = Double.MAX_VALUE;
+            SpawnPoint closestSpawnPoint = null;
+            for (SpawnPoint spawnPoint : reachableSpawnPoints) {
+                double distance = spawnPoint.getLocation().distance(location);
+                distance = distance / spawnPoint.getStrength();
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    closestSpawnPoint = spawnPoint;
+                }
+            }
+            return Optional.of(closestSpawnPoint);
+        } else
+            for (DefaultSpawnOption defaultSpawnOption : MMOCore.plugin.spawnPointManager.getDefaultSpawnOptions()) {
+                Bukkit.broadcastMessage("world: " + world.getName() + " matches: " + defaultSpawnOption.matches(world));
+                if (defaultSpawnOption.matches(world)) {
+                    return Optional.of(defaultSpawnOption.getSpawnPoint(playerData));
+                }
+            }
+
+        return Optional.empty();
+    }
+
+    public Optional<SpawnPoint> getLastSpawnPoint(PlayerData playerData) {
+        return getLastSpawnPoint(playerData.getPlayer().getLocation(), playerData);
+    }
+}

MMOCore-Dist/src/main/resources/default/spawn-points.yml

@@ -0,0 +1,96 @@
+global:
+  #This condition will need to be matched as well as the spawn point's condition unless
+  #overrides-unlock-condition is set to true in the spawn point's config.
+  unlock-condition:
+    type: boolean
+    formula: "true"
+
+  #Will be run for each spawn point unless it has the option overrides-unlock-script set to true.
+  unlock-script:
+    mechanics:
+      play_sound:
+        type: sound
+        sound: ENTITY_PLAYER_LEVELUP
+
+  #Will be run for each spawn point unless it has the option overrides-respawn-script set to true.
+  respawn-script:
+    mechanics:
+      play_sound:
+        type: sound
+        sound: BLOCK_BEACON_ACTIVATE
+
+
+spawn-points:
+  default:
+    location:
+      world: world
+      x: -7.5
+      y: -59
+      z: 2.5
+      yaw: 0.0
+      pitch: 0.0
+    unlock-condition:
+      type: boolean
+      formula: "true"
+    strength: 1
+
+    overrides-unlock-condition: false
+    overrides-unlock-script: false
+    #The global respawn script will not be run for this spawn point.
+    overrides-respawn-script: true
+    respawn-script:
+      mechanics:
+        send_message:
+          type: tell
+          format: 'You just respawned to the lobby.'
+        play_sound:
+          type: sound
+          sound: ENTITY_PLAYER_LEVELUP
+
+
+  village1:
+    location:
+      world: world
+      x: 10
+      y: -59
+      z: 0
+      yaw: 0.0
+      pitch: 0.0
+
+    unlock-condition:
+      type: boolean
+      formula: "false"
+      # type: distance
+      # location: # Location targeter needed here
+      #   type: custom
+      #   world: world
+      #   x: 10
+      #   y: -59
+      #   z: 0
+      #   source: false
+      #   relative: false
+      # max: 100 # 10 blocks away max
+      # source: true
+
+    strength: 1
+    unlock-script:
+      mechanics:
+        send_message:
+          type: tell
+          format: 'Unlocked the village.'
+        play_sound:
+          type: sound
+          sound: ENTITY_PLAYER_LEVELUP
+    respawn-script:
+      mechanics:
+        send_message:
+          type: tell
+          format: 'You just respawned to the village.'
+        #play_sound:
+        #  type: sound
+        #  sound: ENTITY_PLAYER_LEVELUP
+
+default-spawn:
+  #- 'spawnpoint{world-expression="world_nether";id="default"}'
+  - 'last{world-expression="world_nether"}'
+

pom.xml

@@ -75,7 +75,7 @@
         <dependency>
             <groupId>io.lumine</groupId>
             <artifactId>MythicLib-dist</artifactId>
-            <version>1.6-SNAPSHOT</version>
+            <version>1.6.2-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>