still doesnt work but it works more™️

common/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java

@@ -13,6 +13,11 @@ public class MutableInteger extends MutableNumber<Integer> {
         add(1);
     }
 
+    public void addMod(int add, int mod) {
+        add(add);
+        value %= mod;
+    }
+
     public void decrement() {
         subtract(1);
     }

platforms/fabric/src/main/java/com/dfsek/terra/fabric/TerraFabricPlugin.java

@@ -50,6 +50,7 @@ import com.dfsek.terra.registry.exception.DuplicateEntryException;
 import com.dfsek.terra.registry.master.AddonRegistry;
 import com.dfsek.terra.registry.master.ConfigRegistry;
 import com.dfsek.terra.world.TerraWorld;
+import com.google.common.collect.ImmutableMap;
 import com.mojang.brigadier.arguments.StringArgumentType;
 import com.mojang.brigadier.builder.RequiredArgumentBuilder;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
@@ -63,12 +64,15 @@ import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.text.LiteralText;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.BuiltinRegistries;
+import net.minecraft.util.registry.DynamicRegistryManager;
 import net.minecraft.util.registry.Registry;
 import net.minecraft.util.registry.RegistryKey;
 import net.minecraft.world.biome.Biome;
 import net.minecraft.world.biome.BiomeEffects;
 import net.minecraft.world.biome.GenerationSettings;
+import net.minecraft.world.dimension.DimensionType;
 import net.minecraft.world.gen.GenerationStep;
+import net.minecraft.world.gen.GeneratorOptions;
 import net.minecraft.world.gen.chunk.ChunkGenerator;
 import net.minecraft.world.gen.chunk.ChunkGeneratorSettings;
 import net.minecraft.world.gen.decorator.Decorator;
@@ -91,6 +95,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 
 import static net.minecraft.server.command.CommandManager.argument;
 import static net.minecraft.server.command.CommandManager.literal;
@@ -300,16 +305,33 @@ public class TerraFabricPlugin implements TerraPlugin, ModInitializer {
 
         if(FabricLoader.getInstance().getEnvironmentType() == EnvType.CLIENT) {
             registry.forEach(pack -> {
-                final GeneratorType generatorType = new GeneratorType("terra." + pack.getTemplate().getID()) {
+
-                    @Override
-                    protected ChunkGenerator getChunkGenerator(Registry<Biome> biomeRegistry, Registry<ChunkGeneratorSettings> chunkGeneratorSettingsRegistry, long seed) {
-                        return new FabricChunkGeneratorWrapper(new TerraBiomeSource(biomeRegistry, seed, pack), seed, pack);
-                    }
-                };
-                //noinspection ConstantConditions
-                ((GeneratorTypeAccessor) generatorType).setTranslationKey(new LiteralText("Terra:" + pack.getTemplate().getID()));
-                GeneratorTypeAccessor.getValues().add(generatorType);
             });
+
+            ConfigPack pack = registry.get("DEFAULT");
+            final GeneratorType generatorType = new GeneratorType("terra") {
+                @Override
+                public TerraGeneratorOptions createDefaultOptions(DynamicRegistryManager.Impl registryManager, long seed, boolean generateStructures, boolean bonusChest) {
+                    Registry<Biome> registry = registryManager.get(Registry.BIOME_KEY);
+                    Registry<DimensionType> registry2 = registryManager.get(Registry.DIMENSION_TYPE_KEY);
+                    Registry<ChunkGeneratorSettings> registry3 = registryManager.get(Registry.NOISE_SETTINGS_WORLDGEN);
+
+
+                    return new TerraGeneratorOptions(seed, generateStructures, bonusChest, GeneratorOptions.method_28608(registry2, DimensionType.createDefaultDimensionOptions(registry2, registry, registry3, seed), this.getChunkGenerator(registry, registry3, seed)), registry, registry3);
+                }
+
+                @Override
+                protected ChunkGenerator getChunkGenerator(Registry<Biome> biomeRegistry, Registry<ChunkGeneratorSettings> chunkGeneratorSettingsRegistry, long seed) {
+                    return new FabricChunkGeneratorWrapper(new TerraBiomeSource(biomeRegistry, seed, pack), seed, pack);
+                }
+            };
+            Map<Optional<GeneratorType>, GeneratorType.ScreenProvider> screenProviderMap = new HashMap<>(GeneratorTypeAccessor.getScreenProviders());
+
+            screenProviderMap.put(Optional.of(generatorType), (screen, generatorOptions) -> new TerraOptionsScreen(screen, (TerraGeneratorOptions) generatorOptions));
+
+            GeneratorTypeAccessor.setScreenProviders(ImmutableMap.copyOf(screenProviderMap)); // jumping through hoops because ImmutableMap
+
+            GeneratorTypeAccessor.getValues().add(generatorType);
         }
 
         logger.info("Loaded packs.");

platforms/fabric/src/main/java/com/dfsek/terra/fabric/TerraGeneratorOptions.java

@@ -0,0 +1,159 @@
+package com.dfsek.terra.fabric;
+
+import com.dfsek.terra.api.util.generic.pair.ImmutablePair;
+import com.dfsek.terra.fabric.mixin.access.SimpleRegistryAccessor;
+import com.google.common.collect.Iterators;
+import com.mojang.serialization.Lifecycle;
+import net.minecraft.client.world.GeneratorType;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.util.registry.RegistryKey;
+import net.minecraft.util.registry.SimpleRegistry;
+import net.minecraft.world.biome.Biome;
+import net.minecraft.world.dimension.DimensionOptions;
+import net.minecraft.world.dimension.DimensionType;
+import net.minecraft.world.gen.GeneratorOptions;
+import net.minecraft.world.gen.chunk.ChunkGenerator;
+import net.minecraft.world.gen.chunk.ChunkGeneratorSettings;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.OptionalLong;
+import java.util.Random;
+
+public class TerraGeneratorOptions extends GeneratorOptions {
+    private final Map<DimensionType, ImmutablePair<GeneratorType, ChunkGenerator>> override = new HashMap<>();
+    private final Registry<Biome> biomeRegistry;
+    private final Registry<ChunkGeneratorSettings> chunkGeneratorSettingsRegistry;
+
+    public TerraGeneratorOptions(long seed, boolean generateStructures, boolean bonusChest, SimpleRegistry<DimensionOptions> simpleRegistry,
+                                 Registry<Biome> registry2, Registry<ChunkGeneratorSettings> registry3) {
+        super(seed, generateStructures, bonusChest, simpleRegistry);
+        System.out.println("Creating Terra options");
+        Thread.dumpStack();
+        this.biomeRegistry = registry2;
+        this.chunkGeneratorSettingsRegistry = registry3;
+    }
+
+    public Registry<ChunkGeneratorSettings> getChunkGeneratorSettingsRegistry() {
+        return chunkGeneratorSettingsRegistry;
+    }
+
+    public Registry<Biome> getBiomeRegistry() {
+        return biomeRegistry;
+    }
+
+    public void overrideChunkGenerator(DimensionType dimensionType, GeneratorType identifier, ChunkGenerator newGenerator) {
+        override.put(dimensionType, ImmutablePair.of(identifier, newGenerator));
+    }
+
+    @Override
+    public TerraGeneratorOptions toggleGenerateStructures() {
+        return new TerraGeneratorOptions(getSeed(), !shouldGenerateStructures(), hasBonusChest(), getDimensions(), biomeRegistry, chunkGeneratorSettingsRegistry);
+    }
+
+    @Override
+    public TerraGeneratorOptions toggleBonusChest() {
+        return new TerraGeneratorOptions(getSeed(), shouldGenerateStructures(), !hasBonusChest(), getDimensions(), biomeRegistry, chunkGeneratorSettingsRegistry);
+    }
+
+    @Override
+    public GeneratorOptions withHardcore(boolean hardcore, OptionalLong seed) {
+        long l = seed.orElse(this.getSeed());
+        SimpleRegistry<DimensionOptions> simpleRegistry2;
+        if(seed.isPresent()) {
+            simpleRegistry2 = new SimpleRegistry<>(Registry.DIMENSION_OPTIONS, Lifecycle.experimental());
+            long longSeed = seed.getAsLong();
+
+            for(Map.Entry<RegistryKey<DimensionOptions>, DimensionOptions> registryKeyDimensionOptionsEntry : getDimensions().getEntries()) {
+                RegistryKey<DimensionOptions> registryKey = registryKeyDimensionOptionsEntry.getKey();
+                simpleRegistry2.add(registryKey, new DimensionOptions(registryKeyDimensionOptionsEntry.getValue().getDimensionTypeSupplier(), registryKeyDimensionOptionsEntry.getValue().getChunkGenerator().withSeed(longSeed)), getDimensions().getEntryLifecycle(registryKeyDimensionOptionsEntry.getValue()));
+            }
+        } else {
+            simpleRegistry2 = getDimensions();
+        }
+
+        GeneratorOptions generatorOptions2;
+
+        if(this.isDebugWorld()) {
+            generatorOptions2 = new TerraGeneratorOptions(l, false, false, simpleRegistry2, biomeRegistry, chunkGeneratorSettingsRegistry);
+        } else {
+            generatorOptions2 = new TerraGeneratorOptions(l, this.shouldGenerateStructures(), hasBonusChest() && !hardcore, simpleRegistry2, biomeRegistry, chunkGeneratorSettingsRegistry);
+        }
+
+        return generatorOptions2;
+    }
+
+    public Map<DimensionType, ImmutablePair<GeneratorType, ChunkGenerator>> getOverrides() {
+        return override;
+    }
+
+    @Override
+    public ChunkGenerator getChunkGenerator() {
+        System.out.println("Getting chunk generator");
+        Thread.dumpStack();
+        return super.getChunkGenerator();
+    }
+
+    @Override
+    public SimpleRegistry<DimensionOptions> getDimensions() {
+        new SimpleRegistry<DimensionOptions>(Registry.DIMENSION_OPTIONS, Lifecycle.stable()) {
+            @Nullable
+            @Override
+            public DimensionOptions get(int index) {
+                DimensionOptions options = super.get(index);
+                if(options == null) return null;
+                return new DimensionOptionsOverride(options);
+            }
+
+            @Nullable
+            @Override
+            public DimensionOptions get(@Nullable RegistryKey<DimensionOptions> key) {
+                DimensionOptions options = super.get(key);
+                if(options == null) return null;
+                return new DimensionOptionsOverride(options);
+            }
+
+            @Nullable
+            @Override
+            public DimensionOptions get(@Nullable Identifier id) {
+                DimensionOptions options = super.get(id);
+                if(options == null) return null;
+                return new DimensionOptionsOverride(options);
+            }
+
+            @Nullable
+            @Override
+            public DimensionOptions getRandom(Random random) {
+                DimensionOptions options = super.getRandom(random);
+                if(options == null) return null;
+                return new DimensionOptionsOverride(options);
+            }
+
+            @SuppressWarnings({"unchecked", "ConstantConditions"})
+            @Override
+            public Iterator<DimensionOptions> iterator() {
+                return Iterators.filter(((SimpleRegistryAccessor<DimensionOptions>) (Object) this).getRawIdToEntry().stream().map(DimensionOptionsOverride::new).map(dimensionOptionsOverride -> (DimensionOptions) dimensionOptionsOverride).iterator(), Objects::nonNull);
+            }
+        };
+        return super.getDimensions();
+    }
+
+    public final class DimensionOptionsOverride extends DimensionOptions {
+
+        public DimensionOptionsOverride(DimensionOptions options) {
+            super(options.getDimensionTypeSupplier(), options.getChunkGenerator());
+            System.out.println("Overriding " + getDimensionType());
+        }
+
+        @Override
+        public ChunkGenerator getChunkGenerator() {
+            ChunkGenerator overridden = override.get(getDimensionType()).getRight();
+            if(overridden != null) return overridden;
+            return super.getChunkGenerator();
+        }
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/TerraOptionsScreen.java

@@ -0,0 +1,122 @@
+package com.dfsek.terra.fabric;
+
+import com.dfsek.terra.api.util.generic.pair.ImmutablePair;
+import com.dfsek.terra.api.util.mutable.MutableInteger;
+import com.dfsek.terra.config.pack.ConfigPack;
+import com.dfsek.terra.fabric.generation.FabricChunkGeneratorWrapper;
+import com.dfsek.terra.fabric.generation.TerraBiomeSource;
+import com.dfsek.terra.fabric.mixin.access.GeneratorTypeAccessor;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.widget.ButtonListWidget;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.options.CyclingOption;
+import net.minecraft.client.options.GameOptions;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.world.GeneratorType;
+import net.minecraft.text.BaseText;
+import net.minecraft.text.LiteralText;
+import net.minecraft.text.Text;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.world.biome.Biome;
+import net.minecraft.world.dimension.DimensionType;
+import net.minecraft.world.gen.chunk.ChunkGenerator;
+import net.minecraft.world.gen.chunk.ChunkGeneratorSettings;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TerraOptionsScreen extends Screen {
+    private final Screen parent;
+    private final List<GeneratorType> generatorList = new ArrayList<>();
+    private final TerraGeneratorOptions terraGeneratorOptions;
+    private ButtonListWidget buttonListWidget;
+
+    public TerraOptionsScreen(Screen parent, TerraGeneratorOptions terraGeneratorOptions) {
+        super(new LiteralText("Terra Options"));
+        this.parent = parent;
+        this.terraGeneratorOptions = terraGeneratorOptions;
+        generatorList.add(GeneratorType.DEFAULT);
+
+        TerraFabricPlugin.getInstance().getConfigRegistry().forEach(pack -> generatorList.add(new TempGeneratorType(pack)));
+    }
+
+    @Override
+    protected void init() {
+        addButton(new ButtonWidget(width / 2 - 60, height - 30, 120, 20, new TranslatableText("terra.screen.close"), btn -> client.openScreen(parent)));
+        this.buttonListWidget = new ButtonListWidget(client, width - 20, height - 20, 32, height - 50, 25);
+
+        buttonListWidget.setLeftPos(10);
+
+        terraGeneratorOptions.getDimensions().getEntries().forEach((entry) -> buttonListWidget.addSingleOptionEntry(new GeneratorCycler(entry.getKey().getValue(), entry.getValue().getDimensionType())));
+
+        addChild(buttonListWidget);
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        this.renderBackground(matrices);
+        this.buttonListWidget.render(matrices, mouseX, mouseY, delta);
+        DrawableHelper.drawCenteredText(matrices, textRenderer, new TranslatableText("terra.config-screen"), width / 2, 20, 0xffffff);
+        super.render(matrices, mouseX, mouseY, delta);
+    }
+
+    private static final class TempGeneratorType extends GeneratorType {
+        private final ConfigPack pack;
+
+        protected TempGeneratorType(ConfigPack pack) {
+            super("terra:" + pack.getTemplate().getID());
+            this.pack = pack;
+            //noinspection ConstantConditions
+            ((GeneratorTypeAccessor) (Object) this).setTranslationKey(new LiteralText("Terra:" + this.pack.getTemplate().getID()));
+        }
+
+        @Override
+        protected ChunkGenerator getChunkGenerator(Registry<Biome> biomeRegistry, Registry<ChunkGeneratorSettings> chunkGeneratorSettingsRegistry, long seed) {
+            return new FabricChunkGeneratorWrapper(new TerraBiomeSource(biomeRegistry, seed, pack), seed, pack);
+        }
+
+        @Override
+        public int hashCode() {
+            return pack.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if(!(obj instanceof TempGeneratorType)) return false;
+            return ((TempGeneratorType) obj).pack.equals(this.pack);
+        }
+    }
+
+    private final class GeneratorCycler extends CyclingOption {
+        private final MutableInteger amount = new MutableInteger(0);
+        private final DimensionType value;
+
+        public GeneratorCycler(Identifier key, DimensionType value) {
+            super(key.toString(), null, null);
+            this.value = value;
+            ImmutablePair<GeneratorType, ChunkGenerator> generatorTypeChunkGeneratorImmutablePair = terraGeneratorOptions.getOverrides().get(value);
+
+            if(generatorTypeChunkGeneratorImmutablePair != null) {
+                this.amount.set(generatorList.indexOf(generatorTypeChunkGeneratorImmutablePair.getLeft()));
+            }
+        }
+
+        @Override
+        public Text getMessage(GameOptions options) {
+            return ((BaseText) getDisplayPrefix()).copy().append(new LiteralText(": ")).append(generatorList.get(amount.get()).getTranslationKey().copy());
+        }
+
+        @Override
+        public void cycle(GameOptions options, int amount) {
+            this.amount.addMod(amount, generatorList.size());
+            terraGeneratorOptions.overrideChunkGenerator(value, generatorList.get(this.amount.get()),
+                    ((GeneratorTypeAccessor) generatorList.get(this.amount.get()))
+                            .callGetChunkGenerator(terraGeneratorOptions.getBiomeRegistry(),
+                                    terraGeneratorOptions.getChunkGeneratorSettingsRegistry(),
+                                    terraGeneratorOptions.getSeed()));
+        }
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/config/FabricWorldConfig.java

@@ -0,0 +1,28 @@
+package com.dfsek.terra.fabric.config;
+
+import com.dfsek.tectonic.annotations.Default;
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.tectonic.config.ConfigTemplate;
+import com.dfsek.terra.config.pack.ConfigPack;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FabricWorldConfig implements ConfigTemplate {
+    @SuppressWarnings("FieldMayBeFinal")
+    @Value(".")
+    @Default
+    private Map<String, ConfigPack> worlds;
+
+    public FabricWorldConfig(Map<String, ConfigPack> worlds) {
+        this.worlds = worlds;
+    }
+
+    public FabricWorldConfig() {
+        this(new HashMap<>());
+    }
+
+    public Map<String, ConfigPack> getWorlds() {
+        return worlds;
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/GeneratorOptionsMixin.java

@@ -2,8 +2,9 @@ package com.dfsek.terra.fabric.mixin;
 
 import com.dfsek.terra.config.pack.ConfigPack;
 import com.dfsek.terra.fabric.TerraFabricPlugin;
-import com.dfsek.terra.fabric.generation.TerraBiomeSource;
+import com.dfsek.terra.fabric.TerraGeneratorOptions;
 import com.dfsek.terra.fabric.generation.FabricChunkGeneratorWrapper;
+import com.dfsek.terra.fabric.generation.TerraBiomeSource;
 import com.google.common.base.MoreObjects;
 import net.minecraft.util.registry.DynamicRegistryManager;
 import net.minecraft.util.registry.Registry;
@@ -13,7 +14,9 @@ import net.minecraft.world.dimension.DimensionOptions;
 import net.minecraft.world.dimension.DimensionType;
 import net.minecraft.world.gen.GeneratorOptions;
 import net.minecraft.world.gen.chunk.ChunkGeneratorSettings;
+import net.minecraft.world.gen.chunk.NoiseChunkGenerator;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@@ -21,8 +24,15 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import java.util.Properties;
 import java.util.Random;
 
+import static net.minecraft.world.gen.GeneratorOptions.method_28608;
+
 @Mixin(GeneratorOptions.class)
 public abstract class GeneratorOptionsMixin {
+    @Shadow
+    public static NoiseChunkGenerator createOverworldGenerator(Registry<Biome> biomeRegistry, Registry<ChunkGeneratorSettings> chunkGeneratorSettingsRegistry, long seed) {
+        return null;
+    }
+
     @Inject(method = "fromProperties(Lnet/minecraft/util/registry/DynamicRegistryManager;Ljava/util/Properties;)Lnet/minecraft/world/gen/GeneratorOptions;", at = @At("HEAD"), cancellable = true)
     private static void fromProperties(DynamicRegistryManager dynamicRegistryManager, Properties properties, CallbackInfoReturnable<GeneratorOptions> cir) {
         if(properties.get("level-type") == null) {
@@ -51,13 +61,20 @@ public abstract class GeneratorOptionsMixin {
             Registry<ChunkGeneratorSettings> chunkGeneratorSettings = dynamicRegistryManager.get(Registry.NOISE_SETTINGS_WORLDGEN);
             SimpleRegistry<DimensionOptions> dimensionOptions = DimensionType.createDefaultDimensionOptions(dimensionTypes, biomes, chunkGeneratorSettings, l);
 
+
             prop = prop.substring(prop.indexOf(":") + 1);
 
             ConfigPack pack = TerraFabricPlugin.getInstance().getConfigRegistry().get(prop);
 
             if(pack == null) throw new IllegalArgumentException("No such pack " + prop);
 
-            cir.setReturnValue(new GeneratorOptions(l, generateStructures, false, GeneratorOptions.method_28608(dimensionTypes, dimensionOptions, new FabricChunkGeneratorWrapper(new TerraBiomeSource(biomes, l, pack), l, pack))));
+            cir.setReturnValue(new TerraGeneratorOptions(l, generateStructures, false, method_28608(dimensionTypes, dimensionOptions, new FabricChunkGeneratorWrapper(new TerraBiomeSource(biomes, l, pack), l, pack)), biomes, chunkGeneratorSettings));
         }
     }
+
+    @Inject(method = "getDefaultOptions(Lnet/minecraft/util/registry/Registry;Lnet/minecraft/util/registry/Registry;Lnet/minecraft/util/registry/Registry;)Lnet/minecraft/world/gen/GeneratorOptions;", at = @At("HEAD"), cancellable = true)
+    private static void injectDefaultOptions(Registry<DimensionType> registry, Registry<Biome> registry2, Registry<ChunkGeneratorSettings> registry3, CallbackInfoReturnable<GeneratorOptions> cir) {
+        long l = (new Random()).nextLong();
+        cir.setReturnValue(new TerraGeneratorOptions(l, true, false, method_28608(registry, DimensionType.createDefaultDimensionOptions(registry, registry2, registry3, l), createOverworldGenerator(registry2, registry3, l)), registry2, registry3));
+    }
 }

platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/MinecraftServerMixin.java

@@ -0,0 +1,25 @@
+package com.dfsek.terra.fabric.mixin;
+
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.WorldGenerationProgressListener;
+import net.minecraft.world.SaveProperties;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(MinecraftServer.class)
+public abstract class MinecraftServerMixin {
+    @Shadow
+    @Final
+    protected SaveProperties saveProperties;
+
+
+    @Inject(method = "createWorlds(Lnet/minecraft/server/WorldGenerationProgressListener;)V", at = @At("HEAD"))
+    public void injectCreateWorlds(WorldGenerationProgressListener worldGenerationProgressListener, CallbackInfo ci) {
+        System.out.println("Generator: " + this.saveProperties.getGeneratorOptions());
+        Thread.dumpStack();
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/access/GeneratorTypeAccessor.java

@@ -2,11 +2,18 @@ package com.dfsek.terra.fabric.mixin.access;
 
 import net.minecraft.client.world.GeneratorType;
 import net.minecraft.text.Text;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.world.biome.Biome;
+import net.minecraft.world.gen.chunk.ChunkGenerator;
+import net.minecraft.world.gen.chunk.ChunkGeneratorSettings;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Mutable;
 import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
 
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 
 @Mixin(GeneratorType.class)
 public interface GeneratorTypeAccessor {
@@ -15,7 +22,21 @@ public interface GeneratorTypeAccessor {
         throw new UnsupportedOperationException();
     }
 
+    @Accessor("SCREEN_PROVIDERS")
+    static Map<Optional<GeneratorType>, GeneratorType.ScreenProvider> getScreenProviders() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Mutable
+    @Accessor("SCREEN_PROVIDERS")
+    static void setScreenProviders(Map<Optional<GeneratorType>, GeneratorType.ScreenProvider> SCREEN_PROVIDERS) {
+        throw new UnsupportedOperationException();
+    }
+
     @Mutable
     @Accessor("translationKey")
     void setTranslationKey(Text translationKey);
+
+    @Invoker("getChunkGenerator")
+    ChunkGenerator callGetChunkGenerator(Registry<Biome> biomeRegistry, Registry<ChunkGeneratorSettings> chunkGeneratorSettingsRegistry, long seed);
 }

platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/access/LevelPropertiesAccessor.java

@@ -0,0 +1,12 @@
+package com.dfsek.terra.fabric.mixin.access;
+
+import net.minecraft.world.gen.GeneratorOptions;
+import net.minecraft.world.level.LevelProperties;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(LevelProperties.class)
+public interface LevelPropertiesAccessor {
+    @Accessor("generatorOptions")
+    void setGeneratorOptions(GeneratorOptions generatorOptions);
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/access/SimpleRegistryAccessor.java

@@ -0,0 +1,12 @@
+package com.dfsek.terra.fabric.mixin.access;
+
+import it.unimi.dsi.fastutil.objects.ObjectList;
+import net.minecraft.util.registry.SimpleRegistry;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(SimpleRegistry.class)
+public interface SimpleRegistryAccessor<T> {
+    @Accessor("rawIdToEntry")
+    ObjectList<T> getRawIdToEntry();
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/client/MinecraftClientMixin.java

@@ -1,4 +1,4 @@
-package com.dfsek.terra.fabric.mixin.init;
+package com.dfsek.terra.fabric.mixin.client;
 
 import com.dfsek.terra.fabric.TerraFabricPlugin;
 import net.minecraft.client.MinecraftClient;

platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/server/MinecraftServerMixin.java

@@ -1,4 +1,4 @@
-package com.dfsek.terra.fabric.mixin.init;
+package com.dfsek.terra.fabric.mixin.server;
 
 import com.dfsek.terra.fabric.TerraFabricPlugin;
 import com.mojang.authlib.GameProfileRepository;

platforms/fabric/src/main/resources/assets/terra/lang/en_us.json

@@ -1,4 +1,6 @@
 {
-  "generator.terra": "Terra"
+  "generator.terra": "Terra",
+  "terra.config-screen": "Terra Configuration",
+  "terra.screen.close": "Close"
 }
 

platforms/fabric/src/main/resources/terra.accesswidener

@@ -1,3 +1,5 @@
 accessWidener v1 named
 
-extendable method net/minecraft/client/world/GeneratorType <init> (Ljava/lang/String;)V
+extendable method net/minecraft/client/world/GeneratorType <init> (Ljava/lang/String;)V
+
+extendable class net/minecraft/world/dimension/DimensionOptions

platforms/fabric/src/main/resources/terra.mixins.json

@@ -5,8 +5,11 @@
   "compatibilityLevel": "JAVA_8",
   "mixins": [
     "GeneratorOptionsMixin",
+    "MinecraftServerMixin",
     "access.BiomeEffectsAccessor",
+    "access.LevelPropertiesAccessor",
     "access.MobSpawnerLogicAccessor",
+    "access.SimpleRegistryAccessor",
     "access.StateAccessor",
     "implementations.BiomeMixin",
     "implementations.ChunkGeneratorMixin",
@@ -34,10 +37,10 @@
   ],
   "client": [
     "access.GeneratorTypeAccessor",
-    "init.MinecraftClientMixin"
+    "client.MinecraftClientMixin"
   ],
   "server": [
-    "init.MinecraftServerMixin"
+    "server.MinecraftServerMixin"
   ],
   "injectors": {
     "defaultRequire": 1