Public Access
Add native biome families, desert vegetation, static sky controls and Seamless views
Build and smoke / changes (push) Waiting to run
Build and smoke / changes (push) Waiting to run
This commit is contained in:
1 parent
90e4a98a7a
commit
d199ac253e
92 files changed
+2520
-224
No files matched your search
@@ -0,0 +1,77 @@
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Random;
|
||||
import net.dnorberg.rivencraft.shared.DesertVegetation;
|
||||
import net.dnorberg.rivencraft.shared.DesertVegetation.*;
|
||||
|
||||
/** Storage-free shared placement checks; no fixture is packaged into either mod JAR. */
|
||||
public class DesertVegetationChecks {
|
||||
record Pos(int x, int y, int z) {}
|
||||
static class World implements DesertVegetation.World {
|
||||
final Map<Pos, Plant> plants = new HashMap<>();
|
||||
Ground ground = Ground.SAND;
|
||||
boolean desert = true;
|
||||
boolean mixed;
|
||||
boolean blocked;
|
||||
int ceiling = 320;
|
||||
int readsOutside;
|
||||
public int surfaceY(int x, int z) { return 4; }
|
||||
public int maxY() { return ceiling; }
|
||||
public boolean desert(int x, int y, int z) { return desert && (!mixed || x < 8); }
|
||||
public Ground ground(int x, int y, int z) { return ground; }
|
||||
public boolean air(int x, int y, int z) {
|
||||
if (x < 0 || x > 15 || z < 0 || z > 15) readsOutside++;
|
||||
return y >= 4 && !blocked && !plants.containsKey(new Pos(x,y,z));
|
||||
}
|
||||
public void set(int x, int y, int z, Plant plant) {
|
||||
if (x < 0 || x > 15 || z < 0 || z > 15 || y >= ceiling)
|
||||
throw new AssertionError("Write outside chunk/world bounds");
|
||||
if (plants.putIfAbsent(new Pos(x,y,z),plant) != null)
|
||||
throw new AssertionError("Overwrote existing vegetation");
|
||||
}
|
||||
}
|
||||
static int place(World w, Kind k, long seed) {
|
||||
return DesertVegetation.place(w,k,0,0,new Random(seed)::nextInt);
|
||||
}
|
||||
static void check(boolean condition, String label) {
|
||||
if (!condition) throw new AssertionError(label);
|
||||
}
|
||||
public static void main(String[] args) {
|
||||
for (Kind kind : Kind.values()) {
|
||||
var a = new World();
|
||||
int count = place(a,kind,108);
|
||||
check(count > 0,"Page produces plants: "+kind);
|
||||
var b = new World();
|
||||
place(b,kind,108);
|
||||
check(a.plants.equals(b.plants),"Seeded repeatability: "+kind);
|
||||
check(a.readsOutside == 0,"Chunk-local checks: "+kind);
|
||||
if (kind == Kind.FLOWERS)
|
||||
check(a.plants.values().stream().allMatch(p -> p == Plant.DEAD_BUSH),"Desert plants only");
|
||||
else {
|
||||
int max = a.plants.keySet().stream().mapToInt(Pos::y).max().orElseThrow() - 3;
|
||||
check(kind == Kind.HUGE_TREES ? max >= 5 && max <= 9 : max <= 3,"Cactus heights");
|
||||
}
|
||||
int original = a.plants.size();
|
||||
for (int n=1;n<4;n++) place(a,kind,108+n);
|
||||
check(a.plants.size() > original,"Repeated pages add plants: "+kind);
|
||||
|
||||
var outside = new World(); outside.desert = false;
|
||||
check(place(outside,kind,108)==0 && outside.plants.isEmpty(),"No non-desert writes");
|
||||
var unsupported = new World(); unsupported.ground=Ground.OTHER;
|
||||
check(place(unsupported,kind,108)==0 && unsupported.plants.isEmpty(),"Preserve rock/invalid ground");
|
||||
var blocked = new World(); blocked.blocked=true; blocked.ground=Ground.SOIL;
|
||||
check(place(blocked,kind,108)==0 && blocked.plants.isEmpty(),"No partial writes when obstructed");
|
||||
var mixed = new World(); mixed.mixed=true;
|
||||
place(mixed,kind,108);
|
||||
check(mixed.plants.keySet().stream().allMatch(p -> p.x()<8),"Candidate biome selection");
|
||||
}
|
||||
var flat = new World(); flat.ground=Ground.SOIL;
|
||||
int cacti=place(flat,Kind.TREES,108);
|
||||
check(cacti>0 && flat.plants.values().stream().filter(p -> p==Plant.SAND).count()==cacti,
|
||||
"Flat soil converts exactly one base per cactus");
|
||||
var low = new World(); low.ceiling=8;
|
||||
check(place(low,Kind.HUGE_TREES,108)==0 && low.plants.isEmpty(),"No truncated tall cactus/headroom writes");
|
||||
System.out.println("DESERT108_PASS: placement, heights, repeated pages, seed repeatability, biome boundaries, "
|
||||
+"chunk bounds, obstruction, ground protection, Flat bases and ceiling");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
package net.dnorberg.rivencraft.regression;
|
||||
|
||||
import java.util.List;
|
||||
import net.dnorberg.rivencraft.age.*;
|
||||
import net.dnorberg.rivencraft.writing.PortRegistryPages;
|
||||
import net.minecraft.core.BlockPos;
|
||||
import net.minecraft.core.registries.Registries;
|
||||
import net.minecraft.resources.Identifier;
|
||||
import net.minecraft.resources.ResourceKey;
|
||||
import net.minecraft.tags.TagKey;
|
||||
import net.minecraft.world.level.biome.Biome;
|
||||
import net.minecraft.world.level.block.Blocks;
|
||||
import net.neoforged.bus.api.SubscribeEvent;
|
||||
import net.neoforged.fml.common.EventBusSubscriber;
|
||||
import net.neoforged.neoforge.event.server.ServerStartedEvent;
|
||||
|
||||
@EventBusSubscriber(modid="rivencraft")
|
||||
public class DesertProbe {
|
||||
@SubscribeEvent public static void start(ServerStartedEvent event) {
|
||||
event.getServer().execute(() -> {
|
||||
try {
|
||||
var server=event.getServer();
|
||||
for (String name : List.of("minecraft:desert","biomesoplenty:dryland")) {
|
||||
var biome=server.registryAccess().lookupOrThrow(Registries.BIOME)
|
||||
.getOrThrow(ResourceKey.create(Registries.BIOME,Identifier.parse(name)));
|
||||
System.out.println("DESERT263_CLASSIFY "+name+" own="+biome.is(PortSurfaceVegetation.DESERTS)
|
||||
+" common="+biome.is(TagKey.<Biome>create(Registries.BIOME,Identifier.parse("c:is_desert")))
|
||||
+" cave="+PortRegistryPages.isCaveBiome(biome));
|
||||
var level=RuntimeAgeBackend.create(server,Identifier.parse("rivencraft:age/probe_"+name.split(":")[1]),
|
||||
1115555888188619066L,
|
||||
new PortBiomePlan(PortBiomePlan.Distribution.SINGLE,List.of(Identifier.parse(name))),
|
||||
PortAgeTerrain.FLAT,null,
|
||||
new PortVegetationPlan(List.of(PortVegetationPlan.TREES,PortVegetationPlan.HUGE_TREES,
|
||||
PortVegetationPlan.FLOWERS)),0,null,null);
|
||||
level.getChunk(0,0);
|
||||
var probePos=new BlockPos(8,3,8);
|
||||
System.out.println("DESERT263_HEIGHT "+name
|
||||
+" motion="+level.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.MOTION_BLOCKING_NO_LEAVES,8,8)
|
||||
+" wg="+level.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.WORLD_SURFACE_WG,8,8)
|
||||
+" ground="+level.getBlockState(probePos)
|
||||
+" dirt="+level.getBlockState(probePos).is(net.minecraft.tags.BlockTags.DIRT)
|
||||
+" belowSturdy="+level.getBlockState(probePos.below()).isFaceSturdy(level,probePos.below(),net.minecraft.core.Direction.UP));
|
||||
java.util.Map<String,Integer> ground=new java.util.TreeMap<>();
|
||||
int cacti=0,bushes=0;
|
||||
for(int x=0;x<16;x++)for(int z=0;z<16;z++) {
|
||||
ground.merge(level.getBlockState(new BlockPos(x,4,z)).toString(),1,Integer::sum);
|
||||
for(int y=4;y<20;y++) {
|
||||
var state=level.getBlockState(new BlockPos(x,y,z));
|
||||
if(state.is(Blocks.CACTUS))cacti++;
|
||||
if(state.is(Blocks.DEAD_BUSH))bushes++;
|
||||
}
|
||||
}
|
||||
System.out.println("DESERT263_RESULT "+name+" cacti="+cacti+" bushes="+bushes+" ground="+ground);
|
||||
if(cacti==0)
|
||||
throw new AssertionError("No authored cactus in "+name);
|
||||
}
|
||||
System.out.println("DESERT263_PASS");
|
||||
}catch(Throwable error){
|
||||
System.out.println("DESERT263_FAIL "+error);
|
||||
error.printStackTrace();
|
||||
}finally{event.getServer().halt(false);}
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
package net.dnorberg.rivencraft.book;
|
||||
import java.util.*;
|
||||
import net.dnorberg.rivencraft.shared.NativeBiomeKind;
|
||||
import net.dnorberg.rivencraft.compat.TerraBlenderBiomes;
|
||||
import net.minecraft.core.Holder;
|
||||
import net.minecraft.core.registries.Registries;
|
||||
import net.minecraft.resources.ResourceLocation;
|
||||
import net.minecraft.resources.ResourceKey;
|
||||
import net.minecraft.tags.BiomeTags;
|
||||
import net.minecraft.world.level.biome.*;
|
||||
import net.minecraft.server.MinecraftServer;
|
||||
import net.neoforged.bus.api.SubscribeEvent;
|
||||
import net.neoforged.fml.common.EventBusSubscriber;
|
||||
import net.neoforged.neoforge.event.server.ServerStartedEvent;
|
||||
|
||||
|
||||
@EventBusSubscriber(modid="rivencraft")
|
||||
public final class NativeBiomeProbe {
|
||||
static net.dnorberg.rivencraft.writing.WritingEntry page(String path) {
|
||||
return net.dnorberg.rivencraft.writing.WritingEntry.symbol(
|
||||
new net.dnorberg.rivencraft.writing.SymbolReference(id(path)));
|
||||
}
|
||||
static int checks;
|
||||
static void check(boolean value,String label) { if(!value) throw new AssertionError(label); checks++; }
|
||||
static ResourceLocation id(String path) { return ResourceLocation.fromNamespaceAndPath("rivencraft",path); }
|
||||
@SubscribeEvent public static void start(ServerStartedEvent event) {
|
||||
event.getServer().execute(() -> {
|
||||
try { run(event.getServer()); System.out.println("NATIVE111_PASS checks="+checks); }
|
||||
catch(Throwable error) { System.out.println("NATIVE111_FAIL "+error); error.printStackTrace(); }
|
||||
finally { event.getServer().halt(false); }
|
||||
});
|
||||
}
|
||||
static void run(MinecraftServer server) throws Exception {
|
||||
var registry=server.registryAccess().lookupOrThrow(Registries.BIOME);
|
||||
var nether=new HashSet<>(TerraBlenderBiomes.nether(server.registryAccess()));
|
||||
nether.remove(ResourceLocation.parse("terrablender:deferred_placeholder"));
|
||||
var caves=NativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.CAVES);
|
||||
check(caves.size()>=3,"Multiple baseline caves");
|
||||
check(caves.stream().allMatch(key->!registry.getOrThrow(ResourceKey.create(Registries.BIOME,key))
|
||||
.is(BiomeTags.IS_NETHER) && !nether.contains(key)),"Native caves exclude all Nether sources");
|
||||
check(NativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.NETHER).containsAll(nether),"Region-based Nether inclusion");
|
||||
var lush=registry.getOrThrow(Biomes.LUSH_CAVES);
|
||||
var bind=Holder.Reference.class.getDeclaredMethod("bindTags",Collection.class);
|
||||
bind.setAccessible(true);
|
||||
var old=lush.tags().toList();
|
||||
try {
|
||||
var tags=new ArrayList<>(old);tags.add(BiomeTags.IS_NETHER);bind.invoke(lush,tags);
|
||||
check(!NativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.CAVES).contains(Biomes.LUSH_CAVES.location()),
|
||||
"Nether wins over overlapping Cave tag");
|
||||
} finally { bind.invoke(lush,old); }
|
||||
if(!nether.isEmpty()) {
|
||||
var key=nether.stream().sorted().findFirst().orElseThrow();
|
||||
var biome=registry.getOrThrow(ResourceKey.create(Registries.BIOME,key));
|
||||
var original=biome.tags().toList();
|
||||
try {
|
||||
var tags=new ArrayList<>(original);tags.remove(BiomeTags.IS_NETHER);tags.add(NativeBiomePools.CAVES);
|
||||
bind.invoke(biome,tags);
|
||||
check(!biome.is(BiomeTags.IS_NETHER),"Region-only fixture lacks Nether tag");
|
||||
check(NativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.NETHER).contains(key),"Region-only Nether retained");
|
||||
check(!NativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.CAVES).contains(key),"Region-only Nether excluded from Caves");
|
||||
} finally { bind.invoke(biome,original); }
|
||||
}
|
||||
var allTags=new LinkedHashMap<Holder.Reference<Biome>,List<net.minecraft.tags.TagKey<Biome>>>();
|
||||
try {
|
||||
registry.listElements().forEach(biome->{
|
||||
var tags=biome.tags().toList();allTags.put(biome,tags);
|
||||
var stripped=new ArrayList<>(tags);stripped.remove(NativeBiomePools.CAVES);
|
||||
try { bind.invoke(biome,stripped); } catch(Exception error) { throw new RuntimeException(error); }
|
||||
});
|
||||
check(NativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.CAVES).contains(Biomes.LUSH_CAVES.location()),
|
||||
"Empty cave tag has non-Nether vanilla fallback");
|
||||
} finally {
|
||||
for(var entry:allTags.entrySet()) bind.invoke(entry.getKey(),entry.getValue());
|
||||
}
|
||||
var traits=AgeTraits.select(111L).withBiomeDistribution(AgeTraits.BiomeDistribution.NATIVE);
|
||||
var sourceMethod=AgeDimensionService.class.getDeclaredMethod("createBiomeSource",
|
||||
MinecraftServer.class,AgeDefinition.class,AgeRuntimeProfile.class);
|
||||
sourceMethod.setAccessible(true);
|
||||
for(var family:List.of(NativeBiomeKind.CAVES,NativeBiomeKind.NETHER,NativeBiomeKind.END))
|
||||
for(var terrain:List.of("standard","amplified","island","cave","flat","void")) {
|
||||
var writing=new net.dnorberg.rivencraft.writing.OrderedWriting(List.of(
|
||||
net.dnorberg.rivencraft.writing.WritingEntry.linkPanel(),page("terrain/"+terrain),
|
||||
page("biome/native_"+family.name().toLowerCase(Locale.ROOT))));
|
||||
var plan=AgeGenerationPlan.compile(writing,111L,AgeGenerationProfiles.STANDARD,traits,server.registryAccess());
|
||||
check(plan.biomeSelection().nativeKind()==family,"Family on "+terrain);
|
||||
check(plan.biomeSelection().biomes().equals(NativeBiomePools.pool(server.registryAccess(),family)),"Frozen family pool");
|
||||
var loaded=AgeGenerationPlan.load(plan.save());
|
||||
check(loaded.biomeSelection().equals(plan.biomeSelection()),"Plan reload");
|
||||
var age=new AgeDefinition(UUID.randomUUID(),"probe",111L,AgeGenerationProfiles.STANDARD,
|
||||
AgeDefinition.CURRENT_GENERATION_VERSION,0L,id("age/probe"),null,traits,loaded);
|
||||
var source=(BiomeSource)sourceMethod.invoke(null,server,age,loaded.runtimeProfile());
|
||||
check(source.possibleBiomes().stream().map(b->b.unwrapKey().orElseThrow().location()).collect(java.util.stream.Collectors.toSet())
|
||||
.equals(new HashSet<>(plan.biomeSelection().biomes())),"Generator consumes family on "+terrain);
|
||||
}
|
||||
var repeated=new net.dnorberg.rivencraft.writing.OrderedWriting(List.of(
|
||||
net.dnorberg.rivencraft.writing.WritingEntry.linkPanel(),page("terrain/flat"),
|
||||
page("biome/native_nether"),page("biome/native_end")));
|
||||
check(AgeGenerationPlan.compile(repeated,111L,AgeGenerationProfiles.STANDARD,traits,server.registryAccess())
|
||||
.biomeSelection().nativeKind()==NativeBiomeKind.END,"Last family controller wins");
|
||||
var caveProfile=AgeRuntimeProfiles.resolve(AgeGenerationProfiles.CAVE);
|
||||
var empty=net.dnorberg.rivencraft.writing.WritingGrammar.parse(net.dnorberg.rivencraft.writing.OrderedWriting.EMPTY);
|
||||
var omitted=AgeBiomeSelection.compile(empty,traits,caveProfile,111L,server.registryAccess());
|
||||
check(omitted.nativeKind()==NativeBiomeKind.CAVES && omitted.biomes().equals(caves),"Seed-completed Cave Native");
|
||||
var nativeWriting=new net.dnorberg.rivencraft.writing.OrderedWriting(List.of(
|
||||
net.dnorberg.rivencraft.writing.WritingEntry.linkPanel(),page("terrain/cave"),page("biome/native")));
|
||||
check(AgeGenerationPlan.compile(nativeWriting,111L,AgeGenerationProfiles.STANDARD,traits,server.registryAccess())
|
||||
.biomeSelection().biomes().equals(caves),"Explicit Cave Native");
|
||||
var authored=new net.dnorberg.rivencraft.writing.OrderedWriting(List.of(
|
||||
net.dnorberg.rivencraft.writing.WritingEntry.linkPanel(),page("terrain/cave"),
|
||||
page("biome/crimson_forest"),page("biome/single")));
|
||||
check(AgeGenerationPlan.compile(authored,111L,AgeGenerationProfiles.STANDARD,traits,server.registryAccess())
|
||||
.biomeSelection().biomes().equals(List.of(ResourceLocation.withDefaultNamespace("crimson_forest"))),"Authored Nether Cave retained");
|
||||
var oldPool=new AgeBiomeSelection(AgeTraits.BiomeDistribution.NATIVE,List.of(
|
||||
ResourceLocation.withDefaultNamespace("lush_caves"),ResourceLocation.withDefaultNamespace("crimson_forest")));
|
||||
var tag=oldPool.save();tag.remove("NativeKind");
|
||||
check(AgeBiomeSelection.load(tag).equals(oldPool),"Old frozen mixed pool retained");
|
||||
var one=new AgeBiomeSelection(AgeTraits.BiomeDistribution.NATIVE,List.of(ResourceLocation.withDefaultNamespace("lush_caves")),NativeBiomeKind.CAVES);
|
||||
check(AgeBiomeSelection.load(one.save()).equals(one),"Single-cave pool is valid");
|
||||
var policy=new RandomPagePolicy(Set.of(id("biome/native_nether")),Set.of());
|
||||
check(policy.allows(id("biome/plains")) && !policy.allows(id("biome/native")),"Controller lists do not restrict individual biomes");
|
||||
String name=null;
|
||||
for(int i=0;i<10000;i++) {
|
||||
String candidate="native111_"+i;
|
||||
long seed=server.overworld().getSeed()+AgeDefinition.namedDimensionId(candidate).hashCode();
|
||||
if(AgeRuntimeProfiles.select(seed).equals(AgeGenerationProfiles.CAVE)
|
||||
&& AgeTraits.select(seed).biomeDistribution()==AgeTraits.BiomeDistribution.NATIVE) {name=candidate;break;}
|
||||
}
|
||||
check(name!=null,"Find random Native Cave seed");
|
||||
var age=AgeRegistrySavedData.resolveOrCreate(server.overworld(),new AgeReference(UUID.randomUUID(),name));
|
||||
check(age.randomBiomes()!=null && age.randomBiomes().nativeKind()==NativeBiomeKind.CAVES,"Random Native Cave frozen at creation");
|
||||
check(age.withSpawn(new net.minecraft.core.BlockPos(0,64,0)).randomBiomes().equals(age.randomBiomes()),"Spawn update preserves pool");
|
||||
var saved=AgeRegistrySavedData.get(server.overworld()).save(new net.minecraft.nbt.CompoundTag(),server.registryAccess());
|
||||
var restored=AgeRegistrySavedData.load(saved,server.registryAccess()).find(age.id()).orElseThrow();
|
||||
check(restored.randomBiomes().equals(age.randomBiomes()),"Random pool registry round trip");
|
||||
|
||||
try(var stream=NativeBiomeProbe.class.getResourceAsStream("/assets/rivencraft/creative_symbol_pages.json")) {
|
||||
var index=com.google.gson.JsonParser.parseReader(new java.io.InputStreamReader(stream)).getAsJsonObject();
|
||||
for(var family:List.of("native_caves","native_nether","native_end"))
|
||||
check(index.getAsJsonObject("rivencraft:biome/"+family).getAsJsonObject("semantics")
|
||||
.get("role").getAsString().equals("biome_controller"),"Creative/JEI index controller "+family);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
package net.dnorberg.rivencraft.age;
|
||||
import java.util.*;
|
||||
import net.dnorberg.rivencraft.shared.NativeBiomeKind;
|
||||
import net.dnorberg.rivencraft.compat.TerraBlenderBiomes;
|
||||
import net.minecraft.core.Holder;
|
||||
import net.minecraft.core.registries.Registries;
|
||||
import net.minecraft.resources.Identifier;
|
||||
import net.minecraft.resources.ResourceKey;
|
||||
import net.minecraft.tags.BiomeTags;
|
||||
import net.minecraft.world.level.biome.*;
|
||||
import net.minecraft.server.MinecraftServer;
|
||||
import net.neoforged.bus.api.SubscribeEvent;
|
||||
import net.neoforged.fml.common.EventBusSubscriber;
|
||||
import net.neoforged.neoforge.event.server.ServerStartedEvent;
|
||||
|
||||
|
||||
@EventBusSubscriber(modid="rivencraft")
|
||||
public final class NativeBiomeProbe {
|
||||
static int checks;
|
||||
static void check(boolean value,String label) { if(!value) throw new AssertionError(label); checks++; }
|
||||
static Identifier id(String path) { return Identifier.fromNamespaceAndPath("rivencraft",path); }
|
||||
@SubscribeEvent public static void start(ServerStartedEvent event) {
|
||||
event.getServer().execute(() -> {
|
||||
try { run(event.getServer()); System.out.println("NATIVE111_PASS checks="+checks); }
|
||||
catch(Throwable error) { System.out.println("NATIVE111_FAIL "+error); error.printStackTrace(); }
|
||||
finally { event.getServer().halt(false); }
|
||||
});
|
||||
}
|
||||
static void run(MinecraftServer server) throws Exception {
|
||||
var registry=server.registryAccess().lookupOrThrow(Registries.BIOME);
|
||||
var nether=new HashSet<>(TerraBlenderBiomes.nether(server.registryAccess()));
|
||||
nether.remove(Identifier.parse("terrablender:deferred_placeholder"));
|
||||
var caves=PortNativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.CAVES);
|
||||
check(caves.size()>=3,"Multiple baseline caves");
|
||||
check(caves.stream().allMatch(key->!registry.getOrThrow(ResourceKey.create(Registries.BIOME,key))
|
||||
.is(BiomeTags.IS_NETHER) && !nether.contains(key)),"Native caves exclude all Nether sources");
|
||||
check(PortNativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.NETHER).containsAll(nether),"Region-based Nether inclusion");
|
||||
var lush=registry.getOrThrow(Biomes.LUSH_CAVES);
|
||||
var bind=Holder.Reference.class.getDeclaredMethod("bindTags",Collection.class);
|
||||
bind.setAccessible(true);
|
||||
var old=lush.tags().toList();
|
||||
try {
|
||||
var tags=new ArrayList<>(old);tags.add(BiomeTags.IS_NETHER);bind.invoke(lush,tags);
|
||||
check(!PortNativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.CAVES).contains(Biomes.LUSH_CAVES.identifier()),
|
||||
"Nether wins over overlapping Cave tag");
|
||||
} finally { bind.invoke(lush,old); }
|
||||
if(!nether.isEmpty()) {
|
||||
var key=nether.stream().sorted().findFirst().orElseThrow();
|
||||
var biome=registry.getOrThrow(ResourceKey.create(Registries.BIOME,key));
|
||||
var original=biome.tags().toList();
|
||||
try {
|
||||
var tags=new ArrayList<>(original);tags.remove(BiomeTags.IS_NETHER);tags.add(PortNativeBiomePools.CAVES);
|
||||
bind.invoke(biome,tags);
|
||||
check(!biome.is(BiomeTags.IS_NETHER),"Region-only fixture lacks Nether tag");
|
||||
check(PortNativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.NETHER).contains(key),"Region-only Nether retained");
|
||||
check(!PortNativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.CAVES).contains(key),"Region-only Nether excluded from Caves");
|
||||
} finally { bind.invoke(biome,original); }
|
||||
}
|
||||
var allTags=new LinkedHashMap<Holder.Reference<Biome>,List<net.minecraft.tags.TagKey<Biome>>>();
|
||||
try {
|
||||
registry.listElements().forEach(biome->{
|
||||
var tags=biome.tags().toList();allTags.put(biome,tags);
|
||||
var stripped=new ArrayList<>(tags);stripped.remove(PortNativeBiomePools.CAVES);
|
||||
try { bind.invoke(biome,stripped); } catch(Exception error) { throw new RuntimeException(error); }
|
||||
});
|
||||
check(PortNativeBiomePools.pool(server.registryAccess(),NativeBiomeKind.CAVES).contains(Biomes.LUSH_CAVES.identifier()),
|
||||
"Empty cave tag has non-Nether vanilla fallback");
|
||||
} finally {
|
||||
for(var entry:allTags.entrySet()) bind.invoke(entry.getKey(),entry.getValue());
|
||||
}
|
||||
var sourceMethod=RuntimeAgeBackend.class.getDeclaredMethod("authoredBiomeSource",
|
||||
MinecraftServer.class,PortBiomePlan.class,long.class);sourceMethod.setAccessible(true);
|
||||
for(var family:List.of(NativeBiomeKind.CAVES,NativeBiomeKind.NETHER,NativeBiomeKind.END))
|
||||
for(var terrain:List.of("standard","amplified","island","cave","flat","void")) {
|
||||
var selected=net.dnorberg.rivencraft.writing.PortAuthoredTerrainSelection.select(server,List.of(
|
||||
id("terrain/"+terrain),id("biome/native_"+family.name().toLowerCase(Locale.ROOT))),111L);
|
||||
var plan=selected.biomes();
|
||||
check(plan.nativeKind()==family,"Family on "+terrain);
|
||||
check(plan.biomes().equals(PortNativeBiomePools.pool(server.registryAccess(),family)),"Frozen family pool");
|
||||
var saved=PortBiomePlan.CODEC.encodeStart(com.mojang.serialization.JsonOps.INSTANCE,plan).getOrThrow();
|
||||
check(PortBiomePlan.CODEC.parse(com.mojang.serialization.JsonOps.INSTANCE,saved).getOrThrow().equals(plan),"Plan codec reload");
|
||||
var source=(BiomeSource)sourceMethod.invoke(null,server,plan,111L);
|
||||
check(source.possibleBiomes().stream().map(b->b.unwrapKey().orElseThrow().identifier()).collect(java.util.stream.Collectors.toSet())
|
||||
.equals(new HashSet<>(plan.biomes())),"Source consumes family");
|
||||
}
|
||||
check(net.dnorberg.rivencraft.writing.PortAuthoredWriting.biomePlan(List.of(id("terrain/flat"),
|
||||
id("biome/native_nether"),id("biome/native_end")),server,111L).nativeKind()==NativeBiomeKind.END,
|
||||
"Last family controller wins even for direct compiler calls");
|
||||
var explicit=net.dnorberg.rivencraft.writing.PortAuthoredTerrainSelection.select(server,
|
||||
List.of(id("terrain/cave"),id("biome/native")),111L).biomes();
|
||||
check(explicit.nativeKind()==NativeBiomeKind.CAVES && explicit.biomes().equals(caves),"Explicit Cave Native");
|
||||
long nativeSeed=0;
|
||||
while(PortRandomAgeSelection.distribution(nativeSeed)!=PortBiomePlan.Distribution.NATIVE)nativeSeed++;
|
||||
var omitted=net.dnorberg.rivencraft.writing.PortAuthoredTerrainSelection.select(server,
|
||||
List.of(id("terrain/cave")),nativeSeed).biomes();
|
||||
check(omitted.nativeKind()==NativeBiomeKind.CAVES,"Seed-completed Native Cave");
|
||||
long randomSeed=0;
|
||||
while(PortRandomAgeSelection.terrain(randomSeed)!=PortAgeTerrain.CAVE
|
||||
|| PortRandomAgeSelection.distribution(randomSeed)!=PortBiomePlan.Distribution.NATIVE)randomSeed++;
|
||||
var random=PortRandomAgeSelection.select(server,randomSeed);
|
||||
check(random.biomes().nativeKind()==NativeBiomeKind.CAVES && random.biomes().biomes().equals(caves),"Random Native Cave");
|
||||
var authored=net.dnorberg.rivencraft.writing.PortAuthoredTerrainSelection.select(server,List.of(
|
||||
id("terrain/cave"),id("biome/crimson_forest"),id("biome/single")),111L).biomes();
|
||||
check(authored.biomes().equals(List.of(Identifier.withDefaultNamespace("crimson_forest"))),"Authored Nether Cave retained");
|
||||
var oldJson=com.google.gson.JsonParser.parseString(
|
||||
"{\"distribution\":\"NATIVE\",\"biomes\":[\"minecraft:lush_caves\",\"minecraft:crimson_forest\"]}");
|
||||
var oldPool=PortBiomePlan.CODEC.parse(com.mojang.serialization.JsonOps.INSTANCE,oldJson).getOrThrow();
|
||||
check(oldPool.nativeKind()==NativeBiomeKind.TERRAIN && oldPool.biomes().size()==2,"Old frozen mixed pool retained");
|
||||
var policy=new PortRandomPagePolicy(Set.of(id("biome/native_nether")),Set.of());
|
||||
check(policy.allows(id("biome/plains")) && !policy.allows(id("biome/native")),"Policy category");
|
||||
int n=0;
|
||||
for(var family:List.of(NativeBiomeKind.CAVES,NativeBiomeKind.NETHER,NativeBiomeKind.END)) {
|
||||
var terrain=family==NativeBiomeKind.CAVES?PortAgeTerrain.VOID:family==NativeBiomeKind.NETHER?PortAgeTerrain.STANDARD:PortAgeTerrain.CAVE;
|
||||
var plan=new PortBiomePlan(PortBiomePlan.Distribution.NATIVE,PortNativeBiomePools.pool(server.registryAccess(),family),family);
|
||||
var age=RuntimeAgeBackend.create(server,id("age/native111_"+n++),111L,plan,terrain);
|
||||
check(age.getChunkSource().getGenerator().getBiomeSource().possibleBiomes().size()==plan.biomes().size(),"Runtime terrain override "+terrain);
|
||||
}
|
||||
check(registry.get(ResourceKey.create(Registries.BIOME,Identifier.withDefaultNamespace("sulfur_caves"))).isEmpty()
|
||||
|| caves.contains(Identifier.withDefaultNamespace("sulfur_caves")),"New vanilla Sulfur Caves included");
|
||||
|
||||
try(var stream=NativeBiomeProbe.class.getResourceAsStream("/assets/rivencraft/creative_symbol_pages.json")) {
|
||||
var index=com.google.gson.JsonParser.parseReader(new java.io.InputStreamReader(stream)).getAsJsonObject();
|
||||
for(var family:List.of("native_caves","native_nether","native_end"))
|
||||
check(index.getAsJsonObject("rivencraft:biome/"+family).getAsJsonObject("semantics")
|
||||
.get("role").getAsString().equals("biome_controller"),"Creative/JEI index controller "+family);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
package net.dnorberg.rivencraft.regression;
|
||||
|
||||
import java.util.List;
|
||||
import net.dnorberg.rivencraft.Rivencraft;
|
||||
import net.dnorberg.rivencraft.PortConfig;
|
||||
import net.dnorberg.rivencraft.age.*;
|
||||
import net.dnorberg.rivencraft.compat.*;
|
||||
import net.dnorberg.rivencraft.portal.*;
|
||||
import net.dnorberg.rivencraft.block.*;
|
||||
import net.dnorberg.rivencraft.block.entity.BookReceptacleBlockEntity;
|
||||
import net.dnorberg.rivencraft.item.LinkBookTarget;
|
||||
import net.minecraft.core.BlockPos;
|
||||
import net.minecraft.core.Direction;
|
||||
import net.minecraft.resources.Identifier;
|
||||
import net.minecraft.world.item.ItemStack;
|
||||
import net.minecraft.world.phys.AABB;
|
||||
import net.neoforged.bus.api.SubscribeEvent;
|
||||
import net.neoforged.fml.common.EventBusSubscriber;
|
||||
import net.neoforged.neoforge.event.server.ServerStartedEvent;
|
||||
|
||||
@EventBusSubscriber(modid="rivencraft")
|
||||
public final class PortalEngineProbe {
|
||||
private static int checks;
|
||||
@SubscribeEvent public static void join(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) {
|
||||
if(event.getEntity().getClass().getName().startsWith("qouteall.imm_ptl"))
|
||||
System.out.println("PORTAL117_SPAWN "+event.getEntity()+" at "+event.getEntity().getBoundingBox());
|
||||
}
|
||||
private static void check(boolean pass,String label) {
|
||||
if(!pass) throw new AssertionError(label);
|
||||
checks++;
|
||||
}
|
||||
private static int warmup;
|
||||
@SubscribeEvent public static void start(ServerStartedEvent event) {
|
||||
event.getServer().overworld().setChunkForced(0,0,true);
|
||||
warmup=3;
|
||||
}
|
||||
@SubscribeEvent public static void tick(net.neoforged.neoforge.event.tick.ServerTickEvent.Post event) {
|
||||
if(warmup<=0 || --warmup!=0) return;
|
||||
event.getServer().execute(() -> {
|
||||
try {
|
||||
run(event.getServer());
|
||||
System.out.println("PORTAL117_PASS checks="+checks);
|
||||
}catch(Throwable error) {
|
||||
System.out.println("PORTAL117_FAIL "+error);
|
||||
error.printStackTrace();
|
||||
}finally { event.getServer().halt(false); }
|
||||
});
|
||||
}
|
||||
private static void run(net.minecraft.server.MinecraftServer server) {
|
||||
boolean nativeViews=ImmersiveBookPreviews.available();
|
||||
check(ImmersiveBookPreviews.bookViewsEnabled()==nativeViews,"Default book view selection");
|
||||
check(ImmersiveBookPreviews.crystalViewsEnabled()==nativeViews,"Default crystal view selection");
|
||||
var id=Identifier.parse("rivencraft:age/portal117");
|
||||
var destination=RuntimeAgeBackend.create(server,id,117L,null,PortAgeTerrain.FLAT);
|
||||
check(ImmersivePortalsCompatibility.synchronize(server),"Dynamic catalog sync");
|
||||
check(server.getLevel(destination.dimension())==destination,"First-party Age remains authoritative");
|
||||
destination.getChunkAt(new BlockPos(24,4,24));
|
||||
var level=server.overworld();
|
||||
level.getChunk(0,0);
|
||||
var owner=new BlockPos(7,65,7);
|
||||
for(int x=7;x<=10;x++) for(int y=64;y<=68;y++)
|
||||
if(x==7 || x==10 || y==64 || y==68)
|
||||
level.setBlock(new BlockPos(x,y,8),Rivencraft.CRYSTAL_BLOCK.get().defaultBlockState(),2);
|
||||
level.setBlock(owner,Rivencraft.BOOK_RECEPTACLE.get().defaultBlockState()
|
||||
.setValue(BookReceptacleBlock.FACING,Direction.NORTH),2);
|
||||
var holder=(BookReceptacleBlockEntity)level.getBlockEntity(owner);
|
||||
var book=new ItemStack(Rivencraft.LINKING_BOOK.get());
|
||||
book.set(Rivencraft.LINK_BOOK_TARGET.get(),new LinkBookTarget(id,24.5,4,24.5,90,0));
|
||||
holder.setBook(book);
|
||||
var plan=CrystalPortalNetwork.plan(level,owner);
|
||||
check(plan.valid() && plan.portalCells().size()==6,"One six-cell opening");
|
||||
check(CrystalPortalNetwork.activate(level,owner,plan,null),"Frame activation");
|
||||
System.out.println("PORTAL117_SURFACES "+CrystalPortalSurfaces.group(level,plan));
|
||||
System.out.println("PORTAL117_DEST "+PortalBookTravel.destination(level,book,owner,0,0));
|
||||
if(nativeViews) System.out.println("PORTAL117_NATIVE "+Native.count(level,owner));
|
||||
check(plan.portalCells().stream().allMatch(pos->level.getBlockState(pos).getValue(CrystalPortalBlock.LIVE_VIEW)==nativeViews),
|
||||
"Native or fallback state");
|
||||
if(nativeViews) Native.checkViews(level,owner,plan,id);
|
||||
CrystalPortalNetwork.shutdown(level,owner);
|
||||
if(nativeViews) check(Native.count(level,owner)==0,"Shutdown removes native surfaces");
|
||||
check(plan.portalCells().stream().noneMatch(pos->level.getBlockState(pos).is(Rivencraft.CRYSTAL_PORTAL.get())),
|
||||
"Shutdown removes cells");
|
||||
}
|
||||
private static final class Native {
|
||||
static java.util.List<qouteall.imm_ptl.core.portal.Portal> portals(
|
||||
net.minecraft.server.level.ServerLevel level,BlockPos owner) {
|
||||
return level.getEntitiesOfClass(qouteall.imm_ptl.core.portal.Portal.class,new AABB(owner).inflate(20),
|
||||
e->e.portalTag!=null && e.portalTag.startsWith("rivencraft:crystal:mc263:v1:"));
|
||||
}
|
||||
static int count(net.minecraft.server.level.ServerLevel level,BlockPos owner) { return portals(level,owner).size(); }
|
||||
static void checkViews(net.minecraft.server.level.ServerLevel level,BlockPos owner,
|
||||
CrystalPortalNetwork.Plan plan,Identifier id) {
|
||||
var views=portals(level,owner);
|
||||
check(views.size()==2,"One continuous mesh per side, not six repeated views");
|
||||
for(var view:views) {
|
||||
check(!view.getTeleportable() && !view.isInteractable(),"Rivencraft retains travel/interactions");
|
||||
double spanX=Math.abs(view.getAxisW().x*view.getWidth())+Math.abs(view.getAxisH().x*view.getHeight());
|
||||
double spanY=Math.abs(view.getAxisW().y*view.getWidth())+Math.abs(view.getAxisH().y*view.getHeight());
|
||||
check(Math.abs(spanX-2)<0.00001 && Math.abs(spanY-3)<0.00001,"Whole opening dimensions");
|
||||
var eye=new net.minecraft.world.phys.Vec3(9,65+1.62,8.5);
|
||||
check(view.transformPoint(eye).distanceTo(new net.minecraft.world.phys.Vec3(24.5,4+1.62,24.5))<0.00001,
|
||||
"Standing eye maps to exact linked arrival");
|
||||
check(view.getDestDim().identifier().equals(id),"Dynamic destination");
|
||||
check(view.getPortalShape() instanceof qouteall.imm_ptl.core.portal.shape.SpecialFlatPortalShape,
|
||||
"Masked opening mesh");
|
||||
}
|
||||
var ids=views.stream().map(net.minecraft.world.entity.Entity::getUUID).collect(java.util.stream.Collectors.toSet());
|
||||
ImmersiveCrystalPortals.refresh(level,owner,plan,
|
||||
((BookReceptacleBlockEntity)level.getBlockEntity(owner)).getBook());
|
||||
check(portals(level,owner).stream().allMatch(p->ids.contains(p.getUUID())),"Refresh reuses existing views");
|
||||
var setting=ImmersiveBookPreviews.seamless()?PortConfig.SEAMLESS_CRYSTAL_VIEWS:PortConfig.CRYSTAL_LIVE_VIEWS;
|
||||
setting.set(false);
|
||||
ImmersiveCrystalPortals.refresh(level,owner,plan,
|
||||
((BookReceptacleBlockEntity)level.getBlockEntity(owner)).getBook());
|
||||
check(count(level,owner)==0,"Config disable removes views");
|
||||
check(plan.portalCells().stream().noneMatch(pos->level.getBlockState(pos).getValue(CrystalPortalBlock.LIVE_VIEW)),
|
||||
"Disabled config restores animated fallback");
|
||||
setting.set(true);
|
||||
ImmersiveCrystalPortals.refresh(level,owner,plan,
|
||||
((BookReceptacleBlockEntity)level.getBlockEntity(owner)).getBook());
|
||||
check(count(level,owner)==2,"Config enable rebuilds views");
|
||||
}
|
||||
}
|
||||
}
|
||||
+70
@@ -0,0 +1,70 @@
|
||||
package net.dnorberg.rivencraft.regression;
|
||||
import java.util.List;
|
||||
import io.netty.buffer.Unpooled;
|
||||
import net.minecraft.network.RegistryFriendlyByteBuf;
|
||||
import net.neoforged.bus.api.SubscribeEvent;
|
||||
import net.neoforged.fml.common.EventBusSubscriber;
|
||||
import net.neoforged.neoforge.event.server.ServerStartedEvent;
|
||||
import net.dnorberg.rivencraft.book.*;
|
||||
import net.dnorberg.rivencraft.writing.*;
|
||||
import net.dnorberg.rivencraft.network.AgeCelestialAnglePayload;
|
||||
import net.minecraft.resources.ResourceLocation;
|
||||
@EventBusSubscriber(modid="rivencraft")
|
||||
public class StaticSkyProbe {
|
||||
static int checks;
|
||||
static void check(boolean condition,String label) {
|
||||
if(!condition) throw new AssertionError(label);
|
||||
checks++;
|
||||
}
|
||||
@SubscribeEvent public static void start(ServerStartedEvent event) {
|
||||
event.getServer().execute(() -> {
|
||||
try {
|
||||
run(event.getServer());
|
||||
System.out.println("STATIC109_PASS checks="+checks);
|
||||
}catch(Throwable error) {
|
||||
System.out.println("STATIC109_FAIL "+error);
|
||||
error.printStackTrace();
|
||||
}finally { event.getServer().halt(false); }
|
||||
});
|
||||
}
|
||||
static WritingEntry page(String id) {
|
||||
return WritingEntry.symbol(new SymbolReference(ResourceLocation.fromNamespaceAndPath("rivencraft",id)));
|
||||
}
|
||||
static AgeGenerationPlan plan(net.minecraft.server.MinecraftServer server,String... ids) {
|
||||
var entries=new java.util.ArrayList<WritingEntry>();
|
||||
entries.add(WritingEntry.linkPanel());
|
||||
for(var id:ids) entries.add(page(id));
|
||||
return AgeGenerationPlan.compile(new OrderedWriting(entries),109L,
|
||||
AgeGenerationProfiles.STANDARD,AgeTraits.select(109L),server.registryAccess());
|
||||
}
|
||||
static void run(net.minecraft.server.MinecraftServer server) {
|
||||
String[][] pages={{"sky/static"},{"number/0","sky/static"},{"number/8","sky/static"},
|
||||
{"number/1","number/23","sky/static"},{"number/5","number/3","sky/static"},
|
||||
{"number/24","number/24","sky/static"}};
|
||||
int[] expected={48,1,8,48,128,128};
|
||||
for(int i=0;i<pages.length;i++) {
|
||||
var plan=plan(server,pages[i]);
|
||||
check(plan.writingInstability()==0,"No number/order penalty");
|
||||
var sky=AgeSkyProfile.compile(plan,AgeTraits.select(109L));
|
||||
check(sky.staticResolution()==expected[i],"Resolution");
|
||||
var loaded=AgeGenerationPlan.load(plan.save());
|
||||
check(AgeSkyProfile.compile(loaded,AgeTraits.select(109L)).equals(sky),"Frozen plan persistence");
|
||||
var buffer=new RegistryFriendlyByteBuf(Unpooled.buffer(),server.registryAccess());
|
||||
try {
|
||||
var packet=new AgeCelestialAnglePayload(net.minecraft.world.level.Level.OVERWORLD,0F,sky);
|
||||
AgeCelestialAnglePayload.STREAM_CODEC.encode(buffer,packet);
|
||||
check(AgeCelestialAnglePayload.STREAM_CODEC.decode(buffer).equals(packet),"Network round trip");
|
||||
check(buffer.readableBytes()==0,"No unread bytes");
|
||||
}finally { buffer.release(); }
|
||||
}
|
||||
var color=plan(server,"number/10","color/red","number/8","sky/static");
|
||||
var sky=AgeSkyProfile.compile(color,AgeTraits.select(109L));
|
||||
check(sky.color()==0x640000 && sky.staticResolution()==8,"Independent color and resolution");
|
||||
check(AgeSkyProfile.compile(plan(server,"sky/overworld"),AgeTraits.select(109L)).staticResolution()==48,
|
||||
"Non-static default");
|
||||
var misplaced=plan(server,"number/8","color/red","sky/static");
|
||||
check(AgeSkyProfile.compile(misplaced,AgeTraits.select(109L)).staticResolution()==48,"Adjacent only");
|
||||
var flood=plan(server,"number/2","number/24","environment/flooded");
|
||||
check(AgeFlooding.requested(flood)==74 && flood.writingInstability()==0,"Flooded digit grammar unchanged");
|
||||
}
|
||||
}
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
package net.dnorberg.rivencraft.regression;
|
||||
import java.util.List;
|
||||
import io.netty.buffer.Unpooled;
|
||||
import net.minecraft.network.RegistryFriendlyByteBuf;
|
||||
import net.neoforged.bus.api.SubscribeEvent;
|
||||
import net.neoforged.fml.common.EventBusSubscriber;
|
||||
import net.neoforged.neoforge.event.server.ServerStartedEvent;
|
||||
import net.dnorberg.rivencraft.age.*;
|
||||
import net.dnorberg.rivencraft.writing.PortWritingRecovery;
|
||||
import net.minecraft.resources.Identifier;
|
||||
import com.mojang.serialization.JsonOps;
|
||||
import com.google.gson.JsonParser;
|
||||
@EventBusSubscriber(modid="rivencraft")
|
||||
public class StaticSkyProbe {
|
||||
static int checks;
|
||||
static void check(boolean condition,String label) {
|
||||
if(!condition) throw new AssertionError(label);
|
||||
checks++;
|
||||
}
|
||||
@SubscribeEvent public static void start(ServerStartedEvent event) {
|
||||
event.getServer().execute(() -> {
|
||||
try {
|
||||
run(event.getServer());
|
||||
System.out.println("STATIC109_PASS checks="+checks);
|
||||
}catch(Throwable error) {
|
||||
System.out.println("STATIC109_FAIL "+error);
|
||||
error.printStackTrace();
|
||||
}finally { event.getServer().halt(false); }
|
||||
});
|
||||
}
|
||||
static List<Identifier> pages(String... paths) {
|
||||
return java.util.Arrays.stream(paths).map(s->Identifier.fromNamespaceAndPath("rivencraft",s)).toList();
|
||||
}
|
||||
static void run(net.minecraft.server.MinecraftServer server) {
|
||||
String[][] cases={{"sky/static"},{"number/0","sky/static"},{"number/8","sky/static"},
|
||||
{"number/1","number/23","sky/static"},{"number/5","number/3","sky/static"},
|
||||
{"number/24","number/24","sky/static"}};
|
||||
int[] expected={48,1,8,48,128,128};
|
||||
for(int i=0;i<cases.length;i++) {
|
||||
var writing=pages(cases[i]);
|
||||
check(PortWritingRecovery.recover(writing).diagnostics().isEmpty(),"No number/order penalty");
|
||||
check(PortAgeColors.validNumbers(writing),"Numeric writing valid");
|
||||
var colors=PortAgeColors.compile(writing,109L);
|
||||
check(colors.staticResolution()==expected[i],"Resolution");
|
||||
var saved=PortAgeColors.CODEC.encodeStart(JsonOps.INSTANCE,colors).getOrThrow();
|
||||
check(PortAgeColors.CODEC.parse(JsonOps.INSTANCE,saved).getOrThrow().equals(colors),"Saved codec");
|
||||
var buffer=new RegistryFriendlyByteBuf(Unpooled.buffer(),server.registryAccess());
|
||||
try {
|
||||
var id=Identifier.parse("rivencraft:age/static_probe");
|
||||
var packet=new AgeCatalogPayload(109,List.of(id),java.util.Map.of(id,colors),
|
||||
java.util.Map.of(),java.util.Map.of());
|
||||
AgeCatalogPayload.STREAM_CODEC.encode(buffer,packet);
|
||||
check(AgeCatalogPayload.STREAM_CODEC.decode(buffer).equals(packet),"Full catalog round trip");
|
||||
check(buffer.readableBytes()==0,"No unread bytes");
|
||||
}finally { buffer.release(); }
|
||||
}
|
||||
var old=PortAgeColors.CODEC.parse(JsonOps.INSTANCE,JsonParser.parseString(
|
||||
"{\"sky\":-1,\"ambient\":-1}")).getOrThrow();
|
||||
check(old.staticResolution()==48 && old.equals(PortAgeColors.NATIVE),"Old save default");
|
||||
var color=PortAgeColors.compile(pages("number/10","color/red","number/8","sky/static"),109L);
|
||||
check(color.sky()==0x640000 && color.staticResolution()==8,"Independent color");
|
||||
check(PortAgeColors.compile(pages("number/8","color/red","sky/static"),109L).staticResolution()==48,
|
||||
"Adjacent only");
|
||||
check(PortAgeColors.compile(pages("sky/overworld"),109L).staticResolution()==48,"Non-static default");
|
||||
var flood=pages("number/2","number/24","environment/flooded");
|
||||
check(PortFlooding.requested(flood)==74 && PortWritingRecovery.recover(flood).diagnostics().isEmpty(),
|
||||
"Flooded grammar unchanged");
|
||||
check(!PortWritingRecovery.recover(pages("number/8","sky/overworld")).diagnostics().isEmpty(),
|
||||
"Other sky does not consume number");
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user