From 92aacd1281d87229b8b28cf78ffc5eb46445bfbb Mon Sep 17 00:00:00 2001 From: Pixirora Date: Thu, 17 Aug 2023 22:09:34 -0400 Subject: [PATCH] Use a persistent MultiGenerator instance for all chunks As opposed to creating a new instance per chunk. This seems to increase generation speed quite noticeably, making it a lot more enjoyable to fly around and generate new chunks with. --- .../net/pixaurora/janerator/Janerator.java | 34 ----- .../janerator/config/GraphProperties.java | 12 +- .../janerator/config/JaneratorConfig.java | 34 ++++- .../janerator/graphing/ChunkGrapher.java | 9 +- .../janerator/graphing/GraphedChunk.java | 44 +++++-- .../janerator/mixin/ChunkStatusMixin.java | 6 +- .../worldgen/FullGeneratorLookup.java | 18 +++ ...eratorFinder.java => GeneratorLookup.java} | 4 +- .../worldgen/WrappedBiomeResolver.java | 4 +- .../worldgen/generator/MultiGenerator.java | 119 ++++++++++-------- 10 files changed, 166 insertions(+), 118 deletions(-) create mode 100644 src/main/java/net/pixaurora/janerator/worldgen/FullGeneratorLookup.java rename src/main/java/net/pixaurora/janerator/worldgen/{GeneratorFinder.java => GeneratorLookup.java} (95%) diff --git a/src/main/java/net/pixaurora/janerator/Janerator.java b/src/main/java/net/pixaurora/janerator/Janerator.java index aa467d4..4cf23ad 100644 --- a/src/main/java/net/pixaurora/janerator/Janerator.java +++ b/src/main/java/net/pixaurora/janerator/Janerator.java @@ -3,40 +3,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import net.minecraft.resources.ResourceKey; -import net.minecraft.world.level.Level; -import net.minecraft.world.level.chunk.ChunkAccess; -import net.minecraft.world.level.chunk.ChunkGenerator; -import net.minecraft.world.level.chunk.ImposterProtoChunk; -import net.minecraft.world.level.chunk.LevelChunk; -import net.pixaurora.janerator.config.GraphProperties; -import net.pixaurora.janerator.config.JaneratorConfig; -import net.pixaurora.janerator.worldgen.generator.MultiGenerator; - public class Janerator { public static final Logger LOGGER = LoggerFactory.getLogger("Janerator"); - - public static ChunkGenerator getGeneratorAt( - ResourceKey dimension, - ChunkGenerator defaultGenerator, - ChunkAccess chunk - ) { - JaneratorConfig config = JaneratorConfig.getInstance(); - - boolean chunkAlreadyGenerated = chunk instanceof LevelChunk || chunk instanceof ImposterProtoChunk; - - if (chunkAlreadyGenerated || config.missingPresetFor(dimension)) { - return defaultGenerator; - } - - GraphProperties dimensionPreset = config.getPresetFor(dimension); - - return new MultiGenerator( - dimensionPreset.getGrapher(), - defaultGenerator, - dimensionPreset.getShadedGenerator(), - dimensionPreset.getOutlineGenerator(), - chunk - ); - } } diff --git a/src/main/java/net/pixaurora/janerator/config/GraphProperties.java b/src/main/java/net/pixaurora/janerator/config/GraphProperties.java index 22bf1bc..7566b06 100644 --- a/src/main/java/net/pixaurora/janerator/config/GraphProperties.java +++ b/src/main/java/net/pixaurora/janerator/config/GraphProperties.java @@ -15,7 +15,7 @@ public class GraphProperties { private ResourceKey dimension; private ChunkGenerator shadedGenerator; - private ChunkGenerator outlineGenerator; + private ChunkGenerator outlinesGenerator; private ChunkGrapher grapher; @@ -24,14 +24,14 @@ public class GraphProperties { ResourceKey.codec(Registries.DIMENSION).fieldOf("dimension").forGetter(GraphProperties::getDimension), ConfiguredGrapherSettings.CODEC.fieldOf("function_to_graph").forGetter(GraphProperties::getSettings), ChunkGenerator.CODEC.fieldOf("shaded_in_generator").forGetter(GraphProperties::getShadedGenerator), - ChunkGenerator.CODEC.fieldOf("outlines_generator").forGetter(GraphProperties::getOutlineGenerator) + ChunkGenerator.CODEC.fieldOf("outlines_generator").forGetter(GraphProperties::getOutlinesGenerator) ).apply(instance, GraphProperties::new) ); - public GraphProperties(ResourceKey dimension, ConfiguredGrapherSettings grapherSettings, ChunkGenerator shadedGenerator, ChunkGenerator outlineGenerator) { + public GraphProperties(ResourceKey dimension, ConfiguredGrapherSettings grapherSettings, ChunkGenerator shadedGenerator, ChunkGenerator outlinesGenerator) { this.dimension = dimension; - this.outlineGenerator = outlineGenerator; + this.outlinesGenerator = outlinesGenerator; this.shadedGenerator = shadedGenerator; this.grapher = new ChunkGrapher(grapherSettings); @@ -53,7 +53,7 @@ public ChunkGenerator getShadedGenerator() { return this.shadedGenerator; } - public ChunkGenerator getOutlineGenerator() { - return this.outlineGenerator; + public ChunkGenerator getOutlinesGenerator() { + return this.outlinesGenerator; } } diff --git a/src/main/java/net/pixaurora/janerator/config/JaneratorConfig.java b/src/main/java/net/pixaurora/janerator/config/JaneratorConfig.java index 1e14882..b3f71d3 100644 --- a/src/main/java/net/pixaurora/janerator/config/JaneratorConfig.java +++ b/src/main/java/net/pixaurora/janerator/config/JaneratorConfig.java @@ -10,6 +10,8 @@ import net.minecraft.resources.ResourceKey; import net.minecraft.world.level.Level; +import net.minecraft.world.level.chunk.ChunkGenerator; +import net.pixaurora.janerator.worldgen.generator.MultiGenerator; public class JaneratorConfig { public static Codec CODEC = @@ -39,9 +41,11 @@ public static void destroy() { } private Map, GraphProperties> presets; + private Map, MultiGenerator> generators; public JaneratorConfig(List presets) { this.presets = new HashMap<>(presets.size()); + this.generators = new HashMap<>(presets.size()); for (GraphProperties preset : presets) { this.presets.put(preset.getDimension(), preset); @@ -49,9 +53,7 @@ public JaneratorConfig(List presets) { } public List getAllPresets() { - return this.presets - .values() - .stream() + return this.presets.values().stream() .toList(); } @@ -62,4 +64,30 @@ public GraphProperties getPresetFor(ResourceKey dimension) { public boolean missingPresetFor(ResourceKey dimension) { return ! this.presets.containsKey(dimension); } + + public synchronized ChunkGenerator createGenerator(ResourceKey dimension, ChunkGenerator defaultGenerator) { + GraphProperties preset = this.presets.get(dimension); + + return this.generators.computeIfAbsent( + dimension, + (dim) -> new MultiGenerator( + preset.getGrapher(), + defaultGenerator, + preset.getShadedGenerator(), + preset.getOutlinesGenerator() + ) + ); + } + + public ChunkGenerator getIntendedGenerator(ResourceKey dimension, ChunkGenerator defaultGenerator) { + if (this.missingPresetFor(dimension)) { + return defaultGenerator; + } + + if (! this.generators.containsKey(dimension)) { + return this.createGenerator(dimension, defaultGenerator); + } else { + return this.generators.get(dimension); + } + } } diff --git a/src/main/java/net/pixaurora/janerator/graphing/ChunkGrapher.java b/src/main/java/net/pixaurora/janerator/graphing/ChunkGrapher.java index 05bd261..8f7bacb 100644 --- a/src/main/java/net/pixaurora/janerator/graphing/ChunkGrapher.java +++ b/src/main/java/net/pixaurora/janerator/graphing/ChunkGrapher.java @@ -11,7 +11,7 @@ import net.minecraft.core.BlockPos; import net.minecraft.world.level.ChunkPos; -public class ChunkGrapher extends CacheLoader { +public class ChunkGrapher { private ConfiguredGrapherSettings settings; private ThreadLocal localPointGrapher; @@ -24,7 +24,7 @@ public ChunkGrapher(ConfiguredGrapherSettings settings) { this.cache = CacheBuilder.newBuilder() .expireAfterWrite(60, TimeUnit.SECONDS) .maximumSize(1024) - .build(this); + .build(CacheLoader.from(this::graphChunk)); } public ConfiguredGrapherSettings getSettings() { @@ -43,9 +43,8 @@ public CompletableFuture schedulePointGraphing(int x, int z) { return CompletableFuture.supplyAsync(() -> this.isPointShaded(x, z), GraphingUtils.threadPool); } - @Override - public GraphedChunk load(ChunkPos pos) { - return new GraphedChunk(this, pos); + private GraphedChunk graphChunk(ChunkPos pos) { + return GraphedChunk.fromGraphing(this, pos); } public GraphedChunk getChunkGraph(ChunkPos pos) { diff --git a/src/main/java/net/pixaurora/janerator/graphing/GraphedChunk.java b/src/main/java/net/pixaurora/janerator/graphing/GraphedChunk.java index dfb20da..6f57e9d 100644 --- a/src/main/java/net/pixaurora/janerator/graphing/GraphedChunk.java +++ b/src/main/java/net/pixaurora/janerator/graphing/GraphedChunk.java @@ -1,6 +1,7 @@ package net.pixaurora.janerator.graphing; import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -10,6 +11,8 @@ import net.minecraft.world.level.ChunkPos; import net.minecraft.world.level.chunk.ChunkGenerator; +import net.pixaurora.janerator.worldgen.FullGeneratorLookup; +import net.pixaurora.janerator.worldgen.generator.MultiGenerator; public class GraphedChunk { public static boolean SHADED = true; @@ -20,10 +23,13 @@ public class GraphedChunk { private ChunkGrapher grapher; - public GraphedChunk(ChunkGrapher grapher, ChunkPos pos) { + private GraphedChunk(ChunkGrapher grapher, ChunkPos pos, List shading) { this.grapher = grapher; this.pos = pos; + this.shading = shading; + } + public static GraphedChunk fromGraphing(ChunkGrapher grapher, ChunkPos pos) { List> graphingFutures = new ArrayList<>(); int startX = pos.getMinBlockX(); @@ -38,31 +44,43 @@ public GraphedChunk(ChunkGrapher grapher, ChunkPos pos) { } } - this.shading = graphingFutures - .stream() - .map(future -> GraphingUtils.completeFuture(future)) - .toList(); + return new GraphedChunk( + grapher, + pos, + graphingFutures + .stream() + .map(future -> GraphingUtils.completeFuture(future)) + .toList() + ); } - public List getGeneratorMap(ChunkGenerator defaultGenerator, ChunkGenerator modifiedGenerator, ChunkGenerator outlineGenerator) { + public static GraphedChunk allUnshaded(ChunkGrapher grapher, ChunkPos pos) { + return new GraphedChunk( + grapher, + pos, + Collections.nCopies(256, GraphedChunk.UNSHADED) + ); + } + + private List getBlockScaleMap(MultiGenerator multiGenerator) { List generatorMap = new ArrayList<>( IntStream.range(0, 256) .boxed() - .map(value -> defaultGenerator) + .map(value -> multiGenerator.getDefaultGenerator()) .toList() ); GraphingUtils.getIndices(this.shading, GraphedChunk.SHADED) .stream() - .forEach(coord -> generatorMap.set(coord.toListIndex(), modifiedGenerator)); + .forEach(coord -> generatorMap.set(coord.toListIndex(), multiGenerator.getShadedGenerator())); this.findOutlinedPortion() .stream() - .forEach(coord -> generatorMap.set(coord.toListIndex(), outlineGenerator)); + .forEach(coord -> generatorMap.set(coord.toListIndex(), multiGenerator.getOutlinesGenerator())); return generatorMap; } - public List sampleBiomeGeneratorMap(ChunkGenerator defaultGenerator, ChunkGenerator modifiedGenerator) { + private List getBiomeScaleMap(MultiGenerator multiGenerator) { List biomeGeneratorMap = new ArrayList<>(); // Because biomes are placed per every 4 blocks, we sample @@ -86,7 +104,7 @@ public List sampleBiomeGeneratorMap(ChunkGenerator defaultGenera .get().getKey(); biomeGeneratorMap.add( - sampledShade ? modifiedGenerator : defaultGenerator + sampledShade ? multiGenerator.getShadedGenerator() : multiGenerator.getDefaultGenerator() ); } } @@ -94,6 +112,10 @@ public List sampleBiomeGeneratorMap(ChunkGenerator defaultGenera return biomeGeneratorMap; } + public FullGeneratorLookup toLookup(MultiGenerator generator) { + return new FullGeneratorLookup(this.getBlockScaleMap(generator), this.getBiomeScaleMap(generator)); + } + private List findOutlinedPortion() { List outlinedPortion = new ArrayList<>(); diff --git a/src/main/java/net/pixaurora/janerator/mixin/ChunkStatusMixin.java b/src/main/java/net/pixaurora/janerator/mixin/ChunkStatusMixin.java index 9f9379f..1157cc1 100644 --- a/src/main/java/net/pixaurora/janerator/mixin/ChunkStatusMixin.java +++ b/src/main/java/net/pixaurora/janerator/mixin/ChunkStatusMixin.java @@ -8,10 +8,9 @@ import net.minecraft.resources.ResourceKey; import net.minecraft.server.level.ServerLevel; import net.minecraft.world.level.Level; -import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkGenerator; import net.minecraft.world.level.chunk.ChunkStatus; -import net.pixaurora.janerator.Janerator; +import net.pixaurora.janerator.config.JaneratorConfig; @Mixin(ChunkStatus.class) public class ChunkStatusMixin { @@ -25,10 +24,9 @@ public class ChunkStatusMixin { public void janerator$overrideGeneratorType( Args args ) { - ChunkAccess chunk = args.get(8); ResourceKey dimension = ((ServerLevel) args.get(2)).dimension(); ChunkGenerator normalGenerator = args.get(3); - args.set(3, Janerator.getGeneratorAt(dimension, normalGenerator, chunk)); + args.set(3, JaneratorConfig.getInstance().getIntendedGenerator(dimension, normalGenerator)); } } diff --git a/src/main/java/net/pixaurora/janerator/worldgen/FullGeneratorLookup.java b/src/main/java/net/pixaurora/janerator/worldgen/FullGeneratorLookup.java new file mode 100644 index 0000000..74ee654 --- /dev/null +++ b/src/main/java/net/pixaurora/janerator/worldgen/FullGeneratorLookup.java @@ -0,0 +1,18 @@ +package net.pixaurora.janerator.worldgen; + +import java.util.List; + +import net.minecraft.world.level.chunk.ChunkGenerator; + +public class FullGeneratorLookup extends GeneratorLookup { + private GeneratorLookup biomeScale; + + public FullGeneratorLookup(List blockLevelMapping, List biomeLevel) { + super(blockLevelMapping); + this.biomeScale = new GeneratorLookup(biomeLevel); + } + + public GeneratorLookup atBiomeScale() { + return this.biomeScale; + } +} diff --git a/src/main/java/net/pixaurora/janerator/worldgen/GeneratorFinder.java b/src/main/java/net/pixaurora/janerator/worldgen/GeneratorLookup.java similarity index 95% rename from src/main/java/net/pixaurora/janerator/worldgen/GeneratorFinder.java rename to src/main/java/net/pixaurora/janerator/worldgen/GeneratorLookup.java index 51d3e7a..a96b011 100644 --- a/src/main/java/net/pixaurora/janerator/worldgen/GeneratorFinder.java +++ b/src/main/java/net/pixaurora/janerator/worldgen/GeneratorLookup.java @@ -6,13 +6,13 @@ import net.pixaurora.janerator.graphing.Coordinate; import net.pixaurora.janerator.graphing.GraphingUtils; -public class GeneratorFinder { +public class GeneratorLookup { private List generatorMap; private List selections; private ChunkGenerator fallbackGenerator; - public GeneratorFinder( + public GeneratorLookup( List generatorMap ) { this.generatorMap = generatorMap; diff --git a/src/main/java/net/pixaurora/janerator/worldgen/WrappedBiomeResolver.java b/src/main/java/net/pixaurora/janerator/worldgen/WrappedBiomeResolver.java index 5563f64..2119bf5 100644 --- a/src/main/java/net/pixaurora/janerator/worldgen/WrappedBiomeResolver.java +++ b/src/main/java/net/pixaurora/janerator/worldgen/WrappedBiomeResolver.java @@ -22,12 +22,12 @@ import net.pixaurora.janerator.mixin.NoiseChunkAccessor; public class WrappedBiomeResolver implements BiomeResolver { - GeneratorFinder generators; + GeneratorLookup generators; Map biomeResolvers; Map samplers; public WrappedBiomeResolver( - GeneratorFinder generators, + GeneratorLookup generators, Blender blender, ChunkAccess chunk, StructureManager structureManager, diff --git a/src/main/java/net/pixaurora/janerator/worldgen/generator/MultiGenerator.java b/src/main/java/net/pixaurora/janerator/worldgen/generator/MultiGenerator.java index a9c53d6..f0a7475 100644 --- a/src/main/java/net/pixaurora/janerator/worldgen/generator/MultiGenerator.java +++ b/src/main/java/net/pixaurora/janerator/worldgen/generator/MultiGenerator.java @@ -2,8 +2,13 @@ import java.util.List; import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor; +import java.util.concurrent.TimeUnit; +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; import com.mojang.serialization.Codec; import net.minecraft.core.BlockPos; @@ -18,6 +23,8 @@ import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkGenerator; import net.minecraft.world.level.chunk.ChunkGeneratorStructureState; +import net.minecraft.world.level.chunk.ImposterProtoChunk; +import net.minecraft.world.level.chunk.LevelChunk; import net.minecraft.world.level.levelgen.GenerationStep; import net.minecraft.world.level.levelgen.Heightmap; import net.minecraft.world.level.levelgen.RandomState; @@ -25,81 +32,91 @@ import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager; import net.pixaurora.janerator.graphing.ChunkGrapher; import net.pixaurora.janerator.graphing.GraphedChunk; -import net.pixaurora.janerator.worldgen.GeneratorFinder; +import net.pixaurora.janerator.worldgen.FullGeneratorLookup; import net.pixaurora.janerator.worldgen.PlacementSelection; import net.pixaurora.janerator.worldgen.WrappedBiomeResolver; public class MultiGenerator extends ChunkGenerator { - private boolean generatorsMapped; - private ChunkGenerator defaultGenerator; - private ChunkGenerator modifiedGenerator; - private ChunkGenerator outlineGenerator; + private ChunkGrapher grapher; - private ChunkPos pos; + private ChunkGenerator defaultGenerator; + private ChunkGenerator shadedGenerator; + private ChunkGenerator outlinesGenerator; - private GeneratorFinder generators; - private GeneratorFinder biomeGenerators; + private LoadingCache selectionCache; public MultiGenerator( ChunkGrapher grapher, ChunkGenerator defaultGenerator, - ChunkGenerator modifiedGenerator, - ChunkGenerator outlineGenerator, - ChunkAccess chunk + ChunkGenerator shadedGenerator, + ChunkGenerator outlinesGenerator ) { super(defaultGenerator.getBiomeSource()); - this.generatorsMapped = false; + this.grapher = grapher; this.defaultGenerator = defaultGenerator; - this.modifiedGenerator = modifiedGenerator; - this.outlineGenerator = outlineGenerator; + this.shadedGenerator = shadedGenerator; + this.outlinesGenerator = outlinesGenerator; - this.pos = chunk.getPos(); + this.selectionCache = CacheBuilder.newBuilder() + .maximumSize(1024) + .expireAfterAccess(60, TimeUnit.SECONDS) + .build(CacheLoader.from(pos -> this.grapher.getChunkGraph(pos).toLookup(this))); - for (ChunkGenerator generator : List.of(this, defaultGenerator, modifiedGenerator, outlineGenerator)) { + for (ChunkGenerator generator : List.of(this, defaultGenerator, shadedGenerator, outlinesGenerator)) { generator.janerator$setupMultiGenerating(grapher, this); } } - @Override - public MultiGenerator janerator$getParent() { - throw new RuntimeException("MultiGenerator cannot have a MultiGenerator parent."); + public ChunkGrapher getGrapher() { + return this.grapher; } - @Override - public Codec codec() { - return CODEC; - } - - private void organizeGenerators() { - GraphedChunk graphedArea = this.janerator$getGrapher().getChunkGraph(pos); + public ChunkGenerator getDefaultGenerator() { + return this.defaultGenerator; + } - this.generators = new GeneratorFinder(graphedArea.getGeneratorMap(this.defaultGenerator, this.modifiedGenerator, this.outlineGenerator)); - this.biomeGenerators = new GeneratorFinder(graphedArea.sampleBiomeGeneratorMap(this.defaultGenerator, this.modifiedGenerator)); + public ChunkGenerator getShadedGenerator() { + return this.shadedGenerator; + } - this.generatorsMapped = true; + public ChunkGenerator getOutlinesGenerator() { + return this.outlinesGenerator; } - private GeneratorFinder getGenerators() { - if (!generatorsMapped) { - this.organizeGenerators(); + public FullGeneratorLookup getGenerators(ChunkPos pos) { + try { + return this.selectionCache.get(pos); + } catch (ExecutionException e) { + throw new RuntimeException(e); } - - return this.generators; } - private GeneratorFinder getBiomeGenerators() { - if (!generatorsMapped) { - this.organizeGenerators(); + public FullGeneratorLookup getGenerators(ChunkAccess chunk) { + ChunkPos pos = chunk.getPos(); + + boolean chunkAlreadyGenerated = chunk instanceof LevelChunk || chunk instanceof ImposterProtoChunk; + if (chunkAlreadyGenerated) { + this.selectionCache.put(pos, GraphedChunk.allUnshaded(grapher, pos).toLookup(this)); } - return this.biomeGenerators; + return this.getGenerators(pos); + } + + @Override + public MultiGenerator janerator$getParent() { + throw new RuntimeException("MultiGenerator cannot have a MultiGenerator parent."); } + @Override + public Codec codec() { + return CODEC; + } + @Override public void buildSurface(WorldGenRegion region, StructureManager structureManager, RandomState randomState, ChunkAccess chunk) { - for (PlacementSelection selection : this.getGenerators().getAllSelections()) { + for (PlacementSelection selection : this.getGenerators(chunk).getAllSelections()) { selection.getUsedGenerator().buildSurface( region, structureManager, @@ -113,7 +130,7 @@ public void buildSurface(WorldGenRegion region, StructureManager structureManage @Override public int getSpawnHeight(LevelHeightAccessor world) { - return this.getGenerators().getDefault().getSpawnHeight(world); + return this.defaultGenerator.getSpawnHeight(world); } @Override @@ -123,7 +140,7 @@ public CompletableFuture fillFromNoise( CompletableFuture placeholderFuture = new CompletableFuture<>(); CompletableFuture future = placeholderFuture; - for(PlacementSelection selection : this.getGenerators().getAllSelections()) { + for(PlacementSelection selection : this.getGenerators(chunk).getAllSelections()) { future = future.thenCompose( access -> selection.getUsedGenerator().fillFromNoise( executor, @@ -145,12 +162,12 @@ public CompletableFuture fillFromNoise( @Override public int getBaseHeight(int x, int z, Heightmap.Types heightmap, LevelHeightAccessor world, RandomState randomState) { - return this.modifiedGenerator.getBaseHeight(x, z, heightmap, world, randomState); + return this.shadedGenerator.getBaseHeight(x, z, heightmap, world, randomState); } @Override public NoiseColumn getBaseColumn(int x, int z, LevelHeightAccessor world, RandomState randomState) { - return this.modifiedGenerator.getBaseColumn(x, z, world, randomState); + return this.shadedGenerator.getBaseColumn(x, z, world, randomState); } @Override @@ -164,7 +181,7 @@ public CompletableFuture createBiomes( () -> { chunk.fillBiomesFromNoise( new WrappedBiomeResolver( - this.getBiomeGenerators(), + this.getGenerators(chunk).atBiomeScale(), blender, chunk, structureManager, @@ -187,7 +204,7 @@ public void applyCarvers( ChunkAccess chunk, GenerationStep.Carving generationStep ) { - for (PlacementSelection selection : this.getGenerators().getAllSelections()) { + for (PlacementSelection selection : this.getGenerators(chunk).getAllSelections()) { selection.getUsedGenerator().applyCarvers( chunkRegion, seed, @@ -204,12 +221,12 @@ public void applyCarvers( @Override public void spawnOriginalMobs(WorldGenRegion region) { - this.getGenerators().getDefault().spawnOriginalMobs(region); + this.getGenerators(region.getCenter()).getDefault().spawnOriginalMobs(region); } @Override public void applyBiomeDecoration(WorldGenLevel world, ChunkAccess chunk, StructureManager structureManager) { - for (PlacementSelection selection : this.getGenerators().getAllSelections()) { + for (PlacementSelection selection : this.getGenerators(chunk).getAllSelections()) { selection.getUsedGenerator().applyBiomeDecoration( world, chunk, @@ -228,7 +245,7 @@ public void createStructures( ChunkAccess chunk, StructureTemplateManager templateManager ) { - for (PlacementSelection selection : this.getGenerators().getAllSelections()) { + for (PlacementSelection selection : this.getGenerators(chunk).getAllSelections()) { selection.getUsedGenerator().createStructures( registryManager, chunkGeneratorStructureState, @@ -241,16 +258,16 @@ public void createStructures( @Override public int getMinY() { - return 0; + return defaultGenerator.getMinY(); } @Override public int getGenDepth() { - return 384; + return defaultGenerator.getGenDepth(); } @Override public int getSeaLevel() { - return -63; + return defaultGenerator.getSeaLevel(); } }