Fixes a debug route

Ignores &[0-9a-f] color codes when counting towards the name and network string limits
Makes portal lists store cleaned portal and network names to ignore case and color
Names and networks will now match regardless of case and color
Increases portal name/network limit to 13 characters

README.md

@@ -14,6 +14,7 @@ can share a network or be split into clusters; they can be hidden on a network o
 - Underwater portals -- portals can be placed underwater as long as a waterproof button is used
 - API available -- using the API, a lot of behavior can be changed
 - Button customization -- a large amount of materials usable as buttons (buttons, wall corals, shulkers, chests)
+- Config commands -- All main config values can be changed from the commandline
 
 ## Background
 
@@ -80,11 +81,12 @@ stargate.free -- Allow free use/creation/destruction of Stargates
   stargate.free.create -- Allow free creation of Stargates
   stargate.free.destroy -- Allow free destruction of Stargates
   
-stargate.admin -- Allow all admin features (Hidden/Private only so far)
+stargate.admin -- Allow all admin features (Hidden/Private bypass, BungeeCord, Reload, Config)
   stargate.admin.private -- Allow use of Private gates not owned by user
   stargate.admin.hidden -- Allow access to Hidden gates not ownerd by user
   stargate.admin.bungee -- Allow the creation of BungeeCord stargates (U option)
   stargate.admin.reload -- Allow use of the reload command
+  stargate.admin.config -- Allows the player to change config values from the chat
 ```
 
 ## Default Permissions
@@ -117,9 +119,9 @@ section). See the Custom Gate Layout section to learn how to add custom gates.
 
 ### Sign Layout:
 
-- Line 1: Gate Name (Max 11 characters)
-- Line 2: Destination Name \[Optional] (Max 11 characters, used for fixed-gates only)
-- Line 3: Network name \[Optional] (Max 11 characters)
+- Line 1: Gate Name (Max 13 characters)
+- Line 2: Destination Name \[Optional] (Max 13 characters, used for fixed-gates only)
+- Line 3: Network name \[Optional] (Max 13 characters)
 - Line 4: Options \[Optional] :
     - 'A' for always-on fixed gate
     - 'H' for hidden networked gate
@@ -134,7 +136,9 @@ section). See the Custom Gate Layout section to learn how to add custom gates.
     - 'I' is for a silent gate, which does not output anything to the chat while teleporting. Increases immersion
     - 'E' is for gate without a sign. Only for fixed stargates
 
-The options are the single letter, not the word. So to make a private hidden gate, your 4th line would be 'PH'.
+The options are the single letter, not the word. So to make a private hidden gate, your 4th line would be 'PH'. The
+&\[0-9a-f] color codes are not counted in the character limit, thus allowing a 13-character name with an additional 2
+characters used for the color code.
 
 #### Gate networks:
 
@@ -321,7 +325,8 @@ economy:
   useCost - The cost to use a stargate
   toOwner - Whether the money from gate-use goes to the owner or nobody
   chargeFreeDestination - Enable to make players pay for teleportation even if the destination is free
-  freeGatesGreen - Enable to make gates that won't cost the player money show up as green
+  freeGatesColored - Enable to make gates that won't cost the player money show up as green
+  freeGatesColor - This allows you to specify the color of the markings and name of free stargates
 debugging:
   debug - Whether to show massive debug output
   permissionDebug - Whether to show massive permission debug output
@@ -386,6 +391,28 @@ portalInfoServer=Server: %server%
 
 # Changes
 
+#### \[Version 0.9.2.0] EpicKnarvik97 fork
+
+- Increases max length of names and networks to 13 characters
+- Excludes color codes from the counted character length to allow a colored, 13-character name
+- Makes portal names and networks case- and color-agnostic to prevent some confusion caused by typos or sloppy
+  configuration
+- Makes the free gate color configurable, and renames freeGatesGreen to freeGatesColored
+
+#### \[Version 0.9.1.2] EpicKnarvik97 fork
+
+- Allows a sneaking player to see information about a silent stargate with no sign
+
+#### \[Version 0.9.1.1] EpicKnarvik97 fork
+
+- Makes sure to translate the `&` character to fix a bug causing portal signs to not be colored on some servers
+
+#### \[Version 0.9.1.0] EpicKnarvik97 fork
+
+- Rewrites config loading as a part of the changes required to implement config commands
+- This update adds commands to change all config values from the chat or the console, complete with tab completion
+- Adds a new permission "stargate.admin.config" which is required to edit config values from the chat
+
 #### \[Version 0.9.0.7] EpicKnarvik97 fork
 
 - Stops registering the sign as a lookup block for stargates without a sign

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>net.knarcraft</groupId>
     <artifactId>Stargate</artifactId>
-    <version>0.9.0.7</version>
+    <version>0.9.2.0</version>
 
     <licenses>
         <license>

src/main/java/net/knarcraft/stargate/Stargate.java

@@ -139,6 +139,15 @@ public class Stargate extends JavaPlugin {
         return logger;
     }
 
+    /**
+     * Gets the max length of portal names and networks
+     *
+     * @return <p>The max portal name/network length</p>
+     */
+    public static int getMaxNameNetworkLength() {
+        return 13;
+    }
+
     /**
      * Sends a debug message
      *

src/main/java/net/knarcraft/stargate/command/CommandConfig.java

@@ -0,0 +1,144 @@
+package net.knarcraft.stargate.command;
+
+import net.knarcraft.stargate.Stargate;
+import net.knarcraft.stargate.config.ConfigOption;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * This command represents the config command for changing config values
+ */
+public class CommandConfig implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                             @NotNull String[] args) {
+        if (commandSender instanceof Player player) {
+            if (!player.hasPermission("stargate.admin.config")) {
+                Stargate.getMessageSender().sendErrorMessage(commandSender, "Permission Denied");
+                return true;
+            }
+        }
+
+        if (args.length > 0) {
+            ConfigOption selectedOption = ConfigOption.getByName(args[0]);
+            if (selectedOption == null) {
+                return false;
+            }
+            if (args.length > 1) {
+                updateConfigValue(selectedOption, commandSender, args[1]);
+            } else {
+                //Display info and the current value of the given config value
+                printConfigOptionValue(commandSender, selectedOption);
+            }
+            return true;
+        } else {
+            //Display all config options
+            displayConfigValues(commandSender);
+        }
+        return true;
+    }
+
+    /**
+     * Updates a config value
+     *
+     * @param selectedOption <p>The option which should be updated</p>
+     * @param commandSender  <p>The command sender that changed the value</p>
+     * @param value          <p>The new value of the config option</p>
+     */
+    private void updateConfigValue(ConfigOption selectedOption, CommandSender commandSender, String value) {
+        FileConfiguration configuration = Stargate.getInstance().getConfig();
+
+        //Validate any sign colors
+        if (selectedOption == ConfigOption.MAIN_SIGN_COLOR || selectedOption == ConfigOption.HIGHLIGHT_SIGN_COLOR) {
+            try {
+                ChatColor.valueOf(value.toUpperCase());
+            } catch (IllegalArgumentException | NullPointerException ignored) {
+                commandSender.sendMessage(ChatColor.RED + "Invalid color given");
+                return;
+            }
+        }
+
+        //Store the config values, accounting for the data type
+        switch (selectedOption.getDataType()) {
+            case BOOLEAN -> configuration.set(selectedOption.getConfigNode(), Boolean.parseBoolean(value));
+            case INTEGER -> {
+                try {
+                    configuration.set(selectedOption.getConfigNode(), Integer.parseInt(value));
+                } catch (NumberFormatException exception) {
+                    commandSender.sendMessage(ChatColor.RED + "Invalid number given");
+                    return;
+                }
+            }
+            case STRING -> {
+                if (selectedOption == ConfigOption.GATE_FOLDER || selectedOption == ConfigOption.PORTAL_FOLDER ||
+                        selectedOption == ConfigOption.DEFAULT_GATE_NETWORK) {
+                    if (value.contains("../") || value.contains("..\\")) {
+                        commandSender.sendMessage(ChatColor.RED + "Path traversal characters cannot be used");
+                        return;
+                    }
+                }
+                configuration.set(selectedOption.getConfigNode(), value);
+            }
+            default -> configuration.set(selectedOption.getConfigNode(), value);
+        }
+
+        //Save the config file and reload if necessary
+        Stargate.getInstance().saveConfig();
+        reloadIfNecessary(commandSender);
+    }
+
+    /**
+     * Reloads the config if necessary
+     *
+     * @param commandSender <p>The command sender initiating the reload</p>
+     */
+    private void reloadIfNecessary(CommandSender commandSender) {
+        //TODO: Only update the config values which have changed and do the least amount of work necessary to load the 
+        // changes. Only do a full reload if absolutely necessary, or when the partial reloading would be as 
+        // inefficient as a full reload.
+        Stargate.getStargateConfig().reload(commandSender);
+    }
+
+    /**
+     * Prints information about a config option and its current value
+     *
+     * @param sender <p>The command sender that sent the command</p>
+     * @param option <p>The config option to print information about</p>
+     */
+    private void printConfigOptionValue(CommandSender sender, ConfigOption option) {
+        Object value = Stargate.getStargateConfig().getConfigOptions().get(option);
+        sender.sendMessage(getOptionDescription(option));
+        sender.sendMessage(ChatColor.GREEN + "Current value: " + ChatColor.GOLD + value);
+    }
+
+    /**
+     * Displays the name and a small description of every config value
+     *
+     * @param sender <p>The command sender to display the config list to</p>
+     */
+    private void displayConfigValues(CommandSender sender) {
+        sender.sendMessage(ChatColor.GREEN + Stargate.getBackupString("prefix") + ChatColor.GOLD +
+                "Config values:");
+        for (ConfigOption option : ConfigOption.values()) {
+            sender.sendMessage(getOptionDescription(option));
+        }
+    }
+
+    /**
+     * Gets the description of a single config option
+     *
+     * @param option <p>The option to describe</p>
+     * @return <p>A string describing the config option</p>
+     */
+    private String getOptionDescription(ConfigOption option) {
+        return ChatColor.GOLD + option.getName() + ChatColor.WHITE + " - " + ChatColor.GREEN + option.getDescription() +
+                ChatColor.DARK_GRAY + " (Default: " + ChatColor.GRAY + option.getDefaultValue() + ChatColor.DARK_GRAY + ")";
+    }
+
+}

src/main/java/net/knarcraft/stargate/command/CommandStarGate.java

@@ -1,6 +1,7 @@
 package net.knarcraft.stargate.command;
 
 import net.knarcraft.stargate.Stargate;
+import org.apache.commons.lang.ArrayUtils;
 import org.bukkit.ChatColor;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
@@ -23,6 +24,9 @@ public class CommandStarGate implements CommandExecutor {
                 return new CommandAbout().onCommand(commandSender, command, s, args);
             } else if (args[0].equalsIgnoreCase("reload")) {
                 return new CommandReload().onCommand(commandSender, command, s, args);
+            } else if (args[0].equalsIgnoreCase("config")) {
+                String[] subArgs = (String[]) ArrayUtils.remove(args, 0);
+                return new CommandConfig().onCommand(commandSender, command, s, subArgs);
             }
             return false;
         } else {

src/main/java/net/knarcraft/stargate/command/ConfigTabCompleter.java

@@ -0,0 +1,183 @@
+package net.knarcraft.stargate.command;
+
+import net.knarcraft.stargate.config.ConfigOption;
+import net.knarcraft.stargate.config.OptionDataType;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This is the completer for stargates config sub-command (/sg config)
+ */
+public class ConfigTabCompleter implements TabCompleter {
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                                      @NotNull String[] args) {
+
+        if (args.length > 1) {
+            ConfigOption selectedOption = ConfigOption.getByName(args[0]);
+            if (selectedOption == null) {
+                return new ArrayList<>();
+            } else {
+                return getPossibleOptionValues(selectedOption, args[1]);
+            }
+        } else {
+            List<String> configOptionNames = new ArrayList<>();
+            for (ConfigOption option : ConfigOption.values()) {
+                configOptionNames.add(option.getName());
+            }
+            return filterMatching(configOptionNames, args[0]);
+        }
+    }
+
+    /**
+     * Find completable strings which match the text typed by the command's sender
+     *
+     * @param values    <p>The values to filter</p>
+     * @param typedText <p>The text the player has started typing</p>
+     * @return <p>The given string values which start with the player's typed text</p>
+     */
+    private List<String> filterMatching(List<String> values, String typedText) {
+        List<String> configValues = new ArrayList<>();
+        for (String value : values) {
+            if (value.toLowerCase().startsWith(typedText.toLowerCase())) {
+                configValues.add(value);
+            }
+        }
+        return configValues;
+    }
+
+    /**
+     * Get possible values for the selected option
+     *
+     * @param selectedOption <p>The selected option</p>
+     * @param typedText      <p>The beginning of the typed text, for filtering matching results</p>
+     * @return <p>Some or all of the valid values for the option</p>
+     */
+    private List<String> getPossibleOptionValues(ConfigOption selectedOption, String typedText) {
+        List<String> booleans = new ArrayList<>();
+        booleans.add("true");
+        booleans.add("false");
+
+        List<String> numbers = new ArrayList<>();
+        numbers.add("0");
+        numbers.add("5");
+
+        switch (selectedOption) {
+            case LANGUAGE:
+                //Return available languages
+                return filterMatching(getLanguages(), typedText);
+            case GATE_FOLDER:
+            case PORTAL_FOLDER:
+            case DEFAULT_GATE_NETWORK:
+                //Just return the default value as most values should be possible
+                if (typedText.trim().isEmpty()) {
+                    return putStringInList((String) selectedOption.getDefaultValue());
+                } else {
+                    return new ArrayList<>();
+                }
+            case MAIN_SIGN_COLOR:
+            case HIGHLIGHT_SIGN_COLOR:
+            case FREE_GATES_COLOR:
+                //Return all colors
+                return filterMatching(getColors(), typedText);
+        }
+
+        //If the config value is a boolean, show the two boolean values
+        if (selectedOption.getDataType() == OptionDataType.BOOLEAN) {
+            return filterMatching(booleans, typedText);
+        }
+
+        //If the config value is an integer, display some valid numbers
+        if (selectedOption.getDataType() == OptionDataType.INTEGER) {
+            if (typedText.trim().isEmpty()) {
+                return numbers;
+            } else {
+                return new ArrayList<>();
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Gets all available languages
+     *
+     * @return <p>The available languages</p>
+     */
+    private List<String> getLanguages() {
+        List<String> languages = new ArrayList<>();
+        languages.add("de");
+        languages.add("en");
+        languages.add("es");
+        languages.add("fr");
+        languages.add("hu");
+        languages.add("it");
+        languages.add("nb-no");
+        languages.add("nl");
+        languages.add("nn-no");
+        languages.add("pt-br");
+        languages.add("ru");
+        return languages;
+    }
+
+    /**
+     * Gets all available colors
+     *
+     * @return <p>All available colors</p>
+     */
+    private List<String> getColors() {
+        List<String> colors = new ArrayList<>();
+        for (ChatColor color : getChatColors()) {
+            colors.add(color.name());
+        }
+        return colors;
+    }
+
+    /**
+     * Gets a list of all available chat colors
+     *
+     * @return <p>A list of chat colors</p>
+     */
+    private List<ChatColor> getChatColors() {
+        List<ChatColor> chatColors = new ArrayList<>();
+        chatColors.add(ChatColor.WHITE);
+        chatColors.add(ChatColor.BLUE);
+        chatColors.add(ChatColor.DARK_BLUE);
+        chatColors.add(ChatColor.DARK_PURPLE);
+        chatColors.add(ChatColor.LIGHT_PURPLE);
+        chatColors.add(ChatColor.GOLD);
+        chatColors.add(ChatColor.GREEN);
+        chatColors.add(ChatColor.BLACK);
+        chatColors.add(ChatColor.DARK_GREEN);
+        chatColors.add(ChatColor.DARK_RED);
+        chatColors.add(ChatColor.RED);
+        chatColors.add(ChatColor.AQUA);
+        chatColors.add(ChatColor.DARK_AQUA);
+        chatColors.add(ChatColor.DARK_GRAY);
+        chatColors.add(ChatColor.GRAY);
+        chatColors.add(ChatColor.YELLOW);
+        return chatColors;
+    }
+
+    /**
+     * Puts a single string value into a string list
+     *
+     * @param value <p>The string to make into a list</p>
+     * @return <p>A list containing the string value</p>
+     */
+    private List<String> putStringInList(String value) {
+        List<String> list = new ArrayList<>();
+        list.add(value);
+        return list;
+    }
+
+}

src/main/java/net/knarcraft/stargate/command/StarGateTabCompleter.java

@@ -1,8 +1,10 @@
 package net.knarcraft.stargate.command;
 
+import org.apache.commons.lang.ArrayUtils;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -17,15 +19,39 @@ public class StarGateTabCompleter implements TabCompleter {
     @Override
     public @Nullable List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command,
                                                 @NotNull String s, @NotNull String[] args) {
-        List<String> commands = new ArrayList<>();
-        commands.add("about");
-        commands.add("reload");
-
         if (args.length == 1) {
-            return commands;
+            List<String> commands = getAvailableCommands(commandSender);
+            List<String> matchingCommands = new ArrayList<>();
+            for (String availableCommand : commands) {
+                if (availableCommand.startsWith(args[0])) {
+                    matchingCommands.add(availableCommand);
+                }
+            }
+            return matchingCommands;
+        } else if (args.length > 1 && args[0].equalsIgnoreCase("config")) {
+            String[] subArgs = (String[]) ArrayUtils.remove(args, 0);
+            return new ConfigTabCompleter().onTabComplete(commandSender, command, s, subArgs);
         } else {
             return new ArrayList<>();
         }
     }
 
+    /**
+     * Gets the available commands
+     *
+     * @param commandSender <p>The command sender to get available commands for</p>
+     * @return <p>The commands available to the command sender</p>
+     */
+    private List<String> getAvailableCommands(CommandSender commandSender) {
+        List<String> commands = new ArrayList<>();
+        commands.add("about");
+        if (!(commandSender instanceof Player player) || player.hasPermission("stargate.admin.reload")) {
+            commands.add("reload");
+        }
+        if (!(commandSender instanceof Player player) || player.hasPermission("stargate.admin.config")) {
+            commands.add("config");
+        }
+        return commands;
+    }
+
 }

src/main/java/net/knarcraft/stargate/config/ConfigOption.java

@@ -0,0 +1,245 @@
+package net.knarcraft.stargate.config;
+
+/**
+ * A ConfigOption represents one of the available config options
+ */
+public enum ConfigOption {
+
+    /**
+     * The language used for player-interface text
+     */
+    LANGUAGE("language", "The language used for all signs and all messages to players", "en"),
+
+    /**
+     * The folder for portal files
+     */
+    PORTAL_FOLDER("folders.portalFolder", "The folder containing the portal databases", "plugins/Stargate/portals/"),
+
+    /**
+     * The folder for gate files
+     */
+    GATE_FOLDER("folders.gateFolder", "The folder containing all gate files", "plugins/Stargate/gates/"),
+
+    /**
+     * The max number of portals on a single network
+     */
+    MAX_GATES_EACH_NETWORK("gates.maxGatesEachNetwork", "The max number of stargates in a single network", 0),
+
+    /**
+     * The network used if not specified
+     */
+    DEFAULT_GATE_NETWORK("gates.defaultGateNetwork", "The network used when no network is specified", "central"),
+
+    /**
+     * Whether to remember the lastly used destination
+     */
+    REMEMBER_DESTINATION("gates.cosmetic.rememberDestination", "Whether to remember the last destination used", false),
+
+    /**
+     * Whether to sort the network destinations
+     */
+    SORT_NETWORK_DESTINATIONS("gates.cosmetic.sortNetworkDestinations", "Whether to sort destinations by name", false),
+
+    /**
+     * The main color to use for all signs
+     */
+    MAIN_SIGN_COLOR("gates.cosmetic.mainSignColor", "The main text color of all stargate signs", "BLACK"),
+
+    /**
+     * The color to use for highlighting sign text
+     */
+    HIGHLIGHT_SIGN_COLOR("gates.cosmetic.highlightSignColor", "The text color used for highlighting stargate signs", "WHITE"),
+
+    /**
+     * Whether to destroy portals when any blocks are broken by explosions
+     */
+    DESTROYED_BY_EXPLOSION("gates.integrity.destroyedByExplosion", "Whether stargates should be destroyed by explosions", false),
+
+    /**
+     * Whether to verify each portal's gate layout after each load
+     */
+    VERIFY_PORTALS("gates.integrity.verifyPortals", "Whether to verify that portals match their gate layout on load", false),
+
+    /**
+     * Whether to protect the entrance of portals
+     */
+    PROTECT_ENTRANCE("gates.integrity.protectEntrance", "Whether to protect stargates' entrances", false),
+
+    /**
+     * Whether to enable BungeeCord support
+     */
+    ENABLE_BUNGEE("gates.functionality.enableBungee", "Whether to enable BungeeCord support", false),
+
+    /**
+     * Whether to enable vehicle teleportation
+     */
+    HANDLE_VEHICLES("gates.functionality.handleVehicles", "Whether to enable vehicle teleportation", true),
+
+    /**
+     * Whether to enable teleportation of empty vehicles
+     */
+    HANDLE_EMPTY_VEHICLES("gates.functionality.handleEmptyVehicles", "Whether to enable teleportation of empty vehicles", true),
+
+    /**
+     * Whether to enable teleportation of creatures using vehicles
+     */
+    HANDLE_CREATURE_TRANSPORTATION("gates.functionality.handleCreatureTransportation",
+            "Whether to enable teleportation of vehicles containing non-player creatures", true),
+
+    /**
+     * Whether to allow creatures to teleport alone, bypassing any access restrictions
+     */
+    HANDLE_NON_PLAYER_VEHICLES("gates.functionality.handleNonPlayerVehicles",
+            "Whether to enable teleportation of non-empty vehicles without a player", true),
+
+    /**
+     * Whether to enable teleportations of creatures on a leash
+     */
+    HANDLE_LEASHED_CREATURES("gates.functionality.handleLeashedCreatures",
+            "Whether to enable players to teleport a creature on a leash", true),
+
+    /**
+     * Whether to enable economy support for taking payment from players creating/destroying/using stargates
+     */
+    USE_ECONOMY("economy.useEconomy", "Whether to use economy to incur fees when stargates are used, created or destroyed", false),
+
+    /**
+     * The cost of creating a new stargate
+     */
+    CREATE_COST("economy.createCost", "The cost of creating a new stargate", 0),
+
+    /**
+     * The cost of destroying a stargate
+     */
+    DESTROY_COST("economy.destroyCost", "The cost of destroying a stargate. Negative to refund", 0),
+
+    /**
+     * The cost of using (teleporting through) a stargate
+     */
+    USE_COST("economy.useCost", "The cost of using (teleporting through) a stargate", 0),
+
+    /**
+     * Whether any payments should go to the stargate's owner
+     */
+    TO_OWNER("economy.toOwner", "Whether any teleportation fees should go to the owner of the used stargate", false),
+
+    /**
+     * Whether to charge for using a stargate, even if its destination is free
+     */
+    CHARGE_FREE_DESTINATION("economy.chargeFreeDestination",
+            "Whether to require payment if the destination is free, but the entrance stargate is not", true),
+
+    /**
+     * Whether to mark free gates with a different color
+     */
+    FREE_GATES_COLORED("economy.freeGatesColored", "Whether to use coloring to mark all free stargates", false),
+
+    /**
+     * The color to use for marking free stargates
+     */
+    FREE_GATES_COLOR("economy.freeGatesColor", "The color to use for marking free stargates", "DARK_GREEN"),
+
+    /**
+     * Whether to enable debug output
+     */
+    DEBUG("debugging.debug", "Whether to enable debugging output", false),
+
+    /**
+     * Whether to enable debug output for debugging permissions
+     */
+    PERMISSION_DEBUG("debugging.permissionDebug", "Whether to enable permission debugging output", false);
+
+
+    private final String configNode;
+    private final String description;
+    private final Object defaultValue;
+    private final OptionDataType dataType;
+
+    /**
+     * Instantiates a new config option
+     *
+     * @param configNode   <p>The full path of this config option's config node</p>
+     * @param description  <p>The description of what this config option does</p>
+     * @param defaultValue <p>The default value of this config option</p>
+     */
+    ConfigOption(String configNode, String description, Object defaultValue) {
+        this.configNode = configNode;
+        this.description = description;
+        this.defaultValue = defaultValue;
+
+        if (defaultValue instanceof String) {
+            this.dataType = OptionDataType.STRING;
+        } else if (defaultValue instanceof Boolean) {
+            this.dataType = OptionDataType.BOOLEAN;
+        } else if (defaultValue instanceof Integer) {
+            this.dataType = OptionDataType.INTEGER;
+        } else {
+            throw new IllegalArgumentException("Unknown config data type encountered.");
+        }
+    }
+
+    /**
+     * Gets a config option given its name
+     *
+     * @param name <p>The name of the config option to get</p>
+     * @return <p>The corresponding config option, or null if the name is invalid</p>
+     */
+    public static ConfigOption getByName(String name) {
+        for (ConfigOption option : ConfigOption.values()) {
+            if (option.getName().equalsIgnoreCase(name)) {
+                return option;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Gets the name of this config option
+     *
+     * @return <p>The name of this config option</p>
+     */
+    public String getName() {
+        if (!this.configNode.contains(".")) {
+            return this.configNode;
+        }
+        String[] pathParts = this.configNode.split("\\.");
+        return pathParts[pathParts.length - 1];
+    }
+
+    /**
+     * Gets the data type used for storing this config option
+     *
+     * @return <p>The data type used</p>
+     */
+    public OptionDataType getDataType() {
+        return this.dataType;
+    }
+
+    /**
+     * Gets the config node of this config option
+     *
+     * @return <p>This config option's config node</p>
+     */
+    public String getConfigNode() {
+        return this.configNode;
+    }
+
+    /**
+     * Gets the description of what this config option does
+     *
+     * @return <p>The description of this config option</p>
+     */
+    public String getDescription() {
+        return this.description;
+    }
+
+    /**
+     * Gets this config option's default value
+     *
+     * @return <p>This config option's default value</p>
+     */
+    public Object getDefaultValue() {
+        return this.defaultValue;
+    }
+
+}

src/main/java/net/knarcraft/stargate/config/EconomyConfig.java

@@ -2,17 +2,19 @@ package net.knarcraft.stargate.config;
 
 import net.knarcraft.stargate.Stargate;
 import net.knarcraft.stargate.portal.Portal;
+import net.knarcraft.stargate.portal.PortalSignDrawer;
 import net.knarcraft.stargate.portal.property.gate.Gate;
 import net.knarcraft.stargate.utility.PermissionHelper;
 import net.milkbowl.vault.economy.Economy;
 import org.bukkit.Bukkit;
-import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.RegisteredServiceProvider;
 import org.bukkit.plugin.ServicesManager;
 
+import java.util.Map;
 import java.util.UUID;
 
 /**
@@ -28,15 +30,15 @@ public final class EconomyConfig {
     private int destroyCost = 0;
     private boolean toOwner = false;
     private boolean chargeFreeDestination = true;
-    private boolean freeGatesGreen = false;
+    private boolean freeGatesColored = false;
 
     /**
      * Instantiates a new economy config
      *
-     * @param newConfig <p>The file configuration to read values from</p>
+     * @param configOptions <p>The loaded config options to read</p>
      */
-    public EconomyConfig(FileConfiguration newConfig) {
-        loadEconomyConfig(newConfig);
+    public EconomyConfig(Map<ConfigOption, Object> configOptions) {
+        loadEconomyConfig(configOptions);
     }
 
     /**
@@ -84,12 +86,12 @@ public final class EconomyConfig {
     }
 
     /**
-     * Gets whether free portals should be marked with green coloring
+     * Gets whether free portals should be marked with a different coloring
      *
-     * @return <p>Whether free portals should be green</p>
+     * @return <p>Whether free portals should be colored</p>
      */
-    public boolean drawFreePortalsGreen() {
-        return freeGatesGreen;
+    public boolean drawFreePortalsColored() {
+        return freeGatesColored;
     }
 
     /**
@@ -332,16 +334,23 @@ public final class EconomyConfig {
     /**
      * Loads all config values related to economy
      *
-     * @param newConfig <p>The configuration containing the values to read</p>
+     * @param configOptions <p>The loaded config options to get values from</p>
      */
-    private void loadEconomyConfig(FileConfiguration newConfig) {
-        economyEnabled = newConfig.getBoolean("economy.useEconomy");
-        setDefaultCreateCost(newConfig.getInt("economy.createCost"));
-        setDefaultDestroyCost(newConfig.getInt("economy.destroyCost"));
-        setDefaultUseCost(newConfig.getInt("economy.useCost"));
-        toOwner = newConfig.getBoolean("economy.toOwner");
-        chargeFreeDestination = newConfig.getBoolean("economy.chargeFreeDestination");
-        freeGatesGreen = newConfig.getBoolean("economy.freeGatesGreen");
+    private void loadEconomyConfig(Map<ConfigOption, Object> configOptions) {
+        economyEnabled = (boolean) configOptions.get(ConfigOption.USE_ECONOMY);
+        setDefaultCreateCost((Integer) configOptions.get(ConfigOption.CREATE_COST));
+        setDefaultDestroyCost((Integer) configOptions.get(ConfigOption.DESTROY_COST));
+        setDefaultUseCost((Integer) configOptions.get(ConfigOption.USE_COST));
+        toOwner = (boolean) configOptions.get(ConfigOption.TO_OWNER);
+        chargeFreeDestination = (boolean) configOptions.get(ConfigOption.CHARGE_FREE_DESTINATION);
+        freeGatesColored = (boolean) configOptions.get(ConfigOption.FREE_GATES_COLORED);
+
+        try {
+            String freeColor = (String) configOptions.get(ConfigOption.FREE_GATES_COLOR);
+            PortalSignDrawer.setFreeColor(ChatColor.valueOf(freeColor.toUpperCase()));
+        } catch (IllegalArgumentException | NullPointerException ignored) {
+            PortalSignDrawer.setFreeColor(ChatColor.DARK_GREEN);
+        }
     }
 
     /**

src/main/java/net/knarcraft/stargate/config/OptionDataType.java

@@ -0,0 +1,21 @@
+package net.knarcraft.stargate.config;
+
+/**
+ * An enum defining the different data types an option can have
+ */
+public enum OptionDataType {
+
+    /**
+     * The data type for the option is a String
+     */
+    STRING,
+    /**
+     * The data type for the option is a Boolean
+     */
+    BOOLEAN,
+    /**
+     * The data type for the option is an Integer
+     */
+    INTEGER
+
+}

src/main/java/net/knarcraft/stargate/config/StargateConfig.java

@@ -18,6 +18,7 @@ import org.bukkit.plugin.messaging.Messenger;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Queue;
@@ -47,6 +48,7 @@ public final class StargateConfig {
 
     private boolean debuggingEnabled = false;
     private boolean permissionDebuggingEnabled = false;
+    private final Map<ConfigOption, Object> configOptions;
 
     /**
      * Instantiates a new stargate config
@@ -55,6 +57,7 @@ public final class StargateConfig {
      */
     public StargateConfig(Logger logger) {
         this.logger = logger;
+        configOptions = new HashMap<>();
 
         dataFolderPath = Stargate.getInstance().getDataFolder().getPath().replaceAll("\\\\", "/");
         portalFolder = dataFolderPath + "/portals/";
@@ -90,6 +93,15 @@ public final class StargateConfig {
         setupVaultEconomy();
     }
 
+    /**
+     * Gets a copy of all loaded config options with its values
+     *
+     * @return <p>The loaded config options</p>
+     */
+    public Map<ConfigOption, Object> getConfigOptions() {
+        return new HashMap<>(configOptions);
+    }
+
     /**
      * Gets the queue of open portals
      *
@@ -297,9 +309,7 @@ public final class StargateConfig {
         FileConfiguration newConfig = Stargate.getInstance().getConfig();
 
         boolean isMigrating = false;
-        if (newConfig.getString("lang") != null ||
-                newConfig.getString("gates.integrity.ignoreEntrance") != null ||
-                newConfig.getString("ignoreEntrance") != null) {
+        if (newConfig.getString("lang") != null || newConfig.getString("economy.freeGatesGreen") != null) {
             migrateConfig(newConfig);
             isMigrating = true;
         }
@@ -307,16 +317,34 @@ public final class StargateConfig {
         //Copy missing default values if any values are missing
         newConfig.options().copyDefaults(true);
 
+        //Load all options
+        for (ConfigOption option : ConfigOption.values()) {
+            Object optionValue;
+            String configNode = option.getConfigNode();
+
+            //Load the option using its correct data type
+            switch (option.getDataType()) {
+                case STRING -> {
+                    String value = newConfig.getString(configNode);
+                    optionValue = value != null ? value.trim() : "";
+                }
+                case BOOLEAN -> optionValue = newConfig.getBoolean(configNode);
+                case INTEGER -> optionValue = newConfig.getInt(configNode);
+                default -> throw new IllegalArgumentException("Invalid config data type encountered");
+            }
+            configOptions.put(option, optionValue);
+        }
+
         //Get the language name from the config
-        languageName = newConfig.getString("language");
+        languageName = (String) configOptions.get(ConfigOption.LANGUAGE);
 
         //Get important folders from the config
-        portalFolder = newConfig.getString("folders.portalFolder");
-        gateFolder = newConfig.getString("folders.gateFolder");
+        portalFolder = (String) configOptions.get(ConfigOption.PORTAL_FOLDER);
+        gateFolder = (String) configOptions.get(ConfigOption.GATE_FOLDER);
 
         //Get enabled debug settings from the config
-        debuggingEnabled = newConfig.getBoolean("debugging.debug");
-        permissionDebuggingEnabled = newConfig.getBoolean("debugging.permissionDebug");
+        debuggingEnabled = (boolean) configOptions.get(ConfigOption.DEBUG);
+        permissionDebuggingEnabled = (boolean) configOptions.get(ConfigOption.PERMISSION_DEBUG);
 
         //If users have an outdated config, assume they also need to update their default gates
         if (isMigrating) {
@@ -324,10 +352,10 @@ public final class StargateConfig {
         }
 
         //Load all gate config values
-        stargateGateConfig = new StargateGateConfig(newConfig);
+        stargateGateConfig = new StargateGateConfig(configOptions);
 
         //Load all economy config values
-        economyConfig = new EconomyConfig(newConfig);
+        economyConfig = new EconomyConfig(configOptions);
 
         Stargate.getInstance().saveConfig();
     }

src/main/java/net/knarcraft/stargate/config/StargateGateConfig.java

@@ -3,36 +3,25 @@ package net.knarcraft.stargate.config;
 import net.knarcraft.stargate.Stargate;
 import net.knarcraft.stargate.portal.PortalSignDrawer;
 import org.bukkit.ChatColor;
-import org.bukkit.configuration.file.FileConfiguration;
+
+import java.util.Map;
 
 /**
  * The Stargate gate config keeps track of all global config values related to gates
  */
 public final class StargateGateConfig {
-
-    private int maxGatesEachNetwork = 0;
-    private boolean rememberDestination = false;
-    private boolean handleVehicles = true;
-    private boolean handleEmptyVehicles = true;
-    private boolean handleCreatureTransportation = true;
-    private boolean handleNonPlayerVehicles = true;
-    private boolean handleLeashedCreatures = true;
-    private boolean sortNetworkDestinations = false;
-    private boolean protectEntrance = false;
-    private boolean enableBungee = true;
-    private boolean verifyPortals = true;
-    private boolean destroyExplosion = false;
-    private String defaultGateNetwork = "central";
     private static final int activeTime = 10;
     private static final int openTime = 10;
+    private final Map<ConfigOption, Object> configOptions;
 
     /**
      * Instantiates a new stargate config
      *
-     * @param newConfig <p>The file configuration to read values from</p>
+     * @param configOptions <p>The loaded config options to use</p>
      */
-    public StargateGateConfig(FileConfiguration newConfig) {
-        loadGateConfig(newConfig);
+    public StargateGateConfig(Map<ConfigOption, Object> configOptions) {
+        this.configOptions = configOptions;
+        loadGateConfig();
     }
 
     /**
@@ -59,7 +48,7 @@ public final class StargateGateConfig {
      * @return <p>Maximum number of gates for each network</p>
      */
     public int maxGatesEachNetwork() {
-        return maxGatesEachNetwork;
+        return (int) configOptions.get(ConfigOption.MAX_GATES_EACH_NETWORK);
     }
 
     /**
@@ -68,7 +57,7 @@ public final class StargateGateConfig {
      * @return <p>Whether a portal's lastly used destination should be remembered</p>
      */
     public boolean rememberDestination() {
-        return rememberDestination;
+        return (boolean) configOptions.get(ConfigOption.REMEMBER_DESTINATION);
     }
 
     /**
@@ -77,7 +66,7 @@ public final class StargateGateConfig {
      * @return <p>Whether vehicle teleportation should be handled</p>
      */
     public boolean handleVehicles() {
-        return handleVehicles;
+        return (boolean) configOptions.get(ConfigOption.HANDLE_VEHICLES);
     }
 
     /**
@@ -89,7 +78,7 @@ public final class StargateGateConfig {
      * @return <p>Whether vehicles without passengers should be handled</p>
      */
     public boolean handleEmptyVehicles() {
-        return handleEmptyVehicles;
+        return (boolean) configOptions.get(ConfigOption.HANDLE_EMPTY_VEHICLES);
     }
 
     /**
@@ -101,7 +90,7 @@ public final class StargateGateConfig {
      * @return <p>Whether vehicles with creatures should be handled</p>
      */
     public boolean handleCreatureTransportation() {
-        return handleCreatureTransportation;
+        return (boolean) configOptions.get(ConfigOption.HANDLE_CREATURE_TRANSPORTATION);
     }
 
     /**
@@ -118,7 +107,7 @@ public final class StargateGateConfig {
      * @return <p>Whether non-empty vehicles without a player should be handled</p>
      */
     public boolean handleNonPlayerVehicles() {
-        return handleNonPlayerVehicles;
+        return (boolean) configOptions.get(ConfigOption.HANDLE_NON_PLAYER_VEHICLES);
     }
 
     /**
@@ -127,7 +116,7 @@ public final class StargateGateConfig {
      * @return <p>Whether leashed creatures should be handled</p>
      */
     public boolean handleLeashedCreatures() {
-        return handleLeashedCreatures;
+        return (boolean) configOptions.get(ConfigOption.HANDLE_LEASHED_CREATURES);
     }
 
     /**
@@ -136,7 +125,7 @@ public final class StargateGateConfig {
      * @return <p>Whether network destinations should be sorted</p>
      */
     public boolean sortNetworkDestinations() {
-        return sortNetworkDestinations;
+        return (boolean) configOptions.get(ConfigOption.SORT_NETWORK_DESTINATIONS);
     }
 
     /**
@@ -145,7 +134,7 @@ public final class StargateGateConfig {
      * @return <p>Whether portal entrances should be protected</p>
      */
     public boolean protectEntrance() {
-        return protectEntrance;
+        return (boolean) configOptions.get(ConfigOption.PROTECT_ENTRANCE);
     }
 
     /**
@@ -154,7 +143,7 @@ public final class StargateGateConfig {
      * @return <p>Whether bungee support is enabled</p>
      */
     public boolean enableBungee() {
-        return enableBungee;
+        return (boolean) configOptions.get(ConfigOption.ENABLE_BUNGEE);
     }
 
     /**
@@ -163,7 +152,7 @@ public final class StargateGateConfig {
      * @return <p>Whether portals need to be verified</p>
      */
     public boolean verifyPortals() {
-        return verifyPortals;
+        return (boolean) configOptions.get(ConfigOption.VERIFY_PORTALS);
     }
 
     /**
@@ -172,7 +161,7 @@ public final class StargateGateConfig {
      * @return <p>Whether portals should be destroyed by explosions</p>
      */
     public boolean destroyedByExplosion() {
-        return destroyExplosion;
+        return (boolean) configOptions.get(ConfigOption.DESTROYED_BY_EXPLOSION);
     }
 
     /**
@@ -181,37 +170,16 @@ public final class StargateGateConfig {
      * @return <p>The default portal network</p>
      */
     public String getDefaultPortalNetwork() {
-        return defaultGateNetwork;
+        return (String) configOptions.get(ConfigOption.DEFAULT_GATE_NETWORK);
     }
 
     /**
      * Loads all config values related to gates
-     *
-     * @param newConfig <p>The configuration containing the values to read</p>
      */
-    private void loadGateConfig(FileConfiguration newConfig) {
-        String defaultNetwork = newConfig.getString("gates.defaultGateNetwork");
-        defaultGateNetwork = defaultNetwork != null ? defaultNetwork.trim() : null;
-        maxGatesEachNetwork = newConfig.getInt("gates.maxGatesEachNetwork");
-
-        //Functionality
-        handleVehicles = newConfig.getBoolean("gates.functionality.handleVehicles");
-        handleEmptyVehicles = newConfig.getBoolean("gates.functionality.handleEmptyVehicles");
-        handleCreatureTransportation = newConfig.getBoolean("gates.functionality.handleCreatureTransportation");
-        handleNonPlayerVehicles = newConfig.getBoolean("gates.functionality.handleNonPlayerVehicles");
-        handleLeashedCreatures = newConfig.getBoolean("gates.functionality.handleLeashedCreatures");
-        enableBungee = newConfig.getBoolean("gates.functionality.enableBungee");
-
-        //Integrity
-        protectEntrance = newConfig.getBoolean("gates.integrity.protectEntrance");
-        verifyPortals = newConfig.getBoolean("gates.integrity.verifyPortals");
-        destroyExplosion = newConfig.getBoolean("gates.integrity.destroyedByExplosion");
-
-        //Cosmetic
-        sortNetworkDestinations = newConfig.getBoolean("gates.cosmetic.sortNetworkDestinations");
-        rememberDestination = newConfig.getBoolean("gates.cosmetic.rememberDestination");
-        loadSignColor(newConfig.getString("gates.cosmetic.mainSignColor"),
-                newConfig.getString("gates.cosmetic.highlightSignColor"));
+    private void loadGateConfig() {
+        //Load the sign colors
+        loadSignColor((String) configOptions.get(ConfigOption.MAIN_SIGN_COLOR),
+                (String) configOptions.get(ConfigOption.HIGHLIGHT_SIGN_COLOR));
     }
 
     /**
@@ -220,7 +188,7 @@ public final class StargateGateConfig {
      * @param mainSignColor <p>A string representing the main sign color</p>
      */
     private void loadSignColor(String mainSignColor, String highlightSignColor) {
-        if (mainSignColor != null) {
+        if (mainSignColor != null && highlightSignColor != null) {
             try {
                 PortalSignDrawer.setColors(ChatColor.valueOf(mainSignColor.toUpperCase()),
                         ChatColor.valueOf(highlightSignColor.toUpperCase()));

src/main/java/net/knarcraft/stargate/listener/PlayerEventListener.java

@@ -244,7 +244,7 @@ public class PlayerEventListener implements Listener {
      * @return <p>True if the player should be denied</p>
      */
     private boolean cannotAccessPortal(Player player, Portal portal) {
-        boolean deny = PermissionHelper.cannotAccessNetwork(player, portal.getNetwork());
+        boolean deny = PermissionHelper.cannotAccessNetwork(player, portal.getCleanNetwork());
 
         if (PermissionHelper.portalAccessDenied(player, portal, deny)) {
             if (!portal.getOptions().isSilent()) {
@@ -317,7 +317,7 @@ public class PlayerEventListener implements Listener {
         }
 
         //Display portal information as a portal without a sign does not display any
-        if (portal.getOptions().hasNoSign() && !portal.getOptions().isSilent()) {
+        if (portal.getOptions().hasNoSign() && (!portal.getOptions().isSilent() || player.isSneaking())) {
             MessageSender sender = Stargate.getMessageSender();
             sender.sendSuccessMessage(player, ChatColor.GOLD + Stargate.getString("portalInfoTitle"));
             sender.sendSuccessMessage(player, Stargate.replaceVars(Stargate.getString("portalInfoName"),

src/main/java/net/knarcraft/stargate/portal/Portal.java

@@ -8,6 +8,7 @@ import net.knarcraft.stargate.portal.property.PortalOptions;
 import net.knarcraft.stargate.portal.property.PortalOwner;
 import net.knarcraft.stargate.portal.property.PortalStructure;
 import net.knarcraft.stargate.portal.property.gate.Gate;
+import org.bukkit.ChatColor;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
 
@@ -19,7 +20,10 @@ import java.util.Map;
 public class Portal {
 
     private final String name;
+    private final String cleanName;
     private final String network;
+    private final String cleanNetwork;
+
     private final PortalOwner portalOwner;
     private boolean isRegistered;
 
@@ -53,6 +57,8 @@ public class Portal {
         this.portalOpener = new PortalOpener(this, destination);
         this.structure = new PortalStructure(this, gate, button);
         this.portalActivator = portalOpener.getPortalActivator();
+        this.cleanName = cleanString(name);
+        this.cleanNetwork = cleanString(network);
     }
 
     /**
@@ -149,6 +155,15 @@ public class Portal {
         return network;
     }
 
+    /**
+     * Gets the clean name of the network this portal belongs to
+     *
+     * @return <p>The clean network name</p>
+     */
+    public String getCleanNetwork() {
+        return cleanNetwork;
+    }
+
     /**
      * Gets the time this portal was triggered (activated/opened)
      *
@@ -170,6 +185,15 @@ public class Portal {
         return name;
     }
 
+    /**
+     * Gets the clean name of this portal
+     *
+     * @return <p>The clean name of this portal</p>
+     */
+    public String getCleanName() {
+        return cleanName;
+    }
+
     /**
      * Gets the portal opener used by this portal
      *
@@ -273,6 +297,16 @@ public class Portal {
         return getTopLeft().getRelativeLocation(vector, getYaw());
     }
 
+    /**
+     * Cleans a string by removing color codes, lower-casing and replacing spaces with underscores
+     *
+     * @param string <p>The string to clean</p>
+     * @return <p>The clean string</p>
+     */
+    public static String cleanString(String string) {
+        return ChatColor.stripColor(ChatColor.translateAlternateColorCodes('&', string)).toLowerCase();
+    }
+
     @Override
     public String toString() {
         return String.format("Portal [id=%s, network=%s name=%s, type=%s]", getSignLocation(), network, name,
@@ -283,8 +317,8 @@ public class Portal {
     public int hashCode() {
         final int prime = 31;
         int result = 1;
-        result = prime * result + ((name == null) ? 0 : name.hashCode());
-        result = prime * result + ((network == null) ? 0 : network.hashCode());
+        result = prime * result + ((cleanName == null) ? 0 : cleanName.hashCode());
+        result = prime * result + ((cleanNetwork == null) ? 0 : cleanNetwork.hashCode());
         return result;
     }
 
@@ -297,18 +331,18 @@ public class Portal {
             return false;
         }
         Portal other = (Portal) object;
-        if (name == null) {
-            if (other.name != null) {
+        if (cleanName == null) {
+            if (other.cleanName != null) {
                 return false;
             }
-        } else if (!name.equalsIgnoreCase(other.name)) {
+        } else if (!cleanName.equalsIgnoreCase(other.cleanName)) {
             return false;
         }
         //If none of the portals have a name, check if the network is the same
-        if (network == null) {
-            return other.network == null;
+        if (cleanNetwork == null) {
+            return other.cleanNetwork == null;
         } else {
-            return network.equalsIgnoreCase(other.network);
+            return cleanNetwork.equalsIgnoreCase(other.cleanNetwork);
         }
     }
 }

src/main/java/net/knarcraft/stargate/portal/PortalActivator.java

@@ -6,7 +6,7 @@ import net.knarcraft.stargate.event.StargateDeactivateEvent;
 import org.bukkit.entity.Player;
 
 import java.util.ArrayList;
-import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Random;
 
@@ -64,7 +64,7 @@ public class PortalActivator {
      * @return <p>The destination portal the player should teleport to</p>
      */
     public Portal getDestination(Player player) {
-        String portalNetwork = portal.getNetwork();
+        String portalNetwork = portal.getCleanNetwork();
         if (portal.getOptions().isRandom()) {
             //Find possible destinations
             List<String> destinations = PortalHandler.getDestinations(portal, player, portalNetwork);
@@ -73,10 +73,10 @@ public class PortalActivator {
             }
             //Get one random destination
             String destination = destinations.get((new Random()).nextInt(destinations.size()));
-            return PortalHandler.getByName(destination, portalNetwork);
+            return PortalHandler.getByName(Portal.cleanString(destination), portalNetwork);
         } else {
             //Just return the normal fixed destination
-            return PortalHandler.getByName(destination, portalNetwork);
+            return PortalHandler.getByName(Portal.cleanString(destination), portalNetwork);
         }
     }
 
@@ -136,12 +136,12 @@ public class PortalActivator {
         //Set the given player as the active player
         activePlayer = player;
 
-        String network = portal.getNetwork();
+        String network = portal.getCleanNetwork();
         destinations = PortalHandler.getDestinations(portal, player, network);
 
         //Sort destinations if enabled
         if (Stargate.getGateConfig().sortNetworkDestinations()) {
-            Collections.sort(destinations);
+            destinations.sort(Comparator.comparing(Portal::cleanString));
         }
 
         //Select last used destination if remember destination is enabled
@@ -242,7 +242,7 @@ public class PortalActivator {
             activate = true;
 
             Stargate.debug("cycleDestination", "Network Size: " +
-                    PortalHandler.getNetwork(portal.getNetwork()).size());
+                    PortalHandler.getNetwork(portal.getCleanNetwork()).size());
             Stargate.debug("cycleDestination", "Player has access to: " + destinations.size());
         }
 

src/main/java/net/knarcraft/stargate/portal/PortalCreator.java

@@ -22,6 +22,8 @@ import org.bukkit.event.block.SignChangeEvent;
 import java.util.List;
 import java.util.Map;
 
+import static net.knarcraft.stargate.Stargate.getMaxNameNetworkLength;
+
 /**
  * The portal creator can create and validate a new portal
  */
@@ -105,7 +107,8 @@ public class PortalCreator {
         Stargate.debug("createPortal", builder.toString());
 
         //Use default network if a proper alternative is not set
-        if (!portalOptions.get(PortalOption.BUNGEE) && (network.length() < 1 || network.length() > 11)) {
+        if (!portalOptions.get(PortalOption.BUNGEE) && (network.length() < 1 || network.length() >
+                getMaxNameNetworkLength())) {
             network = Stargate.getDefaultNetwork();
         }
 
@@ -117,8 +120,8 @@ public class PortalCreator {
             Stargate.debug("createPortal", "Player doesn't have create permissions on network. Trying personal");
             if (PermissionHelper.canCreatePersonalPortal(player)) {
                 network = player.getName();
-                if (network.length() > 11) {
-                    network = network.substring(0, 11);
+                if (network.length() > getMaxNameNetworkLength()) {
+                    network = network.substring(0, getMaxNameNetworkLength());
                 }
                 Stargate.debug("createPortal", "Creating personal portal");
                 Stargate.getMessageSender().sendErrorMessage(player, Stargate.getString("createPersonal"));
@@ -228,29 +231,30 @@ public class PortalCreator {
      */
     private boolean checkIfNewPortalIsValid(int cost, String portalName) {
         //Check if the portal name can fit on the sign with padding (>name<)
-        if (portal.getName().length() < 1 || portal.getName().length() > 11) {
-            Stargate.debug("createPortal", "Name length error");
+        if (portal.getCleanName().length() < 1 || portal.getCleanName().length() > getMaxNameNetworkLength()) {
+            Stargate.debug("createPortal", String.format("Name length error. %s is too long.",
+                    portal.getCleanName()));
             Stargate.getMessageSender().sendErrorMessage(player, Stargate.getString("createNameLength"));
             return false;
         }
 
         if (portal.getOptions().isBungee()) {
             //Check if the bungee portal's name has been duplicated
-            if (PortalHandler.getBungeePortals().get(portal.getName().toLowerCase()) != null) {
+            if (PortalHandler.getBungeePortals().get(portal.getCleanName()) != null) {
                 Stargate.debug("createPortal::Bungee", "Gate name duplicate");
                 Stargate.getMessageSender().sendErrorMessage(player, Stargate.getString("createExists"));
                 return false;
             }
         } else {
             //Check if the portal name has been duplicated on the network
-            if (PortalHandler.getByName(portal.getName(), portal.getNetwork()) != null) {
+            if (PortalHandler.getByName(portal.getCleanName(), portal.getCleanNetwork()) != null) {
                 Stargate.debug("createPortal", "Gate name duplicate");
                 Stargate.getMessageSender().sendErrorMessage(player, Stargate.getString("createExists"));
                 return false;
             }
 
             //Check if the number of portals in the network has been surpassed
-            List<String> networkList = PortalHandler.getAllPortalNetworks().get(portal.getNetwork().toLowerCase());
+            List<String> networkList = PortalHandler.getAllPortalNetworks().get(portal.getCleanNetwork());
             int maxGates = Stargate.getGateConfig().maxGatesEachNetwork();
             if (maxGates > 0 && networkList != null && networkList.size() >= maxGates) {
                 Stargate.getMessageSender().sendErrorMessage(player, Stargate.getString("createFull"));
@@ -283,7 +287,7 @@ public class PortalCreator {
             portal.getPortalOpener().openPortal(true);
         } else if (portal.getOptions().isAlwaysOn()) {
             //For a normal always-on portal, open both the portal and the destination
-            Portal destinationPortal = PortalHandler.getByName(destinationName, portal.getNetwork());
+            Portal destinationPortal = PortalHandler.getByName(destinationName, portal.getCleanNetwork());
             if (destinationPortal != null) {
                 portal.getPortalOpener().openPortal(true);
                 destinationPortal.drawSign();

src/main/java/net/knarcraft/stargate/portal/PortalHandler.java

@@ -66,7 +66,7 @@ public class PortalHandler {
      */
     public static List<String> getDestinations(Portal entrancePortal, Player player, String network) {
         List<String> destinations = new ArrayList<>();
-        for (String destination : PortalRegistry.getAllPortalNetworks().get(network.toLowerCase())) {
+        for (String destination : PortalRegistry.getAllPortalNetworks().get(network)) {
             Portal portal = getByName(destination, network);
             if (portal == null) {
                 continue;
@@ -80,11 +80,12 @@ public class PortalHandler {
                 continue;
             }
             //Check if destination is this portal
-            if (destination.equalsIgnoreCase(entrancePortal.getName())) {
+            if (destination.equals(entrancePortal.getCleanName())) {
                 continue;
             }
             //Check if destination is a fixed portal not pointing to this portal
-            if (portal.getOptions().isFixed() && !portal.getDestinationName().equalsIgnoreCase(entrancePortal.getName())) {
+            if (portal.getOptions().isFixed() &&
+                    !Portal.cleanString(portal.getDestinationName()).equals(entrancePortal.getCleanName())) {
                 continue;
             }
             //Allow random use by non-players (Minecarts)
@@ -182,10 +183,10 @@ public class PortalHandler {
      * @param portal <p>The newly created portal</p>
      */
     static void updatePortalsPointingAtNewPortal(Portal portal) {
-        for (String originName : PortalRegistry.getAllPortalNetworks().get(portal.getNetwork().toLowerCase())) {
-            Portal origin = getByName(originName, portal.getNetwork());
+        for (String originName : PortalRegistry.getAllPortalNetworks().get(portal.getCleanNetwork())) {
+            Portal origin = getByName(originName, portal.getCleanNetwork());
             if (origin == null ||
-                    !origin.getDestinationName().equalsIgnoreCase(portal.getName()) ||
+                    !Portal.cleanString(origin.getDestinationName()).equals(portal.getCleanName()) ||
                     !origin.getStructure().isVerified()) {
                 continue;
             }

src/main/java/net/knarcraft/stargate/portal/PortalOpener.java

@@ -126,7 +126,7 @@ public class PortalOpener {
             return;
         }
 
-        boolean thisIsDestination = destination.getDestinationName().equalsIgnoreCase(portal.getName());
+        boolean thisIsDestination = Portal.cleanString(destination.getDestinationName()).equals(portal.getCleanName());
         //Only open destination if it's not-fixed or points at this portal, and is not already open
         if (!options.isRandom() && (!destination.getOptions().isFixed() || thisIsDestination) && !destination.isOpen()) {
             //Open the destination portal

src/main/java/net/knarcraft/stargate/portal/PortalRegistry.java

@@ -63,7 +63,7 @@ public class PortalRegistry {
     private static void clearPortals(List<Portal> portalsToRemove) {
         //Store the names of the portals to remove as some maps require the name, not the object
         List<String> portalNames = new ArrayList<>();
-        portalsToRemove.forEach((portal) -> portalNames.add(portal.getName()));
+        portalsToRemove.forEach((portal) -> portalNames.add(portal.getCleanName()));
 
         //Clear all the lookup locations for the portals
         lookupBlocks.keySet().removeIf((key) -> portalsToRemove.contains(lookupBlocks.get(key)));
@@ -165,8 +165,8 @@ public class PortalRegistry {
         portal.getPortalActivator().deactivate();
         portal.getPortalOpener().closePortal(true);
 
-        String portalName = portal.getName().toLowerCase();
-        String networkName = portal.getNetwork().toLowerCase();
+        String portalName = portal.getCleanName();
+        String networkName = portal.getCleanNetwork();
 
         //Remove portal from lookup blocks
         for (BlockLocation block : portal.getStructure().getFrame()) {
@@ -203,7 +203,7 @@ public class PortalRegistry {
 
             //Update all portals in the same network with this portal as its destination
             for (String originName : allPortalNetworks.get(networkName)) {
-                Portal origin = PortalHandler.getByName(originName, portal.getNetwork());
+                Portal origin = PortalHandler.getByName(originName, portal.getCleanNetwork());
                 if (origin == null || !origin.getDestinationName().equalsIgnoreCase(portalName) ||
                         !origin.getStructure().isVerified()) {
                     continue;
@@ -235,8 +235,8 @@ public class PortalRegistry {
         portal.getOptions().setFixed(portal.getDestinationName().length() > 0 || portal.getOptions().isRandom() ||
                 portal.getOptions().isBungee());
 
-        String portalName = portal.getName().toLowerCase();
-        String networkName = portal.getNetwork().toLowerCase();
+        String portalName = portal.getCleanName();
+        String networkName = portal.getCleanNetwork();
 
         //Bungee portals are stored in their own list
         if (portal.getOptions().isBungee()) {

src/main/java/net/knarcraft/stargate/portal/PortalSignDrawer.java

@@ -15,7 +15,7 @@ public class PortalSignDrawer {
 
     private final Portal portal;
     private final static ChatColor errorColor = ChatColor.DARK_RED;
-    private final static ChatColor freeColor = ChatColor.DARK_GREEN;
+    private static ChatColor freeColor;
     private static ChatColor mainColor;
     private static ChatColor highlightColor;
 
@@ -29,7 +29,7 @@ public class PortalSignDrawer {
     }
 
     /**
-     * Sets the main sign color
+     * Sets the main and highlighting sign colors
      *
      * <p>The main sign color is used for most text on the sign, while the highlighting color is used for the markings
      * around portal names and network names ('>','<','-',')','(')</p>
@@ -42,6 +42,15 @@ public class PortalSignDrawer {
         highlightColor = newHighlightColor;
     }
 
+    /**
+     * Sets the color to use for marking free stargates
+     *
+     * @param freeColor <p>The new color to use for marking free stargates</p>
+     */
+    public static void setFreeColor(ChatColor freeColor) {
+        PortalSignDrawer.freeColor = freeColor;
+    }
+
     /**
      * Draws the sign of the portal this sign drawer is responsible for
      */
@@ -81,8 +90,7 @@ public class PortalSignDrawer {
     private void drawSign(Sign sign) {
         //Clear sign
         clearSign(sign);
-        setLine(sign, 0, highlightColor + "-" + mainColor +
-                portal.getName() + highlightColor + "-");
+        setLine(sign, 0, highlightColor + "-" + mainColor + fixColor(portal.getName()) + highlightColor + "-");
 
         if (!portal.getPortalActivator().isActive()) {
             //Default sign text
@@ -123,7 +131,7 @@ public class PortalSignDrawer {
             return;
         }
         clearSign(sign);
-        sign.setLine(0, portal.getName());
+        sign.setLine(0, fixColor(portal.getName()));
         sign.update();
     }
 
@@ -137,46 +145,46 @@ public class PortalSignDrawer {
         int maxIndex = destinations.getDestinations().size() - 1;
         int signLineIndex = 0;
         int destinationIndex = destinations.getDestinations().indexOf(portal.getDestinationName());
-        boolean freeGatesGreen = Stargate.getEconomyConfig().useEconomy() &&
-                Stargate.getEconomyConfig().drawFreePortalsGreen();
+        boolean freeGatesColored = Stargate.getEconomyConfig().useEconomy() &&
+                Stargate.getEconomyConfig().drawFreePortalsColored();
 
         //Last, and not only entry. Draw the entry two back
         if ((destinationIndex == maxIndex) && (maxIndex > 1)) {
-            drawNetworkSignLine(freeGatesGreen, sign, ++signLineIndex, destinationIndex - 2);
+            drawNetworkSignLine(freeGatesColored, sign, ++signLineIndex, destinationIndex - 2);
         }
         //Not first entry. Draw the previous entry
         if (destinationIndex > 0) {
-            drawNetworkSignLine(freeGatesGreen, sign, ++signLineIndex, destinationIndex - 1);
+            drawNetworkSignLine(freeGatesColored, sign, ++signLineIndex, destinationIndex - 1);
         }
         //Draw the chosen entry (line 2 or 3)
-        drawNetworkSignChosenLine(freeGatesGreen, sign, ++signLineIndex);
+        drawNetworkSignChosenLine(freeGatesColored, sign, ++signLineIndex);
         //Has another entry and space on the sign
         if ((maxIndex >= destinationIndex + 1)) {
-            drawNetworkSignLine(freeGatesGreen, sign, ++signLineIndex, destinationIndex + 1);
+            drawNetworkSignLine(freeGatesColored, sign, ++signLineIndex, destinationIndex + 1);
         }
         //Has another entry and space on the sign
         if ((maxIndex >= destinationIndex + 2) && (++signLineIndex <= 3)) {
-            drawNetworkSignLine(freeGatesGreen, sign, signLineIndex, destinationIndex + 2);
+            drawNetworkSignLine(freeGatesColored, sign, signLineIndex, destinationIndex + 2);
         }
     }
 
     /**
      * Draws the chosen destination on one sign line
      *
-     * @param freeGatesGreen <p>Whether to display free gates in a green color</p>
-     * @param sign           <p>The sign to draw on</p>
-     * @param signLineIndex  <p>The line to draw on</p>
+     * @param freeGatesColored <p>Whether to display free gates in a different color</p>
+     * @param sign             <p>The sign to draw on</p>
+     * @param signLineIndex    <p>The line to draw on</p>
      */
-    private void drawNetworkSignChosenLine(boolean freeGatesGreen, Sign sign, int signLineIndex) {
-        if (freeGatesGreen) {
+    private void drawNetworkSignChosenLine(boolean freeGatesColored, Sign sign, int signLineIndex) {
+        if (freeGatesColored) {
             Portal destination = PortalHandler.getByName(portal.getDestinationName(), portal.getNetwork());
-            boolean green = PermissionHelper.isFree(portal.getActivePlayer(), portal, destination);
-            ChatColor nameColor = (green ? freeColor : highlightColor);
-            setLine(sign, signLineIndex, nameColor + ">" + (green ? freeColor : mainColor) +
-                    portal.getDestinationName() + nameColor + "<");
+            boolean free = PermissionHelper.isFree(portal.getActivePlayer(), portal, destination);
+            ChatColor nameColor = (free ? freeColor : highlightColor);
+            setLine(sign, signLineIndex, nameColor + ">" + (free ? freeColor : mainColor) +
+                    fixColor(portal.getDestinationName()) + nameColor + "<");
         } else {
-            setLine(sign, signLineIndex, highlightColor + ">" + mainColor + portal.getDestinationName() +
-                    highlightColor + "<");
+            setLine(sign, signLineIndex, highlightColor + ">" + mainColor +
+                    fixColor(portal.getDestinationName()) + highlightColor + "<");
         }
     }
 
@@ -194,20 +202,20 @@ public class PortalSignDrawer {
     /**
      * Draws one network destination on one sign line
      *
-     * @param freeGatesGreen   <p>Whether to display free gates in a green color</p>
+     * @param freeGatesColored <p>Whether to display free gates in a different color</p>
      * @param sign             <p>The sign to draw on</p>
      * @param signLineIndex    <p>The line to draw on</p>
      * @param destinationIndex <p>The index of the destination to draw</p>
      */
-    private void drawNetworkSignLine(boolean freeGatesGreen, Sign sign, int signLineIndex, int destinationIndex) {
+    private void drawNetworkSignLine(boolean freeGatesColored, Sign sign, int signLineIndex, int destinationIndex) {
         PortalActivator destinations = portal.getPortalActivator();
         String destinationName = destinations.getDestinations().get(destinationIndex);
-        if (freeGatesGreen) {
+        if (freeGatesColored) {
             Portal destination = PortalHandler.getByName(destinationName, portal.getNetwork());
-            boolean green = PermissionHelper.isFree(portal.getActivePlayer(), portal, destination);
-            setLine(sign, signLineIndex, (green ? freeColor : mainColor) + destinationName);
+            boolean free = PermissionHelper.isFree(portal.getActivePlayer(), portal, destination);
+            setLine(sign, signLineIndex, (free ? freeColor : mainColor) + fixColor(destinationName));
         } else {
-            setLine(sign, signLineIndex, mainColor + destinationName);
+            setLine(sign, signLineIndex, mainColor + fixColor(destinationName));
         }
     }
 
@@ -218,8 +226,10 @@ public class PortalSignDrawer {
      */
     private void drawBungeeSign(Sign sign) {
         setLine(sign, 1, Stargate.getString("bungeeSign"));
-        setLine(sign, 2, highlightColor + ">" + mainColor + portal.getDestinationName() + highlightColor + "<");
-        setLine(sign, 3, highlightColor + "[" + mainColor + portal.getNetwork() + highlightColor + "]");
+        setLine(sign, 2, highlightColor + ">" + mainColor + fixColor(portal.getDestinationName()) +
+                highlightColor + "<");
+        setLine(sign, 3, highlightColor + "[" + mainColor + fixColor(portal.getNetwork()) +
+                highlightColor + "]");
     }
 
     /**
@@ -233,7 +243,8 @@ public class PortalSignDrawer {
         setLine(sign, 1, Stargate.getString("signRightClick"));
         setLine(sign, 2, Stargate.getString("signToUse"));
         if (!portal.getOptions().isNoNetwork()) {
-            setLine(sign, 3, highlightColor + "(" + mainColor + portal.getNetwork() + highlightColor + ")");
+            setLine(sign, 3, highlightColor + "(" + mainColor + fixColor(portal.getNetwork()) +
+                    highlightColor + ")");
         } else {
             setLine(sign, 3, "");
         }
@@ -245,16 +256,20 @@ public class PortalSignDrawer {
      * @param sign <p>The sign to re-draw</p>
      */
     private void drawFixedSign(Sign sign) {
+        Portal destinationPortal = PortalHandler.getByName(Portal.cleanString(portal.getDestinationName()),
+                portal.getCleanNetwork());
         String destinationName = portal.getOptions().isRandom() ? Stargate.getString("signRandom") :
-                portal.getDestinationName();
-        setLine(sign, 1, highlightColor + ">" + mainColor + destinationName + highlightColor + "<");
+                (destinationPortal != null ? destinationPortal.getName() : portal.getDestinationName());
+        setLine(sign, 1, highlightColor + ">" + mainColor + fixColor(destinationName) + highlightColor + "<");
 
         if (portal.getOptions().isNoNetwork()) {
             setLine(sign, 2, "");
         } else {
-            setLine(sign, 2, highlightColor + "(" + mainColor + portal.getNetwork() + highlightColor + ")");
+            setLine(sign, 2, highlightColor + "(" + mainColor + fixColor(portal.getNetwork()) +
+                    highlightColor + ")");
         }
-        Portal destination = PortalHandler.getByName(portal.getDestinationName(), portal.getNetwork());
+        Portal destination = PortalHandler.getByName(Portal.cleanString(portal.getDestinationName()),
+                portal.getNetwork());
         if (destination == null && !portal.getOptions().isRandom()) {
             setLine(sign, 3, errorColor + Stargate.getString("signDisconnected"));
         } else {
@@ -277,4 +292,14 @@ public class PortalSignDrawer {
         Stargate.logInfo(String.format("Gate layout on line %d does not exist [%s]", lineIndex, gateName));
     }
 
+    /**
+     * Fixes coloring of signs as the & character isn't translated on all servers
+     *
+     * @param text <p>The text to fix the coloring of</p>
+     * @return <p>The text with the coloring fixed</p>
+     */
+    private String fixColor(String text) {
+        return ChatColor.translateAlternateColorCodes('&', text);
+    }
+
 }

src/main/java/net/knarcraft/stargate/portal/teleporter/Teleporter.java

@@ -191,9 +191,9 @@ public abstract class Teleporter {
      */
     private Location adjustExitLocation(Location traveller, Location exitLocation) {
         if (exitLocation != null) {
-            BlockData blockData = portal.getWorld().getBlockAt(exitLocation).getBlockData();
-            if ((blockData instanceof Bisected && ((Bisected) blockData).getHalf() == Bisected.Half.BOTTOM) ||
-                    (blockData instanceof Slab) && ((Slab) blockData).getType() == Slab.Type.BOTTOM) {
+            BlockData blockData = exitLocation.getBlock().getBlockData();
+            if ((blockData instanceof Bisected bisected && bisected.getHalf() == Bisected.Half.BOTTOM) ||
+                    (blockData instanceof Slab slab && slab.getType() == Slab.Type.BOTTOM)) {
                 //Prevent traveller from spawning inside a slab
                 Stargate.debug("adjustExitLocation", "Added a block to get above a slab");
                 exitLocation.add(0, 1, 0);

src/main/java/net/knarcraft/stargate/utility/BungeeHelper.java

@@ -4,6 +4,7 @@ import net.knarcraft.stargate.Stargate;
 import net.knarcraft.stargate.portal.Portal;
 import net.knarcraft.stargate.portal.PortalHandler;
 import net.knarcraft.stargate.portal.teleporter.PlayerTeleporter;
+import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 import org.bukkit.event.player.PlayerMoveEvent;
 
@@ -71,7 +72,7 @@ public final class BungeeHelper {
             //Build the message data and send it over the SGBungee BungeeCord channel
             dataOutputStream.writeUTF("Forward");
             //Send the message to the server defined in the entrance portal's network line
-            dataOutputStream.writeUTF(entrancePortal.getNetwork());
+            dataOutputStream.writeUTF(stripColor(entrancePortal.getNetwork()));
             //Specify the sub-channel/tag to make it recognizable on arrival
             dataOutputStream.writeUTF(bungeeSubChannel);
             //Write the length of the message
@@ -102,7 +103,7 @@ public final class BungeeHelper {
 
             //Send a connect-message to connect the player to the server defined in the entrance portal's network line
             dataOutputStream.writeUTF("Connect");
-            dataOutputStream.writeUTF(entrancePortal.getNetwork());
+            dataOutputStream.writeUTF(stripColor(entrancePortal.getNetwork()));
 
             //Send the plugin message
             player.sendPluginMessage(Stargate.getInstance(), bungeeChannel, byteArrayOutputStream.toByteArray());
@@ -207,4 +208,14 @@ public final class BungeeHelper {
         return true;
     }
 
+    /**
+     * Strips all color tags from a string
+     *
+     * @param string <p>The string to strip color from</p>
+     * @return <p>The string without color codes</p>
+     */
+    private static String stripColor(String string) {
+        return ChatColor.stripColor(ChatColor.translateAlternateColorCodes('&', string));
+    }
+
 }

src/main/java/net/knarcraft/stargate/utility/PermissionHelper.java

@@ -8,6 +8,8 @@ import net.knarcraft.stargate.portal.teleporter.PlayerTeleporter;
 import org.bukkit.entity.Player;
 import org.bukkit.event.player.PlayerMoveEvent;
 
+import static net.knarcraft.stargate.Stargate.getMaxNameNetworkLength;
+
 /**
  * Helper class for deciding which actions a player is allowed to perform
  */
@@ -105,12 +107,12 @@ public final class PermissionHelper {
         boolean deny = false;
 
         if (entrancePortal.getOptions().isBungee()) {
-            if (!PermissionHelper.canAccessServer(player, entrancePortal.getNetwork())) {
+            if (!PermissionHelper.canAccessServer(player, entrancePortal.getCleanNetwork())) {
                 //If the portal is a bungee portal, and the player cannot access the server, deny
                 Stargate.debug("cannotAccessPortal", "Cannot access server");
                 deny = true;
             }
-        } else if (PermissionHelper.cannotAccessNetwork(player, entrancePortal.getNetwork())) {
+        } else if (PermissionHelper.cannotAccessNetwork(player, entrancePortal.getCleanNetwork())) {
             //If the player does not have access to the network, deny
             Stargate.debug("cannotAccessPortal", "Cannot access network");
             deny = true;
@@ -200,8 +202,8 @@ public final class PermissionHelper {
         }
         //Is able to create personal gates (Assumption is made they can also access them)
         String playerName = player.getName();
-        if (playerName.length() > 11) {
-            playerName = playerName.substring(0, 11);
+        if (playerName.length() > getMaxNameNetworkLength()) {
+            playerName = playerName.substring(0, getMaxNameNetworkLength());
         }
         return !network.equals(playerName) || !hasPermission(player, "stargate.create.personal");
     }
@@ -345,7 +347,7 @@ public final class PermissionHelper {
      * @return <p>True if the player is allowed to destroy the portal</p>
      */
     public static boolean canDestroyPortal(Player player, Portal portal) {
-        String network = portal.getNetwork();
+        String network = portal.getCleanNetwork();
 
         //Use a special check for bungee portals
         if (portal.getOptions().isBungee()) {

src/main/java/net/knarcraft/stargate/utility/PortalFileHelper.java

@@ -292,16 +292,15 @@ public final class PortalFileHelper {
      */
     private static void updatePortalButton(Portal portal) {
         BlockLocation buttonLocation = getButtonLocation(portal);
-        BlockData buttonData = buttonLocation.getBlock().getBlockData();
         if (portal.getOptions().isAlwaysOn()) {
             //Clear button if not already air or water
-            if (MaterialHelper.isButtonCompatible(buttonData.getMaterial())) {
+            if (MaterialHelper.isButtonCompatible(buttonLocation.getType())) {
                 Material newMaterial = decideRemovalMaterial(buttonLocation, portal);
                 Stargate.addBlockChangeRequest(new BlockChangeRequest(buttonLocation, newMaterial, null));
             }
         } else {
             //Replace button if the material does not match
-            if (buttonData.getMaterial() != portal.getGate().getPortalButton()) {
+            if (buttonLocation.getType() != portal.getGate().getPortalButton()) {
                 generatePortalButton(portal, DirectionHelper.getBlockFaceFromYaw(portal.getYaw()));
             }
         }

src/main/java/net/knarcraft/stargate/utility/UUIDMigrationHelper.java

@@ -19,7 +19,11 @@ import java.util.UUID;
 /**
  * Helps migrate player names to UUID where necessary
  */
-public class UUIDMigrationHelper {
+public final class UUIDMigrationHelper {
+
+    private UUIDMigrationHelper() {
+
+    }
 
     private static Map<String, List<Portal>> playerNamesToMigrate;
 
@@ -40,7 +44,7 @@ public class UUIDMigrationHelper {
             return;
         }
 
-        Stargate.debug("PlayerEventListener::migrateUUID", String.format("Migrating name to UUID for player %s",
+        Stargate.debug("UUIDMigrationHelper::migrateUUID", String.format("Migrating name to UUID for player %s",
                 playerName));
         List<Portal> portalsOwned = playersToMigrate.get(playerName);
         if (portalsOwned == null) {
@@ -64,7 +68,7 @@ public class UUIDMigrationHelper {
 
         //Get the real portal from the copy and set UUID
         for (Portal portalCopy : portals) {
-            Portal portal = PortalHandler.getByName(portalCopy.getName(), portalCopy.getNetwork());
+            Portal portal = PortalHandler.getByName(portalCopy.getCleanName(), portalCopy.getCleanNetwork());
             if (portal != null) {
                 portal.getOwner().setUUID(uniqueId);
                 worldsToSave.add(portal.getWorld());

src/main/resources/config-migrations.txt

@@ -25,3 +25,4 @@ toowner=economy.toOwner
 chargefreedestination=economy.chargeFreeDestination
 freegatesgreen=economy.freeGatesGreen
 CheckUpdates=
+economy.freeGatesGreen=economy.freeGatesColored

src/main/resources/config.yml

@@ -27,7 +27,8 @@
 # useCost - The cost to use a gate
 # toOwner - Whether the charge for using a gate goes to the gate's owner
 # chargeFreeDestination - Whether a gate whose destination is a free gate is still charged
-# freeGatesGreen - Whether a free gate in the destination list is drawn green
+# freeGatesColored - Whether a free gate in the destination list is marked with a color
+# freeGatesColor - The color to use for marking free gates
 # I-------I-------I #
 # Debug options #
 # I-------I-------I #
@@ -64,7 +65,8 @@ economy:
   useCost: 0
   toOwner: false
   chargeFreeDestination: true
-  freeGatesGreen: false
+  freeGatesColored: false
+  freeGatesColor: DARK_GREEN
 debugging:
   debug: false
   permissionDebug: false

src/main/resources/plugin.yml

@@ -1,6 +1,6 @@
 name: Stargate
 main: net.knarcraft.stargate.Stargate
-version: 0.9.0.7
+version: 0.9.2.0
 description: Stargate mod for Bukkit Revived
 author: EpicKnarvik97
 authors: [ Drakia, PseudoKnight, EpicKnarvik97 ]
@@ -138,14 +138,18 @@ permissions:
   stargate.admin.bungee:
     description: Allows the creation and destruction of a stargate between BungeeCord servers
     default: false
+  stargate.admin.config:
+    description: Allows the player to change config values from the chat
+    default: false
   stargate.server:
     description: Allows the creation of a BungeeCord stargate going to any server
     default: false
   stargate.admin:
-    description: Allow all admin features and commands (Hidden/Private bypass, BungeeCord, Reload)
+    description: Allow all admin features and commands (Hidden/Private bypass, BungeeCord, Reload, Config)
     default: op
     children:
       stargate.admin.reload: true
       stargate.admin.hidden: true
       stargate.admin.private: true
       stargate.admin.bungee: true
+      stargate.admin.config: true