Config/gregtech.cfg (#2939)

* first pass on config migration

* second pass on config migration

* removing bad configs

* rename config classes and register them

* move debug options to its own debug category

* migrate pollution

* finish migrating general config

* removing useless config

* finish GregTech.cfg port to GTNHLib

* don't accidentally force panic mode in dev env

* typo

* defaults are now handled by the confg handler

* remove dead config

* force config save after defaults are being written

* stop messing with the GregTech.cfg externally

* removing comments

* new underground fluid builder and porting default underground fluids to code

* move config handlers of gregtech.cfg in their own package

* process MachineStats.cfg

* yeeted MaterialProperties.cfg

* remove unused compat in GTNH

* process OverpoweredStuff.cfg

* process Other.cfg

* ungregify some config variables

* remove unused variables

* fix Ids.cfg not being populated

* delete duplicate printing of MTE IDs in GT5U clients

* bump hodgepodge version to get mod phase timers

* process Client.cfg

* fix bad category naming

* registering all the config handlers in gui

* bump GTNHLib version

* actually only registering client configs

* use proper double arrays now

* move GT ore mixes to patternbuilders

* dead code

* fix multifiles config not being handled properly

* import class from NHCore

* removing reflection

* use enums for registration

* yeet config for Asteroid dimensions

* remove unused since 2015 enum entry

* todo

* rework oremix enums

* imported dimension data in enums

* convert old dirty predicate into proper one

* hook gagreg onto the OreMixes enum

* finally nuke worldgen.ore.mix config category!

* hook gagreg small ores onto the SmallOres enum

* imported dim values in enum

* fix dirty work around in vm predicate

* yeet unused classes

* hook GT stones to GTStones enum

* yeet all the remaining booleans in the worldgen category

* port endasteroids category

* port general category

* deprecated

* yeet unused bw compat

* finish worldgen config migration

* hardcode config into code

* remove not generated config entry

* remove Unification.cfg

* fix build

* migrate oreveins away from config

* migrate small ores away from config

* delete config parser

* forgotten

* fix EoH recipe crash in dev

* fix GT NEI Ore Plugin config and csv paths

* shade opencsv

* rewrite csv generator

* spotless apply

6 files changed, 487 insertions, 6 deletions

diff --git a/src/main/java/bloodasp/galacticgreg/api/Enums.java b/src/main/java/bloodasp/galacticgreg/api/Enums.java
index 0c8afaf243..0d864e54c9 100644
--- a/src/main/java/bloodasp/galacticgreg/api/Enums.java
+++ b/src/main/java/bloodasp/galacticgreg/api/Enums.java
@@ -46,12 +46,6 @@ public class Enums {
          * The Dimension is a planet, and only ores shall be generated in the ground
          */
         Planet,
-
-        /**
-         * The Dimension is a special dim where Asteroids *and* ores shall spawn. Additional config values will be
-         * generated in worldconfig
-         */
-        AsteroidAndPlanet
     }
 
 }
diff --git a/src/main/java/bloodasp/galacticgreg/api/enums/DimensionBlockMetaDefinitionList.java b/src/main/java/bloodasp/galacticgreg/api/enums/DimensionBlockMetaDefinitionList.java
new file mode 100644
index 0000000000..279360d2d9
--- /dev/null
+++ b/src/main/java/bloodasp/galacticgreg/api/enums/DimensionBlockMetaDefinitionList.java
@@ -0,0 +1,57 @@
+package bloodasp.galacticgreg.api.enums;
+
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.init.Blocks;
+
+import bloodasp.galacticgreg.api.ModDBMDef;
+
+public enum DimensionBlockMetaDefinitionList {
+
+    Moon(new ModDBMDef("tile.moonBlock", 4)),
+    Mars(new ModDBMDef("tile.mars", 9)),
+    Phobos(new ModDBMDef("phobosblocks", 2)),
+    Deimos(new ModDBMDef("deimosblocks", 1)),
+    Ceres(new ModDBMDef("ceresblocks", 1)),
+    Io(new ModDBMDef("ioblocks", 2)),
+    Ganymede(new ModDBMDef("ganymedeblocks", 1)),
+    Callisto(new ModDBMDef("callistoblocks", 1)),
+    Venus(new ModDBMDef("venusblocks", 1)),
+    Mercury(new ModDBMDef("mercuryblocks", 2)),
+    Enceladus(new ModDBMDef("enceladusblocks", 1)),
+    Titan(new ModDBMDef("titanblocks", 2)),
+    Oberon(new ModDBMDef("oberonblocks", 2)),
+    Proteus(new ModDBMDef("proteusblocks", 2)),
+    Triton(new ModDBMDef("tritonblocks", 2)),
+    Pluto(new ModDBMDef("plutoblocks", 5)),
+    MakeMake(new ModDBMDef("makemakegrunt", 1)),
+    Haumea(new ModDBMDef("haumeablocks")),
+    CentauriAlpha(new ModDBMDef("acentauribbsubgrunt")),
+    VegaB(new ModDBMDef("vegabsubgrunt")),
+    BarnardaC(new ModDBMDef("barnardaCdirt"), new ModDBMDef(Blocks.stone)),
+    BarnardaE(new ModDBMDef("barnardaEsubgrunt")),
+    BarnardaF(new ModDBMDef("barnardaFsubgrunt")),
+    TcetiE(new ModDBMDef("tcetieblocks", 2)),
+    Miranda(new ModDBMDef("mirandablocks", 2)),
+    Europa(
+        // Europa top layer turned off bc ores are too easy to spot
+        new ModDBMDef("europagrunt", 1), // Europa Ice Layer ~55-65 without top layer
+        new ModDBMDef(Blocks.water), new ModDBMDef(Blocks.flowing_water), new ModDBMDef(Blocks.ice), // Generates
+                                                                                                     // directly over
+                                                                                                     // bedrock
+        new ModDBMDef(Blocks.packed_ice), // Generates directly over bedrock
+        new ModDBMDef("europaunderwatergeyser") // Generates directly over bedrock
+    ),
+    Neper(new ModDBMDef(Blocks.stone), new ModDBMDef("tile.baseBlockRock", 10)),
+    Maahes(new ModDBMDef("tile.baseBlockRock", 1)),
+    Anubis(new ModDBMDef("tile.baseBlockRock", 1)),
+    Horus(new ModDBMDef(Blocks.obsidian)),
+    Seth(new ModDBMDef(Blocks.hardened_clay));
+
+    public final List<ModDBMDef> DBMDefList;
+
+    private DimensionBlockMetaDefinitionList(ModDBMDef... DBMDefArray) {
+        DBMDefList = Arrays.asList(DBMDefArray);
+    }
+}
diff --git a/src/main/java/bloodasp/galacticgreg/api/enums/DimensionDef.java b/src/main/java/bloodasp/galacticgreg/api/enums/DimensionDef.java
new file mode 100644
index 0000000000..d5e766b9f7
--- /dev/null
+++ b/src/main/java/bloodasp/galacticgreg/api/enums/DimensionDef.java
@@ -0,0 +1,228 @@
+package bloodasp.galacticgreg.api.enums;
+
+import net.minecraft.world.gen.ChunkProviderEnd;
+
+import bloodasp.galacticgreg.api.Enums;
+import bloodasp.galacticgreg.api.ModDimensionDef;
+
+public enum DimensionDef {
+
+    EndAsteroids(new ModDimensionDef(DimNames.ENDASTEROIDS, ChunkProviderEnd.class, Enums.DimensionType.Asteroid)),
+    Moon(new ModDimensionDef(
+        DimNames.MOON,
+        "micdoodle8.mods.galacticraft.core.world.gen.ChunkProviderMoon",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Moon.DBMDefList)),
+    Mars(new ModDimensionDef(
+        DimNames.MARS,
+        "micdoodle8.mods.galacticraft.planets.mars.world.gen.ChunkProviderMars",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Mars.DBMDefList)),
+    Asteroids(new ModDimensionDef(
+        DimNames.ASTEROIDS,
+        "micdoodle8.mods.galacticraft.planets.asteroids.world.gen.ChunkProviderAsteroids",
+        Enums.DimensionType.Asteroid)),
+    Pluto(new ModDimensionDef(
+        DimNames.PLUTO,
+        "galaxyspace.SolarSystem.planets.pluto.dimension.ChunkProviderPluto",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Pluto.DBMDefList)),
+    Triton(new ModDimensionDef(
+        DimNames.TRITON,
+        "galaxyspace.SolarSystem.moons.triton.dimension.ChunkProviderTriton",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Triton.DBMDefList)),
+    Proteus(new ModDimensionDef(
+        DimNames.PROTEUS,
+        "galaxyspace.SolarSystem.moons.proteus.dimension.ChunkProviderProteus",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Proteus.DBMDefList)),
+    Oberon(new ModDimensionDef(
+        DimNames.OBERON,
+        "galaxyspace.SolarSystem.moons.oberon.dimension.ChunkProviderOberon",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Oberon.DBMDefList)),
+    Titan(new ModDimensionDef(
+        DimNames.TITAN,
+        "galaxyspace.SolarSystem.moons.titan.dimension.ChunkProviderTitan",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Titan.DBMDefList)),
+    Callisto(new ModDimensionDef(
+        DimNames.CALLISTO,
+        "galaxyspace.SolarSystem.moons.callisto.dimension.ChunkProviderCallisto",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Callisto.DBMDefList)),
+    Ganymede(new ModDimensionDef(
+        DimNames.GANYMEDE,
+        "galaxyspace.SolarSystem.moons.ganymede.dimension.ChunkProviderGanymede",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Ganymede.DBMDefList)),
+    Ceres(new ModDimensionDef(
+        DimNames.CERES,
+        "galaxyspace.SolarSystem.planets.ceres.dimension.ChunkProviderCeres",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Ceres.DBMDefList)),
+    Deimos(new ModDimensionDef(
+        DimNames.DEIMOS,
+        "galaxyspace.SolarSystem.moons.deimos.dimension.ChunkProviderDeimos",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Deimos.DBMDefList)),
+    Enceladus(new ModDimensionDef(
+        DimNames.ENCELADUS,
+        "galaxyspace.SolarSystem.moons.enceladus.dimension.ChunkProviderEnceladus",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Enceladus.DBMDefList)),
+    Io(new ModDimensionDef(
+        DimNames.IO,
+        "galaxyspace.SolarSystem.moons.io.dimension.ChunkProviderIo",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Io.DBMDefList)),
+    Europa(new ModDimensionDef(
+        DimNames.EUROPA,
+        "galaxyspace.SolarSystem.moons.europa.dimension.ChunkProviderEuropa",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Europa.DBMDefList)),
+    Phobos(new ModDimensionDef(
+        DimNames.PHOBOS,
+        "galaxyspace.SolarSystem.moons.phobos.dimension.ChunkProviderPhobos",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Phobos.DBMDefList)),
+    Venus(new ModDimensionDef(
+        DimNames.VENUS,
+        "galaxyspace.SolarSystem.planets.venus.dimension.ChunkProviderVenus",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Venus.DBMDefList)),
+    Mercury(new ModDimensionDef(
+        DimNames.MERCURY,
+        "galaxyspace.SolarSystem.planets.mercury.dimension.ChunkProviderMercury",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Mercury.DBMDefList)),
+    MakeMake(new ModDimensionDef(
+        DimNames.MAKEMAKE,
+        "galaxyspace.SolarSystem.planets.makemake.dimension.ChunkProviderMakemake",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.MakeMake.DBMDefList)),
+    Haumea(new ModDimensionDef(
+        DimNames.HAUMEA,
+        "galaxyspace.SolarSystem.planets.haumea.dimension.ChunkProviderHaumea",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Haumea.DBMDefList)),
+    CentauriAlpha(new ModDimensionDef(
+        DimNames.CENTAURIA,
+        "galaxyspace.ACentauriSystem.planets.aCentauriBb.dimension.ChunkProviderACentauri",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.CentauriAlpha.DBMDefList)),
+    VegaB(new ModDimensionDef(
+        DimNames.VEGAB,
+        "galaxyspace.VegaSystem.planets.vegaB.dimension.ChunkProviderVegaB",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.VegaB.DBMDefList)),
+    BarnardC(new ModDimensionDef(
+        DimNames.BARNARDC,
+        "galaxyspace.BarnardsSystem.planets.barnardaC.dimension.ChunkProviderBarnardaC",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.BarnardaC.DBMDefList)),
+    BarnardE(new ModDimensionDef(
+        DimNames.BARNARDE,
+        "galaxyspace.BarnardsSystem.planets.barnardaE.dimension.ChunkProviderBarnardaE",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.BarnardaE.DBMDefList)),
+    BarnardF(new ModDimensionDef(
+        DimNames.BARNARDF,
+        "galaxyspace.BarnardsSystem.planets.barnardaF.dimension.ChunkProviderBarnardaF",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.BarnardaF.DBMDefList)),
+    TcetiE(new ModDimensionDef(
+        DimNames.TCETIE,
+        "galaxyspace.TCetiSystem.planets.tcetiE.dimension.ChunkProviderTCetiE",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.TcetiE.DBMDefList)),
+    Miranda(new ModDimensionDef(
+        DimNames.MIRANDA,
+        "galaxyspace.SolarSystem.moons.miranda.dimension.ChunkProviderMiranda",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Miranda.DBMDefList)),
+    KuiperBelt(new ModDimensionDef(
+        DimNames.KUIPERBELT,
+        "galaxyspace.SolarSystem.planets.kuiperbelt.dimension.ChunkProviderKuiper",
+        Enums.DimensionType.Asteroid)),
+
+    Neper(new ModDimensionDef(
+        DimNames.NEPER,
+        "de.katzenpapst.amunra.world.neper.NeperChunkProvider",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Neper.DBMDefList)),
+    Maahes(new ModDimensionDef(
+        DimNames.MAAHES,
+        "de.katzenpapst.amunra.world.maahes.MaahesChunkProvider",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Maahes.DBMDefList)),
+    Anubis(new ModDimensionDef(
+        DimNames.ANUBIS,
+        "de.katzenpapst.amunra.world.anubis.AnubisChunkProvider",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Anubis.DBMDefList)),
+    Horus(new ModDimensionDef(
+        DimNames.HORUS,
+        "de.katzenpapst.amunra.world.horus.HorusChunkProvider",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Horus.DBMDefList)),
+    Seth(new ModDimensionDef(
+        DimNames.SETH,
+        "de.katzenpapst.amunra.world.seth.SethChunkProvider",
+        Enums.DimensionType.Planet,
+        DimensionBlockMetaDefinitionList.Seth.DBMDefList)),
+    MehenBelt(new ModDimensionDef(
+        DimNames.MEHENBELT,
+        "de.katzenpapst.amunra.world.mehen.MehenChunkProvider",
+        Enums.DimensionType.Asteroid));
+
+    public static class DimNames {
+
+        public static final String ENDASTEROIDS = "EndAsteroids";
+        public static final String MOON = "Moon";
+        public static final String MARS = "Mars";
+        public static final String ASTEROIDS = "Asteroids";
+        public static final String PLUTO = "Pluto";
+        public static final String TRITON = "Triton";
+        public static final String PROTEUS = "Proteus";
+        public static final String OBERON = "Oberon";
+        public static final String TITAN = "Titan";
+        public static final String ROSS128B = "Ross128b";
+        public static final String ROSS128BA = "Ross128ba";
+        public static final String CALLISTO = "Callisto";
+        public static final String GANYMEDE = "Ganymede";
+        public static final String CERES = "Ceres";
+        public static final String DEIMOS = "Deimos";
+        public static final String ENCELADUS = "Enceladus";
+        public static final String IO = "Io";
+        public static final String EUROPA = "Europa";
+        public static final String PHOBOS = "Phobos";
+        public static final String VENUS = "Venus";
+        public static final String MERCURY = "Mercury";
+        public static final String MAKEMAKE = "MakeMake";
+        public static final String HAUMEA = "Haumea";
+        public static final String CENTAURIA = "CentauriA";
+        public static final String VEGAB = "VegaB";
+        public static final String BARNARDC = "BarnardC";
+        public static final String BARNARDE = "BarnardE";
+        public static final String BARNARDF = "BarnardF";
+        public static final String TCETIE = "TcetiE";
+        public static final String MIRANDA = "Miranda";
+        public static final String KUIPERBELT = "Kuiperbelt";
+        public static final String NEPER = "Neper";
+        public static final String MAAHES = "Maahes";
+        public static final String ANUBIS = "Anubis";
+        public static final String HORUS = "Horus";
+        public static final String SETH = "Seth";
+        public static final String MEHENBELT = "MehenBelt";
+        public static final String DEEPDARK = "Underdark";
+
+    }
+
+    public final ModDimensionDef modDimensionDef;
+
+    private DimensionDef(ModDimensionDef modDimDef) {
+        this.modDimensionDef = modDimDef;
+    }
+}
diff --git a/src/main/java/bloodasp/galacticgreg/api/enums/ModContainers.java b/src/main/java/bloodasp/galacticgreg/api/enums/ModContainers.java
new file mode 100644
index 0000000000..ed81f56f04
--- /dev/null
+++ b/src/main/java/bloodasp/galacticgreg/api/enums/ModContainers.java
@@ -0,0 +1,19 @@
+package bloodasp.galacticgreg.api.enums;
+
+import bloodasp.galacticgreg.api.ModContainer;
+import gregtech.api.enums.Mods;
+
+public enum ModContainers {
+
+    GalactiCraftCore(new ModContainer(Mods.GalacticraftCore.ID)),
+    GalacticraftMars(new ModContainer(Mods.GalacticraftMars.ID)),
+    GalaxySpace(new ModContainer(Mods.GalaxySpace.ID)),
+    AmunRa(new ModContainer("GalacticraftAmunRa")),
+    Vanilla(new ModContainer("Vanilla"));
+
+    public final ModContainer modContainer;
+
+    private ModContainers(ModContainer modContainer) {
+        this.modContainer = modContainer;
+    }
+}
diff --git a/src/main/java/bloodasp/galacticgreg/api/enums/properties/AsteroidPropertyBuilder.java b/src/main/java/bloodasp/galacticgreg/api/enums/properties/AsteroidPropertyBuilder.java
new file mode 100644
index 0000000000..82d8b99b41
--- /dev/null
+++ b/src/main/java/bloodasp/galacticgreg/api/enums/properties/AsteroidPropertyBuilder.java
@@ -0,0 +1,105 @@
+package bloodasp.galacticgreg.api.enums.properties;
+
+public class AsteroidPropertyBuilder {
+
+    public int probability;
+    public int sizeMin, sizeMax;
+    public int specialBlockChance;
+    public OreSpawnPropertyBuilder oreSpawn;
+    public LootPropertyBuilder loot;
+
+    public static class OreSpawnPropertyBuilder {
+
+        public int baseOreChance;
+        public boolean obeyHeighLimits;
+        public boolean oresOnlyInsideAsteroids;
+        public int primaryToRareOreOffset;
+        public int smallOreChance;
+
+        public OreSpawnPropertyBuilder baseOreChance(int baseOreChance) {
+            this.baseOreChance = baseOreChance;
+            return this;
+        }
+
+        public OreSpawnPropertyBuilder doesObeyingHeightLimits(boolean obeyHeighLimits) {
+            this.obeyHeighLimits = obeyHeighLimits;
+            return this;
+        }
+
+        public OreSpawnPropertyBuilder AreOresOnlyInsideAsteroids(boolean oresOnlyInsideAsteroids) {
+            this.oresOnlyInsideAsteroids = oresOnlyInsideAsteroids;
+            return this;
+        }
+
+        public OreSpawnPropertyBuilder primaryToRareOreOffset(int primaryToRareOreOffset) {
+            this.primaryToRareOreOffset = primaryToRareOreOffset;
+            return this;
+        }
+
+        public OreSpawnPropertyBuilder smallOreChance(int smallOreChance) {
+            this.smallOreChance = smallOreChance;
+            return this;
+        }
+
+    }
+
+    public static class LootPropertyBuilder {
+
+        public int lootChestChance;
+        public int lootChestItemCount;
+        public int lootChestTable;
+        public boolean randomizeLootItemCount;
+
+        public LootPropertyBuilder lootChestChance(int lootChestChance) {
+            this.lootChestChance = lootChestChance;
+            return this;
+        }
+
+        public LootPropertyBuilder lootChestItemCount(int lootChestItemCount) {
+            this.lootChestItemCount = lootChestItemCount;
+            return this;
+        }
+
+        public LootPropertyBuilder lootChestTable(int lootChestTable) {
+            this.lootChestTable = lootChestTable;
+            return this;
+        }
+
+        public LootPropertyBuilder isLootItemCountRandomized(boolean randomizeLootItemCount) {
+            this.randomizeLootItemCount = randomizeLootItemCount;
+            return this;
+        }
+
+    }
+
+    public AsteroidPropertyBuilder() {
+        oreSpawn = new OreSpawnPropertyBuilder();
+        loot = new LootPropertyBuilder();
+    }
+
+    public AsteroidPropertyBuilder probability(int probability) {
+        this.probability = probability;
+        return this;
+    }
+
+    public AsteroidPropertyBuilder sizeRange(int sizeMin, int sizeMax) {
+        this.sizeMin = sizeMin;
+        this.sizeMax = sizeMax;
+        return this;
+    }
+
+    public AsteroidPropertyBuilder specialBlockChance(int specialBlockChance) {
+        this.specialBlockChance = specialBlockChance;
+        return this;
+    }
+
+    public AsteroidPropertyBuilder oreSpawn(OreSpawnPropertyBuilder oreSpawnPropertyBuilder) {
+        this.oreSpawn = oreSpawnPropertyBuilder;
+        return this;
+    }
+
+    public AsteroidPropertyBuilder loot(LootPropertyBuilder lootPropertyBuilder) {
+        this.loot = lootPropertyBuilder;
+        return this;
+    }
+}
diff --git a/src/main/java/bloodasp/galacticgreg/api/enums/properties/Asteroids.java b/src/main/java/bloodasp/galacticgreg/api/enums/properties/Asteroids.java
new file mode 100644
index 0000000000..6a305407cd
--- /dev/null
+++ b/src/main/java/bloodasp/galacticgreg/api/enums/properties/Asteroids.java
@@ -0,0 +1,78 @@
+package bloodasp.galacticgreg.api.enums.properties;
+
+import bloodasp.galacticgreg.api.enums.DimensionDef;
+import bloodasp.galacticgreg.api.enums.ModContainers;
+
+public enum Asteroids {
+
+    // spotless : off
+    EndAsteroids(ModContainers.Vanilla, DimensionDef.EndAsteroids, new AsteroidPropertyBuilder().probability(200)
+        .sizeRange(5, 15)
+        .specialBlockChance(5)
+        .oreSpawn(
+            new AsteroidPropertyBuilder.OreSpawnPropertyBuilder().baseOreChance(5)
+                .doesObeyingHeightLimits(false)
+                .AreOresOnlyInsideAsteroids(false)
+                .primaryToRareOreOffset(5)
+                .smallOreChance(10))
+        .loot(
+            new AsteroidPropertyBuilder.LootPropertyBuilder().lootChestChance(1)
+                .lootChestItemCount(10)
+                .lootChestTable(3)
+                .isLootItemCountRandomized(true))),
+    KuiperBelt(ModContainers.GalaxySpace, DimensionDef.KuiperBelt, new AsteroidPropertyBuilder().probability(200)
+        .sizeRange(5, 15)
+        .specialBlockChance(5)
+        .oreSpawn(
+            new AsteroidPropertyBuilder.OreSpawnPropertyBuilder().baseOreChance(5)
+                .doesObeyingHeightLimits(false)
+                .AreOresOnlyInsideAsteroids(false)
+                .primaryToRareOreOffset(5)
+                .smallOreChance(10))
+        .loot(
+            new AsteroidPropertyBuilder.LootPropertyBuilder().lootChestChance(1)
+                .lootChestItemCount(10)
+                .lootChestTable(3)
+                .isLootItemCountRandomized(true))),
+    MehenBelt(ModContainers.AmunRa, DimensionDef.MehenBelt, new AsteroidPropertyBuilder().probability(200)
+        .sizeRange(5, 15)
+        .specialBlockChance(5)
+        .oreSpawn(
+            new AsteroidPropertyBuilder.OreSpawnPropertyBuilder().baseOreChance(5)
+                .doesObeyingHeightLimits(false)
+                .AreOresOnlyInsideAsteroids(false)
+                .primaryToRareOreOffset(5)
+                .smallOreChance(10))
+        .loot(
+            new AsteroidPropertyBuilder.LootPropertyBuilder().lootChestChance(1)
+                .lootChestItemCount(10)
+                .lootChestTable(3)
+                .isLootItemCountRandomized(true))),
+    Asteroids(ModContainers.GalacticraftMars, DimensionDef.Asteroids, new AsteroidPropertyBuilder().probability(200)
+        .sizeRange(5, 15)
+        .specialBlockChance(5)
+        .oreSpawn(
+            new AsteroidPropertyBuilder.OreSpawnPropertyBuilder().baseOreChance(5)
+                .doesObeyingHeightLimits(false)
+                .AreOresOnlyInsideAsteroids(false)
+                .primaryToRareOreOffset(5)
+                .smallOreChance(10))
+        .loot(
+            new AsteroidPropertyBuilder.LootPropertyBuilder().lootChestChance(1)
+                .lootChestItemCount(10)
+                .lootChestTable(3)
+                .isLootItemCountRandomized(true))),;
+
+    // spotless : on
+
+    public ModContainers modContainers;
+    public DimensionDef dimensionDef;
+    public AsteroidPropertyBuilder asteroidPropertyBuilder;
+
+    private Asteroids(ModContainers modContainers, DimensionDef dimensionDef,
+        AsteroidPropertyBuilder asteroidPropertyBuilder) {
+        this.modContainers = modContainers;
+        this.dimensionDef = dimensionDef;
+        this.asteroidPropertyBuilder = asteroidPropertyBuilder;
+    }
+}