Merge branch 'MartijnMuijsers-feature/1.19.3-and-more'

README.md

···
 # minecraft-stress-test
 
-Automate the stress testing of your 1.19.2 Minecraft server with bots.
+Automate the stress testing of your 1.19.3 Minecraft server with bots.
 This project will log offline-mode bots into the specified server which will
 fly around and explore the world.
 
···
 Set the bot count to 1000. This will either connect more bots, or disconnect existing bots as needed.
 
 `speed 0.2`  
-Set the bots' movement speed. The default is 0.2 blocks/tick.
+Set the bots' movement speed. The default is 0.1 blocks/tick.
+
+`radius 600`  
+Set the radius of the area the bots can move around in. The default is 1000 blocks.

src/main/java/com/github/puregero/minecraftstresstest/Bot.java

···
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
 
 public class Bot extends ChannelInboundHandlerAdapter {
-    private static final int PROTOCOL_VERSION = Integer.parseInt(System.getProperty("bot.protocol.version", "760")); // 760 is 1.19.2 https://wiki.vg/Protocol_version_numbers
-    private static final double RADIUS = Double.parseDouble(System.getProperty("bot.radius", "1000"));
+    private static final int PROTOCOL_VERSION = Integer.parseInt(System.getProperty("bot.protocol.version", "761")); // 761 is 1.19.3 https://wiki.vg/Protocol_version_numbers
     private static final double CENTER_X = Double.parseDouble(System.getProperty("bot.x", "0"));
     private static final double CENTER_Z = Double.parseDouble(System.getProperty("bot.z", "0"));
     private static final boolean LOGS = Boolean.parseBoolean(System.getProperty("bot.logs", "true"));
···
 
     private static final Executor ONE_TICK_DELAY = CompletableFuture.delayedExecutor(50,TimeUnit.MILLISECONDS);
 
-    public static double SPEED = Double.parseDouble(System.getProperty("bot.speed", "0.1"));
+    public static final String DEFAULT_SPEED = "0.1";
+    public static double SPEED = Double.parseDouble(System.getProperty("bot.speed", DEFAULT_SPEED));
+    public static final String DEFAULT_RADIUS = "1000";
+    public static double RADIUS = Double.parseDouble(System.getProperty("bot.radius", DEFAULT_RADIUS));
 
     public SocketChannel channel;
     private String username;
···
 
     @Override
     public void channelActive(final ChannelHandlerContext ctx) {
-        FriendlyByteBuf handshakePacket = new FriendlyByteBuf(ctx.alloc().buffer());
-        handshakePacket.writeVarInt(0x00);
-        handshakePacket.writeVarInt(PROTOCOL_VERSION);
-        handshakePacket.writeUtf(address);
-        handshakePacket.writeShort(port);
-        handshakePacket.writeVarInt(2);
-        ctx.write(handshakePacket);
+        sendPacket(ctx, PacketIds.Serverbound.Handshaking.HANDSHAKE, buffer -> {
+            buffer.writeVarInt(PROTOCOL_VERSION);
+            buffer.writeUtf(address);
+            buffer.writeShort(port);
+            buffer.writeVarInt(2);
+        });
 
-        FriendlyByteBuf loginStartPacket = new FriendlyByteBuf(ctx.alloc().buffer());
-        loginStartPacket.writeVarInt(0x00);
-        loginStartPacket.writeUtf(username);
-        loginStartPacket.writeBoolean(false);
-        loginStartPacket.writeBoolean(false);
-        ctx.writeAndFlush(loginStartPacket);
+        sendPacket(ctx, PacketIds.Serverbound.Login.LOGIN_START, buffer -> {
+            buffer.writeUtf(username);
+            buffer.writeBoolean(false);
+        });
     }
 
     @Override
···
     private void channelReadLogin(ChannelHandlerContext ctx, FriendlyByteBuf byteBuf) {
         int packetId = byteBuf.readVarInt();
 
-        if (packetId == 0) {
+        if (packetId == PacketIds.Clientbound.Login.DISCONNECT) {
             System.out.println(username + " was disconnected during login due to " + byteBuf.readUtf());
             ctx.close();
-        } else if (packetId == 2) {
+        } else if (packetId == PacketIds.Clientbound.Login.LOGIN_SUCCESS) {
             UUID uuid = byteBuf.readUUID();
             String username = byteBuf.readUtf();
             loggedIn(ctx, uuid, username);
-        } else if (packetId == 3) {
+        } else if (packetId == PacketIds.Clientbound.Login.SET_COMPRESSION) {
             byteBuf.readVarInt();
             ctx.pipeline().addAfter("packetDecoder", "compressionDecoder", new CompressionDecoder());
             ctx.pipeline().addAfter("packetEncoder", "compressionEncoder", new CompressionEncoder());
···
         loginState = false;
 
         CompletableFuture.delayedExecutor(1000,TimeUnit.MILLISECONDS).execute(() -> {
-            FriendlyByteBuf settingsPacket = new FriendlyByteBuf(ctx.alloc().buffer());
-            settingsPacket.writeVarInt(0x08);
-            settingsPacket.writeUtf("en_GB");
-            settingsPacket.writeByte(VIEW_DISTANCE);
-            settingsPacket.writeVarInt(0);
-            settingsPacket.writeBoolean(true);
-            settingsPacket.writeByte(0);
-            settingsPacket.writeVarInt(0);
-            settingsPacket.writeBoolean(false);
-            settingsPacket.writeBoolean(true);
-            ctx.writeAndFlush(settingsPacket);
+            sendPacket(ctx, PacketIds.Serverbound.Play.CLIENT_INFORMATION, buffer -> {
+                buffer.writeUtf("en_GB");
+                buffer.writeByte(VIEW_DISTANCE);
+                buffer.writeVarInt(0);
+                buffer.writeBoolean(true);
+                buffer.writeByte(0);
+                buffer.writeVarInt(0);
+                buffer.writeBoolean(false);
+                buffer.writeBoolean(true);
+            });
 
             CompletableFuture.delayedExecutor(1000, TimeUnit.MILLISECONDS).execute(() -> tick(ctx));
         });
···
             y -= SPEED / 10;
         }
 
-        FriendlyByteBuf movePacket = new FriendlyByteBuf(ctx.alloc().buffer());
-        movePacket.writeVarInt(0x15);
-        movePacket.writeDouble(x);
-        movePacket.writeDouble(y);
-        movePacket.writeDouble(z);
-        movePacket.writeFloat(yaw);
-        movePacket.writeFloat(0);
-        movePacket.writeBoolean(true);
-        ctx.writeAndFlush(movePacket);
+        sendPacket(ctx, PacketIds.Serverbound.Play.SET_PLAYER_POSITION_AND_ROTATION, buffer -> {
+            buffer.writeDouble(x);
+            buffer.writeDouble(y);
+            buffer.writeDouble(z);
+            buffer.writeFloat(yaw);
+            buffer.writeFloat(0);
+            buffer.writeBoolean(true);
+        });
     }
 
     private void channelReadPlay(ChannelHandlerContext ctx, FriendlyByteBuf byteBuf) {
         int packetId = byteBuf.readVarInt();
 //        System.out.println("id 0x" + Integer.toHexString(packetId) + " (" + (dataLength == 0 ? length : dataLength) + ")");
 
-        if (packetId == 0x19) {
+        if (packetId == PacketIds.Clientbound.Play.DISCONNECT) {
             System.out.println(username + " (" + uuid + ") was kicked due to " + byteBuf.readUtf());
             ctx.close();
-        } else if (packetId == 0x20) {
+        } else if (packetId == PacketIds.Clientbound.Play.KEEP_ALIVE) {
             long id = byteBuf.readLong();
 
-            FriendlyByteBuf keepAlivePacket = new FriendlyByteBuf(ctx.alloc().buffer());
-            keepAlivePacket.writeVarInt(0x12);
-            keepAlivePacket.writeLong(id);
-            ctx.writeAndFlush(keepAlivePacket);
-        } else if (packetId == 0x2F) {
+            sendPacket(ctx, PacketIds.Serverbound.Play.KEEP_ALIVE, buffer -> buffer.writeLong(id));
+        } else if (packetId == PacketIds.Clientbound.Play.PING) {
             int id = byteBuf.readInt();
 
-            FriendlyByteBuf keepAlivePacket = new FriendlyByteBuf(ctx.alloc().buffer());
-            keepAlivePacket.writeVarInt(0x20);
-            keepAlivePacket.writeInt(id);
-            ctx.writeAndFlush(keepAlivePacket);
-        } else if (packetId == 0x39) {
+            sendPacket(ctx, PacketIds.Serverbound.Play.PONG, buffer -> buffer.writeInt(id));
+        } else if (packetId == PacketIds.Clientbound.Play.SYNCHRONIZE_PLAYER_POSITION) {
             double dx = byteBuf.readDouble();
             double dy = byteBuf.readDouble();
             double dz = byteBuf.readDouble();
···
                 if (!goDown) yaw = (float) (Math.random() * 360);
             }
 
-            FriendlyByteBuf teleportConfirmPacket = new FriendlyByteBuf(ctx.alloc().buffer());
-            teleportConfirmPacket.writeVarInt(0x00);
-            teleportConfirmPacket.writeVarInt(id);
-            ctx.writeAndFlush(teleportConfirmPacket);
-        } else if (packetId == 0x3D) {
+            sendPacket(ctx, PacketIds.Serverbound.Play.CONFIRM_TELEPORTATION, buffer -> buffer.writeVarInt(id));
+        } else if (packetId == PacketIds.Clientbound.Play.RESOURCE_PACK) {
             String url = byteBuf.readUtf();
             String hash = byteBuf.readUtf();
             boolean forced = byteBuf.readBoolean();
             String message = null;
             if (byteBuf.readBoolean()) message = byteBuf.readUtf();
             System.out.println("Resource pack info:\n" + url + "\n" + hash + "\n" + forced + "\n" + message);
-            FriendlyByteBuf resourcePackResponsePacket = new FriendlyByteBuf(ctx.alloc().buffer());
-            resourcePackResponsePacket.writeVarInt(0x24);
-            resourcePackResponsePacket.writeVarInt(RESOURCE_PACK_RESPONSE);
-            ctx.writeAndFlush(resourcePackResponsePacket);
+
+            sendPacket(ctx, PacketIds.Serverbound.Play.RESOURCE_PACK, buffer -> buffer.writeVarInt(RESOURCE_PACK_RESPONSE));
         }
     }
 
     public void close() {
         channel.close();
+    }
+
+    public static void sendPacket(ChannelHandlerContext ctx, int packetId, Consumer<FriendlyByteBuf> applyToBuffer) {
+        FriendlyByteBuf buffer = new FriendlyByteBuf(ctx.alloc().buffer());
+        buffer.writeVarInt(packetId);
+        applyToBuffer.accept(buffer);
+        ctx.writeAndFlush(buffer);
     }
 }

src/main/java/com/github/puregero/minecraftstresstest/MinecraftStressTest.java

···
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Scanner;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 public class MinecraftStressTest {
 
-    private static final int BOT_COUNT = Integer.parseInt(System.getProperty("bot.count", "1"));
     private static final String ADDRESS = System.getProperty("bot.ip", "127.0.0.1");
     private static final int PORT = Integer.parseInt(System.getProperty("bot.port", "25565"));
     private static final int DELAY_BETWEEN_BOTS_MS = Integer.parseInt(System.getProperty("bot.login.delay.ms", "100"));
 
+    private static final String DEFAULT_BOT_COUNT = "1";
+    private static int BOT_COUNT = Integer.parseInt(System.getProperty("bot.count", DEFAULT_BOT_COUNT));
+
+    private static final List<Bot> bots = new ArrayList<>();
+    private static final Lock botsLock = new ReentrantLock();
+    private static final AtomicBoolean addingBots = new AtomicBoolean();
+
     private static final EventLoopGroup workerGroup = new NioEventLoopGroup();
 
     public static void main(String[] a) {
-        List<Bot> bots = new ArrayList<>();
-
-        updateBotCount(bots, BOT_COUNT);
+        updateBotCount();
 
         Scanner scanner = new Scanner(System.in);
 
···
 
             try {
                 if (args[0].equalsIgnoreCase("count") || args[0].equalsIgnoreCase("botcount")) {
-                    int botCount = Integer.parseInt(args[1]);
+                    int botCount = Math.max(0, Integer.parseInt(args[1]));
                     System.out.println("Setting bot count to " + botCount);
-                    updateBotCount(bots, botCount);
+                    BOT_COUNT = botCount;
+                    updateBotCount();
                 } else if (args[0].equalsIgnoreCase("speed")) {
-                    double speed = Double.parseDouble(args[1]);
+                    double speed = Math.max(0.0, Double.parseDouble(args[1]));
                     System.out.println("Setting speed to " + speed);
                     Bot.SPEED = speed;
+                } else if (args[0].equalsIgnoreCase("radius")) {
+                    double radius = Math.max(0.0, Double.parseDouble(args[1]));
+                    System.out.println("Setting radius to " + radius);
+                    Bot.RADIUS = radius;
                 } else {
                     System.out.println("Commands:");
-                    System.out.println("count <number of bots>");
-                    System.out.println("speed <0.2>");
+                    System.out.println("count <number of bots>   (Default: " + DEFAULT_BOT_COUNT + ")");
+                    System.out.println("speed <value>            (Default: " + Bot.DEFAULT_SPEED + ")");
+                    System.out.println("radius <value>           (Default: " + Bot.DEFAULT_RADIUS + ")");
                 }
             } catch (Exception e) {
                 e.printStackTrace();
···
         System.out.println("stdin ended");
     }
 
-    private static void updateBotCount(List<Bot> bots, int botCount) {
-        while (bots.size() > botCount && !bots.isEmpty()) {
-            bots.remove(bots.size() - 1).close();
+    private static void updateBotCount() {
+        removeBotsIfNeeded();
+        addBotIfNeeded(true);
+    }
+
+    private static void removeBotsIfNeeded() {
+        botsLock.lock();
+        while (true) {
+            Bot removedBot;
+            try {
+                if (bots.size() <= BOT_COUNT) {
+                    break;
+                }
+                removedBot = bots.remove(bots.size() - 1);
+            } finally {
+                botsLock.unlock();
+            }
+            removedBot.close();
         }
+    }
 
-        while (bots.size() < botCount) {
-            bots.add(connectBot(System.getProperty("bot.name", "Bot") + (bots.size() + 1), ADDRESS, PORT));
+    private static void addBotIfNeeded(boolean firstCall) {
+        if (!firstCall || !addingBots.getAndSet(true)) {
+            boolean scheduledNextCall = false;
             try {
-                Thread.sleep(DELAY_BETWEEN_BOTS_MS);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
+                botsLock.lock();
+                try {
+                    if (bots.size() < BOT_COUNT) {
+                        bots.add(connectBot(System.getProperty("bot.name", "Bot") + (bots.size() + 1), ADDRESS, PORT));
+                        CompletableFuture.delayedExecutor(DELAY_BETWEEN_BOTS_MS, TimeUnit.MILLISECONDS).execute(() -> addBotIfNeeded(false));
+                        scheduledNextCall = true;
+                    }
+                } finally {
+                    botsLock.unlock();
+                }
+            } finally {
+                if (!scheduledNextCall) {
+                    addingBots.set(false);
+                }
             }
         }
     }

src/main/java/com/github/puregero/minecraftstresstest/PacketIds.java

···
+package com.github.puregero.minecraftstresstest;
+
+public final class PacketIds {
+	private PacketIds() {}
+
+	public static final class Clientbound {
+		private Clientbound() {}
+
+		public static final class Login {
+			private Login() {}
+			public static final int
+					DISCONNECT = 0x00,
+					LOGIN_SUCCESS = 0x02,
+					SET_COMPRESSION = 0x03;
+		}
+
+		public static final class Play {
+			private Play() {}
+			public static final int
+					DISCONNECT = 0x17,
+					KEEP_ALIVE = 0x1F,
+					PING = 0x2E,
+					SYNCHRONIZE_PLAYER_POSITION = 0x38,
+					RESOURCE_PACK = 0x3C;
+		}
+
+	}
+
+	public static final class Serverbound {
+		private Serverbound() {}
+
+		public static final class Handshaking {
+			private Handshaking() {}
+			public static final int
+					HANDSHAKE = 0x00;
+		}
+
+		public static final class Login {
+			private Login() {}
+			public static final int
+					LOGIN_START = 0x00;
+		}
+
+		public static final class Play {
+			private Play() {}
+			public static final int
+					CONFIRM_TELEPORTATION = 0x00,
+					CLIENT_INFORMATION = 0x07,
+					KEEP_ALIVE = 0x11,
+					SET_PLAYER_POSITION_AND_ROTATION = 0x14,
+					PONG = 0x1F,
+					RESOURCE_PACK = 0x24;
+		}
+
+	}
+
+}