diff --git a/docs/AGE_PROFILES.md b/docs/AGE_PROFILES.md index 34c800d..dbb0443 100644 --- a/docs/AGE_PROFILES.md +++ b/docs/AGE_PROFILES.md @@ -53,9 +53,10 @@ which already forms its own islands. Cave terrain rejects it. A page-free random Age may also roll Floating Islands as one of its material features. An unpaired Block or Fluid page chooses a compatible feature from the Age seed: -full blocks can become Rocks or Floating Islands; source fluids can become one -of the lake features. Flat and Void terrain can only use Floating Islands from -this pool, while Cave terrain has no compatible material feature. A page-free +full blocks can become Rocks, Floating Islands, Tendrils, Spheres, or Spikes; source fluids can become one +of the lake features. Flat terrain can use Floating Islands, Tendrils, Spheres, +or Spikes; Void can use Floating Islands, Tendrils, or Spheres; Cave can use +Spheres or Tendrils. A page-free random Age rolls zero, one, or two distinct compatible material features, choosing each material from the Block or Fluid Pages pool. The choices are saved on the Age definition, so opening the Age again does not reroll them. @@ -101,6 +102,25 @@ including on Cave terrain where the surface material features are unavailable. The shape and placement use only the Age seed and source-chunk coordinates, so revisiting an Age recreates the same geometry. +**Spheres** and **Spikes** are two separate Feature pages. Spheres adds +winding chains of solid sphere nodes within terrain generation; like Tendrils, +it works on all terrain families, even Void and Cave. Spikes is a later, +rarer surface decoration (roughly one attempt per 18 chunks) that rises from +solid ground on Standard, Amplified, Sky Islands, or Flat terrain. Cave and +Void reject the Spikes page because they do not provide a suitable exposed +surface. Each page accepts its own immediately preceding full-collision Block +page; without one, the Age seed chooses a compatible material. The pages +remain distinct in the catalog, Creative menu, JEI, ordered writing, and +saved Age definition. Page-free random Ages can select either where compatible. + +For an in-game check, make separate Void/Spheres and Flat/Spikes books with +Glowstone Block pages directly before their respective Feature pages. Spheres +should form connected bright globes across chunk boundaries in Void; Spikes +should appear as rare upward clusters rooted on the Flat surface. Revisit the +same Ages to confirm stable locations. Check that a Void/Spikes book is +rejected, and that Spheres and Spikes remain two independently selectable +pages in Creative and JEI. + For a clear visual check, bind a Void Age with a Glowstone Block page followed by Tendrils. Fly around world Y=0–120 across several chunks: branching solid forms should appear in the otherwise empty dimension, continue across chunk diff --git a/docs/LEGACY_AGE_GRAMMAR_AUDIT.md b/docs/LEGACY_AGE_GRAMMAR_AUDIT.md index ca45dc8..955fdbf 100644 --- a/docs/LEGACY_AGE_GRAMMAR_AUDIT.md +++ b/docs/LEGACY_AGE_GRAMMAR_AUDIT.md @@ -18,7 +18,7 @@ Legacy does **not** reject a book just because it omits terrain, biome, weather, | `WeatherNorm`, `Fast`, `Slow`, `Off`, `On`, `Cloudy`, `Rain`, `Snow`, `Storm` | `AgeTraits.Weather` has matching names except Legacy `On` maps to `ALWAYS` | Compile weather semantics separately from biome selection. `Snow` must remain deferred until optional season integration; do not silently substitute another weather mode. | | Suns, moons, starfields; angle, phase, period, color/gradient/sunset modifiers | One `celestialPeriod`, `celestialAngle`, `celestialPhase` on `AgeTraits` | Compile only the representable single-cycle subset first. Multiple celestial bodies, independent periods, custom stars, gradients and sunsets need a richer definition and renderer, not flattening into one value. | | Sky/fog/cloud/grass/foliage/water colors, natural variants, horizon, rainbow | Existing sky/dimension visuals and preview | Require an explicit modern client/biome-color design; metadata-only symbol pages must not pretend to change rendering. | -| Caves, ores, huge trees, lakes, floating islands, tendrils, skylands, spheres, spikes, crystals; vanilla villages, strongholds, mineshafts, dungeons, fortresses, obelisks, fissures | Current cave profile, vanilla data-pack generation, and authored Floating Islands/Tendrils/Skylands | Compile supported vanilla placements and port bespoke shapes explicitly. Remaining bespoke structures and polish stay in later issues. | +| Caves, ores, huge trees, lakes, floating islands, tendrils, skylands, spheres, spikes, crystals; vanilla villages, strongholds, mineshafts, dungeons, fortresses, obelisks, fissures | Current cave profile, vanilla data-pack generation, and authored Floating Islands/Tendrils/Skylands/Spheres/Spikes | Compile supported vanilla placements and port bespoke shapes explicitly. Remaining bespoke structures and polish stay in later issues. | | `EnvAccel`, explosions, lightning, meteors, scorching; PvP and dummy suppression pages | No equivalent Age-definition effect | Defer environmental hazards/instability effects to milestone 6, PvP rule to a separately scoped server policy; retain authored IDs without fake behavior. | The Legacy symbol list and page names come from [ModSymbols](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L129-L240) and [SymbolRules](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/SymbolRules.java#L19-L137). Rivencraft's [catalog](../src/main/java/net/dnorberg/rivencraft/writing/SymbolCatalog.java) currently holds display metadata only; its built-in set is just standard terrain, native biomes, normal weather, normal lighting, normal time, and caves. [OrderedWriting](../src/main/java/net/dnorberg/rivencraft/writing/OrderedWriting.java) preserves page order, but no compiler yet connects it to [AgeTraits](../src/main/java/net/dnorberg/rivencraft/book/AgeTraits.java) or [Age profiles](AGE_PROFILES.md). diff --git a/gradle.properties b/gradle.properties index 2ccd75a..adf49ca 100644 --- a/gradle.properties +++ b/gradle.properties @@ -36,7 +36,7 @@ mod_name=Rivencraft # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default. mod_license=LGPL-3.0-or-later # The mod version. Rivencraft uses the x.y.z.b policy documented in README.md. -mod_version=0.4.13.0 +mod_version=0.4.14.0 immersive_portals_version=6.0.7 terrablender_version=4.1.0.8 serene_seasons_version_id=B6nTjh4b diff --git a/src/main/java/net/dnorberg/rivencraft/book/AgeFeatureSelection.java b/src/main/java/net/dnorberg/rivencraft/book/AgeFeatureSelection.java index c08633e..5741b09 100644 --- a/src/main/java/net/dnorberg/rivencraft/book/AgeFeatureSelection.java +++ b/src/main/java/net/dnorberg/rivencraft/book/AgeFeatureSelection.java @@ -25,7 +25,7 @@ import net.minecraft.world.level.block.Blocks; /** Validates and freezes supported feature pages and their preceding material modifiers. */ public final class AgeFeatureSelection { private static final List BLOCK_FEATURES = List.of( - id("rocks"), id("floating_islands"), id("tendrils")); + id("rocks"), id("floating_islands"), id("tendrils"), id("spheres"), id("spikes")); private static final List FLUID_FEATURES = List.of( id("surface_lakes"), id("deep_lakes"), id("lava_lakes")); private static final long RANDOM_SKYLANDS_SALT = 0x534B594C414E4453L; @@ -114,8 +114,9 @@ public final class AgeFeatureSelection { } private static boolean compatible(ResourceLocation feature, AgeRuntimeProfile profile) { - if (tendrils(feature)) return true; + if (tendrils(feature) || spheres(feature)) return true; if (AgeBiomeSelection.isCave(profile)) return false; + if (spikes(feature)) return profile.terrain() != AgeRuntimeProfile.Terrain.VOID; return floatingIslands(feature) || profile.terrain() == AgeRuntimeProfile.Terrain.NOISE; } @@ -128,7 +129,8 @@ public final class AgeFeatureSelection { plan.runtimeProfile(), plan.ageSeed())) { if (choice.material().isPresent() || !isRock(choice.id()) && !isLake(choice.id()) - && !floatingIslands(choice.id()) && !tendrils(choice.id())) { + && !floatingIslands(choice.id()) && !tendrils(choice.id()) + && !spheres(choice.id()) && !spikes(choice.id())) { resolved.add(choice); continue; } @@ -151,7 +153,7 @@ public final class AgeFeatureSelection { List choices = new ArrayList<>(); for (ResourceLocation feature : features) { if (choices.size() >= count) break; - var category = isRock(feature) || floatingIslands(feature) || tendrils(feature) + var category = solidFeature(feature) ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY; List materials = BlockSymbolPages.availableBlocks(category).stream() .filter(id -> materialError(new Choice(feature, Optional.of(id))) == null).toList(); @@ -165,7 +167,7 @@ public final class AgeFeatureSelection { } private static List shuffledMaterials(long ageSeed, ResourceLocation feature) { - var category = isRock(feature) || floatingIslands(feature) || tendrils(feature) + var category = solidFeature(feature) ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY; List pool = new ArrayList<>(BlockSymbolPages.availableBlocks(category).stream() .filter(id -> materialError(new Choice(feature, Optional.of(id))) == null).toList()); @@ -187,6 +189,12 @@ public final class AgeFeatureSelection { public static String error(ResourceLocation choice, AgeRuntimeProfile profile, RegistryAccess registries) { if (skylands(choice)) return null; if (tendrils(choice)) return null; + if (spheres(choice)) return null; + if (spikes(choice)) { + if (AgeBiomeSelection.isCave(profile) || profile.terrain() == AgeRuntimeProfile.Terrain.VOID) + return "Feature " + choice + " needs an exposed solid surface, not Cave or Void terrain"; + return null; + } if (floatingIslands(choice)) { if (AgeBiomeSelection.isCave(profile)) return "Feature " + choice + " cannot form above Cave terrain"; @@ -225,7 +233,7 @@ public final class AgeFeatureSelection { if (block.isEmpty() || block.orElseThrow() == Blocks.AIR) { return "Feature " + choice.id() + " references missing block material " + material; } - if (isRock(choice.id()) || floatingIslands(choice.id()) || tendrils(choice.id())) { + if (solidFeature(choice.id())) { if (!BlockSymbolPages.isRockMaterial(block.orElseThrow())) { return "Feature " + choice.id() + " needs a full solid block without a block entity: " + material; } @@ -269,6 +277,19 @@ public final class AgeFeatureSelection { return choice.equals(id("tendrils")); } + public static boolean spheres(ResourceLocation choice) { + return choice.equals(id("spheres")); + } + + public static boolean spikes(ResourceLocation choice) { + return choice.equals(id("spikes")); + } + + private static boolean solidFeature(ResourceLocation choice) { + return isRock(choice) || floatingIslands(choice) || tendrils(choice) + || spheres(choice) || spikes(choice); + } + public static boolean skylands(ResourceLocation choice) { return choice.equals(id("skylands")); } diff --git a/src/main/java/net/dnorberg/rivencraft/book/AgePersistenceGameTests.java b/src/main/java/net/dnorberg/rivencraft/book/AgePersistenceGameTests.java index 0156bd7..bfa9728 100644 --- a/src/main/java/net/dnorberg/rivencraft/book/AgePersistenceGameTests.java +++ b/src/main/java/net/dnorberg/rivencraft/book/AgePersistenceGameTests.java @@ -79,7 +79,7 @@ public final class AgePersistenceGameTests { ? choice.material().isEmpty() : choice.material().isPresent() && AgeFeatureSelection.materialError(choice) == null, - "Random material features need valid blocks or fluids; Skylands needs none"); + "Random material features, including Spheres and Spikes, need valid blocks or fluids; Skylands needs none"); } } AgeRegistrySavedData registry = AgeRegistrySavedData.get(helper.getLevel()); diff --git a/src/main/java/net/dnorberg/rivencraft/book/FeatureWritingGameTests.java b/src/main/java/net/dnorberg/rivencraft/book/FeatureWritingGameTests.java index 4f076b3..222f7f0 100644 --- a/src/main/java/net/dnorberg/rivencraft/book/FeatureWritingGameTests.java +++ b/src/main/java/net/dnorberg/rivencraft/book/FeatureWritingGameTests.java @@ -32,7 +32,8 @@ public final class FeatureWritingGameTests { Set pages = Set.of("feature/caves", "feature/flowers", "feature/trees", "feature/huge_trees", "feature/rocks", "feature/lava_lakes", "feature/surface_lakes", "feature/deep_lakes", "feature/ravines", - "feature/floating_islands", "feature/tendrils", "feature/skylands"); + "feature/floating_islands", "feature/tendrils", "feature/skylands", + "feature/spheres", "feature/spikes"); helper.assertTrue(PageItem.bundledCreativeSymbols().containsAll(pages), "Supported feature pages must appear in the creative and JEI symbol feed"); for (String path : pages) { @@ -61,7 +62,9 @@ public final class FeatureWritingGameTests { if (AgeFeatureSelection.caves(choice.id()) || AgeFeatureSelection.ravines(choice.id()) || AgeFeatureSelection.floatingIslands(choice.id()) || AgeFeatureSelection.tendrils(choice.id()) - || AgeFeatureSelection.skylands(choice.id())) continue; + || AgeFeatureSelection.skylands(choice.id()) + || AgeFeatureSelection.spheres(choice.id()) + || AgeFeatureSelection.spikes(choice.id())) continue; var placement = AgeFeatureSelection.placedFeature(choice.id()); helper.assertTrue(registries.lookupOrThrow(Registries.PLACED_FEATURE) .get(ResourceKey.create(Registries.PLACED_FEATURE, placement)).isPresent(), @@ -171,9 +174,11 @@ public final class FeatureWritingGameTests { boolean found = false; for (long seed = 0; seed < 12; seed++) { List random = AgeFeatureSelection.randomChoices(seed, caveProfile, registries); - helper.assertTrue(random.stream().allMatch(choice -> AgeFeatureSelection.tendrils(choice.id())), + helper.assertTrue(random.stream().allMatch(choice -> AgeFeatureSelection.tendrils(choice.id()) + || AgeFeatureSelection.spheres(choice.id()) + || AgeFeatureSelection.skylands(choice.id())), "Cave random Ages must not choose incompatible surface features"); - if (!random.isEmpty()) found = true; + if (random.stream().anyMatch(choice -> AgeFeatureSelection.tendrils(choice.id()))) found = true; } helper.assertTrue(found, "A page-free random Cave Age must be able to roll Tendrils"); helper.succeed(); @@ -214,6 +219,55 @@ public final class FeatureWritingGameTests { helper.succeed(); } + @GameTest(template = "empty") + public static void spheresAndSpikesHaveSeparateAuthoredPagesAndMaterials(GameTestHelper helper) { + var registries = helper.getLevel().registryAccess(); + OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"), + block("glowstone"), page("feature/spheres"), block("stone"), page("feature/spikes"))); + AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 1717L, + AgeGenerationProfiles.STANDARD, AgeTraits.select(1717L), registries); + List expected = List.of( + new AgeFeatureSelection.Choice(id("spheres"), Optional.of( + ResourceLocation.withDefaultNamespace("glowstone"))), + new AgeFeatureSelection.Choice(id("spikes"), Optional.of( + ResourceLocation.withDefaultNamespace("stone")))); + helper.assertValueEqual(AgeFeatureSelection.resolved(plan), expected, + "Each page must preserve its own preceding Block material and writing order"); + helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), expected, + "Spheres and Spikes must retain their identities and materials after reload"); + for (String terrain : List.of("standard", "amplified", "island", "flat", "void", "cave")) { + var profile = AgeRuntimeProfiles.resolve(id(terrain)); + helper.assertTrue(AgeFeatureSelection.error(id("spheres"), profile, registries) == null, + "Spheres must be additive on " + terrain + " terrain"); + boolean surface = !terrain.equals("void") && !terrain.equals("cave"); + helper.assertValueEqual(AgeFeatureSelection.error(id("spikes"), profile, registries) == null, + surface, "Spikes require a solid surface on " + terrain + " terrain"); + } + rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/void"), + page("feature/spikes"))), "needs an exposed solid surface"); + rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/cave"), + page("feature/spikes"))), "needs an exposed solid surface"); + boolean randomSpheres = false; + boolean randomSpikes = false; + for (long seed = 0; seed < 80; seed++) { + var random = AgeFeatureSelection.randomChoices(seed, + AgeRuntimeProfiles.resolve(id("standard")), registries); + randomSpheres |= random.stream().anyMatch(choice -> AgeFeatureSelection.spheres(choice.id())); + randomSpikes |= random.stream().anyMatch(choice -> AgeFeatureSelection.spikes(choice.id())); + } + helper.assertTrue(randomSpheres && randomSpikes, + "Page-free surface Ages must be able to select both separate features"); + for (String terrain : List.of("void", "cave")) { + var profile = AgeRuntimeProfiles.resolve(id(terrain)); + for (long seed = 0; seed < 30; seed++) { + helper.assertTrue(AgeFeatureSelection.randomChoices(seed, profile, registries).stream() + .noneMatch(choice -> AgeFeatureSelection.spikes(choice.id())), + "Random " + terrain + " Ages must never choose unsupported Spikes"); + } + } + helper.succeed(); + } + @GameTest(template = "empty") public static void voidBiomesAreIndependentOfFloatingIslands(GameTestHelper helper) { OrderedWriting voidDefault = new OrderedWriting(List.of(panel(), page("terrain/void"))); @@ -354,7 +408,9 @@ public final class FeatureWritingGameTests { ? AgeFeatureSelection.isLake(choices.getFirst().id()) : AgeFeatureSelection.isRock(choices.getFirst().id()) || AgeFeatureSelection.floatingIslands(choices.getFirst().id()) - || AgeFeatureSelection.tendrils(choices.getFirst().id()), + || AgeFeatureSelection.tendrils(choices.getFirst().id()) + || AgeFeatureSelection.spheres(choices.getFirst().id()) + || AgeFeatureSelection.spikes(choices.getFirst().id()), "The inferred feature must accept the material type"); helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices, "The inferred feature must be deterministic across a plan reload"); diff --git a/src/main/java/net/dnorberg/rivencraft/world/AgeFeatureChunkGenerator.java b/src/main/java/net/dnorberg/rivencraft/world/AgeFeatureChunkGenerator.java index 1c6a333..812865c 100644 --- a/src/main/java/net/dnorberg/rivencraft/world/AgeFeatureChunkGenerator.java +++ b/src/main/java/net/dnorberg/rivencraft/world/AgeFeatureChunkGenerator.java @@ -77,6 +77,7 @@ public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator { CompletableFuture filled = super.fillFromNoise(blender, random, structures, chunk); if (features.stream().noneMatch(choice -> AgeFeatureSelection.floatingIslands(choice.id()) || AgeFeatureSelection.tendrils(choice.id()) + || AgeFeatureSelection.spheres(choice.id()) || AgeFeatureSelection.skylands(choice.id()))) return filled; return filled.thenApply(result -> { // Legacy's Skylands primer filter removes base terrain before large @@ -86,12 +87,15 @@ public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator { Map occurrences = new HashMap<>(); for (AgeFeatureSelection.Choice choice : features) { if (!AgeFeatureSelection.floatingIslands(choice.id()) - && !AgeFeatureSelection.tendrils(choice.id())) continue; + && !AgeFeatureSelection.tendrils(choice.id()) + && !AgeFeatureSelection.spheres(choice.id())) continue; int occurrence = occurrences.merge(choice.id(), 1, Integer::sum) - 1; long featureSeed = ageSeed ^ (long) occurrence * 0x9E3779B97F4A7C15L; if (AgeFeatureSelection.floatingIslands(choice.id())) FloatingIslandFeature.generate(result, getBiomeSource(), random, featureSeed, choice); - else TendrilFeature.generate(result, featureSeed, choice); + else if (AgeFeatureSelection.tendrils(choice.id())) + TendrilFeature.generate(result, featureSeed, choice); + else SpheresFeature.generate(result, featureSeed, choice); } return result; }); @@ -147,9 +151,15 @@ public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator { int z = chunk.getPos().getMinBlockZ(); BlockPos origin = new BlockPos(x, level.getMinBuildHeight(), z); Map occurrences = new HashMap<>(); + Map spikeOccurrences = new HashMap<>(); for (int index = 0; index < features.size(); index++) { AgeFeatureSelection.Choice choice = features.get(index); int occurrence = occurrences.merge(choice, 1, Integer::sum) - 1; + if (AgeFeatureSelection.spikes(choice.id())) { + SpikesFeature.generate(level, chunk, ageSeed, choice, + spikeOccurrences.merge(choice.id(), 1, Integer::sum) - 1); + continue; + } if (AgeFeatureSelection.surfaceVegetation(choice.id())) { int surface = chunk.getHeight(Heightmap.Types.WORLD_SURFACE_WG, 8, 8); if (!AgeFeatureSelection.supportsSurfaceVegetation( diff --git a/src/main/java/net/dnorberg/rivencraft/world/AgeFlatChunkGenerator.java b/src/main/java/net/dnorberg/rivencraft/world/AgeFlatChunkGenerator.java index 780f392..9afa48d 100644 --- a/src/main/java/net/dnorberg/rivencraft/world/AgeFlatChunkGenerator.java +++ b/src/main/java/net/dnorberg/rivencraft/world/AgeFlatChunkGenerator.java @@ -19,6 +19,7 @@ import net.minecraft.server.level.WorldGenRegion; import net.minecraft.world.level.LevelHeightAccessor; import net.minecraft.world.level.NoiseColumn; import net.minecraft.world.level.StructureManager; +import net.minecraft.world.level.WorldGenLevel; import net.minecraft.world.level.biome.BiomeManager; import net.minecraft.world.level.biome.BiomeSource; import net.minecraft.world.level.block.Blocks; @@ -105,16 +106,29 @@ public final class AgeFlatChunkGenerator extends ChunkGenerator { Map occurrences = new HashMap<>(); for (AgeFeatureSelection.Choice choice : features) { if (!AgeFeatureSelection.floatingIslands(choice.id()) - && !AgeFeatureSelection.tendrils(choice.id())) continue; + && !AgeFeatureSelection.tendrils(choice.id()) + && !AgeFeatureSelection.spheres(choice.id())) continue; int occurrence = occurrences.merge(choice.id(), 1, Integer::sum) - 1; long featureSeed = ageSeed ^ (long) occurrence * 0x9E3779B97F4A7C15L; if (AgeFeatureSelection.floatingIslands(choice.id())) FloatingIslandFeature.generate(chunk, biomeSource, random, featureSeed, choice); - else TendrilFeature.generate(chunk, featureSeed, choice); + else if (AgeFeatureSelection.tendrils(choice.id())) + TendrilFeature.generate(chunk, featureSeed, choice); + else SpheresFeature.generate(chunk, featureSeed, choice); } return CompletableFuture.completedFuture(chunk); } + @Override + public void applyBiomeDecoration(WorldGenLevel level, ChunkAccess chunk, StructureManager structures) { + super.applyBiomeDecoration(level, chunk, structures); + int occurrence = 0; + for (AgeFeatureSelection.Choice choice : features) { + if (AgeFeatureSelection.spikes(choice.id())) + SpikesFeature.generate(level, chunk, ageSeed, choice, occurrence++); + } + } + @Override public int getBaseHeight(int x, int z, Heightmap.Types type, LevelHeightAccessor level, RandomState random) { List layers = settings.getLayers(); diff --git a/src/main/java/net/dnorberg/rivencraft/world/SpheresFeature.java b/src/main/java/net/dnorberg/rivencraft/world/SpheresFeature.java new file mode 100644 index 0000000..23ecb90 --- /dev/null +++ b/src/main/java/net/dnorberg/rivencraft/world/SpheresFeature.java @@ -0,0 +1,127 @@ +package net.dnorberg.rivencraft.world; + +import java.util.Random; +import net.dnorberg.rivencraft.book.AgeFeatureSelection; +import net.minecraft.core.BlockPos; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.util.Mth; +import net.minecraft.world.level.ChunkPos; +import net.minecraft.world.level.block.Blocks; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.chunk.ChunkAccess; +import net.minecraft.world.level.levelgen.Heightmap; + +/** + * Solid, wandering sphere nodes adapted from Mystcraft Legacy's MapGenSpheresMyst + * (Mystcraft contributors, LGPL-3.0-or-later, commit 9bc8ddc). NeoForge chunk + * writes and seed mixing are Rivencraft-specific. + */ +final class SpheresFeature { + private static final int SOURCE_RANGE = 8; + private static final long SALT = 0x53504845524553L; + + private SpheresFeature() {} + + static void generate(ChunkAccess chunk, long ageSeed, AgeFeatureSelection.Choice choice) { + BlockState material = choice.material() + .map(id -> BuiltInRegistries.BLOCK.get(id).defaultBlockState()) + .orElse(Blocks.COBBLESTONE.defaultBlockState()); + ChunkPos target = chunk.getPos(); + Random master = new Random(ageSeed ^ SALT); + long xSeed = master.nextLong(); + long zSeed = master.nextLong(); + for (int sx = target.x - SOURCE_RANGE; sx <= target.x + SOURCE_RANGE; sx++) { + for (int sz = target.z - SOURCE_RANGE; sz <= target.z + SOURCE_RANGE; sz++) { + Random source = new Random((long) sx * xSeed ^ (long) sz * zSeed ^ ageSeed ^ SALT); + if (source.nextFloat() > 0.05F) continue; + double x = sx * 16 + source.nextInt(16); + double y = source.nextInt(source.nextInt(192) + 1) + 32; + double z = sz * 16 + source.nextInt(16); + trace(chunk, material, source.nextLong(), x, y, z, + 1.0F + source.nextFloat() * 4.0F, 0, 0, -1, -1); + } + } + } + + private static void trace(ChunkAccess chunk, BlockState material, long seed, + double x, double y, double z, float radius, float yaw, float pitch, + int step, int length) { + Random random = new Random(seed); + if (length <= 0) { + int maximum = SOURCE_RANGE * 16 - 16; + length = maximum - random.nextInt(maximum / 4); + } + boolean singleNode = step == -1; + if (singleNode) step = length / 2; + int splitAt = random.nextInt(length / 2) + length / 4; + boolean slowPitch = random.nextInt(6) == 0; + float yawDrift = 0; + float pitchDrift = 0; + double middleX = chunk.getPos().getMinBlockX() + 8; + double middleZ = chunk.getPos().getMinBlockZ() + 8; + for (; step < length; step++) { + double nodeRadius = 1.5D + Math.sin(step * Math.PI / length) * radius; + float horizontal = Mth.cos(pitch); + x += Mth.cos(yaw) * horizontal; + y += Mth.sin(pitch); + z += Mth.sin(yaw) * horizontal; + pitch *= slowPitch ? 0.92F : 0.7F; + pitch += pitchDrift * 0.1F; + yaw += yawDrift * 0.1F; + pitchDrift = pitchDrift * 0.9F + + (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0F; + yawDrift = yawDrift * 0.75F + + (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0F; + if (!singleNode && step == splitAt && radius > 1.0F) { + trace(chunk, material, random.nextLong(), x, y, z, + random.nextFloat() * 0.5F + 0.5F, yaw - Mth.HALF_PI, pitch / 3, step, length); + trace(chunk, material, random.nextLong(), x, y, z, + random.nextFloat() * 0.5F + 0.5F, yaw + Mth.HALF_PI, pitch / 3, step, length); + return; + } + if (!singleNode && random.nextInt(4) == 0) continue; + double dx = x - middleX; + double dz = z - middleZ; + double remaining = length - step; + double reach = radius + 18; + if (dx * dx + dz * dz - remaining * remaining > reach * reach) return; + if (Math.abs(dx) <= 16 + nodeRadius * 2 && Math.abs(dz) <= 16 + nodeRadius * 2) + fillNode(chunk, material, x, y, z, nodeRadius); + if (singleNode) break; + } + } + + private static void fillNode(ChunkAccess chunk, BlockState material, + double centerX, double centerY, double centerZ, double radius) { + int originX = chunk.getPos().getMinBlockX(); + int originZ = chunk.getPos().getMinBlockZ(); + int minX = Math.max(0, Mth.floor(centerX - radius) - originX - 1); + int maxX = Math.min(16, Mth.floor(centerX + radius) - originX + 2); + int minZ = Math.max(0, Mth.floor(centerZ - radius) - originZ - 1); + int maxZ = Math.min(16, Mth.floor(centerZ + radius) - originZ + 2); + int minY = Math.max(chunk.getMinBuildHeight() + 1, Mth.floor(centerY - radius) - 1); + int maxY = Math.min(chunk.getMaxBuildHeight(), Mth.floor(centerY + radius) + 2); + Heightmap surface = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG); + Heightmap floor = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG); + BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos(); + for (int worldY = minY; worldY < maxY; worldY++) { + double dy = (worldY + 0.5D - centerY) / radius; + for (int localZ = minZ; localZ < maxZ; localZ++) { + double dz = (originZ + localZ + 0.5D - centerZ) / radius; + for (int localX = minX; localX < maxX; localX++) { + double dx = (originX + localX + 0.5D - centerX) / radius; + if (!insideSphere(dx, dy, dz)) continue; + pos.set(originX + localX, worldY, originZ + localZ); + if (chunk.getBlockState(pos).is(Blocks.BEDROCK)) continue; + chunk.setBlockState(pos, material, false); + surface.update(localX, worldY, localZ, material); + floor.update(localX, worldY, localZ, material); + } + } + } + } + + static boolean insideSphere(double dx, double dy, double dz) { + return dx * dx + dy * dy + dz * dz < 1.0D; + } +} diff --git a/src/main/java/net/dnorberg/rivencraft/world/SpikesFeature.java b/src/main/java/net/dnorberg/rivencraft/world/SpikesFeature.java new file mode 100644 index 0000000..d11614c --- /dev/null +++ b/src/main/java/net/dnorberg/rivencraft/world/SpikesFeature.java @@ -0,0 +1,65 @@ +package net.dnorberg.rivencraft.world; + +import net.dnorberg.rivencraft.book.AgeFeatureSelection; +import net.minecraft.core.BlockPos; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.util.RandomSource; +import net.minecraft.world.level.WorldGenLevel; +import net.minecraft.world.level.block.Blocks; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.chunk.ChunkAccess; +import net.minecraft.world.level.levelgen.Heightmap; + +/** + * Rare surface spikes adapted from Mystcraft Legacy's WorldGenSpikesAdv + * (Mystcraft contributors, LGPL-3.0-or-later, commit 9bc8ddc). The footprint + * is kept in one chunk to avoid generation-order seams. + */ +final class SpikesFeature { + private static final long SALT = 0x5350494B4553L; + + private SpikesFeature() {} + + static void generate(WorldGenLevel level, ChunkAccess chunk, long ageSeed, + AgeFeatureSelection.Choice choice, int occurrence) { + int originX = chunk.getPos().getMinBlockX(); + int originZ = chunk.getPos().getMinBlockZ(); + RandomSource random = RandomSource.create(ageSeed ^ SALT + ^ (long) originX * 341873128712L ^ (long) originZ * 132897987541L + ^ (long) occurrence * 0x9E3779B97F4A7C15L); + if (random.nextInt(18) != 0) return; + BlockState material = choice.material() + .map(id -> BuiltInRegistries.BLOCK.get(id).defaultBlockState()) + .orElse(Blocks.STONE.defaultBlockState()); + // Keep the entire footprint in this chunk; neighboring decoration order + // must not decide whether a spike exists or cut it at a chunk border. + int x = originX + 4 + random.nextInt(8); + int z = originZ + 4 + random.nextInt(8); + int y = level.getHeight(Heightmap.Types.WORLD_SURFACE_WG, x, z); + int height = 6 + random.nextInt(32); + int width = 1 + random.nextInt(4); + if (y < level.getMinBuildHeight() + 1 || y + height >= level.getMaxBuildHeight()) return; + BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos(); + if (!level.isEmptyBlock(pos.set(x, y, z))) return; + for (int px = x - width; px <= x + width; px++) { + for (int pz = z - width; pz <= z + width; pz++) { + if (!insideFootprint(px - x, pz - z, width)) continue; + if (!level.getBlockState(pos.set(px, y - 1, pz)).isSolid()) return; + } + } + for (int px = x - width; px <= x + width; px++) { + for (int pz = z - width; pz <= z + width; pz++) { + if (!insideFootprint(px - x, pz - z, width)) continue; + int top = y + 1 + random.nextInt(random.nextInt(height) + 1); + for (int py = y; py < top; py++) { + pos.set(px, py, pz); + if (level.isEmptyBlock(pos)) level.setBlock(pos, material, 2); + } + } + } + } + + static boolean insideFootprint(int dx, int dz, int width) { + return dx * dx + dz * dz <= width * width + 1; + } +} diff --git a/src/main/java/net/dnorberg/rivencraft/writing/WritingGrammar.java b/src/main/java/net/dnorberg/rivencraft/writing/WritingGrammar.java index 9d625ee..a330ff5 100644 --- a/src/main/java/net/dnorberg/rivencraft/writing/WritingGrammar.java +++ b/src/main/java/net/dnorberg/rivencraft/writing/WritingGrammar.java @@ -77,7 +77,8 @@ public final class WritingGrammar { pendingBlock = parsed; } else if (role == Role.FEATURE && pendingBlock != null) { ResourceLocation feature = ((SymbolSemantics.ResourceValue) parsed.semantics().value()).id(); - if (!Set.of("rocks", "surface_lakes", "deep_lakes", "lava_lakes", "floating_islands", "tendrils") + if (!Set.of("rocks", "surface_lakes", "deep_lakes", "lava_lakes", + "floating_islands", "tendrils", "spheres", "spikes") .contains(feature.getPath()) || !feature.getNamespace().equals("rivencraft")) { diagnostics.add(new Diagnostic(Code.MISPLACED_MODIFIER, pendingBlock.index(), "This feature cannot consume a material page")); diff --git a/src/main/resources/assets/rivencraft/lang/en_us.json b/src/main/resources/assets/rivencraft/lang/en_us.json index bc63038..d8cfdfb 100644 --- a/src/main/resources/assets/rivencraft/lang/en_us.json +++ b/src/main/resources/assets/rivencraft/lang/en_us.json @@ -249,6 +249,10 @@ "symbol.rivencraft.feature.tendrils.description": "Add winding solid tendrils through the Age, using a random block or a preceding Block page.", "symbol.rivencraft.feature.skylands": "Skylands", "symbol.rivencraft.feature.skylands.description": "Remove terrain below a shifting sky cutoff; unlike Floating Islands, this does not add land.", + "symbol.rivencraft.feature.spheres": "Spheres", + "symbol.rivencraft.feature.spheres.description": "Add wandering chains of solid spheres through the Age, with a random or selected block material.", + "symbol.rivencraft.feature.spikes": "Spikes", + "symbol.rivencraft.feature.spikes.description": "Add rare rising spikes on exposed solid ground, with a random or selected block material.", "symbol.rivencraft.feature.lava_lakes": "Small Lakes", "symbol.rivencraft.feature.lava_lakes.description": "Add small surface lakes using a random fluid, or specify one with a fluid page.", "generator.rivencraft.standard": "Standard", diff --git a/src/main/resources/data/rivencraft/rivencraft/symbols/feature/spheres.json b/src/main/resources/data/rivencraft/rivencraft/symbols/feature/spheres.json new file mode 100644 index 0000000..3cc6b8a --- /dev/null +++ b/src/main/resources/data/rivencraft/rivencraft/symbols/feature/spheres.json @@ -0,0 +1,8 @@ +{ + "schema_version": 2, + "name": "symbol.rivencraft.feature.spheres", + "description": "symbol.rivencraft.feature.spheres.description", + "category": "rivencraft:feature", + "semantics": { "role": "feature", "value": "rivencraft:spheres" }, + "poem": "Terrain Transform Form Cycle" +} diff --git a/src/main/resources/data/rivencraft/rivencraft/symbols/feature/spikes.json b/src/main/resources/data/rivencraft/rivencraft/symbols/feature/spikes.json new file mode 100644 index 0000000..436130b --- /dev/null +++ b/src/main/resources/data/rivencraft/rivencraft/symbols/feature/spikes.json @@ -0,0 +1,8 @@ +{ + "schema_version": 2, + "name": "symbol.rivencraft.feature.spikes", + "description": "symbol.rivencraft.feature.spikes.description", + "category": "rivencraft:feature", + "semantics": { "role": "feature", "value": "rivencraft:spikes" }, + "poem": "Nature Encourage Entropy Structure" +}