Upstream
/
Minestom
mirror of https://github.com/Minestom/Minestom.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Deprecate ChatPosition, extend Messenger, add CommonChatType, rename ChatMessageType to ChatPreference

This commit is contained in:
Noel Németh 2022-06-19 01:18:03 +02:00
parent 9b6c277212
commit 4c5731e579
14 changed files with 181 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
demo/src/main/java/net/minestom/demo/Main.java
View File

@ -20,6 +20,7 @@ import net.minestom.server.message.MessageSender;
import net.minestom.server.message.registry.ChatDecoration;
import net.minestom.server.message.registry.ChatRegistryManager;
import net.minestom.server.message.registry.ChatType;
import net.minestom.server.message.registry.CommonChatType;
import net.minestom.server.ping.ResponseData;
import net.minestom.server.utils.identity.NamedAndIdentified;
import net.minestom.server.utils.time.TimeUnit;
@ -109,7 +110,7 @@ public class Main {
});
final ChatRegistryManager chatRegistryManager = MinecraftServer.getChatRegistryManager();
chatRegistryManager.addChatType(ChatType.chat(ChatRegistryManager.DEFAULT_CHAT,
chatRegistryManager.addChatType(ChatType.chat(CommonChatType.CHAT.getName(),
ChatDecoration.full("%s | %s> %s", Style.style(NamedTextColor.DARK_RED)).toTextDisplay()));
PlayerInit.init();

8
demo/src/main/java/net/minestom/demo/commands/CommandSignTest.java
View File

@ -8,9 +8,10 @@ import net.minestom.server.command.builder.arguments.minecraft.ArgumentMessage;
import net.minestom.server.crypto.MessageSignature;
import net.minestom.server.crypto.SignatureValidator;
import net.minestom.server.entity.Player;
import net.minestom.server.message.ChatPosition;
import net.minestom.server.message.Messenger;
import java.util.List;
public class CommandSignTest extends Command {
private static final ArgumentMessage message = ArgumentType.Message("message");
@ -21,14 +22,13 @@ public class CommandSignTest extends Command {
if (sender instanceof Player player) {
final MessageSignature signature = context.getSignature().signatureOf(message, player.getUuid());
final SignatureValidator validator = SignatureValidator.from(player);
Messenger.sendSystemMessage(player,
Messenger.sendSystemMessage(List.of(player),
Component.text("Signature details: preview: ")
.append(formatBoolean(context.getSignature().signedPreview()))
.append(Component.text(", argument_signature: "))
.append(format(SignatureValidator.validate(validator, signature, Component.text(context.get(message)))))
.append(Component.text(", preview_signature: "))
.append(format(SignatureValidator.validate(validator, signature, player.getLastPreviewedMessage()))),
ChatPosition.CHAT);
.append(format(SignatureValidator.validate(validator, signature, player.getLastPreviewedMessage()))));
} else {
// TODO Handle this case
}

11
src/main/java/net/minestom/server/adventure/audience/PacketGroupingAudience.java
View File

@ -8,12 +8,14 @@ import net.kyori.adventure.identity.Identity;
import net.kyori.adventure.sound.Sound;
import net.kyori.adventure.sound.SoundStop;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.title.TitlePart;
import net.minestom.server.MinecraftServer;
import net.minestom.server.adventure.AdventurePacketConvertor;
import net.minestom.server.entity.Player;
import net.minestom.server.message.ChatPosition;
import net.minestom.server.message.MessageSender;
import net.minestom.server.message.Messenger;
import net.minestom.server.message.registry.CommonChatType;
import net.minestom.server.network.packet.server.ServerPacket;
import net.minestom.server.network.packet.server.play.ActionBarPacket;
import net.minestom.server.network.packet.server.play.ClearTitlesPacket;
@ -58,8 +60,11 @@ public interface PacketGroupingAudience extends ForwardingAudience {
@Override
default void sendMessage(@NotNull Identity source, @NotNull Component message, @NotNull MessageType type) {
// FIXME: 2022. 06. 10.
// Messenger.send(this.getPlayers(), message, ChatPosition.fromMessageType(type), source.uuid());
if (type == MessageType.SYSTEM)
Messenger.sendSystemMessage(getPlayers(), message, CommonChatType.SYSTEM.getId());
else
Messenger.sendUnsignedMessage(getPlayers(), new MessageSender(Component.text("UNKNOWN SENDER",
NamedTextColor.RED), null), message);
}
@Override

23
src/main/java/net/minestom/server/entity/Player.java
View File

@ -45,10 +45,10 @@ import net.minestom.server.item.ItemStack;
import net.minestom.server.item.Material;
import net.minestom.server.item.metadata.WrittenBookMeta;
import net.minestom.server.listener.manager.PacketListenerManager;
import net.minestom.server.message.ChatMessageType;
import net.minestom.server.message.ChatPosition;
import net.minestom.server.message.ChatPreference;
import net.minestom.server.message.MessageSender;
import net.minestom.server.message.Messenger;
import net.minestom.server.message.registry.CommonChatType;
import net.minestom.server.network.ConnectionManager;
import net.minestom.server.network.ConnectionState;
import net.minestom.server.network.PlayerProvider;
@ -667,11 +667,10 @@ public class Player extends LivingEntity implements CommandSender, Localizable,
@Override
public void sendMessage(@NotNull Identity source, @NotNull Component message, @NotNull MessageType type) {
if (type == MessageType.SYSTEM)
Messenger.sendSystemMessage(this, message, ChatPosition.SYSTEM_MESSAGE);
Messenger.sendSystemMessage(List.of(this), message, CommonChatType.SYSTEM.getId());
else
Messenger.sendMessage(List.of(this), PlayerChatMessagePacket.unsigned(message,
// TODO get name from source if possible
ChatPosition.CHAT, new MessageSender(Component.empty(), null)));
Messenger.sendUnsignedMessage(List.of(this), new MessageSender(Component.text("UNKNOWN SENDER",
NamedTextColor.RED), null), message);
}
/**
@ -2103,7 +2102,7 @@ public class Player extends LivingEntity implements CommandSender, Localizable,
private String locale;
private byte viewDistance;
private ChatMessageType chatMessageType;
private ChatPreference chatPreference;
private boolean chatColors;
private byte displayedSkinParts;
private MainHand mainHand;
@ -2137,8 +2136,8 @@ public class Player extends LivingEntity implements CommandSender, Localizable,
*
* @return the messages
*/
public @Nullable ChatMessageType getChatMessageType() {
return chatMessageType;
public @Nullable ChatPreference getChatMessageType() {
return chatPreference;
}
/**
@ -2178,16 +2177,16 @@ public class Player extends LivingEntity implements CommandSender, Localizable,
*
* @param locale the player locale
* @param viewDistance the player view distance
* @param chatMessageType the chat messages the player wishes to receive
* @param chatPreference the chat messages the player wishes to receive
* @param chatColors if chat colors should be displayed
* @param displayedSkinParts the player displayed skin parts
* @param mainHand the player main hand
*/
public void refresh(String locale, byte viewDistance, ChatMessageType chatMessageType, boolean chatColors,
public void refresh(String locale, byte viewDistance, ChatPreference chatPreference, boolean chatColors,
byte displayedSkinParts, MainHand mainHand, boolean enableTextFiltering, boolean allowServerListings) {
this.locale = locale;
this.viewDistance = viewDistance;
this.chatMessageType = chatMessageType;
this.chatPreference = chatPreference;
this.chatColors = chatColors;
this.displayedSkinParts = displayedSkinParts;
this.mainHand = mainHand;

11
src/main/java/net/minestom/server/event/player/PlayerChatEvent.java
View File

@ -6,6 +6,7 @@ import net.minestom.server.entity.Player;
import net.minestom.server.event.trait.CancellableEvent;
import net.minestom.server.event.trait.PlayerInstanceEvent;
import net.minestom.server.message.MessageSender;
import net.minestom.server.message.registry.CommonChatType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@ -28,6 +29,7 @@ public class PlayerChatEvent implements PlayerInstanceEvent, CancellableEvent {
private MessageSignature signature;
private MessageSender sender;
private final Component message;
private int chatType;
public PlayerChatEvent(@NotNull Player player, @NotNull Collection<Player> recipients,
@NotNull String rawMessage, @NotNull MessageSignature signature,
@ -38,6 +40,7 @@ public class PlayerChatEvent implements PlayerInstanceEvent, CancellableEvent {
this.message = message;
this.signature = signature;
this.sender = sender;
this.chatType = CommonChatType.CHAT.getId();
}
public MessageSender getSender() {
@ -114,4 +117,12 @@ public class PlayerChatEvent implements PlayerInstanceEvent, CancellableEvent {
public void setSignature(@NotNull MessageSignature signature) {
this.signature = signature;
}
public int getChatType() {
return chatType;
}
public void setChatType(int chatType) {
this.chatType = chatType;
}
}

14
src/main/java/net/minestom/server/listener/ChatMessageListener.java
View File

@ -7,7 +7,6 @@ import net.minestom.server.entity.Player;
import net.minestom.server.event.EventDispatcher;
import net.minestom.server.event.player.PlayerChatEvent;
import net.minestom.server.event.player.PlayerChatPreviewEvent;
import net.minestom.server.message.ChatPosition;
import net.minestom.server.message.MessageSender;
import net.minestom.server.message.Messenger;
import net.minestom.server.network.ConnectionManager;
@ -15,7 +14,6 @@ import net.minestom.server.network.packet.client.play.ClientChatMessagePacket;
import net.minestom.server.network.packet.client.play.ClientChatPreviewPacket;
import net.minestom.server.network.packet.client.play.ClientCommandChatPacket;
import net.minestom.server.network.packet.server.play.ChatPreviewPacket;
import net.minestom.server.network.packet.server.play.PlayerChatMessagePacket;
import java.util.Collection;
import java.util.Objects;
@ -61,20 +59,18 @@ public class ChatMessageListener {
if (event.getSignature().unsigned()) {
// Event handler set message unsigned -> players with
// "Only Show Secure Chat" option enabled won't see this message
Messenger.sendMessage(event.getRecipients(), PlayerChatMessagePacket
.unsigned(formatFunction.apply(event), ChatPosition.CHAT, event.getSender()));
Messenger.sendUnsignedMessage(event.getRecipients(), event.getSender(), formatFunction.apply(event), event.getChatType());
} else {
// Send both version of message -> players will see different versions based on
// their "Only Show Secure Chat" option
Messenger.sendMessage(event.getRecipients(), PlayerChatMessagePacket
.signedWithUnsignedContent(event.getMessage(), formatFunction.apply(event),
ChatPosition.CHAT, event.getSender(), event.getSignature()));
Messenger.sendSignedMessage(event.getRecipients(), event.getSender(), event.getMessage(),
formatFunction.apply(event), event.getSignature(), event.getChatType());
}
} else {
// There is no way the message got modified, send it with the original signature
// TODO Should we handle poor design where the signature got altered?
Messenger.sendMessage(event.getRecipients(), PlayerChatMessagePacket.signed(event.getMessage(),
ChatPosition.CHAT, event.getSender(), event.getSignature()));
Messenger.sendSignedMessage(event.getRecipients(), event.getSender(), event.getMessage(),
event.getSignature(), event.getChatType());
}
});
}

2
src/main/java/net/minestom/server/listener/SettingsListener.java
View File

@ -9,7 +9,7 @@ public final class SettingsListener {
public static void listener(ClientSettingsPacket packet, Player player) {
Player.PlayerSettings settings = player.getSettings();
final byte viewDistance = (byte) Math.abs(packet.viewDistance());
settings.refresh(packet.locale(), viewDistance, packet.chatMessageType(), packet.chatColors(), packet.displayedSkinParts(), packet.mainHand(), packet.enableTextFiltering(), packet.allowsListing());
settings.refresh(packet.locale(), viewDistance, packet.chatPreference(), packet.chatColors(), packet.displayedSkinParts(), packet.mainHand(), packet.enableTextFiltering(), packet.allowsListing());
EventDispatcher.call(new PlayerSettingsChangeEvent(player));
}
}

7
src/main/java/net/minestom/server/message/ChatPosition.java
View File

@ -1,12 +1,19 @@
package net.minestom.server.message;
import net.kyori.adventure.audience.MessageType;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* The different positions for chat messages.
*
* @deprecated Replaced by {@link net.minestom.server.message.registry.ChatType}, for more information refer to
* {@link net.minestom.server.message.registry.ChatRegistryManager}. No methods should use this enum, only left
* here to help resolve issues when updating.
*/
@Deprecated(forRemoval = true)
@ApiStatus.ScheduledForRemoval(inVersion = "1.0.0")
public enum ChatPosition {
/**
* A player-initiated chat message.

28
src/main/java/net/minestom/server/message/ChatMessageType.java → src/main/java/net/minestom/server/message/ChatPreference.java
View File

@ -2,42 +2,24 @@ package net.minestom.server.message;
import org.jetbrains.annotations.NotNull;
import java.util.EnumSet;
/**
* The messages that a player is willing to receive.
*/
public enum ChatMessageType {
public enum ChatPreference {
/**
* The client wants all chat messages.
*/
FULL(EnumSet.allOf(ChatPosition.class)),
FULL,
/**
* The client only wants messages from commands, or system messages.
*/
SYSTEM(EnumSet.of(ChatPosition.SYSTEM_MESSAGE, ChatPosition.GAME_INFO)),
SYSTEM,
/**
* The client doesn't want any messages.
*/
NONE(EnumSet.of(ChatPosition.GAME_INFO));
private final EnumSet<ChatPosition> acceptedPositions;
ChatMessageType(@NotNull EnumSet<ChatPosition> acceptedPositions) {
this.acceptedPositions = acceptedPositions;
}
/**
* Checks if this message type is accepting of messages from a given position.
*
* @param chatPosition the position
* @return if the message is accepted
*/
public boolean accepts(@NotNull ChatPosition chatPosition) {
return this.acceptedPositions.contains(chatPosition);
}
NONE;
/**
* Gets the packet ID for this chat message type.
@ -54,7 +36,7 @@ public enum ChatMessageType {
* @param id the packet ID
* @return the chat message type
*/
public static @NotNull ChatMessageType fromPacketID(int id) {
public static @NotNull ChatPreference fromPacketID(int id) {
return switch (id) {
case 0 -> FULL;
case 1 -> SYSTEM;

99
src/main/java/net/minestom/server/message/Messenger.java
View File

@ -2,51 +2,78 @@ package net.minestom.server.message;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.minestom.server.crypto.MessageSignature;
import net.minestom.server.entity.Player;
import net.minestom.server.message.registry.CommonChatType;
import net.minestom.server.network.packet.server.play.PlayerChatMessagePacket;
import net.minestom.server.network.packet.server.play.SystemChatPacket;
import net.minestom.server.utils.PacketUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Collection;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* Utility class to handle client chat settings.
*/
public final class Messenger {
/**
* The message sent to the client if they send a chat message but it is rejected by the server.
*/
public static final Component CANNOT_SEND_MESSAGE = Component.translatable("chat.cannotSend", NamedTextColor.RED);
private static final SystemChatPacket CANNOT_SEND_PACKET = new SystemChatPacket(CANNOT_SEND_MESSAGE, ChatPosition.SYSTEM_MESSAGE.getID());
/**
* Sends a message to a player, respecting their chat settings.
*
* @param player the player
* @param message the message
* @param position the position
* @return if the message was sent
*/
public static boolean sendSystemMessage(@NotNull Player player, @NotNull Component message, @NotNull ChatPosition position) {
if (getChatMessageType(player).accepts(position)) {
player.sendPacket(new SystemChatPacket(message, position.getID()));
return true;
}
return false;
private Messenger() {
//no instance
}
private static SystemChatPacket CANNOT_SEND_PACKET;
static {
setRejectionMessage(Component.translatable("chat.cannotSend", NamedTextColor.RED));
}
/**
* Sends a message to some players, respecting their chat settings.
*
* @param recipients the players
*/
public static void sendMessage(@NotNull Collection<Player> recipients, @NotNull PlayerChatMessagePacket packet) {
PacketUtils.sendGroupedPacket(recipients.stream().filter(x -> x.getSettings().getChatMessageType() == null ||
x.getSettings().getChatMessageType().accepts(ChatPosition.fromPacketID(packet.type())))
.collect(Collectors.toList()), packet);
// TODO Should we add overrides with CommonChatType and/or ChatType (and perform protocol id lookup behind the scenes)?
// TODO Javadoc
public static void sendSignedMessage(@NotNull Collection<Player> recipients, @NotNull MessageSender sender,
@NotNull Component message, @Nullable Component unsignedMessage,
@NotNull MessageSignature signature, int chatType) {
PacketUtils.sendGroupedPacket(recipients, new PlayerChatMessagePacket(message, unsignedMessage, chatType,
sender.displayName(), sender.teamName(), signature),
player -> getChatPreference(player) == ChatPreference.FULL);
}
public static void sendSignedMessage(@NotNull Collection<Player> recipients, @NotNull MessageSender sender,
@NotNull Component message, @Nullable Component unsignedMessage,
@NotNull MessageSignature signature) {
sendSignedMessage(recipients, sender, message, unsignedMessage, signature, CommonChatType.CHAT.getId());
}
public static void sendSignedMessage(@NotNull Collection<Player> recipients, @NotNull MessageSender sender,
@NotNull Component message, @NotNull MessageSignature signature,
int chatType) {
sendSignedMessage(recipients, sender, message, null, signature, chatType);
}
public static void sendSignedMessage(@NotNull Collection<Player> recipients, @NotNull MessageSender sender,
@NotNull Component message, @NotNull MessageSignature signature) {
sendSignedMessage(recipients, sender, message, null, signature, CommonChatType.CHAT.getId());
}
public static void sendUnsignedMessage(@NotNull Collection<Player> recipients, @NotNull MessageSender sender,
@NotNull Component message, int chatType) {
sendSignedMessage(recipients, sender, message, null, MessageSignature.UNSIGNED, chatType);
}
public static void sendUnsignedMessage(@NotNull Collection<Player> recipients, @NotNull MessageSender sender,
@NotNull Component message) {
sendUnsignedMessage(recipients, sender, message, CommonChatType.CHAT.getId());
}
public static void sendSystemMessage(@NotNull Collection<Player> recipients, @NotNull Component message, int chatType) {
PacketUtils.sendGroupedPacket(recipients, new SystemChatPacket(message, chatType), player -> {
final ChatPreference preference = getChatPreference(player);
return preference == ChatPreference.FULL || preference == ChatPreference.SYSTEM;
});
}
public static void sendSystemMessage(@NotNull Collection<Player> recipients, @NotNull Component message) {
sendSystemMessage(recipients, message, CommonChatType.CHAT.getId());
}
/**
@ -56,7 +83,7 @@ public final class Messenger {
* @return if the server should receive messages from them
*/
public static boolean canReceiveMessage(@NotNull Player player) {
return getChatMessageType(player) == ChatMessageType.FULL;
return getChatPreference(player) == ChatPreference.FULL;
}
/**
@ -66,7 +93,11 @@ public final class Messenger {
* @return if the server should receive commands from them
*/
public static boolean canReceiveCommand(@NotNull Player player) {
return getChatMessageType(player) != ChatMessageType.NONE;
return getChatPreference(player) != ChatPreference.NONE;
}
public static void setRejectionMessage(Component rejectionMessage) {
CANNOT_SEND_PACKET = new SystemChatPacket(rejectionMessage, CommonChatType.SYSTEM.getId());
}
/**
@ -79,12 +110,12 @@ public final class Messenger {
}
/**
* Gets the chat message type for a player, returning {@link ChatMessageType#FULL} if not set.
* Gets the chat message type for a player, returning {@link ChatPreference#FULL} if not set.
*
* @param player the player
* @return the chat message type
*/
private static @NotNull ChatMessageType getChatMessageType(@NotNull Player player) {
return Objects.requireNonNullElse(player.getSettings().getChatMessageType(), ChatMessageType.FULL);
private static @NotNull ChatPreference getChatPreference(@NotNull Player player) {
return Objects.requireNonNullElse(player.getSettings().getChatMessageType(), ChatPreference.FULL);
}
}

27
src/main/java/net/minestom/server/message/registry/ChatRegistryManager.java
View File

@ -20,9 +20,6 @@ import java.util.stream.Collectors;
* Used to register {@link ChatType chat types} and retrieve their protocol id.
*/
public final class ChatRegistryManager {
// TODO Should this be in an enum e.g. DefaultChatType?
public static final Key DEFAULT_CHAT = Key.key("minecraft:chat");
private final AtomicInteger chatTypesId = new AtomicInteger();
private final Int2ObjectMap<ChatType> idToType = new Int2ObjectOpenHashMap<>();
private final Object2IntMap<ChatType> typeToId = new Object2IntOpenHashMap<>();
@ -60,26 +57,40 @@ public final class ChatRegistryManager {
/**
* @return the protocol id of the type, -1 if it isn't registered
*/
public int getIdOf(ChatType type) {
public int idOf(ChatType type) {
return typeToId.getOrDefault(type, -1);
}
/**
* @return the protocol id of the type with the provided name, -1 if it isn't registered
*/
public int getIdOf(Key name) {
public int idOf(Key name) {
return nameToId.getOrDefault(name, -1);
}
/**
* @return the protocol id of the type, -1 if it isn't registered
*/
public int idOf(CommonChatType type) {
return idOf(type.getName());
}
/**
* Registers default types if the user didn't provide them before calling {@link MinecraftServer#start}
*/
@ApiStatus.Internal
public void initDefaults() {
// Player chat
if (getIdOf(DEFAULT_CHAT) == -1) {
addChatType(ChatType.chat(DEFAULT_CHAT, ChatDecoration.contentWithSender("chat.type.text").toTextDisplay()));
logDefaultRegistering(DEFAULT_CHAT);
CommonChatType.CHAT.setId(idOf(CommonChatType.CHAT));
if (!CommonChatType.CHAT.registered()) {
CommonChatType.CHAT.setId(addChatType(ChatType.chat(CommonChatType.CHAT.getName(), ChatDecoration.contentWithSender("chat.type.text").toTextDisplay())));
logDefaultRegistering(CommonChatType.CHAT.getName());
}
// System messages
CommonChatType.SYSTEM.setId(idOf(CommonChatType.SYSTEM));
if (!CommonChatType.SYSTEM.registered()) {
CommonChatType.SYSTEM.setId(addChatType(ChatType.chat(CommonChatType.SYSTEM.getName(), TextDisplay.undecorated())));
logDefaultRegistering(CommonChatType.SYSTEM.getName());
}
// TODO Should we add all default types?
}

33
src/main/java/net/minestom/server/message/registry/CommonChatType.java Normal file
View File

@ -0,0 +1,33 @@
package net.minestom.server.message.registry;
import net.kyori.adventure.key.Key;
import org.jetbrains.annotations.ApiStatus;
public enum CommonChatType {
CHAT(Key.key("minecraft:chat")),
SYSTEM(Key.key("minecraft:system"));
private final Key name;
private int id;
CommonChatType(Key name) {
this.name = name;
}
public Key getName() {
return name;
}
public int getId() {
return id;
}
public boolean registered() {
return getId() != -1;
}
@ApiStatus.Internal
public void setId(int id) {
this.id = id;
}
}

8
src/main/java/net/minestom/server/network/packet/client/play/ClientSettingsPacket.java
View File

@ -1,14 +1,14 @@
package net.minestom.server.network.packet.client.play;
import net.minestom.server.entity.Player;
import net.minestom.server.message.ChatMessageType;
import net.minestom.server.message.ChatPreference;
import net.minestom.server.network.packet.client.ClientPacket;
import net.minestom.server.utils.binary.BinaryReader;
import net.minestom.server.utils.binary.BinaryWriter;
import org.jetbrains.annotations.NotNull;
public record ClientSettingsPacket(@NotNull String locale, byte viewDistance,
@NotNull ChatMessageType chatMessageType, boolean chatColors,
@NotNull ChatPreference chatPreference, boolean chatColors,
byte displayedSkinParts, @NotNull Player.MainHand mainHand,
boolean enableTextFiltering, boolean allowsListing) implements ClientPacket {
public ClientSettingsPacket {
@ -18,7 +18,7 @@ public record ClientSettingsPacket(@NotNull String locale, byte viewDistance,
public ClientSettingsPacket(BinaryReader reader) {
this(reader.readSizedString(128), reader.readByte(),
ChatMessageType.fromPacketID(reader.readVarInt()), reader.readBoolean(),
ChatPreference.fromPacketID(reader.readVarInt()), reader.readBoolean(),
reader.readByte(), Player.MainHand.values()[reader.readVarInt()],
reader.readBoolean(), reader.readBoolean());
}
@ -27,7 +27,7 @@ public record ClientSettingsPacket(@NotNull String locale, byte viewDistance,
public void write(@NotNull BinaryWriter writer) {
writer.writeSizedString(locale);
writer.writeByte(viewDistance);
writer.writeVarInt(chatMessageType.getPacketID());
writer.writeVarInt(chatPreference.getPacketID());
writer.writeBoolean(chatColors);
writer.writeByte(displayedSkinParts);
writer.writeVarInt(mainHand.ordinal());

13
src/main/java/net/minestom/server/network/packet/server/play/PlayerChatMessagePacket.java
View File

@ -2,7 +2,6 @@ package net.minestom.server.network.packet.server.play;
import net.kyori.adventure.text.Component;
import net.minestom.server.crypto.MessageSignature;
import net.minestom.server.message.ChatPosition;
import net.minestom.server.message.MessageSender;
import net.minestom.server.network.packet.server.ComponentHoldingServerPacket;
import net.minestom.server.network.packet.server.ServerPacket;
@ -32,22 +31,22 @@ public record PlayerChatMessagePacket(@NotNull Component signedContent, @Nullabl
reader.readNullableComponent(), new MessageSignature(sender, reader));
}
public static PlayerChatMessagePacket unsigned(@NotNull Component message, ChatPosition type, @NotNull MessageSender sender) {
return new PlayerChatMessagePacket(message, null, type.getID(),
public static PlayerChatMessagePacket unsigned(@NotNull Component message, int type, @NotNull MessageSender sender) {
return new PlayerChatMessagePacket(message, null, type,
sender.displayName(), sender.teamName(), MessageSignature.UNSIGNED);
}
public static PlayerChatMessagePacket signed(@NotNull Component message, ChatPosition type, @NotNull MessageSender sender,
public static PlayerChatMessagePacket signed(@NotNull Component message, int type, @NotNull MessageSender sender,
@NotNull MessageSignature signature) {
return new PlayerChatMessagePacket(message, null, type.getID(),
return new PlayerChatMessagePacket(message, null, type,
sender.displayName(), sender.teamName(), signature);
}
public static PlayerChatMessagePacket signedWithUnsignedContent(@NotNull Component message,
@NotNull Component unsignedContent,
ChatPosition type, @NotNull MessageSender sender,
int type, @NotNull MessageSender sender,
@NotNull MessageSignature signature) {
return new PlayerChatMessagePacket(message, unsignedContent, type.getID(),
return new PlayerChatMessagePacket(message, unsignedContent, type,
sender.displayName(), sender.teamName(), signature);
}