fabric stuff

common/src/main/java/com/dfsek/terra/api/generic/generator/TerraChunkGenerator.java

@@ -1,6 +1,7 @@
 package com.dfsek.terra.api.generic.generator;
 
 import com.dfsek.terra.api.gaea.profiler.WorldProfiler;
+import com.dfsek.terra.api.generic.TerraPlugin;
 import com.dfsek.terra.api.generic.world.BiomeGrid;
 import com.dfsek.terra.api.generic.world.World;
 import com.dfsek.terra.config.base.ConfigPack;
@@ -28,4 +29,5 @@ public interface TerraChunkGenerator {
 
     List<TerraBlockPopulator> getPopulators();
 
+    TerraPlugin getMain();
 }

common/src/main/java/com/dfsek/terra/generation/TerraChunkGenerator.java

@@ -106,6 +106,11 @@ public class TerraChunkGenerator implements com.dfsek.terra.api.generic.generato
         return Arrays.asList(new CavePopulator(main), new StructurePopulator(main), popMan);
     }
 
+    @Override
+    public TerraPlugin getMain() {
+        return main;
+    }
+
 
     @Override
     @SuppressWarnings({"try"})

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

@@ -16,15 +16,17 @@ import com.dfsek.terra.fabric.inventory.FabricItemHandle;
 import com.dfsek.terra.fabric.mixin.GeneratorTypeAccessor;
 import com.dfsek.terra.fabric.world.FabricBiome;
 import com.dfsek.terra.fabric.world.FabricWorldHandle;
+import com.dfsek.terra.fabric.world.generator.FabricChunkGeneratorWrapper;
+import com.dfsek.terra.fabric.world.generator.TerraChunkGeneratorCodec;
 import com.dfsek.terra.registry.ConfigRegistry;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.loader.api.FabricLoader;
 import net.minecraft.client.world.GeneratorType;
 import net.minecraft.util.registry.Registry;
 import net.minecraft.world.biome.Biome;
+import net.minecraft.world.biome.source.VanillaLayeredBiomeSource;
 import net.minecraft.world.gen.chunk.ChunkGenerator;
 import net.minecraft.world.gen.chunk.ChunkGeneratorSettings;
-import net.minecraft.world.gen.chunk.FlatChunkGenerator;
 import net.minecraft.world.gen.chunk.FlatChunkGeneratorConfig;
 import net.minecraft.world.gen.chunk.StructuresConfig;
 
@@ -35,15 +37,22 @@ import java.util.Optional;
 import java.util.logging.Logger;
 
 public class TerraFabricPlugin implements TerraPlugin, ModInitializer {
-    private static final GeneratorType TERRA = new GeneratorType("terra") {
+    private static TerraFabricPlugin instance;
+    private final GeneratorType TERRA = new GeneratorType("terra") {
         @Override
         protected ChunkGenerator getChunkGenerator(Registry<Biome> biomeRegistry, Registry<ChunkGeneratorSettings> chunkGeneratorSettingsRegistry, long seed) {
             FlatChunkGeneratorConfig config = new FlatChunkGeneratorConfig(
                     new StructuresConfig(Optional.empty(), Collections.emptyMap()), biomeRegistry);
             config.updateLayerBlocks();
-            return new FlatChunkGenerator(config);
+
+            return new FabricChunkGeneratorWrapper(new VanillaLayeredBiomeSource(seed, false, false, biomeRegistry), seed);
         }
     };
+    private final TerraChunkGeneratorCodec chunkGeneratorCodec = new TerraChunkGeneratorCodec(this);
+
+    public static TerraFabricPlugin getInstance() {
+        return instance;
+    }
 
     private final GenericLoaders genericLoaders = new GenericLoaders(this);
     private final Logger logger = Logger.getLogger("Terra");
@@ -122,10 +131,15 @@ public class TerraFabricPlugin implements TerraPlugin, ModInitializer {
 
     @Override
     public void onInitialize() {
+        instance = this;
         config = new File(FabricLoader.getInstance().getConfigDir().toFile(), "Terra");
         LangUtil.load("en_us", this);
         logger.info("Initializing Terra...");
-        GeneratorTypeAccessor.accessor$getValues().add(TERRA);
+        GeneratorTypeAccessor.getValues().add(TERRA);
         registry.loadAll(this);
     }
+
+    public TerraChunkGeneratorCodec getChunkGeneratorCodec() {
+        return chunkGeneratorCodec;
+    }
 }

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

@@ -9,7 +9,7 @@ import java.util.List;
 @Mixin(GeneratorType.class)
 public interface GeneratorTypeAccessor {
     @Accessor("VALUES")
-    static List<GeneratorType> accessor$getValues() {
+    static List<GeneratorType> getValues() {
         throw new AssertionError();
     }
 }

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/BlockStorage.java

@@ -1,8 +1,9 @@
 package com.dfsek.terra.fabric.world;
 
 import com.dfsek.terra.api.generic.world.vector.Location;
+import com.dfsek.terra.fabric.world.handles.FabricWorldAccess;
 import net.minecraft.block.Block;
-import net.minecraft.world.World;
+import net.minecraft.world.WorldAccess;
 
 public class BlockStorage {
     private final Block block;
@@ -21,8 +22,8 @@ public class BlockStorage {
         return location;
     }
 
-    public World getWorld() {
+    public WorldAccess getWorld() {
-        return ((FabricWorld) location.getWorld()).getHandle();
+        return ((FabricWorldAccess) location.getWorld()).getHandle();
     }
 
 

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/FabricBiomeGrid.java

@@ -0,0 +1,32 @@
+package com.dfsek.terra.fabric.world;
+
+import com.dfsek.terra.api.generic.world.Biome;
+import com.dfsek.terra.api.generic.world.BiomeGrid;
+import org.jetbrains.annotations.NotNull;
+
+public class FabricBiomeGrid implements BiomeGrid {
+    @Override
+    public @NotNull Biome getBiome(int x, int z) {
+        return new FabricBiome();
+    }
+
+    @Override
+    public @NotNull Biome getBiome(int x, int y, int z) {
+        return new FabricBiome();
+    }
+
+    @Override
+    public void setBiome(int x, int z, @NotNull Biome bio) {
+
+    }
+
+    @Override
+    public void setBiome(int x, int y, int z, @NotNull Biome bio) {
+
+    }
+
+    @Override
+    public Object getHandle() {
+        return null;
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/generator/FabricChunkData.java

@@ -0,0 +1,36 @@
+package com.dfsek.terra.fabric.world.generator;
+
+import com.dfsek.terra.api.generic.generator.ChunkGenerator;
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.fabric.world.FabricBlockData;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.chunk.Chunk;
+import org.jetbrains.annotations.NotNull;
+
+public class FabricChunkData implements ChunkGenerator.ChunkData {
+    private final Chunk handle;
+
+    public FabricChunkData(Chunk handle) {
+        this.handle = handle;
+    }
+
+    @Override
+    public Chunk getHandle() {
+        return handle;
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return handle.getHeight();
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, @NotNull BlockData blockData) {
+        handle.setBlockState(new BlockPos(x, y, z), ((FabricBlockData) blockData).getHandle(), false);
+    }
+
+    @Override
+    public @NotNull BlockData getBlockData(int x, int y, int z) {
+        return new FabricBlockData(handle.getBlockState(new BlockPos(x, y, z)));
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/generator/FabricChunkGenerator.java

@@ -1,52 +1,65 @@
 package com.dfsek.terra.fabric.world.generator;
 
-import com.mojang.serialization.Codec;
+import com.dfsek.terra.api.generic.generator.BlockPopulator;
-import net.minecraft.world.BlockView;
+import com.dfsek.terra.api.generic.generator.ChunkGenerator;
-import net.minecraft.world.ChunkRegion;
+import com.dfsek.terra.api.generic.generator.TerraChunkGenerator;
-import net.minecraft.world.Heightmap;
+import com.dfsek.terra.api.generic.world.BiomeGrid;
-import net.minecraft.world.WorldAccess;
+import com.dfsek.terra.api.generic.world.World;
-import net.minecraft.world.biome.source.BiomeSource;
+import org.jetbrains.annotations.NotNull;
-import net.minecraft.world.chunk.Chunk;
+import org.jetbrains.annotations.Nullable;
-import net.minecraft.world.gen.StructureAccessor;
-import net.minecraft.world.gen.chunk.ChunkGenerator;
-import net.minecraft.world.gen.chunk.StructuresConfig;
 
-public class FabricChunkGenerator extends ChunkGenerator {
+import java.util.List;
-    public FabricChunkGenerator(BiomeSource biomeSource, StructuresConfig structuresConfig) {
+import java.util.Random;
-        super(biomeSource, structuresConfig);
-    }
 
-    public FabricChunkGenerator(BiomeSource populationSource, BiomeSource biomeSource, StructuresConfig structuresConfig, long worldSeed) {
+public class FabricChunkGenerator implements ChunkGenerator {
-        super(populationSource, biomeSource, structuresConfig, worldSeed);
+    private final net.minecraft.world.gen.chunk.ChunkGenerator delegate;
+
+    public FabricChunkGenerator(net.minecraft.world.gen.chunk.ChunkGenerator delegate) {
+        this.delegate = delegate;
     }
 
     @Override
-    protected Codec<? extends ChunkGenerator> getCodec() {
+    public boolean isParallelCapable() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateCaves() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateMobs() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateStructures() {
+        return false;
+    }
+
+    @Override
+    public ChunkData generateChunkData(@NotNull World world, @NotNull Random random, int x, int z, @NotNull BiomeGrid biome) {
         return null;
     }
 
     @Override
-    public ChunkGenerator withSeed(long seed) {
+    public List<BlockPopulator> getDefaultPopulators(World world) {
         return null;
     }
 
     @Override
-    public void buildSurface(ChunkRegion region, Chunk chunk) {
+    public @Nullable TerraChunkGenerator getTerraGenerator() {
-
-    }
-
-    @Override
-    public void populateNoise(WorldAccess world, StructureAccessor accessor, Chunk chunk) {
-
-    }
-
-    @Override
-    public int getHeight(int x, int z, Heightmap.Type heightmapType) {
-        return 0;
-    }
-
-    @Override
-    public BlockView getColumnSample(int x, int z) {
         return null;
     }
+
+    @Override
+    public net.minecraft.world.gen.chunk.ChunkGenerator getHandle() {
+        return delegate;
+    }
 }

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/generator/FabricChunkGeneratorWrapper.java

@@ -0,0 +1,88 @@
+package com.dfsek.terra.fabric.world.generator;
+
+import com.dfsek.terra.api.gaea.util.FastRandom;
+import com.dfsek.terra.api.generic.Handle;
+import com.dfsek.terra.fabric.TerraFabricPlugin;
+import com.dfsek.terra.fabric.world.FabricBiomeGrid;
+import com.dfsek.terra.fabric.world.handles.FabricSeededWorldAccess;
+import com.dfsek.terra.generation.TerraChunkGenerator;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.world.BlockView;
+import net.minecraft.world.ChunkRegion;
+import net.minecraft.world.Heightmap;
+import net.minecraft.world.WorldAccess;
+import net.minecraft.world.biome.source.BiomeSource;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.gen.StructureAccessor;
+import net.minecraft.world.gen.chunk.ChunkGenerator;
+import net.minecraft.world.gen.chunk.StructuresConfig;
+import net.minecraft.world.gen.chunk.VerticalBlockSample;
+
+public class FabricChunkGeneratorWrapper extends ChunkGenerator implements Handle {
+    private final long seed;
+    private final TerraChunkGenerator delegate;
+    private final Codec<FabricChunkGeneratorWrapper> codec = RecordCodecBuilder.create(instance -> instance.group(
+            BiomeSource.CODEC.fieldOf("biome_source").forGetter(generator -> generator.biomeSource),
+            Codec.LONG.fieldOf("seed").stable().forGetter(generator -> generator.seed))
+            .apply(instance, instance.stable(FabricChunkGeneratorWrapper::new)));
+
+    public FabricChunkGeneratorWrapper(BiomeSource biomeSource, long seed) {
+        super(biomeSource, new StructuresConfig(false));
+        this.delegate = new TerraChunkGenerator(TerraFabricPlugin.getInstance().getRegistry().get("DEFAULT"), TerraFabricPlugin.getInstance());
+        delegate.getMain().getLogger().info("Loading world...");
+
+        this.seed = seed;
+    }
+
+    @Override
+    public TerraChunkGenerator getHandle() {
+        return delegate;
+    }
+
+    @Override
+    protected Codec<? extends ChunkGenerator> getCodec() {
+        return codec;
+    }
+
+    @Override
+    public ChunkGenerator withSeed(long seed) {
+        return new FabricChunkGeneratorWrapper(this.biomeSource.withSeed(seed), seed);
+    }
+
+    @Override
+    public void buildSurface(ChunkRegion region, Chunk chunk) {
+
+    }
+
+    @Override
+    public void populateNoise(WorldAccess world, StructureAccessor accessor, Chunk chunk) {
+        delegate.generateChunkData(new FabricSeededWorldAccess(world, seed, this), new FastRandom(), chunk.getPos().x, chunk.getPos().z, new FabricBiomeGrid(), new FabricChunkData(chunk));
+    }
+
+    @Override
+    public int getHeight(int x, int z, Heightmap.Type heightmapType) {
+        return 0;
+    }
+
+    @Override
+    public BlockView getColumnSample(int x, int z) {
+        int height = 64; // TODO: implementation
+        BlockState[] array = new BlockState[256];
+        for(int y = 255; y >= 0; y--) {
+            if(y > height) {
+                if(y > getSeaLevel()) {
+                    array[y] = Blocks.AIR.getDefaultState();
+                } else {
+                    array[y] = Blocks.WATER.getDefaultState();
+                }
+            } else {
+                array[y] = Blocks.STONE.getDefaultState();
+            }
+        }
+
+        return new VerticalBlockSample(array);
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/generator/TerraChunkGeneratorCodec.java

@@ -0,0 +1,33 @@
+package com.dfsek.terra.fabric.world.generator;
+
+import com.dfsek.terra.api.generic.TerraPlugin;
+import com.dfsek.terra.generation.TerraChunkGenerator;
+import com.mojang.datafixers.util.Pair;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.DynamicOps;
+
+import java.util.Optional;
+
+public class TerraChunkGeneratorCodec implements Codec<TerraChunkGenerator> {
+    private final TerraPlugin main;
+
+    public TerraChunkGeneratorCodec(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @Override
+    public <T> DataResult<Pair<TerraChunkGenerator, T>> decode(DynamicOps<T> ops, T input) {
+        Optional<String> s = ops.getStringValue(input).get().left();
+        if(!s.isPresent()) return DataResult.error("No data present");
+        if(main.getRegistry().contains(s.get())) {
+            return DataResult.success(new Pair<>(new TerraChunkGenerator(main.getRegistry().get(s.get()), main), input));
+        }
+        return null;
+    }
+
+    @Override
+    public <T> DataResult<T> encode(TerraChunkGenerator input, DynamicOps<T> ops, T prefix) {
+        return null;
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/handles/FabricSeededWorldAccess.java

@@ -0,0 +1,113 @@
+package com.dfsek.terra.fabric.world.handles;
+
+import com.dfsek.terra.api.generic.Entity;
+import com.dfsek.terra.api.generic.Tree;
+import com.dfsek.terra.api.generic.generator.ChunkGenerator;
+import com.dfsek.terra.api.generic.world.Chunk;
+import com.dfsek.terra.api.generic.world.World;
+import com.dfsek.terra.api.generic.world.block.Block;
+import com.dfsek.terra.api.generic.world.vector.Location;
+import com.dfsek.terra.fabric.world.generator.FabricChunkGenerator;
+import net.minecraft.world.WorldAccess;
+
+import java.io.File;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+public class FabricSeededWorldAccess implements World {
+
+    private final Handle handle;
+
+    public FabricSeededWorldAccess(WorldAccess access, long seed, net.minecraft.world.gen.chunk.ChunkGenerator generator) {
+        this.handle = new Handle(access, seed, generator);
+    }
+
+    @Override
+    public long getSeed() {
+        return handle.getSeed();
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return handle.getWorldAccess().getDimensionHeight();
+    }
+
+    @Override
+    public ChunkGenerator getGenerator() {
+        return new FabricChunkGenerator(handle.getGenerator());
+    }
+
+    @Override
+    public String getName() {
+        return handle.toString(); // TODO: implementation
+    }
+
+    @Override
+    public UUID getUID() {
+        return UUID.randomUUID(); // TODO: implementation
+    }
+
+    @Override
+    public boolean isChunkGenerated(int x, int z) {
+        return false;
+    }
+
+    @Override
+    public Chunk getChunkAt(int x, int z) {
+        return null;
+    }
+
+    @Override
+    public File getWorldFolder() {
+        return null;
+    }
+
+    @Override
+    public Block getBlockAt(int x, int y, int z) {
+        return null;
+    }
+
+    @Override
+    public Block getBlockAt(Location l) {
+        return null;
+    }
+
+    @Override
+    public boolean generateTree(Location l, Tree vanillaTreeType) {
+        return false;
+    }
+
+    @Override
+    public void spawn(Location location, Class<Entity> entity, Consumer<Entity> consumer) {
+
+    }
+
+    @Override
+    public Handle getHandle() {
+        return handle;
+    }
+
+    public static class Handle {
+        private final WorldAccess worldAccess;
+        private final long seed;
+        private final net.minecraft.world.gen.chunk.ChunkGenerator generator;
+
+        public Handle(WorldAccess worldAccess, long seed, net.minecraft.world.gen.chunk.ChunkGenerator generator) {
+            this.worldAccess = worldAccess;
+            this.seed = seed;
+            this.generator = generator;
+        }
+
+        public net.minecraft.world.gen.chunk.ChunkGenerator getGenerator() {
+            return generator;
+        }
+
+        public long getSeed() {
+            return seed;
+        }
+
+        public WorldAccess getWorldAccess() {
+            return worldAccess;
+        }
+    }
+}

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/handles/FabricWorldAccess.java

@@ -1,4 +1,4 @@
-package com.dfsek.terra.fabric.world;
+package com.dfsek.terra.fabric.world.handles;
 
 import com.dfsek.terra.api.generic.Entity;
 import com.dfsek.terra.api.generic.Tree;
@@ -7,21 +7,22 @@ import com.dfsek.terra.api.generic.world.Chunk;
 import com.dfsek.terra.api.generic.world.World;
 import com.dfsek.terra.api.generic.world.block.Block;
 import com.dfsek.terra.api.generic.world.vector.Location;
+import net.minecraft.world.WorldAccess;
 
 import java.io.File;
 import java.util.UUID;
 import java.util.function.Consumer;
 
-public class FabricWorld implements World {
+public class FabricWorldAccess implements World {
-    private final net.minecraft.world.World delegate;
+    private final WorldAccess delegate;
 
-    public FabricWorld(net.minecraft.world.World delegate) {
+    public FabricWorldAccess(WorldAccess delegate) {
         this.delegate = delegate;
     }
 
     @Override
     public long getSeed() {
-        return 1234;
+        return 1234; // TODO: actually implement this
     }
 
     @Override
@@ -80,7 +81,7 @@ public class FabricWorld implements World {
     }
 
     @Override
-    public net.minecraft.world.World getHandle() {
+    public WorldAccess getHandle() {
         return delegate;
     }
 }

platforms/fabric/src/main/java/com/dfsek/terra/fabric/world/handles/FabricWorldChunkRegion.java

@@ -0,0 +1,87 @@
+package com.dfsek.terra.fabric.world.handles;
+
+import com.dfsek.terra.api.generic.Entity;
+import com.dfsek.terra.api.generic.Tree;
+import com.dfsek.terra.api.generic.generator.ChunkGenerator;
+import com.dfsek.terra.api.generic.world.Chunk;
+import com.dfsek.terra.api.generic.world.World;
+import com.dfsek.terra.api.generic.world.block.Block;
+import com.dfsek.terra.api.generic.world.vector.Location;
+import net.minecraft.world.ChunkRegion;
+
+import java.io.File;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+public class FabricWorldChunkRegion implements World {
+    private final ChunkRegion delegate;
+
+    public FabricWorldChunkRegion(ChunkRegion delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public long getSeed() {
+        return delegate.getSeed();
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return delegate.getHeight();
+    }
+
+    @Override
+    public ChunkGenerator getGenerator() {
+        return null;
+    }
+
+    @Override
+    public String getName() {
+        return null;
+    }
+
+    @Override
+    public UUID getUID() {
+        return null;
+    }
+
+    @Override
+    public boolean isChunkGenerated(int x, int z) {
+        return false;
+    }
+
+    @Override
+    public Chunk getChunkAt(int x, int z) {
+        return null;
+    }
+
+    @Override
+    public File getWorldFolder() {
+        return null;
+    }
+
+    @Override
+    public Block getBlockAt(int x, int y, int z) {
+        return null;
+    }
+
+    @Override
+    public Block getBlockAt(Location l) {
+        return null;
+    }
+
+    @Override
+    public boolean generateTree(Location l, Tree vanillaTreeType) {
+        return false;
+    }
+
+    @Override
+    public void spawn(Location location, Class<Entity> entity, Consumer<Entity> consumer) {
+
+    }
+
+    @Override
+    public Object getHandle() {
+        return null;
+    }
+}