Paper/Spigot-Server-Patches/0483-Broadcast-join-message-to-console.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: AvrooVulcan <avrovulcan.programming@gmail.com>
Date: Fri, 17 Apr 2020 00:15:23 +0100
Subject: [PATCH] Broadcast join message to console


diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java
index 78040e83899f1ef1a6d5c456beb9d13959307c18..c491612267977fb331368825e0d87b2fc297e9c5 100644
--- a/src/main/java/net/minecraft/server/PlayerList.java
+++ b/src/main/java/net/minecraft/server/PlayerList.java
@@ -188,9 +188,9 @@ public abstract class PlayerList {
         joinMessage = playerJoinEvent.getJoinMessage();
 
         if (joinMessage != null && joinMessage.length() > 0) {
-            for (IChatBaseComponent line : org.bukkit.craftbukkit.util.CraftChatMessage.fromString(joinMessage)) {
-                server.getPlayerList().sendAll(new PacketPlayOutChat(line));
-            }
+            // Paper start - Removed sendAll for loop and broadcasted to console also
+            server.getPlayerList().sendMessage(CraftChatMessage.fromString(joinMessage));
+            // Paper end
         }
         // CraftBukkit end
Rebuild all patches using the new rebuild pattern 2020-05-06 11:48:49 +02:00			`From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001`
Broadcast join messages to console 2020-04-17 01:18:51 +02:00			`From: AvrooVulcan <avrovulcan.programming@gmail.com>`
			`Date: Fri, 17 Apr 2020 00:15:23 +0100`
			`Subject: [PATCH] Broadcast join message to console`


			`diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java`
Implement Chunk Priority / Urgency System for Chunks Mark chunks that are blocking main thread for world generation as urgent Implements a general priority system so that chunks that are sorted in the generator queues can prioritize certain chunks over another. Urgent chunks will jump to the front of the line, ensuring that a sync chunk load on an ungenerated chunk does not lag the server for a long period of time if the servers generator queues are filled with lots of chunks already. This massively reduces the lag spikes from sync chunk gens. Then we further prioritize loading order so nearby chunks have higher priority than distant chunks, reducing the pressure a high no tick view distance holds on you. Chunks in front of the player have higher priority, to help with fast traveling players keep up with their movement. This commit also improves single core cpu scenarios in that we will now automatically disable Async Chunks as well as Minecrafts thread pool. It is never recommended to use async chunks on a single CPU as context switching will be slower than just running it all on main. This also bumps the number of server worker threads by default too. Mojang does not utilize the workers in an effecient manner, resulting in them using barely any sustained CPU. So give it more workers so more chunks can be processed concurrently This change also improves urgent chunk loading, so players flying into unloaded chunks will hurt a little bit less (but still hurt) Ping #3395 #3363 (Not marking as closed, we need to make prevent moving work) 2020-05-19 10:01:53 +02:00			`index 78040e83899f1ef1a6d5c456beb9d13959307c18..c491612267977fb331368825e0d87b2fc297e9c5 100644`
Broadcast join messages to console 2020-04-17 01:18:51 +02:00			`--- a/src/main/java/net/minecraft/server/PlayerList.java`
			`+++ b/src/main/java/net/minecraft/server/PlayerList.java`
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity. 2020-05-06 11:22:03 +02:00			`@@ -188,9 +188,9 @@ public abstract class PlayerList {`
Broadcast join messages to console 2020-04-17 01:18:51 +02:00			`joinMessage = playerJoinEvent.getJoinMessage();`

			`if (joinMessage != null && joinMessage.length() > 0) {`
			`- for (IChatBaseComponent line : org.bukkit.craftbukkit.util.CraftChatMessage.fromString(joinMessage)) {`
			`- server.getPlayerList().sendAll(new PacketPlayOutChat(line));`
			`- }`
			`+ // Paper start - Removed sendAll for loop and broadcasted to console also`
			`+ server.getPlayerList().sendMessage(CraftChatMessage.fromString(joinMessage));`
			`+ // Paper end`
			`}`
			`// CraftBukkit end`