Ocean generator

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

@@ -4,6 +4,7 @@
 import com.iridium.iridiumskyblock.configs.*;
 import com.iridium.iridiumskyblock.database.Island;
 import com.iridium.iridiumskyblock.database.User;
+import com.iridium.iridiumskyblock.generators.OceanGenerator;
 import com.iridium.iridiumskyblock.generators.VoidGenerator;
 import com.iridium.iridiumskyblock.listeners.*;
 import com.iridium.iridiumskyblock.managers.*;
@@ -49,6 +50,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;
@@ -79,7 +81,22 @@ public IridiumSkyblock() {
     @Override
     public void onLoad() {
         super.onLoad();
-        this.chunkGenerator = new VoidGenerator();
+
+        // 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 VANILLA: {
+                this.chunkGenerator = null;
+                break;
+            }
+            default: {
+                this.chunkGenerator = new VoidGenerator();
+                break;
+            }
+        }
     }
 
     @Override
@@ -161,6 +178,7 @@ 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);
         super.loadConfigs();
 
         int maxSize = enhancements.sizeEnhancement.levels.values().stream()
@@ -195,6 +213,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.iridium.iridiumcore.Item;
 import com.iridium.iridiumcore.dependencies.xseries.XMaterial;
 import com.iridium.iridiumcore.dependencies.xseries.XSound;
+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,110 @@
+package com.iridium.iridiumskyblock.configs;
+
+import com.google.common.collect.ImmutableMap;
+import com.iridium.iridiumcore.dependencies.fasterxml.annotation.JsonIgnoreProperties;
+import com.iridium.iridiumcore.dependencies.xseries.XBiome;
+import com.iridium.iridiumcore.dependencies.xseries.XMaterial;
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+
+import java.util.Map;
+
+@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
+            ));
+
+    @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
+    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;
+
+        }
+    }
+}

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

@@ -0,0 +1,166 @@
+package com.iridium.iridiumskyblock.generators;
+
+import com.iridium.iridiumcore.dependencies.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.bukkit.util.noise.SimplexOctaveGenerator;
+import org.jetbrains.annotations.NotNull;
+import org.bukkit.generator.WorldInfo;
+
+import java.util.*;
+
+public class OceanGenerator extends ChunkGenerator {
+
+    @Override
+    public @NotNull ChunkData generateChunkData(
+            @NotNull World world, @NotNull Random random, int chunkX, int chunkZ, @NotNull BiomeGrid biomeGrid) {
+
+        SimplexOctaveGenerator generator = new SimplexOctaveGenerator(new Random(world.getSeed()), 8);
+        final ChunkData chunkData = createChunkData(world);
+        generator.setScale(0.005D);
+
+        for (int x = 0; x < 16; x++) {
+            for (int z = 0; z < 16; z++) {
+                int currentFloorHeight = (int) ((generator.noise(
+                        chunkX * 16 + x, chunkZ * 16 + z, 1.5D, 0.5D, true) + 1)
+                        * (getOceanGenerator(world.getEnvironment()).maxFloorHeight - getOceanGenerator(world.getEnvironment()).minFloorHeight)
+                        + getOceanGenerator(world.getEnvironment()).minFloorHeight);
+
+                // Generate layer of bedrock
+                chunkData.setBlock(x, LocationUtils.getMinHeight(world), z,
+                        Objects.requireNonNull(XMaterial.BEDROCK.parseMaterial())
+                );
+
+                // Generate gravel layer
+                for (int y = LocationUtils.getMinHeight(world) + 1; y < currentFloorHeight; y++) {
+                    chunkData.setBlock(x, y, z,
+                            Objects.requireNonNull(getOceanGenerator(world.getEnvironment()).underFloor.parseMaterial())
+                    );
+                }
+
+                // Generate sand on top of gravel
+                chunkData.setBlock(x, currentFloorHeight, z,
+                        Objects.requireNonNull(getOceanGenerator(world.getEnvironment()).floor.parseMaterial())
+                );
+
+                // Generate water or lava on top of the floor
+                for (int y = currentFloorHeight + 1; y <= getOceanGenerator(world.getEnvironment()).liquidHeight; y++) {
+                    chunkData.setBlock(x, y, z, Objects.requireNonNull(
+                            getOceanGenerator(world.getEnvironment()).liquidType.parseMaterial()));
+                }
+
+                biomeGrid.setBiome(x, z, Objects.requireNonNull(getOceanGenerator(world.getEnvironment()).biome.getBiome()));
+            }
+        }
+
+        return chunkData;
+    }
+
+    public void generateOcean(World world, int x, int z) {
+
+        Random random = new Random((world.getSeed()));
+
+        SimplexOctaveGenerator generator = new SimplexOctaveGenerator(random, 8);
+        generator.setScale(0.005D);
+
+        int currentFloorHeight = (int) ((generator.noise(
+                x, z, 1.5D, 0.5D, true) + 1)
+                * (getOceanGenerator(world.getEnvironment()).maxFloorHeight - getOceanGenerator(world.getEnvironment()).minFloorHeight)
+                + getOceanGenerator(world.getEnvironment()).minFloorHeight);
+
+        int minHeightWorld = LocationUtils.getMinHeight(world);
+
+        // Generate layer of bedrock
+        if (world.getBlockAt(x, minHeightWorld, z).getType() != XMaterial.BEDROCK.parseMaterial()) {
+            if (world.getBlockAt(x, minHeightWorld, z).getState() instanceof InventoryHolder) {
+                ((InventoryHolder) world.getBlockAt(x, minHeightWorld, z).getState()).getInventory().clear();
+            }
+            world.getBlockAt(x, minHeightWorld, z).setType(Material.BEDROCK, false);
+        }
+
+        // Generate gravel layer
+        for (int y = minHeightWorld + 1; y < currentFloorHeight; y++) {
+            Block block = world.getBlockAt(x, y, z);
+            if (block.getType() != getOceanGenerator(world.getEnvironment()).underFloor.parseMaterial()
+                    && getOceanGenerator(world.getEnvironment()).underFloor.parseMaterial() != null) {
+
+                if (block.getState() instanceof InventoryHolder) {
+                    ((InventoryHolder) block.getState()).getInventory().clear();
+                }
+                block.setType(Objects.requireNonNull(getOceanGenerator(world.getEnvironment()).underFloor.parseMaterial()), false);
+            }
+        }
+
+        // Generate sand on top of gravel
+        if (world.getBlockAt(x, currentFloorHeight, z).getType() != getOceanGenerator(world.getEnvironment()).floor.parseMaterial()
+                && getOceanGenerator(world.getEnvironment()).floor.parseMaterial() != null) {
+
+            if (world.getBlockAt(x, currentFloorHeight, z).getState() instanceof InventoryHolder) {
+                ((InventoryHolder) world.getBlockAt(x, currentFloorHeight, z).getState()).getInventory().clear();
+            }
+
+            for(int y = currentFloorHeight; y < currentFloorHeight + 5; y++) {
+                world.getBlockAt(x, currentFloorHeight, z)
+                        .setType(Objects.requireNonNull(getOceanGenerator(world.getEnvironment()).floor.parseMaterial()), false);
+                currentFloorHeight++;
+            }
+
+        }
+
+        // Generate water or lava on top of the floor
+        for (int y = currentFloorHeight + 1; y <= getOceanGenerator(world.getEnvironment()).liquidHeight; y++) {
+            Block block = world.getBlockAt(x, y, z);
+            if (block.getType() != getOceanGenerator(world.getEnvironment()).liquidType.parseMaterial() && getOceanGenerator(world.getEnvironment()).liquidType.parseMaterial() != null) {
+                if (block.getState() instanceof InventoryHolder) {
+                    ((InventoryHolder) block.getState()).getInventory().clear();
+                }
+                block.setType(getOceanGenerator(world.getEnvironment()).liquidType.parseMaterial(), false);
+            }
+        }
+
+        // Replace everything else with air
+        for (int y = getOceanGenerator(world.getEnvironment()).liquidHeight + 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
+        shouldGenerateDecorations(world, random , x, z);
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations(@NotNull WorldInfo worldInfo, @NotNull Random random, int x, int z) {
+        return getOceanGenerator(worldInfo.getEnvironment()).decorate;
+    }
+
+    @Override
+    public boolean canSpawn(@NotNull World world, int x, int z) {
+        return getOceanGenerator(world.getEnvironment()).canSpawnEntities;
+    }
+
+    private Generators.OceanGeneratorWorld getOceanGenerator(Environment environment) {
+        switch (environment) {
+            case NETHER: {
+                return IridiumSkyblock.getInstance().getGenerators().oceanGenerator.nether;
+            }
+            case THE_END: {
+                return IridiumSkyblock.getInstance().getGenerators().oceanGenerator.end;
+            }
+            default: {
+                return IridiumSkyblock.getInstance().getGenerators().oceanGenerator.overworld;
+            }
+        }
+    }
+}