Iridium-Development · PeachesMLG · May 10, 2024 · May 10, 2024 · May 10, 2024
diff --git a/src/main/java/com/iridium/iridiumskyblock/IridiumSkyblock.java b/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.FlatGenerator;
 import com.iridium.iridiumskyblock.generators.OceanGenerator;
 import com.iridium.iridiumskyblock.generators.VoidGenerator;
 import com.iridium.iridiumskyblock.listeners.*;
@@ -28,6 +29,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;
 
@@ -83,17 +85,25 @@ public void onLoad() {
         super.onLoad();
 
         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) {
+        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;
             }
             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;
             }

diff --git a/src/main/java/com/iridium/iridiumskyblock/configs/Generators.java b/src/main/java/com/iridium/iridiumskyblock/configs/Generators.java
@@ -26,6 +26,7 @@ public class Generators {
                     true
             )
     );
+
     public Generators.OceanGeneratorConfig oceanGenerator = new OceanGeneratorConfig(
             new com.iridium.iridiumskyblock.configs.Generators.OceanGeneratorWorld(
                     XBiome.OCEAN,
@@ -55,6 +56,32 @@ public class Generators {
                     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 {
@@ -71,6 +98,14 @@ public static class OceanGeneratorConfig {
         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;
@@ -104,7 +139,25 @@ public OceanGeneratorWorld(XBiome biome, XMaterial floor, XMaterial underFloor,
             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;
         }
     }
 }
diff --git a/src/main/java/com/iridium/iridiumskyblock/generators/FlatGenerator.java b/src/main/java/com/iridium/iridiumskyblock/generators/FlatGenerator.java
@@ -0,0 +1,134 @@
+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 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
+        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;
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/iridium/iridiumskyblock/managers/GeneratorType.java b/src/main/java/com/iridium/iridiumskyblock/managers/GeneratorType.java
@@ -8,6 +8,7 @@
 public enum GeneratorType {
     VOID(false), 
     OCEAN(true),
+    FLAT(true),
     VANILLA(true);
 
     private final boolean terrainGenerator;