Ocean generator

src/main/java/com/iridium/iridiumskyblock/IridiumSkyblock.java

@@ -5,6 +5,8 @@
 import com.iridium.iridiumskyblock.configs.*;
 import com.iridium.iridiumskyblock.database.Island;
 import com.iridium.iridiumskyblock.database.User;
+import com.iridium.iridiumskyblock.generators.FlatGenerator;
+import com.iridium.iridiumskyblock.generators.OceanGenerator;
 import com.iridium.iridiumskyblock.generators.VoidGenerator;
 import com.iridium.iridiumskyblock.listeners.*;
 import com.iridium.iridiumskyblock.managers.*;
@@ -34,6 +36,7 @@
 import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
 import java.sql.SQLException;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Objects;
 
@@ -56,6 +59,7 @@ public class IridiumSkyblock extends IridiumTeams<Island, User> {
     private Shop shop;
     private Biomes biomes;
     private Settings settings;
+    private Generators generators;
 
     private IslandPlaceholderBuilder teamsPlaceholderBuilder;
     private UserPlaceholderBuilder userPlaceholderBuilder;
@@ -87,7 +91,35 @@ public IridiumSkyblock() {
     @Override
     public void onLoad() {
         super.onLoad();
-        this.chunkGenerator = new VoidGenerator();
+
+        getLogger().info("Loading world generator...");
+        getLogger().info("Generator Type = " + IridiumSkyblock.getInstance().getConfiguration().generatorType);
+
+        // This switch statement is here so that if we end up adding another generator type, we can throw it in this.
+        switch (IridiumSkyblock.getInstance().getConfiguration().generatorType) {
+            case OCEAN: {
+                this.chunkGenerator = new OceanGenerator();
+                break;
+            }
+            case FLAT: {
+                this.chunkGenerator = new FlatGenerator();
+                break;
+            }
+            case VANILLA: {
+                this.chunkGenerator = null;
+                break;
+            }
+            case VOID: {
+                this.chunkGenerator = new VoidGenerator();
+                break;
+            }
+            default: {
+                getLogger().warning("Invalid generator type [" + IridiumSkyblock.getInstance().getConfiguration().generatorType + "], valid types are " + Arrays.toString(GeneratorType.values()));
+                getLogger().info("Generator Type = " + GeneratorType.VOID);
+                this.chunkGenerator = new VoidGenerator();
+                break;
+            }
+        }
     }
 
     @Override
@@ -173,6 +205,8 @@ public void loadConfigs() {
         this.shop = getPersist().load(Shop.class);
         this.biomes = getPersist().load(Biomes.class);
         this.settings = getPersist().load(Settings.class);
+        this.generators = getPersist().load(Generators.class);
+        getLogger().info("GENERATOR TYPE: " + IridiumSkyblock.getInstance().getConfiguration().generatorType);
         super.loadConfigs();
 
         int maxSize = enhancements.sizeEnhancement.levels.values().stream()
@@ -210,6 +244,7 @@ public void saveConfigs() {
         getPersist().save(shop);
         getPersist().save(biomes);
         getPersist().save(settings);
+        getPersist().save(generators);
         saveSchematics();
     }
 

src/main/java/com/iridium/iridiumskyblock/configs/Configuration.java

@@ -5,6 +5,7 @@
 import com.google.common.collect.ImmutableMap;
 import com.iridium.iridiumcore.Color;
 import com.iridium.iridiumcore.Item;
+import com.iridium.iridiumskyblock.managers.GeneratorType;
 import com.iridium.iridiumteams.Reward;
 import org.bukkit.World;
 
@@ -43,6 +44,7 @@ public Configuration() {
     public String defaultDescription = "Default island description :c";
     public String worldName = "IridiumSkyblock";
     public String spawnWorldName = "world";
+    public GeneratorType generatorType = GeneratorType.VOID;
     public String islandTitleTop = "&9%island_name%";
     public String islandTitleBottom = "&7%island_description%";
     public String paster = "worldedit";

src/main/java/com/iridium/iridiumskyblock/configs/Generators.java

@@ -0,0 +1,160 @@
+package com.iridium.iridiumskyblock.configs;
+
+import com.cryptomorin.xseries.XBiome;
+import com.cryptomorin.xseries.XMaterial;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class Generators {
+
+    public Generators.SkyblockGeneratorConfig skyblockGenerator = new SkyblockGeneratorConfig(
+            new com.iridium.iridiumskyblock.configs.Generators.SkyblockGeneratorWorld(
+                    XBiome.PLAINS,
+                    true
+            ),
+            new com.iridium.iridiumskyblock.configs.Generators.SkyblockGeneratorWorld(
+                    XBiome.NETHER_WASTES,
+                    true
+            ),
+            new com.iridium.iridiumskyblock.configs.Generators.SkyblockGeneratorWorld(
+                    XBiome.THE_END,
+                    true
+            )
+    );
+
+    public Generators.OceanGeneratorConfig oceanGenerator = new OceanGeneratorConfig(
+            new com.iridium.iridiumskyblock.configs.Generators.OceanGeneratorWorld(
+                    XBiome.OCEAN,
+                    XMaterial.SAND,
+                    XMaterial.STONE,
+                    XMaterial.WATER,
+                    63, 48, 53,
+                    true,
+                    true
+            ),
+            new com.iridium.iridiumskyblock.configs.Generators.OceanGeneratorWorld(
+                    XBiome.NETHER_WASTES,
+                    XMaterial.SOUL_SAND,
+                    XMaterial.NETHERRACK,
+                    XMaterial.LAVA,
+                    63, 48, 53,
+                    true,
+                    true
+            ),
+            new com.iridium.iridiumskyblock.configs.Generators.OceanGeneratorWorld(
+                    XBiome.END_BARRENS,
+                    XMaterial.END_STONE,
+                    XMaterial.END_STONE,
+                    XMaterial.VOID_AIR,
+                    63, 48, 53,
+                    true,
+                    true
+            ));
+
+    public Generators.FlatGeneratorConfig flatGenerator = new FlatGeneratorConfig(
+            new com.iridium.iridiumskyblock.configs.Generators.FlatGeneratorWorld(
+                    XBiome.PLAINS,
+                    XMaterial.GRASS_BLOCK,
+                    XMaterial.DIRT,
+                    -59,
+                    true,
+                    true
+            ),
+            new com.iridium.iridiumskyblock.configs.Generators.FlatGeneratorWorld(
+                    XBiome.NETHER_WASTES,
+                    XMaterial.NETHERRACK,
+                    XMaterial.NETHERRACK,
+                    5,
+                    true,
+                    true
+            ),
+            new com.iridium.iridiumskyblock.configs.Generators.FlatGeneratorWorld(
+                    XBiome.END_BARRENS,
+                    XMaterial.END_STONE,
+                    XMaterial.END_STONE,
+                    5,
+                    true,
+                    true
+            ));
+
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class SkyblockGeneratorConfig {
+        public SkyblockGeneratorWorld overworld;
+        public SkyblockGeneratorWorld nether;
+        public SkyblockGeneratorWorld end;
+    }
+
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class OceanGeneratorConfig {
+        public OceanGeneratorWorld overworld;
+        public OceanGeneratorWorld nether;
+        public OceanGeneratorWorld end;
+    }
+
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class FlatGeneratorConfig {
+        public FlatGeneratorWorld overworld;
+        public FlatGeneratorWorld nether;
+        public FlatGeneratorWorld end;
+    }
+
+    @NoArgsConstructor
+    public static class SkyblockGeneratorWorld {
+        public XBiome biome;
+        public boolean canSpawnEntities;
+
+        public SkyblockGeneratorWorld(XBiome biome, boolean canSpawnEntities) {
+            this.biome = biome;
+            this.canSpawnEntities = canSpawnEntities;
+        }
+    }
+
+    @NoArgsConstructor
+    public static class OceanGeneratorWorld {
+        public XBiome biome;
+        public XMaterial floor;
+        public XMaterial underFloor;
+        public XMaterial liquidType;
+        public int liquidHeight;
+        public int minFloorHeight;
+        public int maxFloorHeight;
+        public boolean decorate;
+        public boolean canSpawnEntities;
+
+        public OceanGeneratorWorld(XBiome biome, XMaterial floor, XMaterial underFloor, XMaterial liquidType, int liquidHeight, int minFloorHeight, int maxFloorHeight, boolean decorate, boolean canSpawnEntities) {
+            this.biome = biome;
+            this.floor = floor;
+            this.underFloor = underFloor;
+            this.liquidType = liquidType;
+            this.liquidHeight = liquidHeight;
+            this.minFloorHeight = minFloorHeight;
+            this.maxFloorHeight = maxFloorHeight;
+            this.decorate = decorate;
+            this.canSpawnEntities = canSpawnEntities;
+        }
+    }
+
+    @NoArgsConstructor
+    public static class FlatGeneratorWorld {
+        public XBiome biome;
+        public XMaterial floor;
+        public XMaterial underFloor;
+        public int floorHeight;
+        public boolean decorate;
+        public boolean canSpawnEntities;
+
+        public FlatGeneratorWorld(XBiome biome, XMaterial floor, XMaterial underFloor, int floorHeight, boolean decorate, boolean canSpawnEntities) {
+            this.biome = biome;
+            this.floor = floor;
+            this.underFloor = underFloor;
+            this.floorHeight = floorHeight;
+            this.decorate = decorate;
+            this.canSpawnEntities = canSpawnEntities;
+        }
+    }
+}

src/main/java/com/iridium/iridiumskyblock/generators/FlatGenerator.java

@@ -0,0 +1,134 @@
+package com.iridium.iridiumskyblock.generators;
+
+import com.cryptomorin.xseries.XMaterial;
+import com.iridium.iridiumskyblock.IridiumSkyblock;
+import com.iridium.iridiumskyblock.configs.Generators;
+import com.iridium.iridiumskyblock.utils.LocationUtils;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.World.Environment;
+import org.bukkit.block.Block;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+import org.bukkit.generator.WorldInfo;
+
+import java.util.*;
+
+public class FlatGenerator extends ChunkGenerator {
+
+    @Override
+    public @NotNull ChunkData generateChunkData(
+            @NotNull World world, @NotNull Random random, int chunkX, int chunkZ, @NotNull BiomeGrid biomeGrid) {
+
+        final ChunkData chunkData = createChunkData(world);
+        int floorHeight = getFlatGenerator(world.getEnvironment()).floorHeight;
+
+        for (int x = 0; x < 16; x++) {
+            for (int z = 0; z < 16; z++) {
+
+                // Generate layer of bedrock
+                chunkData.setBlock(x, LocationUtils.getMinHeight(world), z,
+                        Objects.requireNonNull(XMaterial.BEDROCK.parseMaterial())
+                );
+
+                // Generate dirt layer
+                for (int y = LocationUtils.getMinHeight(world) + 1; y < floorHeight; y++) {
+                    chunkData.setBlock(x, y, z,
+                            Objects.requireNonNull(getFlatGenerator(world.getEnvironment()).underFloor.parseMaterial())
+                    );
+                }
+
+                // Generate grass on top of dirt
+                chunkData.setBlock(x, floorHeight, z,
+                        Objects.requireNonNull(getFlatGenerator(world.getEnvironment()).floor.parseMaterial())
+                );
+
+                biomeGrid.setBiome(x, z, Objects.requireNonNull(getFlatGenerator(world.getEnvironment()).biome.getBiome()));
+            }
+        }
+
+        return chunkData;
+    }
+
+    public void generateFlatland(World world, int x, int z) {
+
+        Random random = new Random((world.getSeed()));
+
+        int floorHeight = getFlatGenerator(world.getEnvironment()).floorHeight;
+        int minFloorHeight = world.getMinHeight();
+
+        // Generate layer of bedrock
+        if (world.getBlockAt(x, minFloorHeight, z).getType() != XMaterial.BEDROCK.parseMaterial()) {
+            if (world.getBlockAt(x, minFloorHeight, z).getState() instanceof InventoryHolder) {
+                ((InventoryHolder) world.getBlockAt(x, minFloorHeight, z).getState()).getInventory().clear();
+            }
+            world.getBlockAt(x, minFloorHeight, z).setType(Material.BEDROCK, false);
+        }
+
+        // Generate dirt layer
+        for (int y = minFloorHeight + 1; y < floorHeight; y++) {
+            Block block = world.getBlockAt(x, y, z);
+            if (block.getType() != getFlatGenerator(world.getEnvironment()).underFloor.parseMaterial()
+                    && getFlatGenerator(world.getEnvironment()).underFloor.parseMaterial() != null) {
+
+                if (block.getState() instanceof InventoryHolder) {
+                    ((InventoryHolder) block.getState()).getInventory().clear();
+                }
+                block.setType(Objects.requireNonNull(getFlatGenerator(world.getEnvironment()).underFloor.parseMaterial()), false);
+            }
+        }
+
+        // Generate grass on top of dirt
+        if (world.getBlockAt(x, floorHeight, z).getType() != getFlatGenerator(world.getEnvironment()).floor.parseMaterial()
+                && getFlatGenerator(world.getEnvironment()).floor.parseMaterial() != null) {
+
+            if (world.getBlockAt(x, floorHeight, z).getState() instanceof InventoryHolder) {
+                ((InventoryHolder) world.getBlockAt(x, floorHeight, z).getState()).getInventory().clear();
+            }
+
+            world.getBlockAt(x, floorHeight, z)
+                    .setType(Objects.requireNonNull(getFlatGenerator(world.getEnvironment()).floor.parseMaterial()), false);
+
+        }
+
+        // Replace everything else with air
+        for (int y = floorHeight + 1; y < world.getMaxHeight(); y++) {
+            Block block = world.getBlockAt(x, y, z);
+            if (block.getType() != Material.AIR) {
+                if (block.getState() instanceof InventoryHolder) {
+                    ((InventoryHolder) block.getState()).getInventory().clear();
+                }
+                block.setType(Material.AIR, false);
+            }
+        }
+
+        // Generate kelp, ores, and mineral deposits
+        // BREAKS BELOW 1.18
+        //shouldGenerateDecorations(world, random , x, z);
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations(@NotNull WorldInfo worldInfo, @NotNull Random random, int x, int z) {
+        return getFlatGenerator(worldInfo.getEnvironment()).decorate;
+    }
+
+    @Override
+    public boolean canSpawn(@NotNull World world, int x, int z) {
+        return getFlatGenerator(world.getEnvironment()).canSpawnEntities;
+    }
+
+    private Generators.FlatGeneratorWorld getFlatGenerator(Environment environment) {
+        switch (environment) {
+            case NETHER: {
+                return IridiumSkyblock.getInstance().getGenerators().flatGenerator.nether;
+            }
+            case THE_END: {
+                return IridiumSkyblock.getInstance().getGenerators().flatGenerator.end;
+            }
+            default: {
+                return IridiumSkyblock.getInstance().getGenerators().flatGenerator.overworld;
+            }
+        }
+    }
+}