Repo-Mirror/Leaf
9
0
Fork 0
mirror of https://github.com/Winds-Studio/Leaf.git synced 2025-12-19 15:09:25 +00:00
Code Issues Releases Activity
Files
e380e4b573b5826e1d01d2fed08faf015c2b28b6
Leaf/patches/server/0069-Faster-Random-Generator.patch
Kobe ⑧ 6dcdba5d9c Virtual thread for User Authenticator (#191)
2024-12-31 21:51:59 -05:00

539 lines
34 KiB
Diff
Raw Blame History

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: HaHaWTH <102713261+HaHaWTH@users.noreply.github.com>
Date: Tue, 9 Nov 2077 00:00:00 +0800
Subject: [PATCH] Faster Random Generator
This patch replaces LegacyRandomSource with FasterRandomSource by default,
which is faster in general.
Benchmark results (10,000,000 iterations) (GraalVM 21)
SimpleRandom (Moonrise): 80ms
FasterRandomSource (Leaf) (Backed by Xoroshiro128PlusPlus): 35ms
LegacyRandomSource (Vanilla): 200ms
XoroshiroRandomSource (Vanilla): 47ms
diff --git a/src/main/java/net/minecraft/util/RandomSource.java b/src/main/java/net/minecraft/util/RandomSource.java
index 252aef3ffe0fecd47ebea1ed7df48e14fa873eb9..5b4599927effca11293b367c5bac4541570df06c 100644
--- a/src/main/java/net/minecraft/util/RandomSource.java
+++ b/src/main/java/net/minecraft/util/RandomSource.java
@@ -15,18 +15,32 @@ public interface RandomSource {
return create(RandomSupport.generateUniqueSeed());
}
+ // Leaf start - Faster random generator
@Deprecated
static RandomSource createThreadSafe() {
- return new ThreadSafeLegacyRandomSource(RandomSupport.generateUniqueSeed());
+ return org.dreeam.leaf.config.modules.opt.FastRNG.enabled
+ ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed())
+ : new ThreadSafeLegacyRandomSource(RandomSupport.generateUniqueSeed());
}
static RandomSource create(long seed) {
- return new LegacyRandomSource(seed);
+ return org.dreeam.leaf.config.modules.opt.FastRNG.enabled
+ ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed)
+ : new LegacyRandomSource(seed);
+ }
+
+ static RandomSource createForSlimeChunk(long seed) {
+ return org.dreeam.leaf.config.modules.opt.FastRNG.enabled && !org.dreeam.leaf.config.modules.opt.FastRNG.useLegacyForSlimeChunk
+ ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed)
+ : new LegacyRandomSource(seed);
}
static RandomSource createNewThreadLocalInstance() {
- return new SingleThreadedRandomSource(ThreadLocalRandom.current().nextLong());
+ return org.dreeam.leaf.config.modules.opt.FastRNG.enabled
+ ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed())
+ : new SingleThreadedRandomSource(ThreadLocalRandom.current().nextLong());
}
+ // Leaf end - Faster random generator
RandomSource fork();
diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
index ee64667e5c33afd68d4458bffd858c66db4c1421..8ac2b3a17d1a9df6695c8034b71544704be23036 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
@@ -184,7 +184,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
}
// Paper start - Share random for entities to make them more random
- public static RandomSource SHARED_RANDOM = new RandomRandomSource();
+ public static RandomSource SHARED_RANDOM = org.dreeam.leaf.config.modules.opt.FastRNG.enabled ? org.dreeam.leaf.util.math.random.FasterRandomSource.SHARED_INSTANCE : new RandomRandomSource(); // Leaf - Faster random generator
// Paper start - replace random
private static final class RandomRandomSource extends ca.spottedleaf.moonrise.common.util.ThreadUnsafeRandom {
public RandomRandomSource() {
diff --git a/src/main/java/net/minecraft/world/level/biome/Biome.java b/src/main/java/net/minecraft/world/level/biome/Biome.java
index b725eea9d3ca81d2ef7802f5d0346d924aa1f808..c669c64189b9ae3ddd871290d18e54e3aa7463ea 100644
--- a/src/main/java/net/minecraft/world/level/biome/Biome.java
+++ b/src/main/java/net/minecraft/world/level/biome/Biome.java
@@ -50,14 +50,14 @@ public final class Biome {
);
public static final Codec<Holder<Biome>> CODEC = RegistryFileCodec.create(Registries.BIOME, DIRECT_CODEC);
public static final Codec<HolderSet<Biome>> LIST_CODEC = RegistryCodecs.homogeneousList(Registries.BIOME, DIRECT_CODEC);
- private static final PerlinSimplexNoise TEMPERATURE_NOISE = new PerlinSimplexNoise(new WorldgenRandom(new LegacyRandomSource(1234L)), ImmutableList.of(0));
+ private static final PerlinSimplexNoise TEMPERATURE_NOISE = new PerlinSimplexNoise(new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(1234L) : new LegacyRandomSource(1234L)), ImmutableList.of(0)); // Leaf - Faster random generator
static final PerlinSimplexNoise FROZEN_TEMPERATURE_NOISE = new PerlinSimplexNoise(
- new WorldgenRandom(new LegacyRandomSource(3456L)), ImmutableList.of(-2, -1, 0)
+ new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(3456L) : new LegacyRandomSource(3456L)), ImmutableList.of(-2, -1, 0) // Leaf - Faster random generator
);
@Deprecated(
forRemoval = true
)
- public static final PerlinSimplexNoise BIOME_INFO_NOISE = new PerlinSimplexNoise(new WorldgenRandom(new LegacyRandomSource(2345L)), ImmutableList.of(0));
+ public static final PerlinSimplexNoise BIOME_INFO_NOISE = new PerlinSimplexNoise(new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(2345L) : new LegacyRandomSource(2345L)), ImmutableList.of(0)); // Leaf - Faster random generator
private static final int TEMPERATURE_CACHE_SIZE = 1024;
public final Biome.ClimateSettings climateSettings;
private final BiomeGenerationSettings generationSettings;
diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
index 1582771de72f713c155427587feea73ca7b4b273..c731c13f69dcf92de539707ccddc7089192a2f7c 100644
--- a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
+++ b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
@@ -494,7 +494,7 @@ public abstract class ChunkGenerator {
int x = ichunkaccess.getPos().x;
int z = ichunkaccess.getPos().z;
for (org.bukkit.generator.BlockPopulator populator : world.getPopulators()) {
- WorldgenRandom seededrandom = new WorldgenRandom(new net.minecraft.world.level.levelgen.LegacyRandomSource(generatoraccessseed.getSeed()));
+ WorldgenRandom seededrandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(generatoraccessseed.getSeed()) : new net.minecraft.world.level.levelgen.LegacyRandomSource(generatoraccessseed.getSeed())); // Leaf - Faster random generator
seededrandom.setDecorationSeed(generatoraccessseed.getSeed(), x, z);
populator.populate(world, new org.bukkit.craftbukkit.util.RandomSourceWrapper.RandomWrapper(seededrandom), x, z, limitedRegion);
}
@@ -594,7 +594,7 @@ public abstract class ChunkGenerator {
chunkcoordintpair.x, chunkcoordintpair.z, su.plo.matter.Globals.Salt.GENERATE_FEATURE, 0
);
} else {
- seededrandom = new WorldgenRandom(new LegacyRandomSource(0L));
+ seededrandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator
seededrandom.setLargeFeatureSeed(placementCalculator.getLevelSeed(), chunkcoordintpair.x, chunkcoordintpair.z);
}
diff --git a/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java b/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java
index ac8447e20531ad59d5e26c6db541d6e844d56c0f..0dab53e8e99e7de71cbd2d22a283b49bac635178 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java
@@ -521,7 +521,7 @@ public final class DensityFunctions {
// Paper end - Perf: Optimize end generation
public EndIslandDensityFunction(long seed) {
- RandomSource randomSource = new LegacyRandomSource(seed);
+ RandomSource randomSource = org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed) : new LegacyRandomSource(seed); // Leaf - Faster random generator
randomSource.consumeCount(17292);
this.islandNoise = new SimplexNoise(randomSource);
}
diff --git a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
index aa63b49738ef42122e7cd0f9dbec0d019c9b97b0..bd0eaa7d5253fd4ea9f9a6f0c7bfcf11fbc675a7 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
@@ -232,7 +232,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
BiomeManager biomemanager1 = biomeAccess.withDifferentSource((j, k, l) -> {
return this.biomeSource.getNoiseBiome(j, k, l, noiseConfig.sampler());
});
- WorldgenRandom seededrandom = new WorldgenRandom(new LegacyRandomSource(RandomSupport.generateUniqueSeed()));
+ WorldgenRandom seededrandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed()) : new LegacyRandomSource(RandomSupport.generateUniqueSeed())); // Leaf - Faster random generator
boolean flag = true;
ChunkPos chunkcoordintpair = chunk.getPos();
NoiseChunk noisechunk = chunk.getOrCreateNoiseChunk((ichunkaccess1) -> {
@@ -427,7 +427,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
if (!((NoiseGeneratorSettings) this.settings.value()).disableMobGeneration()) {
ChunkPos chunkcoordintpair = region.getCenter();
Holder<Biome> holder = region.getBiome(chunkcoordintpair.getWorldPosition().atY(region.getMaxY()));
- WorldgenRandom seededrandom = new WorldgenRandom(new LegacyRandomSource(RandomSupport.generateUniqueSeed()));
+ WorldgenRandom seededrandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed()) : new LegacyRandomSource(RandomSupport.generateUniqueSeed())); // Leaf - Faster random generator
seededrandom.setDecorationSeed(region.getSeed(), chunkcoordintpair.getMinBlockX(), chunkcoordintpair.getMinBlockZ());
NaturalSpawner.spawnMobsForChunkGeneration(region, holder, chunkcoordintpair, seededrandom);
diff --git a/src/main/java/net/minecraft/world/level/levelgen/WorldgenRandom.java b/src/main/java/net/minecraft/world/level/levelgen/WorldgenRandom.java
index c6efe6faf68c7a7b1df344e2e527aa7e44bfacb8..fe89e7b7c4267ee2969d1505f83cba1ac17cb13e 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/WorldgenRandom.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/WorldgenRandom.java
@@ -69,9 +69,9 @@ public class WorldgenRandom extends LegacyRandomSource {
}
public static RandomSource seedSlimeChunk(int chunkX, int chunkZ, long worldSeed, long scrambler) {
- return RandomSource.create(
+ return RandomSource.createForSlimeChunk(
worldSeed + (long)(chunkX * chunkX * 4987142) + (long)(chunkX * 5947611) + (long)(chunkZ * chunkZ) * 4392871L + (long)(chunkZ * 389711) ^ scrambler
- );
+ ); // Leaf - Faster RNG
}
public static enum Algorithm {
diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java b/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
index 56888e150a48cf338ecec591d47c979b5c24ad4d..321eb6b9f6ae244c74b801a7d6556dceb82a19dc 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
@@ -44,7 +44,7 @@ public class GeodeFeature extends Feature<GeodeConfiguration> {
// Leaf start - Matter - Feature Secure Seed
WorldgenRandom worldgenRandom = org.dreeam.leaf.config.modules.misc.SecureSeed.enabled
? new su.plo.matter.WorldgenCryptoRandom(0, 0, su.plo.matter.Globals.Salt.GEODE_FEATURE, 0)
- : new WorldgenRandom(new LegacyRandomSource(worldGenLevel.getSeed()));
+ : new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(worldGenLevel.getSeed()) : new LegacyRandomSource(worldGenLevel.getSeed())); // Leaf - Faster random generator
// Leaf end - Matter - Feature Secure Seed
NormalNoise normalNoise = NormalNoise.create(worldgenRandom, -4, 1.0);
List<BlockPos> list2 = Lists.newLinkedList();
diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/DualNoiseProvider.java b/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/DualNoiseProvider.java
index c7eabcbf9132c5dac1e376332f563d8912447b03..8b8cef5f8e73185ea2f8143fbd4fb5f5afc9ef6e 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/DualNoiseProvider.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/DualNoiseProvider.java
@@ -43,7 +43,7 @@ public class DualNoiseProvider extends NoiseProvider {
this.variety = variety;
this.slowNoiseParameters = slowNoiseParameters;
this.slowScale = slowScale;
- this.slowNoise = NormalNoise.create(new WorldgenRandom(new LegacyRandomSource(seed)), slowNoiseParameters);
+ this.slowNoise = NormalNoise.create(new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed) : new LegacyRandomSource(seed)), slowNoiseParameters); // Leaf - Faster random generator
}
@Override
diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/NoiseBasedStateProvider.java b/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/NoiseBasedStateProvider.java
index 990457fb23d22c3b8732d70da54ac5aaed8221db..f55475b812fd989d076c7715b8f060ab8f9ddd26 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/NoiseBasedStateProvider.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/NoiseBasedStateProvider.java
@@ -28,7 +28,7 @@ public abstract class NoiseBasedStateProvider extends BlockStateProvider {
this.seed = seed;
this.parameters = noiseParameters;
this.scale = scale;
- this.noise = NormalNoise.create(new WorldgenRandom(new LegacyRandomSource(seed)), noiseParameters);
+ this.noise = NormalNoise.create(new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed) : new LegacyRandomSource(seed)), noiseParameters); // Leaf - Faster random generator
}
protected double getNoiseValue(BlockPos pos, double scale) {
diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/Structure.java b/src/main/java/net/minecraft/world/level/levelgen/structure/Structure.java
index c10efc79d2cab84703fa4ee6267e12b856f8e248..fb44cb370bdda8d161603ab06851dea6cbbc9d08 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/structure/Structure.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/structure/Structure.java
@@ -240,7 +240,7 @@ public abstract class Structure {
);
}
// Leaf end - Matter - Feature Secure Seed
- WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+ WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator
worldgenRandom.setLargeFeatureSeed(seed, chunkPos.x, chunkPos.z);
return worldgenRandom;
}
diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java
index 5ae511a5a178b0202e6a60cb882fca37a2a92fd4..c763b8a11786d8d746ee72218805aad601deaad4 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java
@@ -78,7 +78,7 @@ public class RandomSpreadStructurePlacement extends StructurePlacement {
i, j, su.plo.matter.Globals.Salt.POTENTIONAL_FEATURE, this.salt
);
} else {
- worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+ worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator
worldgenRandom.setLargeFeatureWithSalt(seed, i, j, this.salt());
}
// Leaf end - Matter - Feature Secure Seed
diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
index d97bb945f59dc7d8da1374fda5beee0d6d0f0f5d..9973f89e65a6a6f7edfbd40b722f1d7b030872d5 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
@@ -125,7 +125,7 @@ public abstract class StructurePlacement {
chunkX, chunkZ, su.plo.matter.Globals.Salt.UNDEFINED, salt
);
} else {
- worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+ worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator
worldgenRandom.setLargeFeatureWithSalt(seed, salt, chunkX, chunkZ);
}
// Leaf end - Matter - Feature Secure Seed
@@ -134,7 +134,7 @@ public abstract class StructurePlacement {
}
private static boolean legacyProbabilityReducerWithDouble(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - Add missing structure set seed configs
- WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+ WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator
if (saltOverride == null) { // Paper - Add missing structure set seed configs
worldgenRandom.setLargeFeatureSeed(seed, chunkX, chunkZ);
// Paper start - Add missing structure set seed configs
@@ -146,7 +146,7 @@ public abstract class StructurePlacement {
}
private static boolean legacyArbitrarySaltProbabilityReducer(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - Add missing structure set seed configs
- WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+ WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator
worldgenRandom.setLargeFeatureWithSalt(seed, chunkX, chunkZ, saltOverride != null ? saltOverride : HIGHLY_ARBITRARY_RANDOM_SALT); // Paper - Add missing structure set seed configs
return worldgenRandom.nextFloat() < frequency;
}
@@ -154,7 +154,7 @@ public abstract class StructurePlacement {
private static boolean legacyPillagerOutpostReducer(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - Add missing structure set seed configs; ignore here
int i = chunkX >> 4;
int j = chunkZ >> 4;
- WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+ WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator
worldgenRandom.setSeed((long)(i ^ j << 4) ^ seed);
worldgenRandom.nextInt();
return worldgenRandom.nextInt((int)(1.0F / frequency)) == 0;
diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/structures/OceanMonumentStructure.java b/src/main/java/net/minecraft/world/level/levelgen/structure/structures/OceanMonumentStructure.java
index 9693641e4129458d94f78a487d66d27fe35cd94e..019f9fb994a1836b73a68cfc9e120515884fba1e 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/structure/structures/OceanMonumentStructure.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/structure/structures/OceanMonumentStructure.java
@@ -55,7 +55,7 @@ public class OceanMonumentStructure extends Structure {
if (pieces.isEmpty()) {
return pieces;
} else {
- WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(RandomSupport.generateUniqueSeed()));
+ WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed()) : new LegacyRandomSource(RandomSupport.generateUniqueSeed())); // Leaf - Faster random generator
worldgenRandom.setLargeFeatureSeed(worldSeed, pos.x, pos.z);
StructurePiece structurePiece = pieces.pieces().get(0);
BoundingBox boundingBox = structurePiece.getBoundingBox();
diff --git a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinSimplexNoise.java b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinSimplexNoise.java
index 64bddc5c2722f7d2a18c31dc654547907b663710..b7302317d47a13c153b7c9fea993635c8f347ef4 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinSimplexNoise.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinSimplexNoise.java
@@ -43,7 +43,7 @@ public class PerlinSimplexNoise {
if (j > 0) {
long n = (long)(simplexNoise.getValue(simplexNoise.xo, simplexNoise.yo, simplexNoise.zo) * 9.223372E18F);
- RandomSource randomSource = new WorldgenRandom(new LegacyRandomSource(n));
+ RandomSource randomSource = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(n) : new LegacyRandomSource(n)); // Leaf - Faster random generator
for (int o = l - 1; o >= 0; o--) {
if (o < k && octaves.contains(l - o)) {
diff --git a/src/main/java/org/bukkit/craftbukkit/generator/CustomChunkGenerator.java b/src/main/java/org/bukkit/craftbukkit/generator/CustomChunkGenerator.java
index e34060c21755c61228ba91e468b7c92fc4c4cf0c..b45349c38011aca9b55fa9a82438e67b338cff6f 100644
--- a/src/main/java/org/bukkit/craftbukkit/generator/CustomChunkGenerator.java
+++ b/src/main/java/org/bukkit/craftbukkit/generator/CustomChunkGenerator.java
@@ -95,7 +95,7 @@ public class CustomChunkGenerator extends InternalChunkGenerator {
}
private static WorldgenRandom getSeededRandom() {
- return new WorldgenRandom(new LegacyRandomSource(0));
+ return new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0) : new LegacyRandomSource(0)); // Leaf - Faster random generator
}
@Override
diff --git a/src/main/java/org/dreeam/leaf/config/modules/opt/FastRNG.java b/src/main/java/org/dreeam/leaf/config/modules/opt/FastRNG.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0fe3e9dfed1bbf3d1f5848b343928d9b80c443b
--- /dev/null
+++ b/src/main/java/org/dreeam/leaf/config/modules/opt/FastRNG.java
@@ -0,0 +1,80 @@
+package org.dreeam.leaf.config.modules.opt;
+
+import org.dreeam.leaf.config.ConfigModules;
+import org.dreeam.leaf.config.EnumConfigCategory;
+import org.dreeam.leaf.config.LeafConfig;
+
+import java.util.random.RandomGeneratorFactory;
+
+public class FastRNG extends ConfigModules {
+
+ public String getBasePath() {
+ return EnumConfigCategory.PERF.getBaseKeyName() + ".faster-random-generator";
+ }
+
+ public static boolean enabled = false;
+ public static boolean enableForWorldgen = false;
+ public static String randomGenerator = "Xoroshiro128PlusPlus";
+ public static boolean warnForSlimeChunk = true;
+ public static boolean useLegacyForSlimeChunk = false;
+
+ public static boolean worldgenEnabled() { return enabled && enableForWorldgen; } // Helper function
+ @Override
+ public void onLoaded() {
+ config.addCommentRegionBased(getBasePath(), """
+ Use faster random generator?
+ Requires a JVM that supports RandomGenerator.
+ Some JREs don't support this.""",
+ """
+ 是否使用更快的随机生成器?
+ 需要支持 RandomGenerator 的 JVM.
+ 一些 JRE 不支持此功能.""");
+
+ enabled = config.getBoolean(getBasePath() + ".enabled", enabled);
+ randomGenerator = config.getString(getBasePath() + ".random-generator", randomGenerator,
+ config.pickStringRegionBased(
+ """
+ Which random generator will be used?
+ See https://openjdk.org/jeps/356""",
+ """
+ 使用什么种类的随机生成器.
+ 请参阅 https://openjdk.org/jeps/356"""));
+ enableForWorldgen = config.getBoolean(getBasePath() + ".enable-for-worldgen", enableForWorldgen,
+ config.pickStringRegionBased(
+ """
+ Enable faster random generator for world generation.
+ WARNING: This will affect world generation!!!""",
+ """
+ 是否为世界生成启用更快的随机生成器.
+ 警告: 此项会影响世界生成!!!"""));
+ warnForSlimeChunk = config.getBoolean(getBasePath() + ".warn-for-slime-chunk", warnForSlimeChunk,
+ config.pickStringRegionBased(
+ "Warn if you are not using legacy random source for slime chunk generation.",
+ "是否在没有为史莱姆区块使用原版随机生成器的情况下进行警告."));
+ useLegacyForSlimeChunk = config.getBoolean(getBasePath() + ".use-legacy-random-for-slime-chunk", useLegacyForSlimeChunk, config.pickStringRegionBased(
+ """
+ Use legacy random source for slime chunk generation,
+ to follow vanilla behavior.""",
+ """
+ 是否使用原版随机生成器来生成史莱姆区块."""));
+
+ if (enabled) {
+ try {
+ RandomGeneratorFactory.of(randomGenerator);
+ } catch (Exception e) {
+ LeafConfig.LOGGER.error("Faster random generator is enabled but {} is not supported by your JVM, " +
+ "falling back to legacy random source.", randomGenerator);
+ enabled = false;
+ }
+ }
+
+ if (enabled && warnForSlimeChunk) {
+ LeafConfig.LOGGER.warn("You enabled faster random generator, it will offset location of slime chunk");
+ LeafConfig.LOGGER.warn("If your server has slime farms or facilities need vanilla slime chunk,");
+ LeafConfig.LOGGER.warn("set performance.faster-random-generator.use-legacy-random-for-slime-chunk " +
+ "to true to use LegacyRandomSource for slime chunk generation.");
+ LeafConfig.LOGGER.warn("Set performance.faster-random-generator.warn-for-slime-chunk to false to " +
+ "disable this warning.");
+ }
+ }
+}
diff --git a/src/main/java/org/dreeam/leaf/util/math/random/FasterRandomSource.java b/src/main/java/org/dreeam/leaf/util/math/random/FasterRandomSource.java
new file mode 100644
index 0000000000000000000000000000000000000000..77fe5ab83535156c016a4808969ae76bd6b92288
--- /dev/null
+++ b/src/main/java/org/dreeam/leaf/util/math/random/FasterRandomSource.java
@@ -0,0 +1,127 @@
+package org.dreeam.leaf.util.math.random;
+
+import com.google.common.annotations.VisibleForTesting;
+import net.minecraft.util.Mth;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.levelgen.BitRandomSource;
+import net.minecraft.world.level.levelgen.PositionalRandomFactory;
+import org.dreeam.leaf.config.modules.opt.FastRNG;
+
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.random.RandomGenerator;
+import java.util.random.RandomGeneratorFactory;
+
+
+public class FasterRandomSource implements BitRandomSource {
+ private static final int INT_BITS = 48;
+ private static final long SEED_MASK = 0xFFFFFFFFFFFFL;
+ private static final long MULTIPLIER = 25214903917L;
+ private static final long INCREMENT = 11L;
+ private static final RandomGeneratorFactory<RandomGenerator> RANDOM_GENERATOR_FACTORY = RandomGeneratorFactory.of(FastRNG.randomGenerator);
+ private static final boolean isSplittableGenerator = RANDOM_GENERATOR_FACTORY.isSplittable();
+ private long seed;
+ private RandomGenerator randomGenerator;
+ public static final FasterRandomSource SHARED_INSTANCE = new FasterRandomSource(ThreadLocalRandom.current().nextLong());
+
+ public FasterRandomSource(long seed) {
+ this.seed = seed;
+ this.randomGenerator = RANDOM_GENERATOR_FACTORY.create(seed);
+ }
+
+ private FasterRandomSource(long seed, RandomGenerator.SplittableGenerator randomGenerator) {
+ this.seed = seed;
+ this.randomGenerator = randomGenerator;
+ }
+
+ @Override
+ public final RandomSource fork() {
+ if (isSplittableGenerator) {
+ return new FasterRandomSource(seed, ((RandomGenerator.SplittableGenerator) this.randomGenerator).split());
+ }
+ return new FasterRandomSource(this.nextLong());
+ }
+
+ @Override
+ public final PositionalRandomFactory forkPositional() {
+ return new FasterRandomSourcePositionalRandomFactory(this.seed);
+ }
+
+ @Override
+ public final void setSeed(long seed) {
+ this.seed = seed;
+ this.randomGenerator = RANDOM_GENERATOR_FACTORY.create(seed);
+ }
+
+ @Override
+ public final int next(int bits) {
+ // >>> instead of Mojang's >> fixes MC-239059
+ return (int) ((seed * MULTIPLIER + INCREMENT & SEED_MASK) >>> INT_BITS - bits);
+ }
+
+ public static class FasterRandomSourcePositionalRandomFactory implements PositionalRandomFactory {
+ private final long seed;
+
+ public FasterRandomSourcePositionalRandomFactory(long seed) {
+ this.seed = seed;
+ }
+
+ @Override
+ public RandomSource at(int x, int y, int z) {
+ long l = Mth.getSeed(x, y, z);
+ long m = l ^ this.seed;
+ return new FasterRandomSource(m);
+ }
+
+ @Override
+ public RandomSource fromHashOf(String seed) {
+ int i = seed.hashCode();
+ return new FasterRandomSource((long)i ^ this.seed);
+ }
+
+ @Override
+ public RandomSource fromSeed(long seed) {
+ return new FasterRandomSource(seed);
+ }
+
+ @VisibleForTesting
+ @Override
+ public void parityConfigString(StringBuilder info) {
+ info.append("FasterRandomSourcePositionalRandomFactory{").append(this.seed).append("}");
+ }
+ }
+
+ @Override
+ public final int nextInt() {
+ return randomGenerator.nextInt();
+ }
+
+ @Override
+ public final int nextInt(int bound) {
+ return randomGenerator.nextInt(bound);
+ }
+
+ @Override
+ public final long nextLong() {
+ return randomGenerator.nextLong();
+ }
+
+ @Override
+ public final boolean nextBoolean() {
+ return randomGenerator.nextBoolean();
+ }
+
+ @Override
+ public final float nextFloat() {
+ return randomGenerator.nextFloat();
+ }
+
+ @Override
+ public final double nextDouble() {
+ return randomGenerator.nextDouble();
+ }
+
+ @Override
+ public final double nextGaussian() {
+ return randomGenerator.nextGaussian();
+ }
+}
diff --git a/src/main/java/su/plo/matter/WorldgenCryptoRandom.java b/src/main/java/su/plo/matter/WorldgenCryptoRandom.java
index fab359afe44c573b8b315115810ddefd85b4d22b..42f4ca3f8ef3b5c4152b4b58e51cdba229ff1a0a 100644
--- a/src/main/java/su/plo/matter/WorldgenCryptoRandom.java
+++ b/src/main/java/su/plo/matter/WorldgenCryptoRandom.java
@@ -24,7 +24,7 @@ public class WorldgenCryptoRandom extends WorldgenRandom {
private final long[] cachedInternalState = new long[16];
public WorldgenCryptoRandom(int x, int z, Globals.Salt typeSalt, long salt) {
- super(new LegacyRandomSource(0L));
+ super(org.dreeam.leaf.config.modules.opt.FastRNG.enabled ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L));
if (typeSalt != null) {
this.setSecureSeed(x, z, typeSalt, salt);
}
Reference in New Issue View Git Blame Copy Permalink