Fixed everything

common/src/main/java/com/seibel/lod/common/clouds/CloudTexture.java

@@ -3,7 +3,7 @@ package com.seibel.lod.common.clouds;
 import com.mojang.blaze3d.platform.NativeImage;
 import net.minecraft.client.renderer.texture.DynamicTexture;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.levelgen.SimpleRandomSource;
+import net.minecraft.world.level.levelgen.WorldgenRandom;
 import net.minecraft.world.level.levelgen.synth.SimplexNoise;
 
 import java.util.*;
@@ -57,8 +57,8 @@ public class CloudTexture {
 
     /** Generates the noise at the start of the game */
     public void initNoise(Random random) {
-//        this.noise = new SimplexNoise(new WorldgenRandom(random.nextLong()));
-        this.noise = new SimplexNoise(new SimpleRandomSource(random.nextLong()));
+        this.noise = new SimplexNoise(new WorldgenRandom(random.nextLong()));
+//        this.noise = new SimplexNoise(new LegacyRandomSource(random.nextLong()));
     }
 
     public DynamicTexture getNativeImage() {

common/src/main/java/com/seibel/lod/common/wrappers/chunk/ChunkWrapper.java

@@ -69,7 +69,6 @@ public class ChunkWrapper implements IChunkWrapper
     @Override
     public IBiomeWrapper getBiome(int x, int y, int z)
     {
-    	
         return BiomeWrapper.getBiomeWrapper(chunk.getBiomes().getNoiseBiome((x & CHUNK_SIZE_MASK) >> 2, y >> 2, (z & CHUNK_SIZE_MASK) >> 2));
     }
 

common/src/main/java/com/seibel/lod/common/wrappers/minecraft/MinecraftRenderWrapper.java

@@ -11,8 +11,8 @@ import com.seibel.lod.common.wrappers.misc.LightMapWrapper;
 import com.seibel.lod.core.api.ModAccessorApi;
 import com.seibel.lod.core.util.LodUtil;
 
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import net.minecraft.client.renderer.LightTexture;
-import net.minecraft.client.renderer.LevelRenderer.RenderChunkInfo;
 
 import com.mojang.math.Vector3f;
 import com.seibel.lod.core.objects.math.Mat4f;
@@ -22,9 +22,6 @@ import com.seibel.lod.core.wrapperInterfaces.block.AbstractBlockPosWrapper;
 import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
 import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.ISodiumAccessor;
-
-import it.unimi.dsi.fastutil.objects.ObjectArrayList;
-
 import com.seibel.lod.common.wrappers.McObjectConverter;
 import com.seibel.lod.common.wrappers.WrapperFactory;
 import com.seibel.lod.common.wrappers.block.BlockPosWrapper;
@@ -153,7 +150,7 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
             return sodium.getNormalRenderedChunks();
         }
         LevelRenderer levelRenderer = MC.levelRenderer;
-        ObjectArrayList<RenderChunkInfo> chunks = levelRenderer.renderChunks;
+        ObjectArrayList<LevelRenderer.RenderChunkInfo> chunks = levelRenderer.renderChunks;
         return (chunks.stream().map((chunk) -> {
             AABB chunkBoundingBox = chunk.chunk.bb;
             return FACTORY.createChunkPos(Math.floorDiv((int) chunkBoundingBox.minX, 16),

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/LodServerWorld.java

@@ -0,0 +1,357 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers.worldGeneration;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import com.seibel.lod.core.util.LodUtil;
+import com.seibel.lod.common.wrappers.WrapperUtil;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.SectionPos;
+import net.minecraft.core.particles.ParticleOptions;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.DifficultyInstance;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.EmptyTickList;
+import net.minecraft.world.level.TickList;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.BiomeManager;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.border.WorldBorder;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkSource;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.entity.EntityTypeTest;
+import net.minecraft.world.level.gameevent.GameEvent;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.levelgen.feature.StructureFeature;
+import net.minecraft.world.level.levelgen.structure.StructureStart;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.level.storage.LevelData;
+import net.minecraft.world.phys.AABB;
+import org.jetbrains.annotations.Nullable;
+
+
+/**
+ * This is a fake ServerWorld used when generating features.
+ * It allows us to keep each LodChunk generation independent
+ * of the actual ServerWorld, allowing
+ * multithread generation.
+ *
+ * @author James Seibel
+ * @version 7-26-2021
+ */
+public class LodServerWorld implements WorldGenLevel
+{
+
+    public HashMap<Heightmap.Types, Heightmap> heightmaps = new HashMap<>();
+
+    public final ChunkAccess chunk;
+
+    public final ServerLevel serverWorld;
+
+    public LodServerWorld(ServerLevel newServerWorld, ChunkAccess newChunk)
+    {
+        chunk = newChunk;
+        serverWorld = newServerWorld;
+    }
+
+
+    @Override
+    public int getHeight(Heightmap.Types heightmapType, int x, int z)
+    {
+        // make sure the block position is set relative to the chunk
+        x = x % LodUtil.CHUNK_WIDTH;
+        x = (x < 0) ? x + 16 : x;
+
+        z = z % LodUtil.CHUNK_WIDTH;
+        z = (z < 0) ? z + 16 : z;
+
+        return chunk.getOrCreateHeightmapUnprimed(WrapperUtil.DEFAULT_HEIGHTMAP).getFirstAvailable(x, z);
+    }
+
+    @Override
+    public Biome getBiome(BlockPos pos)
+    {
+        return chunk.getBiomes().getNoiseBiome(pos.getX() >> 2, pos.getY() >> 2, pos.getZ() >> 2);
+    }
+
+    @Override
+    public boolean setBlock(BlockPos pos, BlockState state, int flags, int recursionLeft)
+    {
+        return chunk.setBlockState(pos, state, false) == state;
+    }
+
+    @Override
+    public BlockState getBlockState(BlockPos pos)
+    {
+        return chunk.getBlockState(pos);
+    }
+
+    @Override
+    public FluidState getFluidState(BlockPos pos)
+    {
+        return chunk.getFluidState(pos);
+    }
+
+
+    @Override
+    public boolean isStateAtPosition(BlockPos pos, Predicate<BlockState> state)
+    {
+        return state.test(chunk.getBlockState(pos));
+    }
+
+    @Override
+    public boolean isFluidAtPosition(BlockPos blockPos, Predicate<FluidState> predicate) {
+        return predicate.test(chunk.getFluidState(blockPos));
+    }
+
+    @Override
+    public TickList<Block> getBlockTicks()
+    {
+        return EmptyTickList.empty();
+    }
+
+    @Override
+    public ChunkAccess getChunk(int x, int z, ChunkStatus requiredStatus, boolean nonnull)
+    {
+        return chunk;
+    }
+
+    @Override
+    public Stream<? extends StructureStart<?>> startsForFeature(SectionPos p_241827_1_, StructureFeature<?> p_241827_2_)
+    {
+        return serverWorld.startsForFeature(p_241827_1_, p_241827_2_);
+    }
+
+    @Override
+    public TickList<Fluid> getLiquidTicks()
+    {
+        return EmptyTickList.empty();
+    }
+
+    @Override
+    public LevelLightEngine getLightEngine()
+    {
+        return new LevelLightEngine(null, false, false);
+    }
+
+    @Override
+    public long getSeed()
+    {
+        return serverWorld.getSeed();
+    }
+
+    @Override
+    public RegistryAccess registryAccess()
+    {
+        return serverWorld.registryAccess();
+    }
+
+
+    /**
+     * All methods below shouldn't be needed
+     * and thus have been left unimplemented.
+     */
+
+
+    @Override
+    public Random getRandom()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public void playSound(Player player, BlockPos pos, SoundEvent soundIn, SoundSource category, float volume,
+                          float pitch)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public void addParticle(ParticleOptions particleData, double x, double y, double z, double xSpeed, double ySpeed,
+                            double zSpeed)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public BiomeManager getBiomeManager()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public int getSeaLevel()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public float getShade(Direction p_230487_1_, boolean p_230487_2_)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public WorldBorder getWorldBorder()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public boolean removeBlock(BlockPos pos, boolean isMoving)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public boolean destroyBlock(BlockPos pos, boolean dropBlock, Entity entity, int recursionLeft)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public ServerLevel getLevel()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public ChunkSource getChunkSource()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public DifficultyInstance getCurrentDifficultyAt(BlockPos arg0)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Nullable
+    @Override
+    public MinecraftServer getServer() {
+        return serverWorld.getServer();
+    }
+
+
+    @Override
+    public LevelData getLevelData()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public void levelEvent(Player arg0, int arg1, BlockPos arg2, int arg3)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+
+    }
+
+    // TODO: Check if this causes any issues
+    @Override
+    public void gameEvent(@Nullable Entity entity, GameEvent gameEvent, BlockPos blockPos) {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public List<Entity> getEntities(Entity arg0, AABB arg1, Predicate<? super Entity> arg2)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+    @Override
+    public <T extends Entity> List<T> getEntities(EntityTypeTest<Entity, T> entityTypeTest, AABB aABB, Predicate<? super T> predicate) {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public <T extends Entity> List<T> getEntitiesOfClass(Class<T> arg0, AABB arg1,
+                                                         Predicate<? super T> arg2)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public List<? extends Player> players()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public int getSkyDarken()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public Biome getUncachedNoiseBiome(int p_225604_1_, int p_225604_2_, int p_225604_3_)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public boolean isClientSide()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public DimensionType dimensionType()
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+
+    @Override
+    public BlockEntity getBlockEntity(BlockPos p_175625_1_)
+    {
+        throw new UnsupportedOperationException("Not Implemented");
+    }
+
+}

fabric/src/main/java/com/seibel/lod/fabric/modAccessor/SodiumAccessor.java

@@ -20,25 +20,26 @@ public class SodiumAccessor implements ISodiumAccessor {
 
     @Override
     public String getModName() {
-        return "Sodium-Fabric-1.18.X";
+        return "Sodium-Fabric-1.17.1";
     }
 
     @Override
     public HashSet<AbstractChunkPosWrapper> getNormalRenderedChunks() {
-        SodiumWorldRenderer renderer = SodiumWorldRenderer.instance();
-        LevelHeightAccessor height =  Minecraft.getInstance().level;
-        // 0b11 = Lighted chunk & loaded chunk
-        return renderer.getChunkTracker().getChunks(0b11).filter(
-                (long l) -> {
-                    for (int i = height.getMinSection(); i<height.getMaxSection(); i++) {
-                        SectionPos p = SectionPos.of(new ChunkPos(l), i);
-                        if (renderer.isBoxVisible(p.minBlockX()+1, p.minBlockY()+1, p.minBlockZ()+1,
-                                p.maxBlockX()-1, p.maxBlockY()-1, p.maxBlockZ()-1)) return true;
-                    }
-                    return false;
-                }).mapToObj((long l) -> {
-            return (AbstractChunkPosWrapper)factory.createChunkPos(l);
-        }).collect(Collectors.toCollection(HashSet::new));
+//        SodiumWorldRenderer renderer = SodiumWorldRenderer.instance();
+//        LevelHeightAccessor height =  Minecraft.getInstance().level;
+//        // 0b11 = Lighted chunk & loaded chunk
+//        return renderer.getChunkTracker().getChunks(0b11).filter(
+//                (long l) -> {
+//                    for (int i = height.getMinSection(); i<height.getMaxSection(); i++) {
+//                        SectionPos p = SectionPos.of(new ChunkPos(l), i);
+//                        if (renderer.isBoxVisible(p.minBlockX()+1, p.minBlockY()+1, p.minBlockZ()+1,
+//                                p.maxBlockX()-1, p.maxBlockY()-1, p.maxBlockZ()-1)) return true;
+//                    }
+//                    return false;
+//                }).mapToObj((long l) -> {
+//            return (AbstractChunkPosWrapper)factory.createChunkPos(l);
+//        }).collect(Collectors.toCollection(HashSet::new));
+        return null;
     }
 
 }

gradle.properties

@@ -9,14 +9,14 @@ toml_version=3.6.0
 
 
 # Fabric loader
-fabric_loader_version=0.12.12
-fabric_api_version=0.44.0+1.18
+fabric_loader_version=0.12.6
+fabric_api_version=0.37.1+1.17
     # Fabric mods
-    modmenu_version=3.0.0
+    modmenu_version=2.0.14
     sodium_version=mc1.17.1-0.3.3
 #    iris_version=1.17.x-v1.1.4
 
 # Forge loader
-forge_version=39.0.5
+forge_version=37.1.0
     # Forge mods
     ## currentlly no mods ##