diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java new file mode 100644 index 000000000..d8c0483b6 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java @@ -0,0 +1,444 @@ +package dev.horizonlab.parity; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.DataInputStream; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.PrintWriter; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.zip.Deflater; +import java.util.zip.Inflater; +import net.minecraft.SharedConstants; +import net.minecraft.core.UUIDUtil; +import net.minecraft.network.FriendlyByteBuf; +import net.minecraft.network.ProtocolInfo; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.protocol.Packet; +import net.minecraft.network.protocol.common.ClientboundDisconnectPacket; +import net.minecraft.network.protocol.common.ClientboundKeepAlivePacket; +import net.minecraft.network.protocol.common.ClientboundPingPacket; +import net.minecraft.network.protocol.common.ServerboundClientInformationPacket; +import net.minecraft.network.protocol.common.ServerboundCustomPayloadPacket; +import net.minecraft.network.protocol.common.ServerboundKeepAlivePacket; +import net.minecraft.network.protocol.common.ServerboundPongPacket; +import net.minecraft.network.protocol.common.custom.BrandPayload; +import net.minecraft.network.protocol.configuration.ClientboundFinishConfigurationPacket; +import net.minecraft.network.protocol.configuration.ClientboundSelectKnownPacks; +import net.minecraft.network.protocol.configuration.ConfigurationProtocols; +import net.minecraft.network.protocol.configuration.ServerboundFinishConfigurationPacket; +import net.minecraft.network.protocol.configuration.ServerboundSelectKnownPacks; +import net.minecraft.network.protocol.game.ClientboundChunkBatchFinishedPacket; +import net.minecraft.network.protocol.game.ClientboundPlayerPositionPacket; +import net.minecraft.network.protocol.game.ClientboundSystemChatPacket; +import net.minecraft.network.protocol.game.GameProtocols; +import net.minecraft.network.protocol.game.ClientboundSetEntityMotionPacket; +import net.minecraft.network.protocol.game.ServerboundAttackPacket; +import net.minecraft.network.protocol.game.ServerboundPlayerCommandPacket; +import net.minecraft.network.protocol.game.ServerboundPunchPacket; +import net.minecraft.network.protocol.game.ServerboundUseItemPacket; +import net.minecraft.world.InteractionHand; +import net.minecraft.network.protocol.game.ServerboundAcceptTeleportationPacket; +import net.minecraft.network.protocol.game.ServerboundChatCommandPacket; +import net.minecraft.network.protocol.game.ServerboundChunkBatchReceivedPacket; +import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket; +import net.minecraft.network.protocol.game.ServerboundPlayerInputPacket; +import net.minecraft.network.protocol.game.ServerboundPlayerLoadedPacket; +import net.minecraft.network.protocol.handshake.ClientIntent; +import net.minecraft.network.protocol.handshake.ClientIntentionPacket; +import net.minecraft.network.protocol.handshake.HandshakeProtocols; +import net.minecraft.network.protocol.login.ClientboundLoginCompressionPacket; +import net.minecraft.network.protocol.login.ClientboundLoginDisconnectPacket; +import net.minecraft.network.protocol.login.ClientboundLoginFinishedPacket; +import net.minecraft.network.protocol.login.LoginProtocols; +import net.minecraft.network.protocol.login.ServerboundHelloPacket; +import net.minecraft.network.protocol.login.ServerboundLoginAcknowledgedPacket; +import net.minecraft.server.level.ClientInformation; +import net.minecraft.world.entity.PositionMoveRotation; +import net.minecraft.world.entity.player.Input; +import net.minecraft.world.phys.Vec3; + +/** + * Players made of vanilla's own protocol code that hit and get hit, for + * knockback (tools/test_server_knockback_parity.py). Script on stdin: + * {@code step LABEL}, {@code join NAME}, {@code cmd NAME COMMAND...} (waits + * for its feedback), {@code pos NAME X Y Z YAW PITCH GROUND} (one client tick + * at that place, on the ground or not), {@code sprint NAME on|off}, {@code + * attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a + * player's name or an entity type's path, the last one added), {@code use + * NAME} (ServerboundUseItemPacket, main hand) and {@code end}. Each player + * records the ClientboundSetEntityMotionPacket it receives, its own sprint + * flag as the server sets it, teleports, and the system chat (command + * feedback). + */ +public final class KnockbackClient { + private static volatile String step = "start"; + private static final Map NAMES = new LinkedHashMap<>(); + + public static void main(String[] args) throws Exception { + ParityData.init(); + String host = args[0]; + int port = Integer.parseInt(args[1]); + Path output = Path.of(args[2]); + Map players = new LinkedHashMap<>(); + BufferedReader script = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8)); + String line; + while ((line = script.readLine()) != null) { + String[] w = line.trim().split(" ", 3); + try { + switch (w[0]) { + case "step" -> step = w[1]; + case "join" -> { + Player p = new Player(w[1]); + players.put(w[1], p); + NAMES.put(UUIDUtil.createOfflinePlayerUUID(w[1]), w[1]); + p.join(host, port); + } + case "cmd" -> players.get(w[1]).command(w[2]); + case "pos" -> { + String[] a = w[2].split(" "); + players.get(w[1]).at(new Vec3(Double.parseDouble(a[0]), Double.parseDouble(a[1]), Double.parseDouble(a[2])), + Float.parseFloat(a[3]), Float.parseFloat(a[4]), a[5].equals("1")); + } + case "sprint" -> players.get(w[1]).sprint(w[2].equals("on")); + case "attack" -> players.get(w[1]).attack(w[2]); + case "use" -> players.get(w[1]).send(new ServerboundUseItemPacket(InteractionHand.MAIN_HAND, 0, 0, 0)); + case "punch" -> players.get(w[1]).send(net.minecraft.network.protocol.game.ServerboundPunchPacket.INSTANCE); + case "mark" -> players.get(w[1]).mark(); + case "await" -> players.get(w[1]).await(); + case "end" -> { + try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(output, StandardCharsets.UTF_8))) { + for (Player p : players.values()) { + synchronized (p.lines) { + for (String l : p.lines) out.println(p.name + " " + l); + } + } + } + for (Player p : players.values()) p.close(); + System.exit(0); + } + default -> throw new IllegalArgumentException("unknown script line " + line); + } + } catch (Exception e) { + Player p = w.length > 1 ? players.get(w[1]) : null; + if (p != null) p.record("error " + w[0] + " " + e); + else System.err.println("error " + line + ": " + e); + } + } + System.exit(1); + } + + private static final class Player { + final String name; + final List lines = new ArrayList<>(); + private Socket socket; + private DataInputStream in; + private OutputStream out; + private int threshold = -1; + private ProtocolInfo inbound; + private ProtocolInfo outbound; + private volatile PositionMoveRotation position = new PositionMoveRotation(Vec3.ZERO, Vec3.ZERO, 0, 0); + private boolean loaded; + private volatile int id = -1; + /** Every entity this player was sent: its id to a name (players) or type path. */ + private final Map seen = new java.util.concurrent.ConcurrentHashMap<>(); + private final Map last = new java.util.concurrent.ConcurrentHashMap<>(); + private final Object replyLock = new Object(); + private int replies; + /** The motion packets about this player it was sent, and how many there were at the last `mark`. */ + private int pushes; + private int marked; + + Player(String name) { + this.name = name; + } + + void command(String command) throws Exception { + synchronized (replyLock) { + int before = replies; + send(new ServerboundChatCommandPacket(command)); + long until = System.nanoTime() + 30_000_000_000L; + while (replies == before) { + long left = (until - System.nanoTime()) / 1_000_000L; + if (left <= 0) { + record("error no reply to /" + command); + return; + } + replyLock.wait(left); + } + } + } + + void mark() { + synchronized (replyLock) { + marked = pushes; + } + } + + /** Waits for a motion packet about this player since the last `mark` (a mob's hit, which comes when its AI + * strikes). */ + void await() throws Exception { + synchronized (replyLock) { + long until = System.nanoTime() + 20_000_000_000L; + while (pushes == marked) { + long left = (until - System.nanoTime()) / 1_000_000L; + if (left <= 0) { + record("error no motion packet since the mark"); + return; + } + replyLock.wait(left); + } + } + } + + void record(String line) { + synchronized (lines) { + lines.add("step=" + step + " " + line); + } + } + + void at(Vec3 to, float yaw, float pitch, boolean ground) throws Exception { + position = new PositionMoveRotation(to, Vec3.ZERO, yaw, pitch); + // A tick of its own: the server takes one position per client tick (receivedPositionThisTick). + send(net.minecraft.network.protocol.game.ServerboundClientTickEndPacket.INSTANCE); + send(new ServerboundMovePlayerPacket.PosRot(to, yaw, pitch, ground, false)); + send(net.minecraft.network.protocol.game.ServerboundClientTickEndPacket.INSTANCE); + } + + void sprint(boolean on) throws Exception { + // ServerboundPlayerCommandPacket's only public constructors take an Entity: read it from its bytes. + FriendlyByteBuf b = new FriendlyByteBuf(Unpooled.buffer()); + b.writeVarInt(id); + b.writeVarInt((on ? ServerboundPlayerCommandPacket.Action.START_SPRINTING : ServerboundPlayerCommandPacket.Action.STOP_SPRINTING).ordinal()); + b.writeVarInt(0); + send(ServerboundPlayerCommandPacket.STREAM_CODEC.decode(b)); + } + + void attack(String target) throws Exception { + Integer entity = last.get(target); + if (entity == null) { + record("error no " + target + " to attack"); + return; + } + send(new ServerboundAttackPacket(entity)); + send(ServerboundPunchPacket.INSTANCE); + } + + void close() throws Exception { + if (socket != null) socket.close(); + } + + void join(String host, int port) throws Exception { + socket = new Socket(); + socket.connect(new InetSocketAddress(host, port), 10_000); + socket.setTcpNoDelay(true); + in = new DataInputStream(socket.getInputStream()); + out = socket.getOutputStream(); + outbound = HandshakeProtocols.SERVERBOUND; + send(new ClientIntentionPacket(SharedConstants.getProtocolVersion(), host, port, ClientIntent.LOGIN)); + outbound = LoginProtocols.SERVERBOUND; + inbound = LoginProtocols.CLIENTBOUND; + send(new ServerboundHelloPacket(name, UUIDUtil.createOfflinePlayerUUID(name))); + while (true) { + Packet p = read().packet; + if (p instanceof ClientboundLoginCompressionPacket c) { + threshold = c.getCompressionThreshold(); + } else if (p instanceof ClientboundLoginFinishedPacket) { + send(ServerboundLoginAcknowledgedPacket.INSTANCE); + break; + } else if (p instanceof ClientboundLoginDisconnectPacket d) { + throw new IllegalStateException("login refused: " + d.reason().getString()); + } + } + outbound = ConfigurationProtocols.SERVERBOUND; + inbound = ConfigurationProtocols.CLIENTBOUND; + send(new ServerboundCustomPayloadPacket(new BrandPayload("vanilla"))); + send(new ServerboundClientInformationPacket(ClientInformation.createDefault())); + while (true) { + Packet p = read().packet; + if (p instanceof ClientboundSelectKnownPacks k) { + send(new ServerboundSelectKnownPacks(k.knownPacks())); + } else if (p instanceof ClientboundKeepAlivePacket k) { + send(new ServerboundKeepAlivePacket(k.getId())); + } else if (p instanceof ClientboundPingPacket k) { + send(new ServerboundPongPacket(k.getId())); + } else if (p instanceof ClientboundFinishConfigurationPacket) { + send(ServerboundFinishConfigurationPacket.INSTANCE); + break; + } else if (p instanceof ClientboundDisconnectPacket d) { + throw new IllegalStateException("disconnected: " + d.reason().getString()); + } + } + GameProtocols.Context context = new GameProtocols.Context() { + @Override + public boolean hasInfiniteMaterials() { + return true; + } + + @Override + public boolean canUseCommandBlocks() { + return true; + } + }; + outbound = GameProtocols.SERVERBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(ParityData.access), context); + inbound = GameProtocols.CLIENTBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(ParityData.access)); + Thread reader = new Thread(this::play, name); + reader.setDaemon(true); + reader.start(); + } + + private void play() { + try { + while (true) { + Received r = read(); + Packet p = r.packet; + if (p instanceof net.minecraft.network.protocol.game.ClientboundLoginPacket l) { + id = l.playerId(); + seen.put(id, "self"); + } else if (p instanceof net.minecraft.network.protocol.game.ClientboundAddEntityPacket a) { + String who = a.getType() == net.minecraft.world.entity.EntityTypes.PLAYER + ? NAMES.getOrDefault(a.getUUID(), "uuid?") + : net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.getKey(a.getType()).getPath(); + seen.put(a.getId(), who); + last.put(who, a.getId()); + } else if (p instanceof ClientboundSetEntityMotionPacket m) { + Vec3 v = m.movement(); + record(String.format(java.util.Locale.ROOT, "motion %s %.5f %.5f %.5f", + seen.getOrDefault(m.id(), "id" + m.id()), v.x, v.y, v.z)); + if (m.id() == id) { + synchronized (replyLock) { + pushes++; + replyLock.notifyAll(); + } + } + } else if (p instanceof net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket d && d.id() == id) { + for (var value : d.packedItems()) { + if (value.id() == 0) record("sprinting " + ((((Byte) value.value()) & 8) != 0)); + } + } else if (p instanceof ClientboundSystemChatPacket c) { + record("chat " + c.content().getString()); + synchronized (replyLock) { + replies++; + replyLock.notifyAll(); + } + } else if (p instanceof ClientboundKeepAlivePacket k) { + send(new ServerboundKeepAlivePacket(k.getId())); + } else if (p instanceof ClientboundPingPacket k) { + send(new ServerboundPongPacket(k.getId())); + } else if (p instanceof ClientboundPlayerPositionPacket t) { + position = PositionMoveRotation.calculateAbsolute(position, t.change(), t.relatives()); + Vec3 at = position.position(); + if (loaded) { + record(String.format(java.util.Locale.ROOT, "teleport %.3f %.3f %.3f", at.x, at.y, at.z)); + } + send(new ServerboundAcceptTeleportationPacket(t.id(), at.x, at.y, at.z, position.yRot(), position.xRot())); + if (!loaded) { + send(new ServerboundMovePlayerPacket.PosRot(at, position.yRot(), position.xRot(), false, false)); + send(new ServerboundPlayerLoadedPacket()); + loaded = true; + } + } else if (p instanceof ClientboundChunkBatchFinishedPacket) { + send(new ServerboundChunkBatchReceivedPacket(64.0F)); + } else if (p instanceof ClientboundDisconnectPacket d) { + record("disconnected " + d.reason().getString()); + return; + } + } + } catch (Exception e) { + if (!socket.isClosed()) record("error play " + e); + } + } + + private record Received(Packet packet, byte[] payload) {} + + private Received read() throws Exception { + byte[] payload = readFrame(); + ByteBuf buf = Unpooled.wrappedBuffer(payload); + Packet packet = inbound.codec().decode(buf); + if (buf.readableBytes() > 0) { + throw new IllegalStateException(packet.type().id() + " was larger than expected: " + buf.readableBytes() + " bytes left"); + } + return new Received(packet, payload); + } + + synchronized void send(Packet packet) throws Exception { + ByteBuf body = Unpooled.buffer(); + ((ProtocolInfo) outbound).codec().encode(body, packet); + byte[] raw = new byte[body.readableBytes()]; + body.readBytes(raw); + ByteBuf frame = Unpooled.buffer(); + if (threshold >= 0) { + ByteBuf inner = Unpooled.buffer(); + if (raw.length >= threshold) { + writeVarInt(inner, raw.length); + Deflater d = new Deflater(); + d.setInput(raw); + d.finish(); + byte[] tmp = new byte[raw.length + 64]; + while (!d.finished()) inner.writeBytes(tmp, 0, d.deflate(tmp)); + d.end(); + } else { + writeVarInt(inner, 0); + inner.writeBytes(raw); + } + writeVarInt(frame, inner.readableBytes()); + frame.writeBytes(inner); + } else { + writeVarInt(frame, raw.length); + frame.writeBytes(raw); + } + byte[] bytes = new byte[frame.readableBytes()]; + frame.readBytes(bytes); + out.write(bytes); + out.flush(); + } + + private byte[] readFrame() throws Exception { + byte[] frame = new byte[readVarInt(in)]; + in.readFully(frame); + if (threshold < 0) return frame; + ByteArrayInputStream header = new ByteArrayInputStream(frame); + int dataLength = readVarInt(header); + int skip = frame.length - header.available(); + if (dataLength == 0) return java.util.Arrays.copyOfRange(frame, skip, frame.length); + Inflater inflater = new Inflater(); + inflater.setInput(frame, skip, frame.length - skip); + byte[] raw = new byte[dataLength]; + int n = inflater.inflate(raw); + inflater.end(); + if (n != dataLength) throw new IllegalStateException("decompressed " + n + " of " + dataLength + " bytes"); + return raw; + } + } + + private static int readVarInt(InputStream in) throws Exception { + int value = 0; + for (int shift = 0; shift < 35; shift += 7) { + int b = in.read(); + if (b < 0) throw new java.io.EOFException(); + value |= (b & 0x7F) << shift; + if ((b & 0x80) == 0) return value; + } + throw new IllegalStateException("VarInt too big"); + } + + private static void writeVarInt(ByteBuf buf, int value) { + while ((value & ~0x7F) != 0) { + buf.writeByte((value & 0x7F) | 0x80); + value >>>= 7; + } + buf.writeByte(value); + } +} diff --git a/tools/test_server_knockback_parity.py b/tools/test_server_knockback_parity.py new file mode 100644 index 000000000..cd061321d --- /dev/null +++ b/tools/test_server_knockback_parity.py @@ -0,0 +1,337 @@ +#!/usr/bin/env python3 +"""Knockback on a dedicated server, against vanilla's, seen by vanilla clients. + +A vanilla dedicated server and Horizon's (`horizon-client --dedicated --nogui`) each serve a copy of one flat +world vanilla generated first, in survival on Normal, with Alice and Bob as operators. KnockbackClient, two +players made of vanilla's protocol code, joins them both and runs one script on each: + +- Alice hits a cow and a zombie: a plain hit, a sprinting hit, Knockback II, a critical hit, and a plain hit on + a mob in the air. The game is frozen around the hit (`/tick freeze`) and stepped a tick at a time: the mob's + Motion just after the hit and its Pos and Motion over the next 20 ticks are compared exactly. The mobs are + slowed to a stop (Slowness 128) so that their walking adds nothing; +- Alice hits Bob: a plain hit, sprinting, Knockback II, a critical hit, Bob behind a raised shield, Bob in + netherite (knockback resistance), two plain hits a second apart, two sprinting hits a second apart (the + first stops Alice's sprint), a mace smash, and a weak hit then a stronger one inside Bob's hurt cooldown. + Bob's own ClientboundSetEntityMotionPacket (the knockback his client applies, Player.causeExtraKnockback), + Alice's motion packets and her sprint flag as the server sets it are compared exactly; +- a zombie hits Bob, twice: the knockback reaches Bob's client once his server-side copy has + travelled a tick (the mob's hit, then ServerPlayer's travel, then ServerEntity.sendChanges). It is night, so + that no zombie burns (a burning mob is in its hurt cooldown). + +Each case is compared on its own. KNOWN lists the cases Horizon still gets wrong and why; one that matches +again is reported, and should leave the list. +""" +import os +from pathlib import Path +import platform +import re +import shutil +import subprocess +import sys +import time + +try: + from . import lab, test_rust_parity as base + from .test_dedicated_server_parity import Server, free_port + from .test_locator_bar_parity import generate_world, ops_json +except ImportError: + import lab + import test_rust_parity as base + from test_dedicated_server_parity import Server, free_port + from test_locator_bar_parity import generate_world, ops_json + +NAME = 'server-knockback-parity' +PROPERTIES = { + 'online-mode': 'false', + 'white-list': 'false', + 'level-seed': '12345', + 'level-type': 'minecraft\\:flat', + 'generate-structures': 'false', + 'gamemode': 'survival', + 'difficulty': 'normal', + 'view-distance': '4', + 'simulation-distance': '4', + 'spawn-protection': '0', + 'max-players': '5', + 'pause-when-empty-seconds': '-1', +} +# Cases Horizon still gets wrong, and why. +VELOCITY = ("a guest's server-side velocity never travels and a hit is sent before it would: each knockback starts " + "from the last one's (ServerPlayer's travel, ServerEntity.sendChanges, Player.causeExtraKnockback)") +SPRINT = "the server never sends a guest its own sprint flag, so a sprint hit doesn't stop the attacker's sprint" +YAW = "the extra knockback's direction comes from f32 sin/cos, not Mth's sine table (z is -2e-8 a block, not 0)" +KNOWN = { + 'cow-sprint': f'{SPRINT}; {YAW}', + 'cow-knockback-2': YAW, + 'zombie-sprint': f'{SPRINT}; {YAW}', + 'zombie-knockback-2': YAW, + 'pvp-plain': VELOCITY, + 'pvp-sprint': f'{VELOCITY}; {SPRINT}', + 'pvp-knockback-2': VELOCITY, + 'pvp-crit': VELOCITY, + 'pvp-netherite': VELOCITY, + 'pvp-twice': VELOCITY, + 'pvp-sprint-twice': f'{VELOCITY}; {SPRINT}', + 'pvp-mace': f'{VELOCITY}; a smash on a player runs none of MaceItem.hurtEnemy (the attacker\'s fall goes on)', + 'pvp-cooldown': f'{VELOCITY}; a hit inside the hurt cooldown still knocks back (LivingEntity.hurtServer)', + 'zombie-hits-bob': VELOCITY, +} + +A = (0.5, -60.0, 0.5) # Alice, facing east (yaw -90) +V = (2.5, -60.0, 0.5) # the mob or Bob, two blocks east +SWORD = 'minecraft:wooden_sword' +KNOCKBACK_SWORD = 'minecraft:wooden_sword[enchantments={"minecraft:knockback":2}]' + + +def stand(name, at, yaw, ticks=3): + """Client ticks on the ground at `at` (one position a tick, as vanilla's client sends).""" + return [f'pos {name} {at[0]} {at[1]} {at[2]} {yaw} 0 1'] * ticks + + +def falling(height): + """Alice off the ground and going down, so that her next hit is critical (or a mace smash).""" + return [f'pos Alice {A[0]} {A[1] + h} {A[2]} -90 0 0' for h in (height, height - 0.3)] + + +def mob_case(kind, weapon=SWORD, sprint=False, crit=False, air=False): + mob = f'@e[type=minecraft:{kind},limit=1]' + summon = [f'cmd Alice summon minecraft:{kind} {V[0]} {V[1] + (1.5 if air else 0)} {V[2]} {{Rotation:[0f,0f]}}', + f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true'] + lines = ['cmd Alice kill @e[type=!player]', 'cmd Alice gamemode creative', 'cmd Bob gamemode creative', + f'cmd Alice item replace entity @s weapon.mainhand with {weapon}', 'cmd Alice tp Bob 2.5 -60 12.5', + *stand('Alice', A, -90), 'sleep 1.2'] + # In the air: frozen before its first tick, so it has not landed. + lines += ['cmd Alice tick freeze', *summon] if air else [*summon, 'sleep 1.5', 'cmd Alice tick freeze'] + lines += ['sleep 0.3', f'cmd Alice data get entity {mob} Pos'] + if sprint: + lines.append('sprint Alice on') + if crit: + lines += falling(0.8) + lines += ['sleep 0.2', f'attack Alice {kind}', 'sleep 0.2', f'cmd Alice data get entity {mob} Motion'] + for _ in range(20): + lines += ['cmd Alice tick step 1', 'sleep 0.25', f'cmd Alice data get entity {mob} Pos', + f'cmd Alice data get entity {mob} Motion'] + lines += ['cmd Alice tick unfreeze', 'cmd Alice kill @e[type=!player]'] + if sprint: + lines.append('sprint Alice off') + lines += [*stand('Alice', A, -90), 'cmd Alice gamemode survival', 'cmd Bob gamemode survival', + f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0'] + return lines + + +def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, twice=False, mace=False, + cooldown=False): + lines = [f'cmd Alice item replace entity @s weapon.mainhand with {weapon}', 'cmd Bob clear @s', + 'cmd Bob effect give @s minecraft:resistance 1000 4 true', + 'cmd Bob effect give @s minecraft:instant_health 1 5 true', *stand('Alice', A, -90), *stand('Bob', V, 90)] + if armour: + lines += [f'cmd Bob item replace entity @s armor.{slot} with minecraft:netherite_{piece}' + for slot, piece in (('head', 'helmet'), ('chest', 'chestplate'), ('legs', 'leggings'), + ('feet', 'boots'))] + if shield: + # A shield blocks from five ticks after it is raised. + lines += ['cmd Bob item replace entity @s weapon.mainhand with minecraft:shield', 'use Bob'] + lines += ['sleep 1.5', *stand('Bob', V, 90, ticks=1)] + if sprint: + lines.append('sprint Alice on') + if crit: + lines += falling(0.8) + if mace: + lines += falling(3.0) + falling(1.5) + if cooldown: + # A swing at the air first: the hit is weak, and the stronger one four ticks later lands inside Bob's hurt + # cooldown (LivingEntity.hurtServer: it hurts by the difference, with no knockback and no motion packet). + lines += ['sleep 0.2', 'punch Alice', 'attack Alice Bob'] + lines += ['sleep 0.2', 'attack Alice Bob', 'sleep 0.3'] + if twice: + lines += [*stand('Bob', V, 90, ticks=20), 'sleep 1.5', 'attack Alice Bob', 'sleep 0.3'] + if sprint: + lines.append('sprint Alice off') + lines += stand('Alice', A, -90) + if shield or armour: + lines.append('cmd Bob clear @s') + return lines + + +def mob_hits_case(kind): + """A mob's own attack on Bob, twice: his motion packet. Alice is in creative, so the mob goes for Bob; each mob + is killed once its hit has come (`await`), and Bob stands back where he was before the next. (A mob with no + attack_knockback of its own: one with some, like a ravager, adds it along its own yaw, which its AI turns.)""" + mob = f'@e[type=minecraft:{kind},limit=1]' + hit = ['mark Bob', f'cmd Alice summon minecraft:{kind} {V[0] + 1} {V[1]} {V[2]} {{Rotation:[90f,0f]}}', + f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true', 'await Bob', f'cmd Alice kill {mob}'] + return ['cmd Bob clear @s', 'cmd Bob effect give @s minecraft:resistance 1000 4 true', 'cmd Alice gamemode creative', + *stand('Bob', V, 90), *hit, 'sleep 2', *stand('Bob', V, 90), *hit, 'sleep 1', + 'cmd Alice kill @e[type=!player]', 'cmd Alice gamemode survival'] + + +CASES = { + 'cow-plain': mob_case('cow'), + 'cow-sprint': mob_case('cow', sprint=True), + 'cow-knockback-2': mob_case('cow', weapon=KNOCKBACK_SWORD), + 'cow-crit': mob_case('cow', crit=True), + 'cow-air': mob_case('cow', air=True), + 'zombie-plain': mob_case('zombie'), + 'zombie-sprint': mob_case('zombie', sprint=True), + 'zombie-knockback-2': mob_case('zombie', weapon=KNOCKBACK_SWORD), + 'zombie-crit': mob_case('zombie', crit=True), + 'zombie-air': mob_case('zombie', air=True), + 'pvp-plain': pvp_case(), + 'pvp-sprint': pvp_case(sprint=True), + 'pvp-knockback-2': pvp_case(weapon=KNOCKBACK_SWORD), + 'pvp-crit': pvp_case(crit=True), + 'pvp-shield': pvp_case(shield=True), + 'pvp-netherite': pvp_case(armour=True), + 'pvp-twice': pvp_case(twice=True), + 'pvp-sprint-twice': pvp_case(sprint=True, twice=True), + 'pvp-mace': pvp_case(weapon='minecraft:mace', mace=True), + 'pvp-cooldown': pvp_case(cooldown=True), + 'zombie-hits-bob': mob_hits_case('zombie'), +} +SETUP = ['cmd Alice gamerule spawn_mobs false', 'cmd Alice gamerule spawn_monsters false', + 'cmd Alice kill @e[type=!player]', 'cmd Alice gamerule advance_time false', 'cmd Alice time set midnight', + f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'sleep 2'] + + +def server_dir(directory, world): + if directory.exists(): + shutil.rmtree(directory) + directory.mkdir(parents=True) + port = free_port() + props = dict(PROPERTIES, **{'server-port': str(port)}) + (directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()), + encoding='iso-8859-1') + (directory / 'eula.txt').write_text('eula=true\n') + (directory / 'ops.json').write_text(ops_json()) + shutil.copytree(world, directory / 'world') + (directory / 'world' / 'session.lock').unlink(missing_ok=True) + return port + + +def run_side(label, server_command, client_command, build, world): + directory = build / label + port = server_dir(directory, world) + out = build / f'{label}.txt' + out.unlink(missing_ok=True) + server = Server(server_command, directory, label) + try: + server.wait_for(r'Done \(') + with (build / f'{label}-client.log').open('w') as log: + client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], + cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, + text=True) + + def send(line): + if line.startswith('sleep '): + time.sleep(float(line.split()[1])) + else: + client.stdin.write(line + '\n') + client.stdin.flush() + try: + for name in ('Alice', 'Bob'): + send(f'join {name}') + server.wait_for(rf'{name} joined the game', timeout=120) + time.sleep(2) + for line in SETUP: + send(line) + for case, lines in CASES.items(): + send(f'step {case}') + for line in lines: + send(line) + time.sleep(0.5) + send('end') + client.wait(timeout=60) + finally: + if client.poll() is None: + client.kill() + finally: + server.stop() + if not out.exists(): + raise AssertionError(f'{label}: the client wrote no transcript (see {build}/{label}-client.log)') + return out.read_text(encoding='utf-8').splitlines() + + +DATA = re.compile(r'^chat \S+ has the following entity data: \[(.*)\]$') + + +def compared(lines): + """Per case, what is compared: the mob's Pos and Motion (to 1e-9), and each player's motion packets and + sprint flag.""" + cases = {} + for line in lines: + who, step, text = line.split(' ', 2) + step = step.removeprefix('step=') + if step not in CASES: + continue + kept = cases.setdefault(step, []) + data = DATA.match(text) + if who == 'Alice' and data: + kept.append('data ' + ' '.join(f'{float(v.rstrip("d")):.9f}' for v in data.group(1).split(', '))) + elif text.startswith('motion self') or text.startswith('sprinting'): + kept.append(f'{who} {text}') + elif text.startswith('error') or text.startswith('disconnected'): + kept.append(f'{who} {text}') + return cases + + +def main(): + lock, jars, libraries = base.verify_artifacts() + build = lab.LOCAL / NAME + build.mkdir(parents=True, exist_ok=True) + report = build / 'report.json' + report.unlink(missing_ok=True) + oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java' + classes = build / 'classes' + shutil.rmtree(classes, ignore_errors=True) + classes.mkdir() + dependencies = os.pathsep.join(map(str, [jars['server'], *libraries])) + subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath', + lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle], + cwd=lab.ROOT, check=True, capture_output=True) + subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT, + check=True, capture_output=True) + import json + metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], + cwd=lab.ROOT, text=True)) + binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client') + vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui'] + horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui'] + client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.KnockbackClient'] + + world = generate_world(vanilla_server, build) + vanilla = compared(run_side('vanilla', vanilla_server, client, build, world)) + horizon = compared(run_side('horizon', horizon_server, client, build, world)) + differ, fixed = [], [] + for case in CASES: + want, got = vanilla.get(case, []), horizon.get(case, []) + if case not in vanilla or any(' error ' in f' {l} ' or 'disconnected' in l for l in want): + raise AssertionError(f'{case}: vanilla recorded nothing or failed: {want}') + if want == got: + if case in KNOWN: + fixed.append(case) + continue + if case in KNOWN: + continue + import difflib + differ.append(f'{case}:\n' + '\n'.join(difflib.unified_diff(want, got, 'vanilla', 'horizon', n=1, lineterm=''))) + if fixed: + print('matching vanilla now, take them out of KNOWN: ' + ', '.join(fixed)) + if differ: + raise AssertionError(f'{len(differ)} cases differ (see {build}/vanilla.txt and horizon.txt):\n' + + '\n'.join(differ)[:8000]) + lab.write_json(report, dict( + schema=1, minecraft=lock['minecraft']['version'], platform=platform.platform(), + java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0], + cases=len(CASES), known=sorted(KNOWN), output_sha256=lab.digest(build / 'horizon.txt', 'sha256'), + scope='Knockback on a dedicated server, as two vanilla-codec players get it: a player hitting a cow and ' + 'a zombie (plain, sprinting, Knockback II, critical, in the air; the mob\'s motion and path over 20 ' + 'ticks), a player hitting a player (the same, a raised shield, netherite, two hits, a mace smash; ' + 'the victim\'s motion packet and the attacker\'s sprint) and a zombie hurting a player.')) + print(f'server knockback: {len(CASES) - len(KNOWN)} of {len(CASES)} cases identical') + + +if __name__ == '__main__': + try: + main() + except AssertionError as error: + sys.exit(f'{NAME}: {error}')