add new layer types and gen types

5 files changed, 260 insertions, 122 deletions

diff --git a/README.md b/README.md
index 8add728..185e2b9 100644
--- a/README.md
+++ b/README.md
@@ -8,9 +8,9 @@ once this list is complete and all bugs are fixed, we *should* be ready for rele
 - [x] layers should be able to generate w/ "clumps" of blocks; instead of only one material as a whole
   - [x] the clump size should be customizable (for later); be able to set a min/max val and it will choose randomly per each clump (not in config file yet, just internally)
     - *Note: this is done through the amount of times each Material shows up in the List--there's no config for it.*
-- [ ] make shovels generation actually work properly
+- [x] make shovels generation actually work properly
   - make different types of platforms (square, circle, multi-tiered, etc.); still should be pseudo-random
-- [ ] make snowballs generation actually work properly (shocker)
+- [x] make snowballs generation actually work properly (shocker)
   - make three layers generate (same layer types as shovels, just multiple of them)
 
 ## game realism  
diff --git a/src/main/java/com/MylesAndMore/tumble/EventListener.java b/src/main/java/com/MylesAndMore/tumble/EventListener.java
index 0de9a86..03d786e 100644
--- a/src/main/java/com/MylesAndMore/tumble/EventListener.java
+++ b/src/main/java/com/MylesAndMore/tumble/EventListener.java
@@ -168,7 +168,7 @@ public class EventListener implements Listener {
                     // then check to see if it hit a player or a block
                     if (event.getHitBlock() != null) {
                         // if it was a block, check if that block is within the game area,
-                        if (event.getHitBlock().getLocation().distanceSquared(Bukkit.getWorld(TumbleManager.getGameWorld()).getSpawnLocation()) < 402) {
+                        if (event.getHitBlock().getLocation().distanceSquared(Bukkit.getWorld(TumbleManager.getGameWorld()).getSpawnLocation()) < 579) {
                             // then remove that block.
                             event.getHitBlock().setType(Material.AIR);
                         }
@@ -231,15 +231,12 @@ public class EventListener implements Listener {
         // Check if a player was left clicking a block in the gameWorld
         if (event.getAction() == Action.LEFT_CLICK_BLOCK) {
             if (event.getClickedBlock().getWorld() == Bukkit.getWorld(TumbleManager.getGameWorld())) {
-                // Then check if it was with an item enchanted w/ silk touch
-                if (event.getPlayer().getInventory().getItemInMainHand().containsEnchantment(Enchantment.SILK_TOUCH)) {
-                    // Then check to see if the player interacted less than 150ms ago
-                    if ((System.currentTimeMillis() - lastTimeI) < 150) return;
+                // Then check to see if the player interacted less than 150ms ago
+                if ((System.currentTimeMillis() - lastTimeI) < 150) return;
                     // If not, set that block to air (break it)
-                    else {
-                        lastTimeI = System.currentTimeMillis();
-                        event.getClickedBlock().setType(Material.AIR);
-                    }
+                else {
+                    lastTimeI = System.currentTimeMillis();
+                    event.getClickedBlock().setType(Material.AIR);
                 }
             }
         }
diff --git a/src/main/java/com/MylesAndMore/tumble/Game.java b/src/main/java/com/MylesAndMore/tumble/Game.java
index 2b3d7b4..3d83d23 100644
--- a/src/main/java/com/MylesAndMore/tumble/Game.java
+++ b/src/main/java/com/MylesAndMore/tumble/Game.java
@@ -48,6 +48,8 @@ public class Game {
     private int autoStartID = -1;
     // Define a variable for music ID
     private int musicID = -1;
+    // Define a variable to keep the list of tracks that have already played in the game
+    List<String> sounds = new ArrayList<>();
 
     // Initialize a new instance of the Random class for use later
     private final Random Random = new Random();
@@ -82,47 +84,27 @@ public class Game {
         }
         else {
             // Define the gameType
-            if (Objects.equals(type, "shovels")) {
-                gameState = "starting";
-                // Set the type to gameType since it won't change for this mode
-                gameType = type;
-                // Clear the players' inventories so they can't bring any items into the game
-                clearInventories(TumbleManager.getPlayersInLobby());
-                // Generate the correct layers for a Shovels game
-                // The else statement is just in case the generator fails; this command will fail
-                if (generateLayers(type)) {
-                    // Send all players from lobby to the game
-                    scatterPlayers(TumbleManager.getPlayersInLobby());
-                }
-                else {
-                    return false;
-                }
-            }
-            else if (Objects.equals(type, "snowballs")) {
-                gameState = "starting";
-                gameType = type;
-                clearInventories(TumbleManager.getPlayersInLobby());
-                if (generateLayers(type)) {
-                    scatterPlayers(TumbleManager.getPlayersInLobby());
-                }
-                else {
-                    return false;
-                }
-            }
-            else if (Objects.equals(type, "mixed")) {
-                gameState = "starting";
-                gameType = type;
-                clearInventories(TumbleManager.getPlayersInLobby());
-                if (generateLayers(type)) {
-                    scatterPlayers(TumbleManager.getPlayersInLobby());
-                }
-                else {
+            switch (type) {
+                case "shovels":
+                case "snowballs":
+                case "mixed":
+                    gameState = "starting";
+                    // Set the type to gameType since it won't change for this mode
+                    gameType = type;
+                    // Clear the players' inventories so they can't bring any items into the game
+                    clearInventories(TumbleManager.getPlayersInLobby());
+                    // Generate the correct layers for a Shovels game
+                    // The else statement is just in case the generator fails; this command will fail
+                    if (generateLayers(type)) {
+                        // Send all players from lobby to the game
+                        scatterPlayers(TumbleManager.getPlayersInLobby());
+                    } else {
+                        return false;
+                    }
+                    break;
+                default:
+                    // The game type in the config did not match a specified game type; return false to signify that
                     return false;
-                }
-            }
-            else {
-                // The game type in the config did not match a specified game type; return false to signify that
-                return false;
             }
             // If a game creation succeeded, then,
             // Update the game's players for later
@@ -230,25 +212,47 @@ public class Game {
 
     // BEGIN PRIVATE METHODS
 
+    // Initialize Layers class
+    private final Layers layers = new Layers();
     /**
      * Generates the layers in the gameWorld for a certain gameType
      * @param type can be either "shovels", "snowballs", or "mixed", anything else will fail generation
      * @return true if gameType was recognized and layers were (hopefully) generated, false if unrecognized
      */
-    // Initialize Layers
-    private final Layers layers = new Layers();
     private boolean generateLayers(String type) {
         // Create a new Location for the layers to work with--this is so that we don't modify the actual gameSpawn var
         Location layer = new Location(gameSpawn.getWorld(), gameSpawn.getX(), gameSpawn.getY(), gameSpawn.getZ(), gameSpawn.getYaw(), gameSpawn.getPitch());
         if (Objects.equals(type, "shovels")) {
             layer.setY(layer.getY() - 1);
-            Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.SNOW_BLOCK), layers.getMaterialList());
-            Generator.generateLayer(layer, 13, 1, Material.AIR);
-            layer.setY(layer.getY() - 1);
-            Generator.generateClumps(Generator.generateLayer(layer, 13, 1, Material.GRASS_BLOCK), layers.getMaterialList());
-            Generator.generateLayer(layer, 4, 1, Material.AIR);
-            layer.setY(layer.getY() - 1);
-            Generator.generateClumps(Generator.generateLayer(layer, 4, 1, Material.PODZOL), layers.getMaterialList());
+            // Choose a random type of generation; a circular layer, a square layer, or a multi-tiered layer of either variety
+            if (Random.nextInt(4) == 0) {
+                // Circular layer
+                Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.SNOW_BLOCK), layers.getMaterialList());
+            }
+            else if (Random.nextInt(4) == 1) {
+                // Square layer
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 17, layer.getY(), layer.getZ() - 17), new Location(layer.getWorld(), layer.getX() + 17, layer.getY(), layer.getZ() + 17), Material.SNOW_BLOCK), layers.getMaterialList());
+            }
+            else if (Random.nextInt(4) == 2) {
+                // Multi-tiered circle
+                Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.SNOW_BLOCK), layers.getMaterialList());
+                Generator.generateLayer(layer, 13, 1, Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateLayer(layer, 13, 1, Material.GRASS_BLOCK), layers.getMaterialList());
+                Generator.generateLayer(layer, 4, 1, Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateLayer(layer, 4, 1, Material.PODZOL), layers.getMaterialList());
+            }
+            else {
+                // Multi-tiered square
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 17, layer.getY(), layer.getZ() - 17), new Location(layer.getWorld(), layer.getX() + 17, layer.getY(), layer.getZ() + 17), Material.SNOW_BLOCK), layers.getMaterialList());
+                Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 13, layer.getY(), layer.getZ() - 13), new Location(layer.getWorld(), layer.getX() + 13, layer.getY(), layer.getZ() + 13), Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 13, layer.getY(), layer.getZ() - 13), new Location(layer.getWorld(), layer.getX() + 13, layer.getY(), layer.getZ() + 13), Material.GRASS_BLOCK), layers.getMaterialList());
+                Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 7, layer.getY(), layer.getZ() - 7), new Location(layer.getWorld(), layer.getX() + 7, layer.getY(), layer.getZ() + 7), Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 7, layer.getY(), layer.getZ() - 7), new Location(layer.getWorld(), layer.getX() + 7, layer.getY(), layer.getZ() + 7), Material.PODZOL), layers.getMaterialList());
+            }
             ItemStack shovel = new ItemStack(Material.IRON_SHOVEL);
             shovel.addEnchantment(Enchantment.SILK_TOUCH, 1);
             if (Objects.equals(gameState, "running")) {
@@ -263,6 +267,7 @@ public class Game {
                 clearInventories(gamePlayers);
                 giveItems(gamePlayers, new ItemStack(Material.SNOWBALL));
                 displayActionbar(gamePlayers, ChatColor.DARK_RED + "Showdown!");
+                playSound(gamePlayers, Sound.ENTITY_ELDER_GUARDIAN_CURSE, SoundCategory.HOSTILE, 1, 1);
                 // End the round in another 2m30s
                 gameID = Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(TumbleManager.getPlugin(), () -> {
                     roundEnd(null);
@@ -271,13 +276,79 @@ public class Game {
         }
         else if (Objects.equals(type, "snowballs")) {
             layer.setY(layer.getY() - 1);
-            Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.STONE), layers.getMaterialList());
-            Generator.generateLayer(layer, 13, 1, Material.AIR);
-            layer.setY(layer.getY() - 1);
-            Generator.generateClumps(Generator.generateLayer(layer, 13, 1, Material.GRANITE), layers.getMaterialList());
-            Generator.generateLayer(layer, 4, 1, Material.AIR);
-            layer.setY(layer.getY() - 1);
-            Generator.generateClumps(Generator.generateLayer(layer, 4, 1, Material.LIME_GLAZED_TERRACOTTA), layers.getMaterialList());
+            // Similar generation to shovels, except there are three layers
+            if (Random.nextInt(4) == 0) {
+                // Circular layer
+                Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.STONE), layers.getMaterialList());
+                layer.setY(layer.getY() - 6);
+                Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.STONE), layers.getMaterialList());
+                layer.setY(layer.getY() - 6);
+                Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.STONE), layers.getMaterialList());
+            }
+            else if (Random.nextInt(4) == 1) {
+                // Square layer
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 17, layer.getY(), layer.getZ() - 17), new Location(layer.getWorld(), layer.getX() + 17, layer.getY(), layer.getZ() + 17), Material.STONE), layers.getMaterialList());
+                layer.setY(layer.getY() - 6);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 17, layer.getY(), layer.getZ() - 17), new Location(layer.getWorld(), layer.getX() + 17, layer.getY(), layer.getZ() + 17), Material.STONE), layers.getMaterialList());
+                layer.setY(layer.getY() - 6);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 17, layer.getY(), layer.getZ() - 17), new Location(layer.getWorld(), layer.getX() + 17, layer.getY(), layer.getZ() + 17), Material.STONE), layers.getMaterialList());
+            }
+            else if (Random.nextInt(4) == 2) {
+                // Multi-tiered circle
+                Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.STONE), layers.getMaterialList());
+                Generator.generateLayer(layer, 13, 1, Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateLayer(layer, 13, 1, Material.GRANITE), layers.getMaterialList());
+                Generator.generateLayer(layer, 4, 1, Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateLayer(layer, 4, 1, Material.LIME_GLAZED_TERRACOTTA), layers.getMaterialList());
+                layer.setY(layer.getY() - 6);
+
+                Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.STONE), layers.getMaterialList());
+                Generator.generateLayer(layer, 13, 1, Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateLayer(layer, 13, 1, Material.GRANITE), layers.getMaterialList());
+                Generator.generateLayer(layer, 4, 1, Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateLayer(layer, 4, 1, Material.LIME_GLAZED_TERRACOTTA), layers.getMaterialList());
+                layer.setY(layer.getY() - 6);
+
+                Generator.generateClumps(Generator.generateLayer(layer, 17, 1, Material.STONE), layers.getMaterialList());
+                Generator.generateLayer(layer, 13, 1, Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateLayer(layer, 13, 1, Material.GRANITE), layers.getMaterialList());
+                Generator.generateLayer(layer, 4, 1, Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateLayer(layer, 4, 1, Material.LIME_GLAZED_TERRACOTTA), layers.getMaterialList());
+            }
+            else {
+                // Multi-tiered square
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 17, layer.getY(), layer.getZ() - 17), new Location(layer.getWorld(), layer.getX() + 17, layer.getY(), layer.getZ() + 17), Material.STONE), layers.getMaterialList());
+                Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 13, layer.getY(), layer.getZ() - 13), new Location(layer.getWorld(), layer.getX() + 13, layer.getY(), layer.getZ() + 13), Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 13, layer.getY(), layer.getZ() - 13), new Location(layer.getWorld(), layer.getX() + 13, layer.getY(), layer.getZ() + 13), Material.GRANITE), layers.getMaterialList());
+                Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 7, layer.getY(), layer.getZ() - 7), new Location(layer.getWorld(), layer.getX() + 7, layer.getY(), layer.getZ() + 7), Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 7, layer.getY(), layer.getZ() - 7), new Location(layer.getWorld(), layer.getX() + 7, layer.getY(), layer.getZ() + 7), Material.LIME_GLAZED_TERRACOTTA), layers.getMaterialList());
+                layer.setY(layer.getY() - 6);
+
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 17, layer.getY(), layer.getZ() - 17), new Location(layer.getWorld(), layer.getX() + 17, layer.getY(), layer.getZ() + 17), Material.STONE), layers.getMaterialList());
+                Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 13, layer.getY(), layer.getZ() - 13), new Location(layer.getWorld(), layer.getX() + 13, layer.getY(), layer.getZ() + 13), Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 13, layer.getY(), layer.getZ() - 13), new Location(layer.getWorld(), layer.getX() + 13, layer.getY(), layer.getZ() + 13), Material.GRANITE), layers.getMaterialList());
+                Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 7, layer.getY(), layer.getZ() - 7), new Location(layer.getWorld(), layer.getX() + 7, layer.getY(), layer.getZ() + 7), Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 7, layer.getY(), layer.getZ() - 7), new Location(layer.getWorld(), layer.getX() + 7, layer.getY(), layer.getZ() + 7), Material.LIME_GLAZED_TERRACOTTA), layers.getMaterialList());
+                layer.setY(layer.getY() - 6);
+
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 17, layer.getY(), layer.getZ() - 17), new Location(layer.getWorld(), layer.getX() + 17, layer.getY(), layer.getZ() + 17), Material.STONE), layers.getMaterialList());
+                Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 13, layer.getY(), layer.getZ() - 13), new Location(layer.getWorld(), layer.getX() + 13, layer.getY(), layer.getZ() + 13), Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 13, layer.getY(), layer.getZ() - 13), new Location(layer.getWorld(), layer.getX() + 13, layer.getY(), layer.getZ() + 13), Material.GRANITE), layers.getMaterialList());
+                Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 7, layer.getY(), layer.getZ() - 7), new Location(layer.getWorld(), layer.getX() + 7, layer.getY(), layer.getZ() + 7), Material.AIR);
+                layer.setY(layer.getY() - 1);
+                Generator.generateClumps(Generator.generateCuboid(new Location(layer.getWorld(), layer.getX() - 7, layer.getY(), layer.getZ() - 7), new Location(layer.getWorld(), layer.getX() + 7, layer.getY(), layer.getZ() + 7), Material.LIME_GLAZED_TERRACOTTA), layers.getMaterialList());
+            }
             if (Objects.equals(gameState, "running")) {
                 giveItems(TumbleManager.getPlayersInGame(), new ItemStack(Material.SNOWBALL));
             }
@@ -285,9 +356,7 @@ public class Game {
                 giveItems(TumbleManager.getPlayersInLobby(), new ItemStack(Material.SNOWBALL));
             }
             // End the round in 5m
-            gameID = Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(TumbleManager.getPlugin(), () -> {
-                roundEnd(null);
-            }, 6160);    
+            gameID = Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(TumbleManager.getPlugin(), () -> roundEnd(null), 6160);
         }
         else if (Objects.equals(type, "mixed")) {
             // Randomly select either shovels or snowballs and re-run the method
@@ -380,30 +449,27 @@ public class Game {
     }
 
     private void playMusic(@NotNull List<Player> players, @NotNull SoundCategory category, float volume, float pitch) {
-        List<String> sounds = new ArrayList<>();
         if (sounds.size() == 0) {
-            sounds = new ArrayList<>(List.of(
-                "minecraft:tumble.0",
-                "minecraft:tumble.1",
-                "minecraft:tumble.2",
-                "minecraft:tumble.3",
-                "minecraft:tumble.4",
-                "minecraft:tumble.5",
-                "minecraft:tumble.6",
-                "minecraft:tumble.7",
-                "minecraft:tumble.8",
-                "minecraft:tumble.9"));
+            sounds.addAll(List.of(
+                    "minecraft:tumble.0",
+                    "minecraft:tumble.1",
+                    "minecraft:tumble.2",
+                    "minecraft:tumble.3",
+                    "minecraft:tumble.4",
+                    "minecraft:tumble.5",
+                    "minecraft:tumble.6",
+                    "minecraft:tumble.7",
+                    "minecraft:tumble.8",
+                    "minecraft:tumble.9"));
         }
-        else {
-            String currentSong = sounds.get(Random.nextInt(sounds.size()));
-            for (Player aPlayer : players) {
-                aPlayer.playSound(aPlayer.getLocation(), currentSong, category, volume, pitch);
-            }
-            sounds.remove(currentSong);
-            musicID = Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(TumbleManager.getPlugin(), () -> {
-                playMusic(gamePlayers, SoundCategory.NEUTRAL, 1, 1);
-            }, 1460);   
+        String currentSong = sounds.get(Random.nextInt(sounds.size()));
+        for (Player aPlayer : players) {
+            aPlayer.playSound(aPlayer.getLocation(), currentSong, category, volume, pitch);
         }
+        sounds.remove(currentSong);
+        musicID = Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(TumbleManager.getPlugin(), () -> {
+            playMusic(gamePlayers, SoundCategory.NEUTRAL, 1, 1);
+        }, 1460);
     }
 
     /**
@@ -437,15 +503,15 @@ public class Game {
     }
 
     private void roundEnd(@Nullable Player winner) {
-        // Cancel the tasks to auto-end the round
+        // Cancel the tasks that auto-end the round
         Bukkit.getServer().getScheduler().cancelTask(gameID);
         // Check if there was a winner of the round
         if (winner != null) {
             // Set the wins of the player to their current # of wins + 1
             gameWins.set(gamePlayers.indexOf(winner), (gameWins.get(gamePlayers.indexOf(winner)) + 1));
         }
-        // Clear old layers (as a fill command, this would be /fill ~-20 ~-4 ~-20 ~20 ~ ~20 relative to spawn)
-        Generator.generateCuboid(new Location(gameSpawn.getWorld(), gameSpawn.getX() - 20, gameSpawn.getY() - 4, gameSpawn.getZ() - 20), new Location(gameSpawn.getWorld(), gameSpawn.getX() + 20, gameSpawn.getY(), gameSpawn.getZ() + 20), Material.AIR);
+        // Clear old layers (as a fill command, this would be /fill ~-20 ~-20 ~-20 ~20 ~ ~20 relative to spawn)
+        Generator.generateCuboid(new Location(gameSpawn.getWorld(), gameSpawn.getX() - 20, gameSpawn.getY() - 20, gameSpawn.getZ() - 20), new Location(gameSpawn.getWorld(), gameSpawn.getX() + 20, gameSpawn.getY(), gameSpawn.getZ() + 20), Material.AIR);
         playSound(gamePlayers, Sound.BLOCK_NOTE_BLOCK_PLING, SoundCategory.BLOCKS, 5, 0);
         // Again, check if there was a winner to...win
         if (winner != null) {
diff --git a/src/main/java/com/MylesAndMore/tumble/api/Generator.java b/src/main/java/com/MylesAndMore/tumble/api/Generator.java
index d66352a..0a35767 100644
--- a/src/main/java/com/MylesAndMore/tumble/api/Generator.java
+++ b/src/main/java/com/MylesAndMore/tumble/api/Generator.java
@@ -45,6 +45,33 @@ public class Generator {
     }
 
     /**
+     * Generates a cubiod (literally just a ripoff fill command)
+     * @param firstPos The first Location to fill (first three coords in a fill command)
+     * @param secondPos The second Location to fill to (second three coords)
+     * @param material The Material to fill
+     */
+    public static List<Block> generateCuboid(Location firstPos, Location secondPos, Material material) {
+        World world = firstPos.getWorld();
+        List<Block> blocks = new ArrayList<>();
+        int fX = firstPos.getBlockX();
+        int fY = firstPos.getBlockY();
+        int fZ = firstPos.getBlockZ();
+        int sX = secondPos.getBlockX();
+        int sY = secondPos.getBlockY();
+        int sZ = secondPos.getBlockZ();
+
+        for (int x = fX; x <= sX; x++) {
+            for (int y = fY; y <= sY; y++) {
+                for (int z = fZ; z <= sZ; z++) {
+                    world.getBlockAt(x, y, z).setType(material);
+                    blocks.add(world.getBlockAt(x, y, z));
+                }
+            }
+        }
+        return blocks;
+    }
+
+    /**
      * Generates clumps in a pre-generated layer.
      * @param blockList A list of block Locations that this method is allowed to edit
      * @param materialList A list of Materials for the generator to randomly choose from.
@@ -87,28 +114,4 @@ public class Generator {
             blocks.remove(aBlock);
         }
     }
-
-    /**
-     * Generates a cubiod (literally just a ripoff fill command)
-     * @param firstPos The first Location to fill (first three coords in a fill command)
-     * @param secondPos The second Location to fill to (second three coords)
-     * @param material The Material to fill
-     */
-    public static void generateCuboid(Location firstPos, Location secondPos, Material material) {
-        World world = firstPos.getWorld();
-        int fX = firstPos.getBlockX();
-        int fY = firstPos.getBlockY();
-        int fZ = firstPos.getBlockZ();
-        int sX = secondPos.getBlockX();
-        int sY = secondPos.getBlockY();
-        int sZ = secondPos.getBlockZ();
-
-        for (int x = fX; x <= sX; x++) {
-            for (int y = fY; y <= sY; y++) {
-                for (int z = fZ; z <= sZ; z++) {
-                    world.getBlockAt(x, y, z).setType(material);
-                }
-            }
-        }
-    }
 }
diff --git a/src/main/java/com/MylesAndMore/tumble/api/Layers.java b/src/main/java/com/MylesAndMore/tumble/api/Layers.java
index fba6fbf..dad5ea8 100644
--- a/src/main/java/com/MylesAndMore/tumble/api/Layers.java
+++ b/src/main/java/com/MylesAndMore/tumble/api/Layers.java
@@ -23,6 +23,41 @@ public class Layers {
         matList.add(gen8);
         matList.add(gen9);
         matList.add(gen10);
+        matList.add(gen12);
+        matList.add(gen14);
+        matList.add(gen15);
+        matList.add(gen16);
+        matList.add(gen0);
+        matList.add(gen1);
+        matList.add(gen2);
+        matList.add(gen3);
+        matList.add(gen4);
+        matList.add(gen5);
+        matList.add(gen6);
+        matList.add(gen7);
+        matList.add(gen8);
+        matList.add(gen9);
+        matList.add(gen10);
+        matList.add(gen12);
+        matList.add(gen14);
+        matList.add(gen15);
+        matList.add(gen16);
+        matList.add(gen0);
+        matList.add(gen1);
+        matList.add(gen2);
+        matList.add(gen3);
+        matList.add(gen4);
+        matList.add(gen5);
+        matList.add(gen6);
+        matList.add(gen7);
+        matList.add(gen8);
+        matList.add(gen9);
+        matList.add(gen10);
+        matList.add(gen12);
+        matList.add(gen14);
+        matList.add(gen15);
+        matList.add(gen16);
+        // Troll glass layer
         matList.add(gen11);
     }
 
@@ -97,17 +132,13 @@ public class Layers {
 
     private final List<Material> gen3 = new ArrayList<>() {{
         add(Material.PACKED_ICE);
-        add(Material.ICE);
         add(Material.PACKED_ICE);
-        add(Material.ICE);
         add(Material.NOTE_BLOCK);
         add(Material.TNT);
         add(Material.LIGHT_BLUE_CONCRETE);
         add(Material.GLASS);
         add(Material.PACKED_ICE);
-        add(Material.ICE);
         add(Material.PACKED_ICE);
-        add(Material.ICE);
         add(Material.NOTE_BLOCK);
         add(Material.TNT);
         add(Material.LIGHT_BLUE_CONCRETE);
@@ -170,6 +201,7 @@ public class Layers {
         add(Material.RED_NETHER_BRICKS);
         add(Material.NETHER_WART_BLOCK);
         add(Material.CRYING_OBSIDIAN);
+        add(Material.MAGMA_BLOCK);
     }};
 
     private final List<Material> gen7 = new ArrayList<>() {{
@@ -266,6 +298,46 @@ public class Layers {
         add(Material.WHITE_STAINED_GLASS);
     }};
 
+    private final List<Material> gen12 = new ArrayList<>() {{
+        add(Material.DIRT);
+        add(Material.DIRT_PATH);
+        add(Material.GRASS_BLOCK);
+        add(Material.OAK_SLAB);
+        add(Material.BRICK_WALL);
+        add(Material.BRICK_STAIRS);
+    }};
+
+    private final List<Material> gen14 = new ArrayList<>() {{
+        add(Material.LECTERN);
+        add(Material.OBSIDIAN);
+        add(Material.SPONGE);
+        add(Material.BEEHIVE);
+        add(Material.DRIED_KELP_BLOCK);
+    }};
+
+    private final List<Material> gen15 = new ArrayList<>() {{
+        add(Material.SANDSTONE);
+        add(Material.SANDSTONE_SLAB);
+        add(Material.RED_SANDSTONE);
+        add(Material.RED_SANDSTONE_SLAB);
+        add(Material.RED_TERRACOTTA);
+        add(Material.TERRACOTTA);
+        add(Material.YELLOW_TERRACOTTA);
+    }};
+
+    private final List<Material> gen16 = new ArrayList<>() {{
+        add(Material.JUNGLE_LOG);
+        add(Material.STRIPPED_JUNGLE_LOG);
+        add(Material.JUNGLE_WOOD);
+        add(Material.STRIPPED_JUNGLE_WOOD);
+        add(Material.MOSSY_COBBLESTONE);
+        add(Material.MOSSY_COBBLESTONE);
+        add(Material.MOSSY_COBBLESTONE);
+        add(Material.JUNGLE_LEAVES);
+        add(Material.JUNGLE_SLAB);
+        add(Material.JUNGLE_TRAPDOOR);
+    }};
+
     private final List<List<Material>> matList = new ArrayList<>();
 
 }