Complete 26.3 parity acceptance and dual-version release workflow
Build and smoke / changes (push) Canceled after 0s
Build and smoke / build (push) Canceled after 0s

This commit is contained in:
dnorberg committed 2026-11-14 12:17:49 -05:00
1 parent 41daff1e61
commit 4a59fb5d02
26 files changed
+1241 -369

No files matched your search

@@ -0,0 +1,58 @@
package net.dnorberg.rivencraft.regression;
import net.dnorberg.rivencraft.Rivencraft;
import net.dnorberg.rivencraft.age.*;
import net.dnorberg.rivencraft.network.*;
import net.minecraft.client.Minecraft;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.ResourceKey;
import net.neoforged.api.distmarker.Dist;
import net.neoforged.bus.api.SubscribeEvent;
import net.neoforged.fml.common.EventBusSubscriber;
import net.neoforged.neoforge.client.network.ClientPacketDistributor;
@EventBusSubscriber(modid = "rivencraft", value = Dist.CLIENT)
public final class MatrixClient {
private static MatrixPayloads.Step pending;
private static int delay;
@SubscribeEvent public static void register(net.neoforged.neoforge.client.network.event.RegisterClientPayloadHandlersEvent event) {
event.register(MatrixPayloads.Step.TYPE, (payload, context) -> { pending = payload; delay = 0; });
}
@SubscribeEvent public static void tick(net.neoforged.neoforge.client.event.ClientTickEvent.Post event) {
var minecraft = Minecraft.getInstance();
// A player object/catalog can arrive before the receiving-level screen
// finishes. Real book input is only possible once normal play resumes.
if (pending == null || minecraft.player == null || minecraft.gui.screen() != null || ++delay < 8) return;
var step = pending; pending = null;
String result = "ok";
try {
switch (step.action()) {
case "bind" -> ClientPacketDistributor.sendToServer(new BindDescriptiveBookPayload(false, "Matrix Live A"));
case "enter" -> ClientPacketDistributor.sendToServer(new UseDescriptiveBookPayload(false));
case "return" -> ClientPacketDistributor.sendToServer(new UseLinkingBookPayload(false));
case "stale" -> {
ClientPacketDistributor.sendToServer(new AgeCatalogAckPayload(step.version()));
ClientPacketDistributor.sendToServer(new UseDescriptiveBookPayload(false));
}
case "verify" -> {
var listener = minecraft.getConnection();
if (listener == null || !listener.levels.contains(ResourceKey.create(Registries.DIMENSION, step.age())))
throw new AssertionError("missing live dimension");
String actual = PortAgeDescription.forClient(step.age()) + "|" + PortDayCycle.forClient(step.age());
if (!actual.equals(step.expected())) throw new AssertionError("environment differs: " + actual);
result = "verified";
}
case "verify_removed" -> {
var listener = minecraft.getConnection();
if (listener == null || listener.levels.contains(ResourceKey.create(Registries.DIMENSION, step.age())))
throw new AssertionError("retired dimension retained");
if (PortAgeDescription.forClient(step.age()) != null) throw new AssertionError("stale description retained");
result = "removed";
}
case "exit" -> { minecraft.stop(); return; }
default -> throw new AssertionError("unknown action");
}
} catch (Throwable error) { result = "FAIL " + error; }
ClientPacketDistributor.sendToServer(new MatrixPayloads.Report(result));
}
}
@@ -0,0 +1,25 @@
package net.dnorberg.rivencraft.regression;
import net.minecraft.network.RegistryFriendlyByteBuf;
import net.minecraft.network.codec.ByteBufCodecs;
import net.minecraft.network.codec.StreamCodec;
import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
import net.minecraft.resources.Identifier;
/** Test-only channels; these sources are never part of either shipping source set. */
public final class MatrixPayloads {
public record Step(String action, Identifier age, String expected, int version) implements CustomPacketPayload {
public static final Type<Step> TYPE = new Type<>(Identifier.fromNamespaceAndPath("rivencraft", "regression_step"));
public static final StreamCodec<RegistryFriendlyByteBuf, Step> CODEC = StreamCodec.composite(
ByteBufCodecs.STRING_UTF8, Step::action, Identifier.STREAM_CODEC, Step::age,
ByteBufCodecs.STRING_UTF8, Step::expected, ByteBufCodecs.VAR_INT, Step::version, Step::new);
@Override public Type<Step> type() { return TYPE; }
}
public record Report(String result) implements CustomPacketPayload {
public static final Type<Report> TYPE = new Type<>(Identifier.fromNamespaceAndPath("rivencraft", "regression_report"));
public static final StreamCodec<RegistryFriendlyByteBuf, Report> CODEC =
StreamCodec.composite(ByteBufCodecs.STRING_UTF8, Report::result, Report::new);
@Override public Type<Report> type() { return TYPE; }
}
private MatrixPayloads() {}
}
@@ -0,0 +1,208 @@
package net.dnorberg.rivencraft.regression;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import net.dnorberg.rivencraft.Rivencraft;
import net.dnorberg.rivencraft.PortConfig;
import net.dnorberg.rivencraft.age.*;
import net.dnorberg.rivencraft.item.LinkBookTarget;
import net.dnorberg.rivencraft.network.PortBookNetworking;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.Identifier;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.storage.LevelResource;
import net.neoforged.bus.api.SubscribeEvent;
import net.neoforged.fml.common.EventBusSubscriber;
import net.neoforged.neoforge.network.PacketDistributor;
@EventBusSubscriber(modid = "rivencraft")
public final class MatrixServer {
private static final Map<String, String> reports = new HashMap<>();
private static int phase, ticks, checks;
private static boolean initialized, restart, finished;
private static Identifier a, b;
private static long seed;
private static final long RESEED = 102030405060L;
@SubscribeEvent public static void payloads(net.neoforged.neoforge.network.event.RegisterPayloadHandlersEvent event) {
var registrar = event.registrar("matrix-1");
registrar.playToClient(MatrixPayloads.Step.TYPE, MatrixPayloads.Step.CODEC);
registrar.playToServer(MatrixPayloads.Report.TYPE, MatrixPayloads.Report.CODEC, (payload, context) -> {
if (context.player() instanceof ServerPlayer player) {
if (payload.result().startsWith("FAIL")) {
finished = true; System.out.println("MC263_MATRIX FAIL " + player.getName().getString() + ": " + payload.result()); return;
}
reports.put(player.getName().getString(), payload.result());
}
});
}
private static void check(boolean ok, String message) {
if (!ok) throw new AssertionError(message);
checks++;
}
private static Identifier id(String path) { return Identifier.fromNamespaceAndPath("rivencraft", path); }
private static Path marker(MinecraftServer server) { return server.getWorldPath(LevelResource.ROOT).resolve("matrix.properties"); }
private static void phase(int next, String label) {
phase = next; ticks = 0; reports.clear();
System.out.println("MC263_MATRIX PHASE " + next + " " + label);
}
private static List<ServerPlayer> players(MinecraftServer server) {
return server.getPlayerList().getPlayers().stream().sorted(Comparator.comparing(p -> p.getName().getString())).toList();
}
private static void send(ServerPlayer player, String action, Identifier age, String expected, int version) {
PacketDistributor.sendToPlayer(player, new MatrixPayloads.Step(action, age, expected, version));
}
private static void both(MinecraftServer server, String action, Identifier age, String expected) {
for (var player : players(server)) send(player, action, age, expected, 0);
}
private static void give(ServerPlayer player, ItemStack book) {
player.getInventory().setSelectedSlot(0);
player.getInventory().setItem(0, book.copy());
player.containerMenu.broadcastChanges();
}
private static ItemStack book(Identifier age) {
var stack = new ItemStack(Rivencraft.DESCRIPTIVE_BOOK.get());
stack.set(Rivencraft.AGE_BOOK_ID.get(), age);
return stack;
}
private static boolean ready(MinecraftServer server, Identifier age) {
return players(server).size() == 2 && players(server).stream().allMatch(p -> AgeCatalogSync.ready(p, age));
}
private static boolean arrived(MinecraftServer server, Identifier age) {
return players(server).size() == 2 && players(server).stream().allMatch(p -> p.level().dimension().identifier().equals(age));
}
private static boolean reported(String expected) {
return reports.size() == 2 && reports.values().stream().allMatch(expected::equals);
}
private static String presentation(MinecraftServer server, Identifier age) {
return RuntimeAgeBackend.loadedDescriptions(server).get(age) + "|" + RuntimeAgeBackend.savedDayCycles(server).get(age);
}
private static void enter(MinecraftServer server, Identifier age) {
for (var player : players(server)) { give(player, book(age)); send(player, "enter", age, "", 0); }
}
private static void leave(MinecraftServer server) {
var source = server.overworld();
for (var player : players(server)) {
int x = player.getName().getString().endsWith("One") ? -4 : 4;
int y = source.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.MOTION_BLOCKING, x, 0);
var stack = new ItemStack(Rivencraft.LINKING_BOOK.get());
stack.set(Rivencraft.LINK_BOOK_TARGET.get(), new LinkBookTarget(Level.OVERWORLD.identifier(), x + .5, y, .5, 0, 0));
give(player, stack); send(player, "return", Level.OVERWORLD.identifier(), "", 0);
}
}
@SubscribeEvent public static void tick(net.neoforged.neoforge.event.tick.ServerTickEvent.Post event) {
if (finished) return;
var server = event.getServer();
try {
if (!initialized) {
initialized = true;
restart = Files.exists(marker(server));
if (restart) {
var p = new Properties();
try (var input = Files.newInputStream(marker(server))) { p.load(input); }
a = Identifier.parse(p.getProperty("a")); b = Identifier.parse(p.getProperty("b"));
seed = Long.parseLong(p.getProperty("seed"));
}
phase(0, restart ? "await restarted clients" : "await two connected clients");
}
ticks++;
var ps = players(server);
if (phase == 0) {
if (ps.size() != 2 || !ready(server, restart ? a : Level.OVERWORLD.identifier())) return;
for (var player : ps) player.setGameMode(net.minecraft.world.level.GameType.CREATIVE);
if (restart) {
check(arrived(server, a), "both saved players restored in Age A");
check(RuntimeAgeBackend.savedAges(server).get(a) == seed, "reseed survives full restart");
check(!RuntimeAgeBackend.savedAges(server).containsKey(b), "retired Age not restored");
both(server, "verify", a, presentation(server, a)); phase(20, "restarted catalog and presentation");
} else {
PortConfig.RANDOM_PAGE_ALLOWLIST.set(List.of("terrain/flat", "biome/single", "biome/minecraft/plains",
"sky/static", "weather/storm", "lighting/bright"));
give(ps.getFirst(), new ItemStack(Rivencraft.DESCRIPTIVE_BOOK.get()));
send(ps.getFirst(), "bind", Level.OVERWORLD.identifier(), "", 0);
phase(1, "normal handheld binding with both clients online");
}
} else if (phase == 1) {
var age = ps.getFirst().getMainHandItem().get(Rivencraft.AGE_BOOK_ID.get());
if (age == null || !ready(server, age)) return;
a = age;
check(ps.stream().allMatch(p -> p.level().dimension() == Level.OVERWORLD), "creation does not teleport either player");
both(server, "verify", a, presentation(server, a)); phase(2, "new catalog reached both clients without reconnect");
} else if (phase == 2 && reported("verified")) {
b = PortBookNetworking.createAge(ps.getLast(), "Matrix Authored B", List.of(
id("terrain/flat"), id("biome/single"), id("biome/minecraft/plains"),
id("sky/end"), id("lighting/dark"), id("weather/off")));
check(b != null && !a.equals(b), "distinct authored Age from normal Binder backend");
phase(3, "expanded authored catalog");
} else if (phase == 3 && ready(server, b)) {
both(server, "verify", b, presentation(server, b)); phase(4, "authored environment arrived at both clients");
} else if (phase == 4 && reported("verified")) {
enter(server, a); phase(5, "normal books enter live-created Age A");
} else if (phase == 5 && arrived(server, a)) {
check(true, "both clients entered live-created A");
leave(server); phase(6, "normal Linking Books return");
} else if (phase == 6 && arrived(server, Level.OVERWORLD.identifier())) {
// Deliberately withhold readiness; the stale acknowledgement itself is a real client payload.
var field = AgeCatalogSync.class.getDeclaredField("STATES"); field.setAccessible(true);
var state = ((Map<?, ?>) field.get(null)).get(server);
var ack = state.getClass().getDeclaredField("acknowledged"); ack.setAccessible(true);
((Map<?, ?>) ack.get(state)).remove(ps.getLast().getUUID());
var version = state.getClass().getDeclaredField("version"); version.setAccessible(true);
give(ps.getLast(), book(a));
send(ps.getLast(), "stale", a, "", version.getInt(state) - 1);
phase(7, "stale acknowledgement and failed travel");
} else if (phase == 7 && ticks >= 30 && reports.containsKey(ps.getLast().getName().getString())) {
check(ps.getLast().level().dimension() == Level.OVERWORLD, "unacknowledged travel stays at source");
check(!AgeCatalogSync.ready(ps.getLast(), a), "stale payload did not acknowledge current catalog");
AgeCatalogSync.onCatalogChanged(server); phase(8, "fresh catalog recovery");
} else if (phase == 8 && ready(server, b)) {
enter(server, b); phase(9, "normal books enter authored Age B");
} else if (phase == 9 && arrived(server, b)) {
boolean refused = false;
try { RuntimeAgeBackend.unload(server, b); } catch (RuntimeException expected) { refused = true; }
check(refused, "occupied Age unload refused");
leave(server); phase(10, "vacate before lifecycle operations");
} else if (phase == 10 && arrived(server, Level.OVERWORLD.identifier())) {
RuntimeAgeBackend.unload(server, a);
check(server.getLevel(ResourceKey.create(Registries.DIMENSION, a)) == null, "unload removed live level");
RuntimeAgeBackend.reload(server, a);
RuntimeAgeBackend.reseed(server, a, RESEED);
check(RuntimeAgeBackend.savedAges(server).get(a) == RESEED, "new seed persisted");
RuntimeAgeBackend.retire(server, b);
check(!RuntimeAgeBackend.savedAges(server).containsKey(b), "retired B removed from catalog");
phase(11, "unload reload reseed retire catalog propagation");
} else if (phase == 11 && ready(server, a)) {
both(server, "verify_removed", b, ""); phase(12, "both clients removed retired dimension");
} else if (phase == 12 && reported("removed")) {
enter(server, b); phase(13, "stale retired book cannot recreate B");
} else if (phase == 13 && ticks >= 30 && reported("ok")) {
check(arrived(server, Level.OVERWORLD.identifier()), "retired books leave players at source");
enter(server, a); phase(14, "save both players inside surviving Age");
} else if (phase == 14 && arrived(server, a)) {
var p = new Properties(); p.setProperty("a", a.toString()); p.setProperty("b", b.toString());
p.setProperty("seed", Long.toString(RESEED));
try (var output = Files.newOutputStream(marker(server))) { p.store(output, "Disposable multiplayer restart evidence"); }
both(server, "exit", a, ""); finished = true;
System.out.println("MC263_MATRIX FIRST_PASS checks=" + checks);
} else if (phase == 20 && reported("verified")) {
both(server, "verify_removed", b, ""); phase(21, "retirement persisted through restart");
} else if (phase == 21 && reported("removed")) {
leave(server); phase(22, "return linking works after reconnect and restart");
} else if (phase == 22 && arrived(server, Level.OVERWORLD.identifier())) {
check(true, "both players returned after full restart");
both(server, "exit", a, ""); finished = true;
System.out.println("MC263_MATRIX RESTART_PASS checks=" + checks);
}
} catch (Throwable error) {
finished = true; System.out.println("MC263_MATRIX FAIL phase=" + phase); error.printStackTrace();
}
}
}