Public Access
Complete 26.3 parity acceptance and dual-version release workflow
This commit is contained in:
1 parent
41daff1e61
commit
4a59fb5d02
26 files changed
+1241
-369
No files matched your search
+58
@@ -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));
|
||||
}
|
||||
}
|
||||
+25
@@ -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() {}
|
||||
}
|
||||
+208
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user