Implement new queue command system.

Fix cannot remove block currency with mvm set command.

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.onarandombox.multiversecore</groupId>
     <artifactId>Multiverse-Core</artifactId>
-    <version>5.0.0-SNAPSHOT</version>
+    <version>4.2.3-SNAPSHOT</version>
     <name>Multiverse-Core</name>
     <description>World Management Plugin</description>
     <properties>
@@ -22,6 +22,10 @@
             <id>onarandombox</id>
             <url>http://repo.onarandombox.com/content/groups/public</url>
         </repository>
+        <repository>
+            <id>spigot</id>
+            <url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
+        </repository>
         <repository>
             <id>vault-repo</id>
             <url>http://nexus.hc.to/content/repositories/pub_releases</url>
@@ -211,7 +215,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
-                <version>3.1.1</version>
+                <version>3.2.4</version>
                 <executions>
                     <execution>
                         <phase>package</phase>
@@ -260,13 +264,19 @@
             <plugin>
                 <groupId>se.eris</groupId>
                 <artifactId>notnull-instrumenter-maven-plugin</artifactId>
-                <version>0.6.8</version>
+                <version>1.0.0</version>
                 <executions>
                     <execution>
                         <goals>
                             <goal>instrument</goal>
                             <goal>tests-instrument</goal>
                         </goals>
+                        <configuration>
+                            <notNull>
+                                <param>org.jetbrains.annotations.NotNull</param>
+                                <param>javax.validation.constraints.NotNull</param>
+                            </notNull>
+                        </configuration>
                     </execution>
                 </executions>
             </plugin>
@@ -275,10 +285,10 @@
 
     <dependencies>
         <dependency>
-            <groupId>org.spigotmc</groupId>
-            <artifactId>spigot-api</artifactId>
-            <version>1.16.5-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
+           <groupId>org.bukkit</groupId>
+           <artifactId>bukkit</artifactId>
+           <version>1.13.2-R0.1-SNAPSHOT</version>
+           <scope>provided</scope>
         </dependency>
         <!-- SerializationConfig Dependency -->
         <dependency>
@@ -307,12 +317,6 @@
             <artifactId>CommandHandler</artifactId>
             <version>11</version>
         </dependency>
-        <!-- End of CommandHandler Dependency -->
-        <dependency>
-            <groupId>net.minidev</groupId>
-            <artifactId>json-smart</artifactId>
-            <version>2.3</version>
-        </dependency>
         <dependency>
             <groupId>com.dumptruckman.minecraft</groupId>
             <artifactId>buscript</artifactId>
@@ -355,21 +359,21 @@
         <dependency>
             <groupId>org.powermock</groupId>
             <artifactId>powermock-module-junit4</artifactId>
-            <version>2.0.0</version>
+            <version>2.0.9</version>
             <type>jar</type>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.powermock</groupId>
             <artifactId>powermock-api-easymock</artifactId>
-            <version>2.0.0</version>
+            <version>2.0.9</version>
             <type>jar</type>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.powermock</groupId>
             <artifactId>powermock-api-mockito2</artifactId>
-            <version>2.0.0</version>
+            <version>2.0.9</version>
             <type>jar</type>
             <scope>test</scope>
         </dependency>

src/main/java/com/onarandombox/MultiverseCore/MVWorld.java

@@ -20,7 +20,6 @@ import com.onarandombox.MultiverseCore.exceptions.PropertyDoesNotExistException;
 import me.main__.util.SerializationConfig.ChangeDeniedException;
 import me.main__.util.SerializationConfig.NoSuchPropertyException;
 import me.main__.util.SerializationConfig.VirtualProperty;
-import net.minidev.json.JSONObject;
 import org.bukkit.ChatColor;
 import org.bukkit.Difficulty;
 import org.bukkit.GameMode;
@@ -29,17 +28,20 @@ import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.World.Environment;
 import org.bukkit.WorldType;
+import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.serialization.SerializableAs;
 import org.bukkit.entity.Player;
 import org.bukkit.permissions.Permission;
 import org.bukkit.permissions.PermissionDefault;
 import org.bukkit.util.Vector;
 import org.jetbrains.annotations.Nullable;
+import org.json.simple.JSONObject;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
+import java.util.logging.Level;
 
 /**
  * The implementation of a Multiverse handled world.

src/main/java/com/onarandombox/MultiverseCore/MultiverseCore.java

@@ -88,6 +88,7 @@ import com.onarandombox.MultiverseCore.listeners.MVWeatherListener;
 import com.onarandombox.MultiverseCore.listeners.MVWorldInitListener;
 import com.onarandombox.MultiverseCore.listeners.MVWorldListener;
 import com.onarandombox.MultiverseCore.utils.AnchorManager;
+import com.onarandombox.MultiverseCore.utils.CompatibilityLayer;
 import com.onarandombox.MultiverseCore.utils.MVEconomist;
 import com.onarandombox.MultiverseCore.utils.MVMessaging;
 import com.onarandombox.MultiverseCore.utils.MVPermissions;
@@ -254,6 +255,8 @@ public class MultiverseCore extends JavaPlugin implements MVPlugin, Core {
         // Setup our SafeTTeleporter
         this.safeTTeleporter = new SimpleSafeTTeleporter(this);
         this.unsafeCallWrapper = new UnsafeCallWrapper(this);
+        // Setup our CompatibilityLayer
+        CompatibilityLayer.init();
     }
 
 
@@ -353,13 +356,16 @@ public class MultiverseCore extends JavaPlugin implements MVPlugin, Core {
      * Initializes the buscript javascript library.
      */
     private void initializeBuscript() {
-        try {
-            buscript = new Buscript(this);
-            // Add global variable "multiverse" to javascript environment
-            buscript.setScriptVariable("multiverse", this);
-        } catch (NullPointerException e) {
-            buscript = null;
-            Logging.warning("Buscript failed to load! The script command will be disabled!");
+        buscript = null;
+
+        if (this.getMVConfig().getEnableBuscript()) {
+            try {
+                buscript = new Buscript(this);
+                // Add global variable "multiverse" to javascript environment
+                buscript.setScriptVariable("multiverse", this);
+            } catch (NullPointerException e) {
+                Logging.warning("Buscript failed to load! The script command will be disabled!");
+            }
         }
     }
 

src/main/java/com/onarandombox/MultiverseCore/MultiverseCoreConfiguration.java

@@ -56,6 +56,8 @@ public class MultiverseCoreConfiguration extends SerializationConfig implements
     @Property
     private volatile boolean displaypermerrors;
     @Property
+    private volatile boolean enablebuscript;
+    @Property
     private volatile int globaldebug;
     @Property
     private volatile boolean silentstart;
@@ -99,6 +101,7 @@ public class MultiverseCoreConfiguration extends SerializationConfig implements
         teleportintercept = true;
         firstspawnoverride = true;
         displaypermerrors = true;
+        enablebuscript = true;
         globaldebug = 0;
         messagecooldown = 5000;
         teleportcooldown = 1000;
@@ -213,6 +216,22 @@ public class MultiverseCoreConfiguration extends SerializationConfig implements
         return this.displaypermerrors;
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean getEnableBuscript() {
+        return this.enablebuscript;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setEnableBuscript(boolean enableBuscript) {
+        this.enablebuscript = enableBuscript;
+    }
+
     /**
      * {@inheritDoc}
      */

src/main/java/com/onarandombox/MultiverseCore/api/MultiverseCoreConfig.java

@@ -86,6 +86,18 @@ public interface MultiverseCoreConfig extends ConfigurationSerializable {
      */
     boolean getDisplayPermErrors();
 
+    /**
+     * Sets enableBuscript.
+     * @param enableBuscript The new value.
+     */
+    void setEnableBuscript(boolean enableBuscript);
+
+    /**
+     * Gets enableBuscript.
+     * @return enableBuscript.
+     */
+    boolean getEnableBuscript();
+
     /**
      * Sets firstSpawnOverride.
      * @param firstSpawnOverride The new value.

src/main/java/com/onarandombox/MultiverseCore/commands/CreateCommand.java

@@ -8,7 +8,12 @@
 package com.onarandombox.MultiverseCore.commands;
 
 import com.onarandombox.MultiverseCore.MultiverseCore;
+import com.onarandombox.MultiverseCore.api.Core;
 import com.onarandombox.MultiverseCore.api.MVWorldManager;
+import com.onarandombox.MultiverseCore.commandtools.flag.CoreFlags;
+import com.onarandombox.MultiverseCore.commandtools.flag.FlagGroup;
+import com.onarandombox.MultiverseCore.commandtools.flag.FlagParseFailedException;
+import com.onarandombox.MultiverseCore.commandtools.flag.FlagResult;
 import com.pneumaticraft.commandhandler.CommandHandler;
 import org.bukkit.ChatColor;
 import org.bukkit.World.Environment;
@@ -26,7 +31,16 @@ import java.util.List;
  * Creates a new world and loads it.
  */
 public class CreateCommand extends MultiverseCommand {
-    private MVWorldManager worldManager;
+
+    private static final FlagGroup FLAG_GROUP = FlagGroup.of(
+            CoreFlags.SEED,
+            CoreFlags.WORLD_TYPE,
+            CoreFlags.GENERATOR,
+            CoreFlags.GENERATE_STRUCTURES,
+            CoreFlags.SPAWN_ADJUST
+    );
+
+    private final MVWorldManager worldManager;
 
     public CreateCommand(MultiverseCore plugin) {
         super(plugin);
@@ -50,22 +64,7 @@ public class CreateCommand extends MultiverseCommand {
     @Override
     public void runCommand(CommandSender sender, List<String> args) {
         String worldName = args.get(0);
-        File worldFile = new File(this.plugin.getServer().getWorldContainer(), worldName);
         String env = args.get(1);
-        String seed = CommandHandler.getFlag("-s", args);
-        String generator = CommandHandler.getFlag("-g", args);
-        boolean allowStructures = true;
-        String structureString = CommandHandler.getFlag("-a", args);
-        if (structureString != null) {
-            allowStructures = Boolean.parseBoolean(structureString);
-        }
-        String typeString = CommandHandler.getFlag("-t", args);
-        boolean useSpawnAdjust = true;
-        for (String s : args) {
-            if (s.equalsIgnoreCase("-n")) {
-                useSpawnAdjust = false;
-            }
-        }
 
         if (this.worldManager.isMVWorld(worldName)) {
             sender.sendMessage(ChatColor.RED + "Multiverse cannot create " + ChatColor.GOLD + ChatColor.UNDERLINE
@@ -73,6 +72,7 @@ public class CreateCommand extends MultiverseCommand {
             return;
         }
 
+        File worldFile = new File(this.plugin.getServer().getWorldContainer(), worldName);
         if (worldFile.exists()) {
             sender.sendMessage(ChatColor.RED + "A Folder/World already exists with this name!");
             sender.sendMessage(ChatColor.RED + "If you are confident it is a world you can import with /mvimport");
@@ -86,35 +86,28 @@ public class CreateCommand extends MultiverseCommand {
             return;
         }
 
-        // If they didn't specify a type, default to NORMAL
-        if (typeString == null) {
-            typeString = "NORMAL";
-        }
-        WorldType type = EnvironmentCommand.getWorldTypeFromString(typeString);
-        if (type == null) {
-            sender.sendMessage(ChatColor.RED + "That is not a valid World Type.");
-            EnvironmentCommand.showWorldTypes(sender);
+        FlagResult flags;
+        try {
+            flags = FLAG_GROUP.calculateResult(args.subList(2, args.size()).toArray(new String[0]));
+        } catch (FlagParseFailedException e) {
+            sender.sendMessage(String.format("%sError: %s", ChatColor.RED, e.getMessage()));
             return;
         }
-        // Determine if the generator is valid. #918
-        if (generator != null) {
-            List<String> genarray = new ArrayList<String>(Arrays.asList(generator.split(":")));
-            if (genarray.size() < 2) {
-                // If there was only one arg specified, pad with another empty one.
-                genarray.add("");
-            }
-            if (this.worldManager.getChunkGenerator(genarray.get(0), genarray.get(1), "test") == null) {
-                // We have an invalid generator.
-                sender.sendMessage("Invalid generator! '" + generator + "'. " + ChatColor.RED + "Aborting world creation.");
-                return;
-            }
-        }
+
         Command.broadcastCommandMessage(sender, "Starting creation of world '" + worldName + "'...");
 
-        if (this.worldManager.addWorld(worldName, environment, seed, type, allowStructures, generator, useSpawnAdjust)) {
+        if (this.worldManager.addWorld(
+                worldName,
+                environment,
+                flags.getValue(CoreFlags.SEED),
+                flags.getValue(CoreFlags.WORLD_TYPE),
+                flags.getValue(CoreFlags.GENERATE_STRUCTURES),
+                flags.getValue(CoreFlags.GENERATOR),
+                flags.getValue(CoreFlags.SPAWN_ADJUST))) {
+
             Command.broadcastCommandMessage(sender, "Complete!");
-        } else {
-            Command.broadcastCommandMessage(sender, "FAILED.");
+            return;
         }
+        Command.broadcastCommandMessage(sender, "FAILED.");
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commands/VersionCommand.java

@@ -64,6 +64,7 @@ public class VersionCommand extends MultiverseCommand {
                 + "[Multiverse-Core]   teleportintercept: " + plugin.getMVConfig().getTeleportIntercept() + '\n'
                 + "[Multiverse-Core]   firstspawnoverride: " + plugin.getMVConfig().getFirstSpawnOverride() + '\n'
                 + "[Multiverse-Core]   displaypermerrors: " + plugin.getMVConfig().getDisplayPermErrors() + '\n'
+                + "[Multiverse-Core]   enablebuscript: " + plugin.getMVConfig().getEnableBuscript() + '\n'
                 + "[Multiverse-Core]   globaldebug: " + plugin.getMVConfig().getGlobalDebug() + '\n'
                 + "[Multiverse-Core]   silentstart: " + plugin.getMVConfig().getSilentStart() + '\n'
                 + "[Multiverse-Core]   messagecooldown: " + plugin.getMessaging().getCooldown() + '\n'

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/CommandFlag.java

@@ -0,0 +1,136 @@
+package com.onarandombox.MultiverseCore.commandtools.flag;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * <p>Represents a flag that can be used in commands. This works as a key value pair.</p>
+ *
+ * <p>Key is the {@link #identifier} and {@link #aliases} set.</p>
+ * <p>Value is the {@link T} parsed based on 3 scenarios during command input:</p>
+ * <ol>
+ *     <li>Flag completely not present. {@link #getDefaultValue()}</li>
+ *     <li>Flag key present but no value. {@link #getValue()}</li>
+ *     <li>Flag key and value present. {@link #getValue(String)}</li>
+ * </ol>
+ *
+ * @param <T>   The flag Type.
+ */
+public abstract class CommandFlag<T> {
+
+    protected final String name;
+    protected final String identifier;
+    protected final Class<T> type;
+    protected final Collection<String> aliases;
+
+    /**
+     * @param name          Readable name for the flag.
+     * @param identifier    Unique key to identify the flag in command arguments.
+     * @param type          The type of value this flag represents.
+     */
+    protected CommandFlag(@NotNull String name,
+                          @NotNull String identifier,
+                          @NotNull Class<T> type) {
+
+        this.name = name;
+        this.identifier = identifier;
+        this.type = type;
+        this.aliases = new ArrayList<>();
+    }
+
+    /**
+     * Gets name of the Command Flag.
+     *
+     * @return The Command Flag name.
+     */
+    @NotNull
+    public String getName() {
+        return this.name;
+    }
+
+    /**
+     * Gets identifier of the Command Flag.
+     *
+     * @return The Command Flag identifier.
+     */
+    @NotNull
+    public String getIdentifier() {
+        return this.identifier;
+    }
+
+    /**
+     * Gets {@link T} Type of the Command Flag.
+     *
+     * @return The Command Flag type.
+     */
+    @NotNull
+    public Class<T> getType() {
+        return this.type;
+    }
+
+    /**
+     * Gets all the alternative key identifiers set for this Command Flag.
+     *
+     * @return Collection of aliases.
+     */
+    @NotNull
+    public Collection<String> getAliases() {
+        return this.aliases;
+    }
+
+    /**
+     * Add alternative key identifiers for this Command Flag.
+     *
+     * @param aliases   Alias(es) to be added.
+     * @return A {@link CommandFlag}.
+     */
+    public CommandFlag<T> addAliases(String...aliases) {
+        Collections.addAll(this.aliases, aliases);
+        return this;
+    }
+
+    /**
+     * Tab-complete suggestion for this Command Flag values.
+     *
+     * @return Collection of suggested values available.
+     */
+    public abstract Collection<String> suggestValue();
+
+    /**
+     * When this Command Flag can get value by a user input.
+     *
+     * @return The {@link T} value.
+     */
+    public abstract T getValue(@NotNull String input) throws FlagParseFailedException;
+
+    /**
+     * When this Command Flag user input value is null/not present.
+     *
+     * @return The {@link T} value.
+     */
+    public T getValue() throws FlagParseFailedException {
+        return null;
+    }
+
+    /**
+     * When this Command Flag is not present in command input.
+     *
+     * @return The {@link T} value.
+     */
+    public T getDefaultValue() {
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return "CommandFlag{" +
+                "name='" + name + '\'' +
+                ", identifier='" + identifier + '\'' +
+                ", type=" + type +
+                ", aliases=" + aliases +
+                '}';
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/CoreFlags.java

@@ -0,0 +1,217 @@
+package com.onarandombox.MultiverseCore.commandtools.flag;
+
+import com.onarandombox.MultiverseCore.MultiverseCore;
+import com.onarandombox.MultiverseCore.utils.webpaste.PasteServiceType;
+import org.bukkit.Bukkit;
+import org.bukkit.WorldType;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.stream.Collectors;
+
+public class CoreFlags {
+
+    private static MultiverseCore multiverse;
+
+    public static void setCoreInstance(MultiverseCore plugin) {
+        multiverse = plugin;
+    }
+
+    /**
+     * Flag for custom seed.
+     */
+    public static final CommandFlag<String> SEED = new RequiredCommandFlag<String>
+            ("Seed", "--seed", String.class) {
+        @Override
+        public Collection<String> suggestValue() {
+            return Collections.singleton(String.valueOf(new Random().nextLong()));
+        }
+
+        @Override
+        public String getValue(@NotNull String input) throws FlagParseFailedException {
+            return input;
+        }
+    }.addAliases("-s");
+
+    /**
+     * Flag for custom seed. No value means random seed.
+     */
+    public static final CommandFlag<String> RANDOM_SEED = new OptionalCommandFlag<String>
+            ("Seed", "--seed", String.class) {
+        @Override
+        public Collection<String> suggestValue() {
+            return Collections.singletonList(String.valueOf(new Random().nextLong()));
+        }
+
+        @Override
+        public String getValue(@NotNull String input) throws FlagParseFailedException {
+            return input;
+        }
+    }.addAliases("-s");
+
+    /**
+     * Flag for world type used.
+     */
+    public static final CommandFlag<WorldType> WORLD_TYPE = new RequiredCommandFlag<WorldType>
+            ("WorldType", "--type", WorldType.class) {
+
+        private final Map<String, String> typeAlias = new HashMap<String, String>(4){{
+            put("normal", "NORMAL");
+            put("flat", "FLAT");
+            put("largebiomes", "LARGE_BIOMES");
+            put("amplified", "AMPLIFIED");
+        }};
+
+        @Override
+        public Collection<String> suggestValue() {
+            return typeAlias.keySet();
+        }
+
+        @Override
+        public WorldType getValue(@NotNull String input) throws FlagParseFailedException {
+            String typeName = typeAlias.getOrDefault(input, input);
+            try {
+                return WorldType.valueOf(input.toUpperCase());
+            }
+            catch (IllegalArgumentException e) {
+                throw new FlagParseFailedException("'%s' is not a valid World Type. See /mv env for available World Types.", input);
+            }
+        }
+
+        @Override
+        public WorldType getDefaultValue() {
+            return WorldType.NORMAL;
+        }
+    }.addAliases("-t");
+
+    /**
+     * Flag for world generator.
+     */
+    public static final CommandFlag<String> GENERATOR = new RequiredCommandFlag<String>
+            ("Generator", "--gen", String.class) {
+        @Override
+        public Collection<String> suggestValue() {
+            return Arrays.stream(Bukkit.getServer().getPluginManager().getPlugins())
+                    .filter(Plugin::isEnabled)
+                    .filter(plugin -> multiverse.getUnsafeCallWrapper().wrap(
+                            () -> plugin.getDefaultWorldGenerator("world", ""),
+                            plugin.getName(),
+                            "Get generator"
+                    ) != null)
+                    .map(plugin -> plugin.getDescription().getName())
+                    .collect(Collectors.toList());
+        }
+
+        @Override
+        public String getValue(@NotNull String input) throws FlagParseFailedException {
+            String[] genArray = input.split(":");
+            String generator = genArray[0];
+            String generatorId = (genArray.length > 1) ? genArray[1] : "";
+            try {
+                if (multiverse.getMVWorldManager().getChunkGenerator(generator, generatorId, "test") == null) {
+                    throw new Exception();
+                }
+            } catch (Exception e) {
+                throw new FlagParseFailedException("Invalid generator string '%s'. See /mv gens for available generators.", input);
+            }
+            return input;
+        }
+    }.addAliases("-g");
+
+    /**
+     * Flag to toggle if world should generate structures.
+     */
+    public static final CommandFlag<Boolean> GENERATE_STRUCTURES = new RequiredCommandFlag<Boolean>
+            ("GenerateStructures", "--structures", Boolean.class) {
+        @Override
+        public Collection<String> suggestValue() {
+            return Arrays.asList("true", "false");
+        }
+
+        @Override
+        public Boolean getValue(@NotNull String input) throws FlagParseFailedException {
+            return input.equalsIgnoreCase("true");
+        }
+
+        @Override
+        public Boolean getDefaultValue() {
+            return true;
+        }
+    }.addAliases("--structure", "-a");
+
+    /**
+     * Flag to toggle if world spawn should be adjusted.
+     */
+    public static final CommandFlag<Boolean> SPAWN_ADJUST = new NoValueCommandFlag<Boolean>
+            ("AdjustSpawn", "--dont-adjust-spawn", Boolean.class) {
+        @Override
+        public Boolean getValue() throws FlagParseFailedException {
+            return false;
+        }
+
+        @Override
+        public Boolean getDefaultValue() {
+            return true;
+        }
+    }.addAliases("-n");
+
+    /**
+     * Flag to specify a paste service.
+     */
+    public static final CommandFlag<PasteServiceType> PASTE_SERVICE_TYPE = new OptionalCommandFlag<PasteServiceType>
+            ("PasteServiceType", "--paste", PasteServiceType.class) {
+
+        private final List<String> pasteTypes = Arrays.stream(PasteServiceType.values())
+                .filter(pt -> pt != PasteServiceType.NONE)
+                .map(p -> p.toString().toLowerCase())
+                .collect(Collectors.toList());
+
+        @Override
+        public Collection<String> suggestValue() {
+            return pasteTypes;
+        }
+
+        @Override
+        public PasteServiceType getValue(@NotNull String input) throws FlagParseFailedException {
+            try {
+                return PasteServiceType.valueOf(input.toUpperCase());
+            }
+            catch (IllegalArgumentException e) {
+                throw new FlagParseFailedException(String.format("Invalid paste service type '%s'.", input));
+            }
+        }
+
+        @Override
+        public PasteServiceType getValue() throws FlagParseFailedException {
+            return PasteServiceType.PASTEGG;
+        }
+
+        @Override
+        public PasteServiceType getDefaultValue() {
+            return PasteServiceType.NONE;
+        }
+    }.addAliases("-p");
+
+    /**
+     * Flag to toggle if plugin list should be included.
+     */
+    public static final CommandFlag<Boolean> INCLUDE_PLUGIN_LIST = new NoValueCommandFlag<Boolean>
+            ("IncludePlugins", "--include-plugin-list", Boolean.class) {
+        @Override
+        public Boolean getValue() throws FlagParseFailedException {
+            return true;
+        }
+
+        @Override
+        public Boolean getDefaultValue() {
+            return true;
+        }
+    }.addAliases("-pl");
+}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/FlagGroup.java

@@ -0,0 +1,96 @@
+package com.onarandombox.MultiverseCore.commandtools.flag;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A group of {@link CommandFlag}, with indexed keys for efficient lookup.
+ */
+public class FlagGroup {
+
+    /**
+     * Create a new Flag Group with multiple {@link CommandFlag}.
+     *
+     * @param flags Multiple flags.
+     * @return A new {@link FlagGroup} generated from the flags.
+     */
+    public static FlagGroup of(CommandFlag<?>...flags) {
+        return new FlagGroup(flags);
+    }
+
+    private final List<String> identifiers;
+    private final Map<String, CommandFlag<?>> keyMap;
+
+    /**
+     * Create a new Flag Group with multiple {@link CommandFlag}.
+     *
+     * @param commandFlags Array of flags
+     */
+    public FlagGroup(CommandFlag<?>[] commandFlags) {
+        this.identifiers = new ArrayList<>(commandFlags.length);
+        this.keyMap = new HashMap<>();
+        for (CommandFlag<?> flag : commandFlags) {
+            addFlag(flag);
+        }
+    }
+
+    /**
+     * Add and indexes a flag.
+     *
+     * @param flag  The flag to add.
+     */
+    private void addFlag(CommandFlag<?> flag) {
+        this.identifiers.add(flag.getIdentifier());
+        this.keyMap.put(flag.getIdentifier(), flag);
+        for (String flagAlias : flag.getAliases()) {
+            this.keyMap.put(flagAlias, flag);
+        }
+    }
+
+    /**
+     * Parse the arguments to get it's flag values.
+     *
+     * @param args  The arguments to parse.
+     * @return A {@link FlagResult} containing value results.
+     * @throws FlagParseFailedException When there is an error parsing, such as invalid format.
+     */
+    @NotNull
+    public FlagResult calculateResult(String[] args) throws FlagParseFailedException {
+        return FlagResult.parse(args,this);
+    }
+
+    /**
+     * Gets flag from pre-indexed key mapping.
+     *
+     * @param key   The target key.
+     * @return A {@link CommandFlag} if found, else null.
+     */
+    @Nullable
+    public CommandFlag<?> getByKey(String key) {
+        return this.keyMap.get(key);
+    }
+
+    /**
+     * Suggest possible identifiers available for this Flag Group.
+     *
+     * @return A collection of identifier strings.
+     */
+    @NotNull
+    public Collection<String> suggestIdentifiers() {
+        return identifiers;
+    }
+
+    @Override
+    public String toString() {
+        return "FlagGroup{" +
+                "flagIdentifiers=" + identifiers +
+                ", keyFlagMap=" + keyMap +
+                '}';
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/FlagParseFailedException.java

@@ -0,0 +1,27 @@
+package com.onarandombox.MultiverseCore.commandtools.flag;
+
+/**
+ * Thrown when there is an issue with parsing flags from string arguments.
+ */
+//TODO: extend this from ACF CommandArgumentFailed exception class.
+public class FlagParseFailedException extends Exception {
+
+    public FlagParseFailedException() {
+    }
+
+    public FlagParseFailedException(String message, Object...replacements) {
+        super(String.format(message, replacements));
+    }
+
+    public FlagParseFailedException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public FlagParseFailedException(Throwable cause) {
+        super(cause);
+    }
+
+    public FlagParseFailedException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/FlagResult.java

@@ -0,0 +1,198 @@
+package com.onarandombox.MultiverseCore.commandtools.flag;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Represents the value result parsed from command arguments.
+ */
+public class FlagResult {
+
+    /**
+     * Parse arguments into its flag key and values.
+     *
+     * @param args      The arguments to parse.
+     * @param flagGroup The flags available to parse into.
+     * @return The {@link FlagResult} from the parse.
+     * @throws FlagParseFailedException there is an issue with parsing flags from string arguments.
+     */
+    public static FlagResult parse(@Nullable String[] args,
+                                   @NotNull FlagGroup flagGroup) throws FlagParseFailedException {
+
+        FlagResult flagResult = new FlagResult();
+
+        // No args to parse.
+        if (args == null || args.length <= 0) {
+            return flagResult;
+        }
+
+        // First arg must be a flag.
+        CommandFlag<?> currentFlag = flagGroup.getByKey(args[0]);
+        boolean completed = false;
+
+        // Parse the arguments.
+        for (int i = 1, argsLength = args.length; i <= argsLength; i++) {
+            if (currentFlag == null) {
+                throw new FlagParseFailedException("%s is not a valid flag.", args[i-1]);
+            }
+            // This ensures that flag is not null during final parse.
+            if (i >= argsLength) {
+                break;
+            }
+
+            String arg = args[i];
+            if (arg == null) {
+                throw new FlagParseFailedException("Arguments cannot be null!");
+            }
+
+            CommandFlag<?> nextFlag = flagGroup.getByKey(arg);
+
+            // Arg must be a flag key.
+            if (currentFlag instanceof NoValueCommandFlag) {
+                flagResult.add(currentFlag, currentFlag.getValue(), false);
+                currentFlag = nextFlag;
+                continue;
+            }
+
+            // Arg can be a flag key or value.
+            if (currentFlag instanceof OptionalCommandFlag) {
+                if (nextFlag != null) {
+                    // It's a key.
+                    flagResult.add(currentFlag, currentFlag.getValue(), false);
+                    currentFlag = nextFlag;
+                    continue;
+                }
+                // It's a value.
+                flagResult.add(currentFlag, currentFlag.getValue(arg), true);
+                if (i == argsLength - 1) {
+                    completed = true;
+                    break;
+                }
+                currentFlag = flagGroup.getByKey(args[++i]);
+                continue;
+            }
+
+            // Arg must be a flag value.
+            if (currentFlag instanceof RequiredCommandFlag) {
+                if (nextFlag != null) {
+                    // It's a key, error!
+                    throw new FlagParseFailedException("%s flag '%s' requires a value input.",
+                            currentFlag.getName(), currentFlag.getIdentifier());
+                }
+                // It's a value.
+                flagResult.add(currentFlag, currentFlag.getValue(arg), true);
+                if (i == argsLength - 1) {
+                    completed = true;
+                    break;
+                }
+                currentFlag = flagGroup.getByKey(args[++i]);
+            }
+        }
+
+        // Parse last flag.
+        if (!completed) {
+            if (currentFlag instanceof RequiredCommandFlag) {
+                throw new FlagParseFailedException("%s flag '%s' requires a value input.",
+                        currentFlag.getName(), currentFlag.getIdentifier());
+            }
+            flagResult.add(currentFlag, currentFlag.getValue(), false);
+        }
+
+        return flagResult;
+    }
+
+    private final Map<CommandFlag<?>, SingleFlagResult<?>> resultMap;
+
+    private FlagResult() {
+        resultMap = new HashMap<>();
+    }
+
+    /**
+     * Add a new value result from parsing arguments.
+     *
+     * @param flag      The flag that the value represents.
+     * @param value     The value of the flag.
+     * @param fromInput Denotes if flag was parsed by a user input.
+     */
+    private void add(CommandFlag<?> flag, Object value, boolean fromInput) {
+        resultMap.put(flag, new SingleFlagResult<>(value, fromInput));
+    }
+
+    /**
+     * Gets value of a flag.
+     *
+     * @param flag  The flag to get value from.
+     * @param <T>   The type of value.
+     * @return The value which is associated with the flag.
+     */
+    public <T> T getValue(CommandFlag<T> flag) {
+        SingleFlagResult<?> result = resultMap.get(flag);
+        if (result == null) {
+            return flag.getDefaultValue();
+        }
+        return (T) result.value;
+    }
+
+    /**
+     * Gets if the flag value is by a user input.
+     *
+     * @param flag  The flag to check against.
+     * @return True if value is by user input, else false.
+     */
+    public boolean isByUserInput(CommandFlag<?> flag) {
+        SingleFlagResult<?> result = resultMap.get(flag);
+        if (result == null) {
+            return false;
+        }
+        return result.isFromUserInput;
+    }
+
+    /**
+     * Gets if the flag is a default value, and key was not present in user's command arguments.
+     * i.e. Not in the {@link #resultMap}.
+     *
+     * @param flag  The flag to check against.
+     * @return True if flag was not present in user's command arguments, else false.
+     */
+    public boolean isDefaulted(CommandFlag<?> flag) {
+        return resultMap.get(flag) != null;
+    }
+
+    @Override
+    public String toString() {
+        return "FlagResult{" +
+                "resultMap=" + resultMap +
+                '}';
+    }
+
+    /**
+     * Represents a single value result parsed.
+     * Stores value and addition data such as if value is by user input.
+     *
+     * @param <T>   The type of value.
+     */
+    private static class SingleFlagResult<T> {
+        private final T value;
+        private final boolean isFromUserInput;
+
+        /**
+         * @param value     The resultant value from argument parsing.
+         * @param fromInput Indicates if value is parsed by user input.
+         */
+        private SingleFlagResult(T value, boolean fromInput) {
+            this.value = value;
+            this.isFromUserInput = fromInput;
+        }
+
+        @Override
+        public String toString() {
+            return "SingleFlagResult{" +
+                    "value=" + value +
+                    ", isFromUserInput=" + isFromUserInput +
+                    '}';
+        }
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/NoValueCommandFlag.java

@@ -0,0 +1,39 @@
+package com.onarandombox.MultiverseCore.commandtools.flag;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * This flag will always not require a user input to parse value.
+ *
+ * @param <T>   The flag Type.
+ */
+public abstract class NoValueCommandFlag<T> extends CommandFlag<T> {
+
+    /**
+     * {@inheritDoc}
+     */
+    public NoValueCommandFlag(String name, String identifier, Class<T> type) {
+        super(name, identifier, type);
+    }
+
+    /**
+     * {@link NoValueCommandFlag} will always not require a user input to parse value.
+     * Thus, no value suggestion needed.
+     */
+    @Override
+    public final Collection<String> suggestValue() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * {@link NoValueCommandFlag} will always not require a user input to parse value.
+     * Thus, this operation is not allowed.
+     */
+    @Override
+    public final T getValue(@NotNull String input) throws FlagParseFailedException {
+        throw new FlagParseFailedException("%s flag '%s' does not require a value.", this.name, this.identifier);
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/OptionalCommandFlag.java

@@ -0,0 +1,16 @@
+package com.onarandombox.MultiverseCore.commandtools.flag;
+
+/**
+ * Command Flag that optionally allows a user input value.
+ *
+ * @param <T>   The flag Type.
+ */
+public abstract class OptionalCommandFlag<T> extends CommandFlag<T> {
+
+    /**
+     * {@inheritDoc}
+     */
+    public OptionalCommandFlag(String name, String identifier, Class<T> type) {
+        super(name, identifier, type);
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/RequiredCommandFlag.java

@@ -0,0 +1,25 @@
+package com.onarandombox.MultiverseCore.commandtools.flag;
+
+/**
+ * This flag will always require a user input to parse value.
+ *
+ * @param <T>   The flag Type.
+ */
+public abstract class RequiredCommandFlag<T> extends CommandFlag<T> {
+
+    /**
+     * {@inheritDoc}
+     */
+    public RequiredCommandFlag(String name, String identifier, Class<T> type) {
+        super(name, identifier, type);
+    }
+
+    /**
+     * {@link RequiredCommandFlag} will always require a user input to parse value.
+     * Thus, this operation is not allowed.
+     */
+    @Override
+    public final T getValue() throws FlagParseFailedException {
+        throw new FlagParseFailedException("%s flag '%s' requires a value input.", this.name, this.identifier);
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/configuration/EntryFee.java

@@ -22,6 +22,8 @@ public class EntryFee extends SerializationConfig {
     @Nullable
     private Material currency;
 
+    private final Material DISABLED_MATERIAL = Material.AIR;
+
     public EntryFee() {
         super();
     }
@@ -51,6 +53,9 @@ public class EntryFee extends SerializationConfig {
      */
     @Nullable
     public Material getCurrency() {
+        if (currency == null || currency.equals(DISABLED_MATERIAL)) {
+            return null;
+        }
         return currency;
     }
 

src/main/java/com/onarandombox/MultiverseCore/enums/RespawnType.java

@@ -0,0 +1,7 @@
+package com.onarandombox.MultiverseCore.enums;
+
+public enum RespawnType {
+    BED,
+    ANCHOR,
+    OTHER
+}

src/main/java/com/onarandombox/MultiverseCore/listeners/MVPlayerListener.java

@@ -15,7 +15,9 @@ import com.dumptruckman.minecraft.util.Logging;
 import com.onarandombox.MultiverseCore.MultiverseCore;
 import com.onarandombox.MultiverseCore.api.MVWorldManager;
 import com.onarandombox.MultiverseCore.api.MultiverseWorld;
+import com.onarandombox.MultiverseCore.enums.RespawnType;
 import com.onarandombox.MultiverseCore.event.MVRespawnEvent;
+import com.onarandombox.MultiverseCore.utils.CompatibilityLayer;
 import com.onarandombox.MultiverseCore.utils.PermissionTools;
 import org.bukkit.GameMode;
 import org.bukkit.Location;
@@ -69,9 +71,16 @@ public class MVPlayerListener implements Listener {
             return;
         }
 
+        RespawnType respawnType = RespawnType.OTHER;
+        if (event.isBedSpawn()) {
+            respawnType = RespawnType.BED;
+        }
+        if (CompatibilityLayer.isAnchorSpawn(event)) {
+            respawnType = RespawnType.ANCHOR;
+        }
 
-        if (mvWorld.getBedRespawn() && event.isBedSpawn()) {
-            Logging.fine("Spawning " + event.getPlayer().getName() + " at their bed");
+        if (mvWorld.getBedRespawn() && (respawnType == RespawnType.BED || respawnType == RespawnType.ANCHOR)) {
+            Logging.fine("Spawning %s at their %s", event.getPlayer().getName(), respawnType);
             return;
         }
 
@@ -305,7 +314,15 @@ public class MVPlayerListener implements Listener {
                     + "' because enforceaccess is off.");
         }
         if (!plugin.getMVConfig().isUsingDefaultPortalSearch()) {
-            event.setSearchRadius(this.plugin.getMVConfig().getPortalSearchRadius());
+            try {
+                Class.forName("org.bukkit.TravelAgent");
+                if (event.getPortalTravelAgent() != null) {
+                    event.getPortalTravelAgent().setSearchRadius(plugin.getMVConfig().getPortalSearchRadius());
+                }
+            } catch (ClassNotFoundException ignore) {
+                Logging.fine("TravelAgent not available for PlayerPortalEvent for " + event.getPlayer().getName());
+            }
+
         }
     }
 

src/main/java/com/onarandombox/MultiverseCore/utils/BukkitTravelAgent.java

@@ -0,0 +1,111 @@
+package com.onarandombox.MultiverseCore.utils;
+
+import java.util.logging.Level;
+
+import com.dumptruckman.minecraft.util.Logging;
+import com.onarandombox.MultiverseCore.api.SafeTTeleporter;
+import com.onarandombox.MultiverseCore.destination.CannonDestination;
+import org.bukkit.Location;
+import org.bukkit.TravelAgent;
+import org.bukkit.event.player.PlayerPortalEvent;
+
+public class BukkitTravelAgent implements TravelAgent {
+    private final MVTravelAgent agent;
+
+    public BukkitTravelAgent(MVTravelAgent agent) {
+        this.agent = agent;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public BukkitTravelAgent setSearchRadius(int radius) {
+        return this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public int getSearchRadius() {
+        return 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public BukkitTravelAgent setCreationRadius(int radius) {
+        return this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public int getCreationRadius() {
+        return 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean getCanCreatePortal() {
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setCanCreatePortal(boolean create) {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Location findOrCreate(Location location) {
+        return this.getSafeLocation();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Location findPortal(Location location) {
+        return this.getSafeLocation();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean createPortal(Location location) {
+        return false;
+    }
+
+    private Location getSafeLocation() {
+        // At this time, these can never use the velocity.
+        if (agent.destination instanceof CannonDestination) {
+            Logging.fine("Using Stock TP method. This cannon will have 0 velocity");
+        }
+        SafeTTeleporter teleporter = agent.core.getSafeTTeleporter();
+        Location newLoc = agent.destination.getLocation(agent.player);
+        if (agent.destination.useSafeTeleporter()) {
+            newLoc = teleporter.getSafeLocation(agent.player, agent.destination);
+        }
+        if (newLoc == null) {
+            return agent.player.getLocation();
+        }
+        return newLoc;
+
+    }
+
+    public void setPortalEventTravelAgent(PlayerPortalEvent event) {
+        event.setPortalTravelAgent(this);
+        event.useTravelAgent(true);
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/utils/CompatibilityLayer.java

@@ -0,0 +1,46 @@
+package com.onarandombox.MultiverseCore.utils;
+
+import com.dumptruckman.minecraft.util.Logging;
+import org.bukkit.Bukkit;
+import org.bukkit.event.player.PlayerRespawnEvent;
+
+import java.lang.reflect.Method;
+
+/**
+ * A utility class to enable version specific minecraft features.
+ */
+public class CompatibilityLayer {
+
+    private static Method checkAnchorSpawn;
+
+    /**
+     * Initialise the reflection methods.
+     */
+    public static void init() {
+        try {
+            checkAnchorSpawn = PlayerRespawnEvent.class.getDeclaredMethod("isAnchorSpawn");
+        } catch (NoSuchMethodException e) {
+            Logging.fine("%s does not support respawn anchors.", Bukkit.getVersion());
+        }
+    }
+
+    /**
+     * Check if the respawn point is of respawn anchor type.
+     * Introduced in minecraft 1.16
+     *
+     * @param event A player respawn event.
+     * @return If the respawn location is an anchor point.
+     */
+    public static boolean isAnchorSpawn(PlayerRespawnEvent event) {
+        if (checkAnchorSpawn == null) {
+            return false;
+        }
+        try {
+            return (boolean) checkAnchorSpawn.invoke(event);
+        } catch (Exception e) {
+            Logging.warning("Error checking for: %s", checkAnchorSpawn);
+            e.printStackTrace();
+        }
+        return false;
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/utils/MVTravelAgent.java

@@ -0,0 +1,27 @@
+/******************************************************************************
+ * Multiverse 2 Copyright (c) the Multiverse Team 2011.                       *
+ * Multiverse 2 is licensed under the BSD License.                            *
+ * For more information please check the README.md file included              *
+ * with this project.                                                         *
+ ******************************************************************************/
+
+package com.onarandombox.MultiverseCore.utils;
+
+import com.onarandombox.MultiverseCore.MultiverseCore;
+import com.onarandombox.MultiverseCore.api.MVDestination;
+import org.bukkit.entity.Player;
+
+/**
+ * The Multiverse TravelAgent.
+ */
+public class MVTravelAgent {
+    protected MVDestination destination;
+    protected MultiverseCore core;
+    protected Player player;
+
+    public MVTravelAgent(MultiverseCore multiverseCore, MVDestination d, Player p) {
+        this.destination = d;
+        this.core = multiverseCore;
+        this.player = p;
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/utils/SimpleLocationManipulation.java

@@ -40,6 +40,15 @@ public class SimpleLocationManipulation implements LocationManipulation {
         orientationInts.put("w", 90);
         orientationInts.put("nw", 135);
 
+        orientationInts.put("north", 180);
+        orientationInts.put("northeast", 225);
+        orientationInts.put("east", 270);
+        orientationInts.put("southeast", 315);
+        orientationInts.put("south", 0);
+        orientationInts.put("southwest", 45);
+        orientationInts.put("west", 90);
+        orientationInts.put("northwest", 135);
+
         // "freeze" the map:
         ORIENTATION_INTS = Collections.unmodifiableMap(orientationInts);
         // END CHECKSTYLE-SUPPRESSION: MagicNumberCheck

src/main/java/com/onarandombox/MultiverseCore/utils/webpaste/BitlyURLShortener.java

@@ -1,8 +1,8 @@
 package com.onarandombox.MultiverseCore.utils.webpaste;
 
-import net.minidev.json.JSONObject;
-import net.minidev.json.parser.JSONParser;
-import net.minidev.json.parser.ParseException;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
 
 import java.io.IOException;
 import java.util.Map;

src/main/java/com/onarandombox/MultiverseCore/utils/webpaste/GitHubPasteService.java

@@ -1,8 +1,8 @@
 package com.onarandombox.MultiverseCore.utils.webpaste;
 
-import net.minidev.json.JSONObject;
-import net.minidev.json.parser.JSONParser;
-import net.minidev.json.parser.ParseException;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
 
 import java.io.IOException;
 import java.util.HashMap;

src/main/java/com/onarandombox/MultiverseCore/utils/webpaste/HastebinPasteService.java

@@ -1,9 +1,8 @@
 package com.onarandombox.MultiverseCore.utils.webpaste;
 
-
-import net.minidev.json.JSONObject;
-import net.minidev.json.parser.JSONParser;
-import net.minidev.json.parser.ParseException;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
 
 import java.io.IOException;
 import java.util.Map;

src/main/java/com/onarandombox/MultiverseCore/utils/webpaste/PasteGGPasteService.java

@@ -1,9 +1,9 @@
 package com.onarandombox.MultiverseCore.utils.webpaste;
 
-import net.minidev.json.JSONArray;
-import net.minidev.json.JSONObject;
-import net.minidev.json.parser.JSONParser;
-import net.minidev.json.parser.ParseException;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
 
 import java.io.IOException;
 import java.util.HashMap;

src/main/java/com/onarandombox/MultiverseCore/utils/webpaste/PasteServiceType.java

@@ -22,5 +22,9 @@ public enum PasteServiceType {
     /**
      * @see GitHubPasteService
      */
-    GITHUB
+    GITHUB,
+    /**
+     * No paste service used.
+     */
+    NONE
 }

src/test/java/com/onarandombox/MultiverseCore/TestEntryFeeConversion.java

@@ -50,6 +50,10 @@ public class TestEntryFeeConversion {
         WorldProperties props = new WorldProperties(config);
         assertNull(props.entryfee.getCurrency());
 
+        entryFee.put("currency", 0);
+        props = new WorldProperties(config);
+        assertNull(props.entryfee.getCurrency());
+
         entryFee.put("currency", 1);
         props = new WorldProperties(config);
         assertEquals(Material.STONE, props.entryfee.getCurrency());

src/test/java/com/onarandombox/MultiverseCore/TestWorldStuff.java

@@ -207,7 +207,7 @@ public class TestWorldStuff {
         assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
 
         // Verify
-        verify(mockCommandSender).sendMessage("Invalid generator! 'BogusGen'. " + ChatColor.RED + "Aborting world creation.");
+        verify(mockCommandSender).sendMessage("§cError: Invalid generator string 'BogusGen'. See /mv gens for available generators.");
     }
 
     @Test

src/test/java/com/onarandombox/MultiverseCore/utils/TestInstanceCreator.java

@@ -214,11 +214,18 @@ public class TestInstanceCreator {
             serverfield.set(core, mockServer);
 
             // Set buscript
-            Buscript buscript = PowerMockito.spy(new Buscript(core));
+            Buscript buscript;
             Field buscriptfield = MultiverseCore.class.getDeclaredField("buscript");
             buscriptfield.setAccessible(true);
+
+            try {
+                buscript = PowerMockito.spy(new Buscript(core));
+                when(buscript.getPlugin()).thenReturn(core);
+            } catch (NullPointerException e) {
+                buscript = null;
+            }
+
             buscriptfield.set(core, buscript);
-            when(buscript.getPlugin()).thenReturn(core);
 
             // Set worldManager
             WorldManager wm = PowerMockito.spy(new WorldManager(core));