Start working on global requirements.

Author: Staartvin

Settings.yml

@@ -50,7 +50,7 @@ sql:
     username: root
     password: ''
     database: minecraft
-    table: autorank
+    server name: '%name%-default'
 # All these options are for configuring your MySQL database with Autorank.
 # Hostname has to include a port, but doesn't have to be port 3306.
 

plugin.yml

@@ -6,7 +6,7 @@ authors: [Staartvin, Armarr]
 softdepend: [Vault, GroupManager, Privileges, bPermissions, PermissionsEx, PermissionsBukkit, DroxPerms, PowerfulPerms, Statz]
 depend: [PluginLibrary]
 description: Reward players based on their stats.
-api-version: 1.14
+api-version: 1.15
 commands:
   autorank:
     description: Master command of AutoRank

pom.xml

@@ -95,14 +95,14 @@
         <dependency>
             <groupId>org.spigotmc</groupId>
             <artifactId>spigot-api</artifactId>
-            <version>1.14.4-R0.1-SNAPSHOT</version>
+            <version>1.15-R0.1-SNAPSHOT</version>
             <type>jar</type>
         </dependency>
 
         <dependency>
             <groupId>org.bukkit</groupId>
             <artifactId>bukkit</artifactId>
-            <version>1.14.4-R0.1-SNAPSHOT</version>
+            <version>1.15-R0.1-SNAPSHOT</version>
         </dependency>
 
         <dependency>

src/me/armar/plugins/autorank/Autorank.java

@@ -18,7 +18,8 @@
 import me.armar.plugins.autorank.pathbuilder.PathManager;
 import me.armar.plugins.autorank.pathbuilder.builders.RequirementBuilder;
 import me.armar.plugins.autorank.pathbuilder.builders.ResultBuilder;
-import me.armar.plugins.autorank.pathbuilder.config.PlayerDataConfig;
+import me.armar.plugins.autorank.pathbuilder.playerdata.global.GlobalPlayerDataStorage;
+import me.armar.plugins.autorank.pathbuilder.playerdata.local.LocalPlayerDataStorage;
 import me.armar.plugins.autorank.pathbuilder.requirement.*;
 import me.armar.plugins.autorank.pathbuilder.result.*;
 import me.armar.plugins.autorank.permissions.PermissionsPluginManager;
@@ -96,7 +97,10 @@ public class Autorank extends JavaPlugin {
     private InternalPropertiesConfig internalPropertiesConfig;
     private PathsConfig pathsConfig;
     private DefaultBehaviorConfig defaultBehaviorConfig;
-    private PlayerDataConfig playerDataConfig;
+
+    // Data storage
+    private LocalPlayerDataStorage localPlayerDataStorage;
+    private GlobalPlayerDataStorage globalPlayerDataStorage;
 
     public static Autorank getInstance() {
         return autorank;
@@ -149,14 +153,17 @@ public void onEnable() {
         setSettingsConfig(new SettingsConfig(this));
         setInternalPropertiesConfig(new InternalPropertiesConfig(this));
         setDefaultBehaviorConfig(new DefaultBehaviorConfig((this)));
-        setPlayerData(new PlayerDataConfig(this));
+
+        // Load data storages
+        setLocalPlayerDataStorage(new LocalPlayerDataStorage(this));
+//        setGlobalPlayerDataStorage(new GlobalPlayerDataStorage(this));
 
         // Create new configs
         this.getDefaultBehaviorConfig().loadConfig();
         this.getPathsConfig().loadConfig();
         this.getSettingsConfig().loadConfig();
         this.getInternalPropertiesConfig().loadConfig();
-        this.getPlayerData().loadConfig();
+        this.getLocalPlayerDataStorage().loadConfig();
 
         // ------------- Initialize managers -------------
 
@@ -791,11 +798,19 @@ public void setTaskManager(TaskManager taskManager) {
         this.taskManager = taskManager;
     }
 
-    public PlayerDataConfig getPlayerData() {
-        return playerDataConfig;
+    public LocalPlayerDataStorage getLocalPlayerDataStorage() {
+        return localPlayerDataStorage;
+    }
+
+    public void setLocalPlayerDataStorage(LocalPlayerDataStorage localPlayerDataStorage) {
+        this.localPlayerDataStorage = localPlayerDataStorage;
+    }
+
+    public GlobalPlayerDataStorage getGlobalPlayerDataStorage() {
+        return globalPlayerDataStorage;
     }
 
-    public void setPlayerData(PlayerDataConfig playerDataConfig) {
-        this.playerDataConfig = playerDataConfig;
+    public void setGlobalPlayerDataStorage(GlobalPlayerDataStorage globalPlayerDataStorage) {
+        this.globalPlayerDataStorage = globalPlayerDataStorage;
     }
 }

src/me/armar/plugins/autorank/config/SettingsConfig.java

@@ -12,11 +12,29 @@
 public class SettingsConfig extends AbstractConfig {
 
     /**
-     * The different type of credentials that is used to connect to a MySQL
-     * database.
+     * Get the value of a specific MySQL credential.
+     *
+     * @param option Type of credential
+     * @return the value for the given MySQL credential.
      */
-    public enum MySQLCredentials {
-        DATABASE, HOSTNAME, PASSWORD, TABLE, USERNAME
+    public String getMySQLCredentials(final MySQLCredentials option) {
+        switch (option) {
+            case HOSTNAME:
+                return this.getConfig().getString("sql.hostname");
+            case USERNAME:
+                return this.getConfig().getString("sql.username");
+            case PASSWORD:
+                return this.getConfig().getString("sql.password");
+            case DATABASE:
+                return this.getConfig().getString("sql.database");
+            case SERVER_NAME:
+                return this.getConfig().getString("sql.server name", "")
+                        .replace("%ip%", getPlugin().getServer().getIp())
+                        .replace("%port%", getPlugin().getServer().getPort() + "")
+                        .replace("%name%", getPlugin().getServer().getName());
+            default:
+                throw new IllegalArgumentException(option + " is not a valid MySQL credential option");
+        }
     }
 
     public SettingsConfig(final Autorank instance) {
@@ -85,26 +103,13 @@ public int getLeaderboardLength() {
     }
 
     /**
-     * Get the value of a specific MySQL credential.
+     * Check whether Autorank should broadcast a message to all online players
+     * when a {@link me.armar.plugins.autorank.storage.TimeType} file is reset.
      *
-     * @param option Type of credential
-     * @return the value for the given MySQL credential.
+     * @return true if Autorank should notice all players. False otherwise.
      */
-    public String getMySQLCredentials(final MySQLCredentials option) {
-        switch (option) {
-            case HOSTNAME:
-                return this.getConfig().getString("sql.hostname");
-            case USERNAME:
-                return this.getConfig().getString("sql.username");
-            case PASSWORD:
-                return this.getConfig().getString("sql.password");
-            case DATABASE:
-                return this.getConfig().getString("sql.database");
-            case TABLE:
-                return this.getConfig().getString("sql.table");
-            default:
-                throw new IllegalArgumentException(option + " is not a valid MySQL credential option");
-        }
+    public boolean shouldBroadcastDataReset() {
+        return this.getConfig().getBoolean("broadcast resetting of data files", true);
     }
 
     /**
@@ -128,13 +133,11 @@ public boolean onlyUsePrimaryGroupVault() {
     }
 
     /**
-     * Check whether Autorank should broadcast a message to all online players
-     * when a {@link TimeType} file is reset.
-     *
-     * @return true if Autorank should notice all players. False otherwise.
+     * The different type of credentials that is used to connect to a MySQL
+     * database.
      */
-    public boolean shouldBroadcastDataReset() {
-        return this.getConfig().getBoolean("broadcast resetting of data files", true);
+    public enum MySQLCredentials {
+        DATABASE, HOSTNAME, PASSWORD, SERVER_NAME, USERNAME
     }
 
     /**

src/me/armar/plugins/autorank/listeners/PlayerJoinListener.java

@@ -93,7 +93,8 @@ public void onPlayerJoin(final PlayerJoinEvent event) {
 
     private void performPendingResults(Player player) {
         // First perform all results when the player has joined a path
-        List<String> joinedPaths = plugin.getPlayerData().getChosenPathsMissingResults(player.getUniqueId());
+        List<String> joinedPaths =
+                plugin.getLocalPlayerDataStorage().getChosenPathsMissingResults(player.getUniqueId());
 
         for (String pathName : joinedPaths) {
             Path path = plugin.getPathManager().findPathByInternalName(pathName, false);
@@ -102,27 +103,27 @@ private void performPendingResults(Player player) {
                 path.performResultsUponChoosing(player);
             }
 
-            plugin.getPlayerData().removeChosenPathMissingResults(player.getUniqueId(), pathName);
+            plugin.getLocalPlayerDataStorage().removeChosenPathMissingResults(player.getUniqueId(), pathName);
         }
 
         // Then perform results when a player has completed a requirement.
         for (Path path : plugin.getPathManager().getAllPaths()) {
             List<Integer> completedRequirements =
-                    plugin.getPlayerData().getCompletedRequirementsMissingResults(player.getUniqueId(),
+                    plugin.getLocalPlayerDataStorage().getCompletedRequirementsMissingResults(player.getUniqueId(),
                             path.getInternalName());
 
             for (int requirementId : completedRequirements) {
                 path.completeRequirement(player.getUniqueId(), requirementId);
 
-                plugin.getPlayerData().removeCompletedRequirementMissingResults(player.getUniqueId(),
+                plugin.getLocalPlayerDataStorage().removeCompletedRequirementMissingResults(player.getUniqueId(),
                         path.getInternalName(), requirementId);
             }
         }
 
 
         // Lastly perform results when a player has completed a path.
         List<String> completedPaths =
-                plugin.getPlayerData().getCompletedPathsMissingResults(player.getUniqueId());
+                plugin.getLocalPlayerDataStorage().getCompletedPathsMissingResults(player.getUniqueId());
 
         for (String pathName : completedPaths) {
             Path path = plugin.getPathManager().findPathByInternalName(pathName, false);
@@ -133,7 +134,7 @@ private void performPendingResults(Player player) {
 
             System.out.println("Performing result of path " + pathName);
 
-            plugin.getPlayerData().removeCompletedPathMissingResults(player.getUniqueId(), pathName);
+            plugin.getLocalPlayerDataStorage().removeCompletedPathMissingResults(player.getUniqueId(), pathName);
         }
 
 

src/me/armar/plugins/autorank/pathbuilder/PathManager.java

@@ -3,8 +3,8 @@
 import me.armar.plugins.autorank.Autorank;
 import me.armar.plugins.autorank.language.Lang;
 import me.armar.plugins.autorank.pathbuilder.builders.PathBuilder;
-import me.armar.plugins.autorank.pathbuilder.config.PlayerDataConfig;
 import me.armar.plugins.autorank.pathbuilder.holders.CompositeRequirement;
+import me.armar.plugins.autorank.pathbuilder.playerdata.local.LocalPlayerDataStorage;
 import me.armar.plugins.autorank.pathbuilder.result.AbstractResult;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
@@ -103,7 +103,7 @@ public void setBuilder(final PathBuilder builder) {
      * @return paths that a player has chosen and is currently on.
      */
     public List<Path> getActivePaths(UUID uuid) {
-        Collection<String> activePathNames = plugin.getPlayerData().getActivePaths(uuid);
+        Collection<String> activePathNames = plugin.getLocalPlayerDataStorage().getActivePaths(uuid);
 
         List<Path> activePaths = new ArrayList<>();
 
@@ -126,7 +126,7 @@ public List<Path> getActivePaths(UUID uuid) {
      * @param uuid UUID of the player.
      */
     public void resetProgressOnActivePaths(UUID uuid) {
-        plugin.getPlayerData().setActivePaths(uuid, new ArrayList<>());
+        plugin.getLocalPlayerDataStorage().setActivePaths(uuid, new ArrayList<>());
     }
 
     /**
@@ -137,8 +137,8 @@ public void resetProgressOnActivePaths(UUID uuid) {
      * @param path Path to reset progress of.
      */
     public void resetProgressOfPath(Path path, UUID uuid) {
-        plugin.getPlayerData().setCompletedPrerequisites(uuid, path.getInternalName(), new ArrayList<>());
-        plugin.getPlayerData().setCompletedRequirements(uuid, path.getInternalName(), new ArrayList<>());
+        plugin.getLocalPlayerDataStorage().setCompletedPrerequisites(uuid, path.getInternalName(), new ArrayList<>());
+        plugin.getLocalPlayerDataStorage().setCompletedRequirements(uuid, path.getInternalName(), new ArrayList<>());
     }
 
     /**
@@ -147,8 +147,8 @@ public void resetProgressOfPath(Path path, UUID uuid) {
      * @param uuid UUID of the player
      */
     public void resetActivePaths(UUID uuid) {
-        for (String activePathName : plugin.getPlayerData().getActivePaths(uuid)) {
-            plugin.getPlayerData().removeActivePath(uuid, activePathName);
+        for (String activePathName : plugin.getLocalPlayerDataStorage().getActivePaths(uuid)) {
+            plugin.getLocalPlayerDataStorage().removeActivePath(uuid, activePathName);
         }
     }
 
@@ -161,7 +161,7 @@ public void resetActivePaths(UUID uuid) {
      * @return a list of paths a player has completed.
      */
     public List<Path> getCompletedPaths(UUID uuid) {
-        Collection<String> completedPathsNames = plugin.getPlayerData().getCompletedPaths(uuid);
+        Collection<String> completedPathsNames = plugin.getLocalPlayerDataStorage().getCompletedPaths(uuid);
 
         List<Path> completedPaths = new ArrayList<>();
 
@@ -184,8 +184,8 @@ public List<Path> getCompletedPaths(UUID uuid) {
      * @param uuid UUID of the player
      */
     public void resetCompletedPaths(UUID uuid) {
-        for (String completedPath : plugin.getPlayerData().getCompletedPaths(uuid)) {
-            plugin.getPlayerData().removeCompletedPath(uuid, completedPath);
+        for (String completedPath : plugin.getLocalPlayerDataStorage().getCompletedPaths(uuid)) {
+            plugin.getLocalPlayerDataStorage().removeCompletedPath(uuid, completedPath);
         }
     }
 
@@ -198,7 +198,7 @@ public void resetCompletedPaths(UUID uuid) {
      * @param reqId Id of the requirement.
      */
     public void addCompletedRequirement(UUID uuid, Path path, int reqId) {
-        plugin.getPlayerData().addCompletedRequirement(uuid, path.getInternalName(), reqId);
+        plugin.getLocalPlayerDataStorage().addCompletedRequirement(uuid, path.getInternalName(), reqId);
     }
 
     /**
@@ -210,7 +210,7 @@ public void addCompletedRequirement(UUID uuid, Path path, int reqId) {
      * @return true if the player has completed the requirement, false otherwise.
      */
     public boolean hasCompletedRequirement(UUID uuid, Path path, int reqId) {
-        return plugin.getPlayerData().hasCompletedRequirement(uuid, path.getInternalName(), reqId);
+        return plugin.getLocalPlayerDataStorage().hasCompletedRequirement(uuid, path.getInternalName(), reqId);
     }
 
     /**
@@ -341,15 +341,15 @@ public void assignPath(Path path, UUID uuid, boolean byForce) throws IllegalArgu
         String internalName = path.getInternalName();
 
         // Add path as an active path.
-        plugin.getPlayerData().addActivePath(uuid, internalName);
+        plugin.getLocalPlayerDataStorage().addActivePath(uuid, internalName);
 
         // Only reset progress if there was no progress stored.
         if (!path.shouldStoreProgressOnDeactivation()) {
             // Reset progress of requirements
-            plugin.getPlayerData().setCompletedRequirements(uuid, internalName, new ArrayList<>());
+            plugin.getLocalPlayerDataStorage().setCompletedRequirements(uuid, internalName, new ArrayList<>());
 
             // Reset progress of prerequisites for a path.
-            plugin.getPlayerData().setCompletedPrerequisites(uuid, internalName, new ArrayList<>());
+            plugin.getLocalPlayerDataStorage().setCompletedPrerequisites(uuid, internalName, new ArrayList<>());
         }
 
         OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(uuid);
@@ -383,7 +383,7 @@ public void deassignPath(Path path, UUID uuid) {
         }
 
         // Remove active path of a player.
-        plugin.getPlayerData().removeActivePath(uuid, path.getInternalName());
+        plugin.getLocalPlayerDataStorage().removeActivePath(uuid, path.getInternalName());
     }
 
     /**
@@ -435,10 +435,10 @@ public List<Path> autoAssignPaths(UUID uuid) {
     public boolean completePath(Path path, UUID uuid) {
 
         // Add progress of completed requirements
-        plugin.getPlayerData().addCompletedPath(uuid, path.getInternalName());
+        plugin.getLocalPlayerDataStorage().addCompletedPath(uuid, path.getInternalName());
 
         // Remove path from active paths.
-        plugin.getPlayerData().removeActivePath(uuid, path.getInternalName());
+        plugin.getLocalPlayerDataStorage().removeActivePath(uuid, path.getInternalName());
 
         OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(uuid);
 
@@ -464,9 +464,9 @@ public boolean completePath(Path path, UUID uuid) {
     /**
      * Get the storage of player data regarding paths and requirements.
      *
-     * @return {@link PlayerDataConfig} object.
+     * @return {@link LocalPlayerDataStorage} object.
      */
-    protected PlayerDataConfig getPlayerDataStorage() {
-        return plugin.getPlayerData();
+    protected LocalPlayerDataStorage getPlayerDataStorage() {
+        return plugin.getLocalPlayerDataStorage();
     }
 }