From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Riley Park Date: Fri, 29 Jan 2021 17:54:03 +0100 Subject: [PATCH] Adventure Co-authored-by: zml Co-authored-by: Jake Potrebic diff --git a/src/main/java/io/papermc/paper/adventure/AdventureComponent.java b/src/main/java/io/papermc/paper/adventure/AdventureComponent.java new file mode 100644 index 0000000000000000000000000000000000000000..3246049fd557951d971ef40112a411c12aec205c --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/AdventureComponent.java @@ -0,0 +1,90 @@ +package io.papermc.paper.adventure; + +import com.google.gson.JsonElement; +import com.google.gson.JsonSerializationContext; +import com.google.gson.JsonSerializer; +import java.lang.reflect.Type; +import java.util.List; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.TextComponent; +import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import net.minecraft.network.chat.ComponentContents; +import net.minecraft.network.chat.MutableComponent; +import net.minecraft.network.chat.Style; +import net.minecraft.network.chat.contents.LiteralContents; +import net.minecraft.util.FormattedCharSequence; +import org.checkerframework.checker.nullness.qual.MonotonicNonNull; +import org.jetbrains.annotations.Nullable; + +public final class AdventureComponent implements net.minecraft.network.chat.Component { + final Component adventure; + private net.minecraft.network.chat.@MonotonicNonNull Component vanilla; + + public AdventureComponent(final Component adventure) { + this.adventure = adventure; + } + + public net.minecraft.network.chat.Component deepConverted() { + net.minecraft.network.chat.Component vanilla = this.vanilla; + if (vanilla == null) { + vanilla = PaperAdventure.WRAPPER_AWARE_SERIALIZER.serialize(this.adventure); + this.vanilla = vanilla; + } + return vanilla; + } + + public net.minecraft.network.chat.@Nullable Component deepConvertedIfPresent() { + return this.vanilla; + } + + @Override + public Style getStyle() { + return this.deepConverted().getStyle(); + } + + @Override + public ComponentContents getContents() { + if (this.adventure instanceof TextComponent) { + return new LiteralContents(((TextComponent) this.adventure).content()); + } else { + return this.deepConverted().getContents(); + } + } + + @Override + public String getString() { + return PlainTextComponentSerializer.plainText().serialize(this.adventure); + } + + @Override + public List getSiblings() { + return this.deepConverted().getSiblings(); + } + + @Override + public MutableComponent plainCopy() { + return this.deepConverted().plainCopy(); + } + + @Override + public MutableComponent copy() { + return this.deepConverted().copy(); + } + + @Override + public FormattedCharSequence getVisualOrderText() { + return this.deepConverted().getVisualOrderText(); + } + + public Component adventure$component() { + return this.adventure; + } + + public static class Serializer implements JsonSerializer { + @Override + public JsonElement serialize(final AdventureComponent src, final Type type, final JsonSerializationContext context) { + return GsonComponentSerializer.gson().serializer().toJsonTree(src.adventure, Component.class); + } + } +} diff --git a/src/main/java/io/papermc/paper/adventure/ChatDecorationProcessor.java b/src/main/java/io/papermc/paper/adventure/ChatDecorationProcessor.java new file mode 100644 index 0000000000000000000000000000000000000000..3b53d87a52cafb2503419f21ddd87d42a5ec0330 --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/ChatDecorationProcessor.java @@ -0,0 +1,145 @@ +package io.papermc.paper.adventure; + +import io.papermc.paper.event.player.AsyncChatCommandDecorateEvent; +import io.papermc.paper.event.player.AsyncChatDecorateEvent; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.regex.Pattern; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.minimessage.MiniMessage; +import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder; +import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver; +import net.minecraft.Optionull; +import net.minecraft.commands.CommandSourceStack; +import net.minecraft.network.chat.ChatDecorator; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerPlayer; +import org.bukkit.craftbukkit.entity.CraftPlayer; +import org.bukkit.craftbukkit.util.LazyPlayerSet; +import org.bukkit.event.Event; +import org.bukkit.event.player.AsyncPlayerChatPreviewEvent; +import org.checkerframework.checker.nullness.qual.NonNull; +import org.checkerframework.checker.nullness.qual.Nullable; +import org.checkerframework.framework.qual.DefaultQualifier; + +import static io.papermc.paper.adventure.ChatProcessor.DEFAULT_LEGACY_FORMAT; +import static io.papermc.paper.adventure.ChatProcessor.canYouHearMe; +import static io.papermc.paper.adventure.ChatProcessor.displayName; +import static net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection; + +@DefaultQualifier(NonNull.class) +public final class ChatDecorationProcessor { + + private static final String DISPLAY_NAME_TAG = "---paper_dn---"; + private static final Pattern DISPLAY_NAME_PATTERN = Pattern.compile("%(1\\$)?s"); + private static final String CONTENT_TAG = "---paper_content---"; + private static final Pattern CONTENT_PATTERN = Pattern.compile("%(2\\$)?s"); + + final MinecraftServer server; + final @Nullable ServerPlayer player; + final @Nullable CommandSourceStack commandSourceStack; + final Component originalMessage; + + public ChatDecorationProcessor(final MinecraftServer server, final @Nullable ServerPlayer player, final @Nullable CommandSourceStack commandSourceStack, final net.minecraft.network.chat.Component originalMessage) { + this.server = server; + this.player = player; + this.commandSourceStack = commandSourceStack; + this.originalMessage = PaperAdventure.asAdventure(originalMessage); + } + + public CompletableFuture process() { + return CompletableFuture.supplyAsync(() -> { + ChatDecorator.Result result = new ChatDecorator.ModernResult(this.originalMessage, true, false); + if (listenToLegacy()) { + result = this.processLegacy(result); + } + return this.processModern(result); + }, this.server.chatExecutor); + } + + @SuppressWarnings("deprecation") + private static boolean listenToLegacy() { + return canYouHearMe(AsyncPlayerChatPreviewEvent.getHandlerList()); + } + + @SuppressWarnings("deprecation") + private ChatDecorator.Result processLegacy(final ChatDecorator.Result input) { + if (this.player != null) { + final CraftPlayer player = this.player.getBukkitEntity(); + final String originalMessage = legacySection().serialize(this.originalMessage); + final AsyncPlayerChatPreviewEvent event = new AsyncPlayerChatPreviewEvent(true, player, originalMessage, new LazyPlayerSet(this.server)); + this.post(event); + + final boolean isDefaultFormat = DEFAULT_LEGACY_FORMAT.equals(event.getFormat()); + if (event.isCancelled() || (isDefaultFormat && originalMessage.equals(event.getMessage()))) { + return input; + } else { + final Component message = legacySection().deserialize(event.getMessage()); + final Component component = isDefaultFormat ? message : legacyFormat(event.getFormat(), ((CraftPlayer) event.getPlayer()), legacySection().deserialize(event.getMessage())); + return legacy(component, event.getFormat(), new ChatDecorator.MessagePair(message, event.getMessage()), isDefaultFormat); + } + } + return input; + } + + private ChatDecorator.Result processModern(final ChatDecorator.Result input) { + final @Nullable CraftPlayer player = Optionull.map(this.player, ServerPlayer::getBukkitEntity); + + final Component initialResult = input.message().component(); + final AsyncChatDecorateEvent event; + if (this.commandSourceStack != null) { + // TODO more command decorate context + event = new AsyncChatCommandDecorateEvent(true, player, this.originalMessage, initialResult); + } else { + event = new AsyncChatDecorateEvent(true, player, this.originalMessage, initialResult); + } + this.post(event); + if (!event.isCancelled() && !event.result().equals(initialResult)) { + if (input instanceof ChatDecorator.LegacyResult legacyResult) { + if (legacyResult.hasNoFormatting()) { + /* + The MessagePair in the decoration result may be different at this point. This is because the legacy + decoration system requires the same modifications be made to the message, so we can't have the initial + message value for the legacy chat events be changed by the modern decorate event. + */ + return noFormatting(event.result(), legacyResult.format(), legacyResult.message().legacyMessage()); + } else { + final Component formatted = legacyFormat(legacyResult.format(), player, event.result()); + return withFormatting(formatted, legacyResult.format(), event.result(), legacyResult.message().legacyMessage()); + } + } else { + return new ChatDecorator.ModernResult(event.result(), true, false); + } + } + return input; + } + + private void post(final Event event) { + this.server.server.getPluginManager().callEvent(event); + } + + private static Component legacyFormat(final String format, final @Nullable CraftPlayer player, final Component message) { + final List args = new ArrayList<>(player != null ? 2 : 1); + if (player != null) { + args.add(Placeholder.component(DISPLAY_NAME_TAG, displayName(player))); + } + args.add(Placeholder.component(CONTENT_TAG, message)); + String miniMsg = MiniMessage.miniMessage().serialize(legacySection().deserialize(format)); + miniMsg = DISPLAY_NAME_PATTERN.matcher(miniMsg).replaceFirst("<" + DISPLAY_NAME_TAG + ">"); + miniMsg = CONTENT_PATTERN.matcher(miniMsg).replaceFirst("<" + CONTENT_TAG + ">"); + return MiniMessage.miniMessage().deserialize(miniMsg, TagResolver.resolver(args)); + } + + public static ChatDecorator.LegacyResult legacy(final Component maybeFormatted, final String format, final ChatDecorator.MessagePair message, final boolean hasNoFormatting) { + return new ChatDecorator.LegacyResult(maybeFormatted, format, message, hasNoFormatting, false); + } + + public static ChatDecorator.LegacyResult noFormatting(final Component component, final String format, final String legacyMessage) { + return new ChatDecorator.LegacyResult(component, format, new ChatDecorator.MessagePair(component, legacyMessage), true, true); + } + + public static ChatDecorator.LegacyResult withFormatting(final Component formatted, final String format, final Component message, final String legacyMessage) { + return new ChatDecorator.LegacyResult(formatted, format, new ChatDecorator.MessagePair(message, legacyMessage), false, true); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/ChatProcessor.java b/src/main/java/io/papermc/paper/adventure/ChatProcessor.java new file mode 100644 index 0000000000000000000000000000000000000000..45830cf2b42c2c983cef922c6355e5d6a7cfb982 --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/ChatProcessor.java @@ -0,0 +1,412 @@ +package io.papermc.paper.adventure; + +import io.papermc.paper.chat.ChatRenderer; +import io.papermc.paper.event.player.AbstractChatEvent; +import io.papermc.paper.event.player.AsyncChatEvent; +import io.papermc.paper.event.player.ChatEvent; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.util.BitSet; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.ExecutionException; +import java.util.function.Function; +import net.kyori.adventure.audience.Audience; +import net.kyori.adventure.audience.ForwardingAudience; +import net.kyori.adventure.key.Key; +import net.kyori.adventure.text.Component; +import net.minecraft.Optionull; +import net.minecraft.Util; +import net.minecraft.core.registries.Registries; +import net.minecraft.network.chat.ChatDecorator; +import net.minecraft.network.chat.ChatType; +import net.minecraft.network.chat.OutgoingChatMessage; +import net.minecraft.network.chat.PlayerChatMessage; +import net.minecraft.resources.ResourceKey; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerPlayer; +import org.bukkit.command.ConsoleCommandSender; +import org.bukkit.craftbukkit.entity.CraftPlayer; +import org.bukkit.craftbukkit.util.LazyPlayerSet; +import org.bukkit.craftbukkit.util.Waitable; +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.bukkit.event.player.AsyncPlayerChatEvent; +import org.bukkit.event.player.PlayerChatEvent; +import org.checkerframework.checker.nullness.qual.NonNull; +import org.checkerframework.checker.nullness.qual.Nullable; +import org.checkerframework.framework.qual.DefaultQualifier; + +import static net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection; + +@DefaultQualifier(NonNull.class) +public final class ChatProcessor { + static final String DEFAULT_LEGACY_FORMAT = "<%1$s> %2$s"; // copied from PlayerChatEvent/AsyncPlayerChatEvent + final MinecraftServer server; + final ServerPlayer player; + final PlayerChatMessage message; + final boolean async; + final String craftbukkit$originalMessage; + final Component paper$originalMessage; + final OutgoingChatMessage outgoing; + + static final int MESSAGE_CHANGED = 1; + static final int FORMAT_CHANGED = 2; + static final int SENDER_CHANGED = 3; // Not used + // static final int FORCE_PREVIEW_USE = 4; // TODO (future, maybe?) + private final BitSet flags = new BitSet(3); + + public ChatProcessor(final MinecraftServer server, final ServerPlayer player, final PlayerChatMessage message, final boolean async) { + this.server = server; + this.player = player; + /* + CraftBukkit's preview/decoration system relies on both the "decorate" and chat event making the same modifications. If + there is unsigned content in the legacyMessage, that is because the player sent the legacyMessage without it being + previewed (probably by sending it too quickly). We can just ignore that because the same changes will + happen in the chat event. + + If unsigned content is present, it will be the same as `this.legacyMessage.signedContent().previewResult().component()`. + */ + this.message = message; + this.async = async; + if (this.message.requireResult().modernized()) { + this.craftbukkit$originalMessage = this.message.requireResult().message().legacyMessage(); + } else { + this.craftbukkit$originalMessage = message.signedContent(); + } + /* + this.paper$originalMessage is the input to paper's chat events. This should be the decorated message component. + Even if the legacy preview event modified the format, and the client signed the formatted message, this should + still just be the message component. + */ + this.paper$originalMessage = this.message.requireResult().message().component(); + this.outgoing = OutgoingChatMessage.create(this.message); + } + + @SuppressWarnings("deprecated") + public void process() { + final boolean listenersOnAsyncEvent = canYouHearMe(AsyncPlayerChatEvent.getHandlerList()); + final boolean listenersOnSyncEvent = canYouHearMe(PlayerChatEvent.getHandlerList()); + if (listenersOnAsyncEvent || listenersOnSyncEvent) { + final CraftPlayer player = this.player.getBukkitEntity(); + final AsyncPlayerChatEvent ae = new AsyncPlayerChatEvent(this.async, player, this.craftbukkit$originalMessage, new LazyPlayerSet(this.server)); + this.post(ae); + if (listenersOnSyncEvent) { + final PlayerChatEvent se = new PlayerChatEvent(player, ae.getMessage(), ae.getFormat(), ae.getRecipients()); + se.setCancelled(ae.isCancelled()); // propagate cancelled state + this.queueIfAsyncOrRunImmediately(new Waitable() { + @Override + protected Void evaluate() { + ChatProcessor.this.post(se); + return null; + } + }); + this.readLegacyModifications(se.getMessage(), se.getFormat(), se.getPlayer()); + this.processModern( + this.modernRenderer(se.getFormat()), + this.viewersFromLegacy(se.getRecipients()), + this.modernMessage(se.getMessage()), + se.getPlayer(), + se.isCancelled() + ); + } else { + this.readLegacyModifications(ae.getMessage(), ae.getFormat(), ae.getPlayer()); + this.processModern( + this.modernRenderer(ae.getFormat()), + this.viewersFromLegacy(ae.getRecipients()), + this.modernMessage(ae.getMessage()), + ae.getPlayer(), + ae.isCancelled() + ); + } + } else { + this.processModern( + defaultRenderer(), + new LazyChatAudienceSet(this.server), + this.paper$originalMessage, + this.player.getBukkitEntity(), + false + ); + } + } + + private ChatRenderer modernRenderer(final String format) { + if (this.flags.get(FORMAT_CHANGED)) { + return legacyRenderer(format); + } else if (this.message.requireResult() instanceof ChatDecorator.LegacyResult legacyResult) { + return legacyRenderer(legacyResult.format()); + } else { + return defaultRenderer(); + } + } + + private Component modernMessage(final String legacyMessage) { + if (this.flags.get(MESSAGE_CHANGED)) { + return legacySection().deserialize(legacyMessage); + } else if (this.message.unsignedContent() == null && this.message.requireResult() instanceof ChatDecorator.LegacyResult legacyResult) { + return legacyResult.message().component(); + } else { + return this.paper$originalMessage; + } + } + + private void readLegacyModifications(final String message, final String format, final Player playerSender) { + if (this.message.requireResult() instanceof ChatDecorator.LegacyResult result) { + if (this.message.unsignedContent() != null && !result.modernized()) { + this.flags.set(MESSAGE_CHANGED, !message.equals(result.message().legacyMessage())); + } else { + this.flags.set(MESSAGE_CHANGED, !message.equals(this.craftbukkit$originalMessage)); + } + this.flags.set(FORMAT_CHANGED, !format.equals(result.format())); + } else { + this.flags.set(MESSAGE_CHANGED, !message.equals(this.craftbukkit$originalMessage)); + this.flags.set(FORMAT_CHANGED, !format.equals(DEFAULT_LEGACY_FORMAT)); + } + this.flags.set(SENDER_CHANGED, playerSender != this.player.getBukkitEntity()); + } + + private void processModern(final ChatRenderer renderer, final Set viewers, final Component message, final Player player, final boolean cancelled) { + final PlayerChatMessage.AdventureView signedMessage = this.message.adventureView(); + final AsyncChatEvent ae = new AsyncChatEvent(this.async, player, viewers, renderer, message, this.paper$originalMessage, signedMessage); + ae.setCancelled(cancelled); // propagate cancelled state + this.post(ae); + final boolean listenersOnSyncEvent = canYouHearMe(ChatEvent.getHandlerList()); + if (listenersOnSyncEvent) { + this.queueIfAsyncOrRunImmediately(new Waitable() { + @Override + protected Void evaluate() { + final ChatEvent se = new ChatEvent(player, ae.viewers(), ae.renderer(), ae.message(), ChatProcessor.this.paper$originalMessage/*, ae.usePreviewComponent()*/, signedMessage); + se.setCancelled(ae.isCancelled()); // propagate cancelled state + ChatProcessor.this.post(se); + ChatProcessor.this.readModernModifications(se, renderer); + ChatProcessor.this.complete(se); + return null; + } + }); + } else { + this.readModernModifications(ae, renderer); + this.complete(ae); + } + } + + private void readModernModifications(final AbstractChatEvent chatEvent, final ChatRenderer originalRenderer) { + if (this.message.unsignedContent() != null) { + this.flags.set(MESSAGE_CHANGED, !chatEvent.message().equals(this.message.requireResult().message().component())); + } else { + this.flags.set(MESSAGE_CHANGED, !chatEvent.message().equals(this.paper$originalMessage)); + } + if (originalRenderer != chatEvent.renderer()) { // don't set to false if it hasn't changed + this.flags.set(FORMAT_CHANGED, true); + } + // this.flags.set(FORCE_PREVIEW_USE, chatEvent.usePreviewComponent()); // TODO (future, maybe?) + } + + private void complete(final AbstractChatEvent event) { + if (event.isCancelled()) { + return; + } + + final CraftPlayer player = ((CraftPlayer) event.getPlayer()); + final Component displayName = displayName(player); + final Component message = event.message(); + final ChatRenderer renderer = event.renderer(); + + final Set viewers = event.viewers(); + final ResourceKey chatTypeKey = renderer instanceof ChatRenderer.Default ? ChatType.CHAT : ChatType.RAW; + final ChatType.Bound chatType = ChatType.bind(chatTypeKey, this.player.level.registryAccess(), PaperAdventure.asVanilla(displayName(player))); + + OutgoingChat outgoingChat = viewers instanceof LazyChatAudienceSet lazyAudienceSet && lazyAudienceSet.isLazy() ? new ServerOutgoingChat() : new ViewersOutgoingChat(); + /* if (this.flags.get(FORCE_PREVIEW_USE)) { // TODO (future, maybe?) + outgoingChat.sendOriginal(player, viewers, chatType); + } else */ + if (this.flags.get(FORMAT_CHANGED)) { + if (renderer instanceof ChatRenderer.ViewerUnaware unaware) { + outgoingChat.sendFormatChangedViewerUnaware(player, PaperAdventure.asVanilla(unaware.render(player, displayName, message)), viewers, chatType); + } else { + outgoingChat.sendFormatChangedViewerAware(player, displayName, message, renderer, viewers, chatType); + } + } else if (this.flags.get(MESSAGE_CHANGED)) { + if (!(renderer instanceof ChatRenderer.ViewerUnaware unaware)) { + throw new IllegalStateException("BUG: There should not be a non-legacy renderer at this point"); + } + final Component renderedComponent = chatTypeKey == ChatType.CHAT ? message : unaware.render(player, displayName, message); + outgoingChat.sendMessageChanged(player, PaperAdventure.asVanilla(renderedComponent), viewers, chatType); + } else { + outgoingChat.sendOriginal(player, viewers, chatType); + } + } + + interface OutgoingChat { + default void sendFormatChangedViewerUnaware(CraftPlayer player, net.minecraft.network.chat.Component renderedMessage, Set viewers, ChatType.Bound chatType) { + this.sendMessageChanged(player, renderedMessage, viewers, chatType); + } + + void sendFormatChangedViewerAware(CraftPlayer player, Component displayName, Component message, ChatRenderer renderer, Set viewers, ChatType.Bound chatType); + + void sendMessageChanged(CraftPlayer player, net.minecraft.network.chat.Component renderedMessage, Set viewers, ChatType.Bound chatType); + + void sendOriginal(CraftPlayer player, Set viewers, ChatType.Bound chatType); + } + + final class ServerOutgoingChat implements OutgoingChat { + @Override + public void sendFormatChangedViewerAware(CraftPlayer player, Component displayName, Component message, ChatRenderer renderer, Set viewers, ChatType.Bound chatType) { + ChatProcessor.this.server.getPlayerList().broadcastChatMessage(ChatProcessor.this.message, ChatProcessor.this.player, chatType, viewer -> PaperAdventure.asVanilla(renderer.render(player, displayName, message, viewer))); + } + + @Override + public void sendMessageChanged(CraftPlayer player, net.minecraft.network.chat.Component renderedMessage, Set viewers, ChatType.Bound chatType) { + ChatProcessor.this.server.getPlayerList().broadcastChatMessage(ChatProcessor.this.message.withUnsignedContent(renderedMessage), ChatProcessor.this.player, chatType); + } + + @Override + public void sendOriginal(CraftPlayer player, Set viewers, ChatType.Bound chatType) { + ChatProcessor.this.server.getPlayerList().broadcastChatMessage(ChatProcessor.this.message, ChatProcessor.this.player, chatType); + } + } + + final class ViewersOutgoingChat implements OutgoingChat { + @Override + public void sendFormatChangedViewerAware(CraftPlayer player, Component displayName, Component message, ChatRenderer renderer, Set viewers, ChatType.Bound chatType) { + this.broadcastToViewers(viewers, chatType, v -> PaperAdventure.asVanilla(renderer.render(player, displayName, message, v))); + } + + @Override + public void sendMessageChanged(CraftPlayer player, net.minecraft.network.chat.Component renderedMessage, Set viewers, ChatType.Bound chatType) { + this.broadcastToViewers(viewers, chatType, $ -> renderedMessage); + } + + @Override + public void sendOriginal(CraftPlayer player, Set viewers, ChatType.Bound chatType) { + this.broadcastToViewers(viewers, chatType, null); + } + + private void broadcastToViewers(Collection viewers, final ChatType.Bound chatType, final @Nullable Function msgFunction) { + for (Audience viewer : viewers) { + if (acceptsNative(viewer)) { + this.sendNative(viewer, chatType, msgFunction); + } else { + final net.minecraft.network.chat.@Nullable Component unsigned = Optionull.map(msgFunction, f -> f.apply(viewer)); + final PlayerChatMessage msg = unsigned == null ? ChatProcessor.this.message : ChatProcessor.this.message.withUnsignedContent(unsigned); + viewer.sendMessage(msg.adventureView(), this.adventure(chatType)); + } + } + } + + private static final Map BUILT_IN_CHAT_TYPES = Util.make(() -> { + final Map map = new HashMap<>(); + for (final Field declaredField : net.kyori.adventure.chat.ChatType.class.getDeclaredFields()) { + if (Modifier.isStatic(declaredField.getModifiers()) && declaredField.getType().equals(ChatType.class)) { + try { + final net.kyori.adventure.chat.ChatType type = (net.kyori.adventure.chat.ChatType) declaredField.get(null); + map.put(type.key().asString(), type); + } catch (final ReflectiveOperationException ignore) { + } + } + } + return map; + }); + + private net.kyori.adventure.chat.ChatType.Bound adventure(ChatType.Bound chatType) { + final String stringKey = Objects.requireNonNull( + ChatProcessor.this.server.registryAccess().registryOrThrow(Registries.CHAT_TYPE).getKey(chatType.chatType()), + () -> "No key for '%s' in CHAT_TYPE registry.".formatted(chatType) + ).toString(); + net.kyori.adventure.chat.@Nullable ChatType adventure = BUILT_IN_CHAT_TYPES.get(stringKey); + if (adventure == null) { + adventure = net.kyori.adventure.chat.ChatType.chatType(Key.key(stringKey)); + } + return adventure.bind( + PaperAdventure.asAdventure(chatType.name()), + PaperAdventure.asAdventure(chatType.targetName()) + ); + } + + private static boolean acceptsNative(final Audience viewer) { + if (viewer instanceof Player || viewer instanceof ConsoleCommandSender) { + return true; + } + if (viewer instanceof ForwardingAudience.Single single) { + return acceptsNative(single.audience()); + } + return false; + } + + private void sendNative(final Audience viewer, final ChatType.Bound chatType, final @Nullable Function msgFunction) { + if (viewer instanceof ConsoleCommandSender) { + this.sendToServer(chatType, msgFunction); + } else if (viewer instanceof CraftPlayer craftPlayer) { + craftPlayer.getHandle().sendChatMessage(ChatProcessor.this.outgoing, ChatProcessor.this.player.shouldFilterMessageTo(craftPlayer.getHandle()), chatType, Optionull.map(msgFunction, f -> f.apply(viewer))); + } else if (viewer instanceof ForwardingAudience.Single single) { + this.sendNative(single.audience(), chatType, msgFunction); + } else { + throw new IllegalStateException("Should only be a Player or Console or ForwardingAudience.Single pointing to one!"); + } + } + + private void sendToServer(final ChatType.Bound chatType, final @Nullable Function msgFunction) { + final PlayerChatMessage toConsoleMessage = msgFunction == null ? ChatProcessor.this.message : ChatProcessor.this.message.withUnsignedContent(msgFunction.apply(ChatProcessor.this.server.console)); + ChatProcessor.this.server.logChatMessage(toConsoleMessage.decoratedContent(), chatType, ChatProcessor.this.server.getPlayerList().verifyChatTrusted(toConsoleMessage) ? null : "Not Secure"); + } + } + + private Set viewersFromLegacy(final Set recipients) { + if (recipients instanceof LazyPlayerSet lazyPlayerSet && lazyPlayerSet.isLazy()) { + return new LazyChatAudienceSet(this.server); + } + final HashSet viewers = new HashSet<>(recipients); + viewers.add(this.server.console); + return viewers; + } + + static String legacyDisplayName(final CraftPlayer player) { + return player.getDisplayName(); + } + + static Component displayName(final CraftPlayer player) { + return player.displayName(); + } + + private static ChatRenderer.Default defaultRenderer() { + return (ChatRenderer.Default) ChatRenderer.defaultRenderer(); + } + + private static ChatRenderer legacyRenderer(final String format) { + if (DEFAULT_LEGACY_FORMAT.equals(format)) { + return defaultRenderer(); + } + return ChatRenderer.viewerUnaware((player, sourceDisplayName, message) -> legacySection().deserialize(legacyFormat(format, player, legacySection().serialize(message)))); + } + + static String legacyFormat(final String format, Player player, String message) { + return String.format(format, legacyDisplayName((CraftPlayer) player), message); + } + + private void queueIfAsyncOrRunImmediately(final Waitable waitable) { + if (this.async) { + this.server.processQueue.add(waitable); + } else { + waitable.run(); + } + try { + waitable.get(); + } catch (final InterruptedException e) { + Thread.currentThread().interrupt(); // tag, you're it + } catch (final ExecutionException e) { + throw new RuntimeException("Exception processing chat", e.getCause()); + } + } + + private void post(final Event event) { + this.server.server.getPluginManager().callEvent(event); + } + + static boolean canYouHearMe(final HandlerList handlers) { + return handlers.getRegisteredListeners().length > 0; + } +} diff --git a/src/main/java/io/papermc/paper/adventure/DisplayNames.java b/src/main/java/io/papermc/paper/adventure/DisplayNames.java new file mode 100644 index 0000000000000000000000000000000000000000..3957f68182e8f7a773613a687f1d9a0cfa4f066c --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/DisplayNames.java @@ -0,0 +1,24 @@ +package io.papermc.paper.adventure; + +import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; +import net.minecraft.server.level.ServerPlayer; +import org.bukkit.ChatColor; +import org.bukkit.craftbukkit.entity.CraftPlayer; + +public final class DisplayNames { + private DisplayNames() { + } + + public static String getLegacy(final CraftPlayer player) { + return getLegacy(player.getHandle()); + } + + public static String getLegacy(final ServerPlayer player) { + final String legacy = player.displayName; + if (legacy != null) { + // thank you for being worse than wet socks, Bukkit + return LegacyComponentSerializer.legacySection().serialize(player.adventure$displayName) + ChatColor.getLastColors(player.displayName); + } + return LegacyComponentSerializer.legacySection().serialize(player.adventure$displayName); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/LazyChatAudienceSet.java b/src/main/java/io/papermc/paper/adventure/LazyChatAudienceSet.java new file mode 100644 index 0000000000000000000000000000000000000000..2fd6c3e65354071af71c7d8ebb97b559b6e105ce --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/LazyChatAudienceSet.java @@ -0,0 +1,26 @@ +package io.papermc.paper.adventure; + +import java.util.HashSet; +import java.util.Set; +import net.kyori.adventure.audience.Audience; +import net.minecraft.server.MinecraftServer; +import org.bukkit.Bukkit; +import org.bukkit.craftbukkit.util.LazyHashSet; +import org.bukkit.craftbukkit.util.LazyPlayerSet; +import org.bukkit.entity.Player; + +final class LazyChatAudienceSet extends LazyHashSet { + private final MinecraftServer server; + + public LazyChatAudienceSet(final MinecraftServer server) { + this.server = server; + } + + @Override + protected Set makeReference() { + final Set playerSet = LazyPlayerSet.makePlayerSet(this.server); + final HashSet audiences = new HashSet<>(playerSet); + audiences.add(Bukkit.getConsoleSender()); + return audiences; + } +} diff --git a/src/main/java/io/papermc/paper/adventure/PaperAdventure.java b/src/main/java/io/papermc/paper/adventure/PaperAdventure.java new file mode 100644 index 0000000000000000000000000000000000000000..01e424792f68bac73ec41726031ebbb53df13da7 --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/PaperAdventure.java @@ -0,0 +1,354 @@ +package io.papermc.paper.adventure; + +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import io.netty.util.AttributeKey; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import net.kyori.adventure.bossbar.BossBar; +import net.kyori.adventure.inventory.Book; +import net.kyori.adventure.key.Key; +import net.kyori.adventure.nbt.api.BinaryTagHolder; +import net.kyori.adventure.sound.Sound; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.TranslatableComponent; +import net.kyori.adventure.text.flattener.ComponentFlattener; +import net.kyori.adventure.text.format.TextColor; +import net.kyori.adventure.text.serializer.ComponentSerializer; +import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer; +import net.kyori.adventure.text.serializer.plain.PlainComponentSerializer; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import net.kyori.adventure.translation.GlobalTranslator; +import net.kyori.adventure.translation.TranslationRegistry; +import net.kyori.adventure.translation.Translator; +import net.kyori.adventure.util.Codec; +import net.minecraft.ChatFormatting; +import net.minecraft.commands.CommandSourceStack; +import net.minecraft.locale.Language; +import net.minecraft.nbt.CompoundTag; +import net.minecraft.nbt.ListTag; +import net.minecraft.nbt.StringTag; +import net.minecraft.nbt.TagParser; +import net.minecraft.network.chat.ComponentUtils; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.sounds.SoundSource; +import net.minecraft.world.BossEvent; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.WrittenBookItem; +import org.bukkit.command.CommandSender; +import org.bukkit.craftbukkit.command.VanillaCommandWrapper; +import org.bukkit.craftbukkit.entity.CraftEntity; +import org.bukkit.entity.Entity; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +public final class PaperAdventure { + private static final Pattern LOCALIZATION_PATTERN = Pattern.compile("%(?:(\\d+)\\$)?s"); + public static final ComponentFlattener FLATTENER = ComponentFlattener.basic().toBuilder() + .complexMapper(TranslatableComponent.class, (translatable, consumer) -> { + if (!Language.getInstance().has(translatable.key())) { + for (final Translator source : GlobalTranslator.translator().sources()) { + if (source instanceof TranslationRegistry registry && registry.contains(translatable.key())) { + consumer.accept(GlobalTranslator.render(translatable, Locale.US)); + return; + } + } + } + final @NotNull String translated = Language.getInstance().getOrDefault(translatable.key()); + + final Matcher matcher = LOCALIZATION_PATTERN.matcher(translated); + final List args = translatable.args(); + int argPosition = 0; + int lastIdx = 0; + while (matcher.find()) { + // append prior + if (lastIdx < matcher.start()) { + consumer.accept(Component.text(translated.substring(lastIdx, matcher.start()))); + } + lastIdx = matcher.end(); + + final @Nullable String argIdx = matcher.group(1); + // calculate argument position + if (argIdx != null) { + try { + final int idx = Integer.parseInt(argIdx) - 1; + if (idx < args.size()) { + consumer.accept(args.get(idx)); + } + } catch (final NumberFormatException ex) { + // ignore, drop the format placeholder + } + } else { + final int idx = argPosition++; + if (idx < args.size()) { + consumer.accept(args.get(idx)); + } + } + } + + // append tail + if (lastIdx < translated.length()) { + consumer.accept(Component.text(translated.substring(lastIdx))); + } + }) + .build(); + public static final AttributeKey LOCALE_ATTRIBUTE = AttributeKey.valueOf("adventure:locale"); // init after FLATTENER because classloading triggered here might create a logger + @Deprecated public static final PlainComponentSerializer PLAIN = PlainComponentSerializer.builder().flattener(FLATTENER).build(); + private static final Codec NBT_CODEC = new Codec() { + @Override + public @NotNull CompoundTag decode(final @NotNull String encoded) throws IOException { + try { + return TagParser.parseTag(encoded); + } catch (final CommandSyntaxException e) { + throw new IOException(e); + } + } + + @Override + public @NotNull String encode(final @NotNull CompoundTag decoded) { + return decoded.toString(); + } + }; + public static final ComponentSerializer WRAPPER_AWARE_SERIALIZER = new WrapperAwareSerializer(); + + private PaperAdventure() { + } + + // Key + + public static ResourceLocation asVanilla(final Key key) { + return new ResourceLocation(key.namespace(), key.value()); + } + + public static ResourceLocation asVanillaNullable(final Key key) { + if (key == null) { + return null; + } + return asVanilla(key); + } + + // Component + + public static Component asAdventure(final net.minecraft.network.chat.Component component) { + return component == null ? Component.empty() : GsonComponentSerializer.gson().serializer().fromJson(net.minecraft.network.chat.Component.Serializer.toJsonTree(component), Component.class); + } + + public static ArrayList asAdventure(final List vanillas) { + final ArrayList adventures = new ArrayList<>(vanillas.size()); + for (final net.minecraft.network.chat.Component vanilla : vanillas) { + adventures.add(asAdventure(vanilla)); + } + return adventures; + } + + public static ArrayList asAdventureFromJson(final List jsonStrings) { + final ArrayList adventures = new ArrayList<>(jsonStrings.size()); + for (final String json : jsonStrings) { + adventures.add(GsonComponentSerializer.gson().deserialize(json)); + } + return adventures; + } + + public static List asJson(final List adventures) { + final List jsons = new ArrayList<>(adventures.size()); + for (final Component component : adventures) { + jsons.add(GsonComponentSerializer.gson().serialize(component)); + } + return jsons; + } + + public static net.minecraft.network.chat.Component asVanilla(final Component component) { + if (component == null) return null; + if (true) return new AdventureComponent(component); + return net.minecraft.network.chat.Component.Serializer.fromJson(GsonComponentSerializer.gson().serializer().toJsonTree(component)); + } + + public static List asVanilla(final List adventures) { + final List vanillas = new ArrayList<>(adventures.size()); + for (final Component adventure : adventures) { + vanillas.add(asVanilla(adventure)); + } + return vanillas; + } + + public static String asJsonString(final Component component, final Locale locale) { + return GsonComponentSerializer.gson().serialize(translated(component, locale)); + } + + public static String asJsonString(final net.minecraft.network.chat.Component component, final Locale locale) { + if (component instanceof AdventureComponent) { + return asJsonString(((AdventureComponent) component).adventure, locale); + } + return net.minecraft.network.chat.Component.Serializer.toJson(component); + } + + public static String asPlain(final Component component, final Locale locale) { + return PlainTextComponentSerializer.plainText().serialize(translated(component, locale)); + } + + private static Component translated(final Component component, final Locale locale) { + return GlobalTranslator.render( + component, + // play it safe + locale != null + ? locale + : Locale.US + ); + } + + public static Component resolveWithContext(final @NotNull Component component, final @Nullable CommandSender context, final @Nullable Entity scoreboardSubject, final boolean bypassPermissions) throws IOException { + final CommandSourceStack css = context != null ? VanillaCommandWrapper.getListener(context) : null; + Boolean previous = null; + if (css != null && bypassPermissions) { + previous = css.bypassSelectorPermissions; + css.bypassSelectorPermissions = true; + } + try { + return asAdventure(ComponentUtils.updateForEntity(css, asVanilla(component), scoreboardSubject == null ? null : ((CraftEntity) scoreboardSubject).getHandle(), 0)); + } catch (CommandSyntaxException e) { + throw new IOException(e); + } finally { + if (css != null && previous != null) { + css.bypassSelectorPermissions = previous; + } + } + } + + // BossBar + + public static BossEvent.BossBarColor asVanilla(final BossBar.Color color) { + return switch (color) { + case PINK -> BossEvent.BossBarColor.PINK; + case BLUE -> BossEvent.BossBarColor.BLUE; + case RED -> BossEvent.BossBarColor.RED; + case GREEN -> BossEvent.BossBarColor.GREEN; + case YELLOW -> BossEvent.BossBarColor.YELLOW; + case PURPLE -> BossEvent.BossBarColor.PURPLE; + case WHITE -> BossEvent.BossBarColor.WHITE; + }; + } + + public static BossBar.Color asAdventure(final BossEvent.BossBarColor color) { + return switch (color) { + case PINK -> BossBar.Color.PINK; + case BLUE -> BossBar.Color.BLUE; + case RED -> BossBar.Color.RED; + case GREEN -> BossBar.Color.GREEN; + case YELLOW -> BossBar.Color.YELLOW; + case PURPLE -> BossBar.Color.PURPLE; + case WHITE -> BossBar.Color.WHITE; + }; + } + + public static BossEvent.BossBarOverlay asVanilla(final BossBar.Overlay overlay) { + return switch (overlay) { + case PROGRESS -> BossEvent.BossBarOverlay.PROGRESS; + case NOTCHED_6 -> BossEvent.BossBarOverlay.NOTCHED_6; + case NOTCHED_10 -> BossEvent.BossBarOverlay.NOTCHED_10; + case NOTCHED_12 -> BossEvent.BossBarOverlay.NOTCHED_12; + case NOTCHED_20 -> BossEvent.BossBarOverlay.NOTCHED_20; + }; + } + + public static BossBar.Overlay asAdventure(final BossEvent.BossBarOverlay overlay) { + return switch (overlay) { + case PROGRESS -> BossBar.Overlay.PROGRESS; + case NOTCHED_6 -> BossBar.Overlay.NOTCHED_6; + case NOTCHED_10 -> BossBar.Overlay.NOTCHED_10; + case NOTCHED_12 -> BossBar.Overlay.NOTCHED_12; + case NOTCHED_20 -> BossBar.Overlay.NOTCHED_20; + }; + } + + public static void setFlag(final BossBar bar, final BossBar.Flag flag, final boolean value) { + if (value) { + bar.addFlag(flag); + } else { + bar.removeFlag(flag); + } + } + + // Book + + public static ItemStack asItemStack(final Book book, final Locale locale) { + final ItemStack item = new ItemStack(net.minecraft.world.item.Items.WRITTEN_BOOK, 1); + final CompoundTag tag = item.getOrCreateTag(); + tag.putString(WrittenBookItem.TAG_TITLE, validateField(asPlain(book.title(), locale), WrittenBookItem.TITLE_MAX_LENGTH, WrittenBookItem.TAG_TITLE)); + tag.putString(WrittenBookItem.TAG_AUTHOR, asPlain(book.author(), locale)); + final ListTag pages = new ListTag(); + if (book.pages().size() > WrittenBookItem.MAX_PAGES) { + throw new IllegalArgumentException("Book provided had " + book.pages().size() + " pages, but is only allowed a maximum of " + WrittenBookItem.MAX_PAGES); + } + for (final Component page : book.pages()) { + pages.add(StringTag.valueOf(validateField(asJsonString(page, locale), WrittenBookItem.PAGE_LENGTH, "page"))); + } + tag.put(WrittenBookItem.TAG_PAGES, pages); + return item; + } + + private static String validateField(final String content, final int length, final String name) { + if (content == null) { + return content; + } + + final int actual = content.length(); + if (actual > length) { + throw new IllegalArgumentException("Field '" + name + "' has a maximum length of " + length + " but was passed '" + content + "', which was " + actual + " characters long."); + } + return content; + } + + // Sounds + + public static SoundSource asVanilla(final Sound.Source source) { + return switch (source) { + case MASTER -> SoundSource.MASTER; + case MUSIC -> SoundSource.MUSIC; + case RECORD -> SoundSource.RECORDS; + case WEATHER -> SoundSource.WEATHER; + case BLOCK -> SoundSource.BLOCKS; + case HOSTILE -> SoundSource.HOSTILE; + case NEUTRAL -> SoundSource.NEUTRAL; + case PLAYER -> SoundSource.PLAYERS; + case AMBIENT -> SoundSource.AMBIENT; + case VOICE -> SoundSource.VOICE; + }; + } + + public static @Nullable SoundSource asVanillaNullable(final Sound.@Nullable Source source) { + if (source == null) { + return null; + } + return asVanilla(source); + } + + // NBT + + public static @Nullable BinaryTagHolder asBinaryTagHolder(final @Nullable CompoundTag tag) { + if (tag == null) { + return null; + } + try { + return BinaryTagHolder.encode(tag, NBT_CODEC); + } catch (final IOException e) { + return null; + } + } + + // Colors + + public static @NotNull TextColor asAdventure(final ChatFormatting formatting) { + final Integer color = formatting.getColor(); + if (color == null) { + throw new IllegalArgumentException("Not a valid color"); + } + return TextColor.color(color); + } + + public static @Nullable ChatFormatting asVanilla(final TextColor color) { + return ChatFormatting.getByHexValue(color.value()); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/VanillaBossBarListener.java b/src/main/java/io/papermc/paper/adventure/VanillaBossBarListener.java new file mode 100644 index 0000000000000000000000000000000000000000..7493efba31403cbe7f26e493f165f1b83aa847bb --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/VanillaBossBarListener.java @@ -0,0 +1,44 @@ +package io.papermc.paper.adventure; + +import java.util.Set; +import java.util.function.Consumer; +import java.util.function.Function; + +import net.kyori.adventure.bossbar.BossBar; +import net.kyori.adventure.text.Component; +import net.minecraft.network.protocol.game.ClientboundBossEventPacket; +import net.minecraft.world.BossEvent; +import org.checkerframework.checker.nullness.qual.NonNull; + +public final class VanillaBossBarListener implements BossBar.Listener { + private final Consumer> action; + + public VanillaBossBarListener(final Consumer> action) { + this.action = action; + } + + @Override + public void bossBarNameChanged(final @NonNull BossBar bar, final @NonNull Component oldName, final @NonNull Component newName) { + this.action.accept(ClientboundBossEventPacket::createUpdateNamePacket); + } + + @Override + public void bossBarProgressChanged(final @NonNull BossBar bar, final float oldProgress, final float newProgress) { + this.action.accept(ClientboundBossEventPacket::createUpdateProgressPacket); + } + + @Override + public void bossBarColorChanged(final @NonNull BossBar bar, final BossBar.@NonNull Color oldColor, final BossBar.@NonNull Color newColor) { + this.action.accept(ClientboundBossEventPacket::createUpdateStylePacket); + } + + @Override + public void bossBarOverlayChanged(final @NonNull BossBar bar, final BossBar.@NonNull Overlay oldOverlay, final BossBar.@NonNull Overlay newOverlay) { + this.action.accept(ClientboundBossEventPacket::createUpdateStylePacket); + } + + @Override + public void bossBarFlagsChanged(final @NonNull BossBar bar, final @NonNull Set flagsAdded, final @NonNull Set flagsRemoved) { + this.action.accept(ClientboundBossEventPacket::createUpdatePropertiesPacket); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/WrapperAwareSerializer.java b/src/main/java/io/papermc/paper/adventure/WrapperAwareSerializer.java new file mode 100644 index 0000000000000000000000000000000000000000..2a08e0461db4e699b7e6a1558a4419c848fc7f4f --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/WrapperAwareSerializer.java @@ -0,0 +1,20 @@ +package io.papermc.paper.adventure; + +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.serializer.ComponentSerializer; +import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer; + +final class WrapperAwareSerializer implements ComponentSerializer { + @Override + public Component deserialize(final net.minecraft.network.chat.Component input) { + if (input instanceof AdventureComponent) { + return ((AdventureComponent) input).adventure; + } + return GsonComponentSerializer.gson().serializer().fromJson(net.minecraft.network.chat.Component.Serializer.toJsonTree(input), Component.class); + } + + @Override + public net.minecraft.network.chat.Component serialize(final Component component) { + return net.minecraft.network.chat.Component.Serializer.fromJson(GsonComponentSerializer.gson().serializer().toJsonTree(component)); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/providers/ClickCallbackProviderImpl.java b/src/main/java/io/papermc/paper/adventure/providers/ClickCallbackProviderImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..3c17001bcd3862a76a22df488bff80a0ff4d1b83 --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/providers/ClickCallbackProviderImpl.java @@ -0,0 +1,96 @@ +package io.papermc.paper.adventure.providers; + +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; +import net.kyori.adventure.audience.Audience; +import net.kyori.adventure.text.event.ClickCallback; +import net.kyori.adventure.text.event.ClickEvent; +import org.jetbrains.annotations.NotNull; + +import java.util.Queue; +import java.util.concurrent.ConcurrentLinkedQueue; + +@SuppressWarnings("UnstableApiUsage") // permitted provider +public class ClickCallbackProviderImpl implements ClickCallback.Provider { + + public static final CallbackManager CALLBACK_MANAGER = new CallbackManager(); + + @Override + public @NotNull ClickEvent create(final @NotNull ClickCallback callback, final ClickCallback.@NotNull Options options) { + return ClickEvent.runCommand("/paper callback " + CALLBACK_MANAGER.addCallback(callback, options)); + } + + public static final class CallbackManager { + + private final Map callbacks = new HashMap<>(); + private final Queue queue = new ConcurrentLinkedQueue<>(); + + private CallbackManager() { + } + + public UUID addCallback(final @NotNull ClickCallback callback, final ClickCallback.@NotNull Options options) { + final UUID id = UUID.randomUUID(); + this.queue.add(new StoredCallback(callback, options, id)); + return id; + } + + public void handleQueue(final int currentTick) { + // Evict expired entries + if (currentTick % 100 == 0) { + this.callbacks.values().removeIf(callback -> !callback.valid()); + } + + // Add entries from queue + StoredCallback callback; + while ((callback = this.queue.poll()) != null) { + this.callbacks.put(callback.id(), callback); + } + } + + public void runCallback(final @NotNull Audience audience, final UUID id) { + final StoredCallback callback = this.callbacks.get(id); + if (callback != null && callback.valid()) { //TODO Message if expired/invalid? + callback.takeUse(); + callback.callback.accept(audience); + } + } + } + + private static final class StoredCallback { + private final long startedAt = System.nanoTime(); + private final ClickCallback callback; + private final long lifetime; + private final UUID id; + private int remainingUses; + + private StoredCallback(final @NotNull ClickCallback callback, final ClickCallback.@NotNull Options options, final UUID id) { + this.callback = callback; + this.lifetime = options.lifetime().toNanos(); + this.remainingUses = options.uses(); + this.id = id; + } + + public void takeUse() { + if (this.remainingUses != ClickCallback.UNLIMITED_USES) { + this.remainingUses--; + } + } + + public boolean hasRemainingUses() { + return this.remainingUses == ClickCallback.UNLIMITED_USES || this.remainingUses > 0; + } + + public boolean expired() { + return System.nanoTime() - this.startedAt >= this.lifetime; + } + + public boolean valid() { + return hasRemainingUses() && !expired(); + } + + public UUID id() { + return this.id; + } + } +} diff --git a/src/main/java/io/papermc/paper/adventure/providers/ComponentLoggerProviderImpl.java b/src/main/java/io/papermc/paper/adventure/providers/ComponentLoggerProviderImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..c3631efda9c7fa531a8a9f18fbee7b5f8655382b --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/providers/ComponentLoggerProviderImpl.java @@ -0,0 +1,19 @@ +package io.papermc.paper.adventure.providers; + +import io.papermc.paper.adventure.PaperAdventure; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.logger.slf4j.ComponentLogger; +import net.kyori.adventure.text.logger.slf4j.ComponentLoggerProvider; +import org.jetbrains.annotations.NotNull; +import org.slf4j.LoggerFactory; + +public class ComponentLoggerProviderImpl implements ComponentLoggerProvider { + @Override + public @NotNull ComponentLogger logger(@NotNull LoggerHelper helper, @NotNull String name) { + return helper.delegating(LoggerFactory.getLogger(name), this::serialize); + } + + private String serialize(final Component message) { + return PaperAdventure.asPlain(message, null); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/providers/GsonComponentSerializerProviderImpl.java b/src/main/java/io/papermc/paper/adventure/providers/GsonComponentSerializerProviderImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..c620d5aa2b0208b769dbe9563f0e99edc9a91047 --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/providers/GsonComponentSerializerProviderImpl.java @@ -0,0 +1,30 @@ +package io.papermc.paper.adventure.providers; + +import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer; +import org.jetbrains.annotations.NotNull; + +import java.util.function.Consumer; + +@SuppressWarnings("UnstableApiUsage") // permitted provider +public class GsonComponentSerializerProviderImpl implements GsonComponentSerializer.Provider { + + @Override + public @NotNull GsonComponentSerializer gson() { + return GsonComponentSerializer.builder() + .legacyHoverEventSerializer(NBTLegacyHoverEventSerializer.INSTANCE) + .build(); + } + + @Override + public @NotNull GsonComponentSerializer gsonLegacy() { + return GsonComponentSerializer.builder() + .legacyHoverEventSerializer(NBTLegacyHoverEventSerializer.INSTANCE) + .downsampleColors() + .build(); + } + + @Override + public @NotNull Consumer builder() { + return builder -> builder.legacyHoverEventSerializer(NBTLegacyHoverEventSerializer.INSTANCE); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/providers/LegacyComponentSerializerProviderImpl.java b/src/main/java/io/papermc/paper/adventure/providers/LegacyComponentSerializerProviderImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..03723dbe32b7eb95253e8ff6e72dbf8d2300a059 --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/providers/LegacyComponentSerializerProviderImpl.java @@ -0,0 +1,36 @@ +package io.papermc.paper.adventure.providers; + +import io.papermc.paper.adventure.PaperAdventure; +import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; +import org.jetbrains.annotations.NotNull; + +import java.util.function.Consumer; + +@SuppressWarnings("UnstableApiUsage") // permitted provider +public class LegacyComponentSerializerProviderImpl implements LegacyComponentSerializer.Provider { + + @Override + public @NotNull LegacyComponentSerializer legacyAmpersand() { + return LegacyComponentSerializer.builder() + .flattener(PaperAdventure.FLATTENER) + .character(LegacyComponentSerializer.AMPERSAND_CHAR) + .hexColors() + .useUnusualXRepeatedCharacterHexFormat() + .build(); + } + + @Override + public @NotNull LegacyComponentSerializer legacySection() { + return LegacyComponentSerializer.builder() + .flattener(PaperAdventure.FLATTENER) + .character(LegacyComponentSerializer.SECTION_CHAR) + .hexColors() + .useUnusualXRepeatedCharacterHexFormat() + .build(); + } + + @Override + public @NotNull Consumer legacy() { + return builder -> builder.flattener(PaperAdventure.FLATTENER); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/providers/MiniMessageProviderImpl.java b/src/main/java/io/papermc/paper/adventure/providers/MiniMessageProviderImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..25fd6992c869c841b1b1b3240f4d524948487614 --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/providers/MiniMessageProviderImpl.java @@ -0,0 +1,20 @@ +package io.papermc.paper.adventure.providers; + +import net.kyori.adventure.text.minimessage.MiniMessage; +import org.jetbrains.annotations.NotNull; + +import java.util.function.Consumer; + +@SuppressWarnings("UnstableApiUsage") // permitted provider +public class MiniMessageProviderImpl implements MiniMessage.Provider { + + @Override + public @NotNull MiniMessage miniMessage() { + return MiniMessage.builder().build(); + } + + @Override + public @NotNull Consumer builder() { + return builder -> {}; + } +} diff --git a/src/main/java/io/papermc/paper/adventure/providers/NBTLegacyHoverEventSerializer.java b/src/main/java/io/papermc/paper/adventure/providers/NBTLegacyHoverEventSerializer.java new file mode 100644 index 0000000000000000000000000000000000000000..b3514a3e415f3444a235f1a45f0c53741264e516 --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/providers/NBTLegacyHoverEventSerializer.java @@ -0,0 +1,89 @@ +package io.papermc.paper.adventure.providers; + +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.kyori.adventure.key.Key; +import net.kyori.adventure.nbt.api.BinaryTagHolder; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.event.HoverEvent; +import net.kyori.adventure.text.serializer.gson.LegacyHoverEventSerializer; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import net.kyori.adventure.util.Codec; +import net.minecraft.nbt.CompoundTag; +import net.minecraft.nbt.Tag; +import net.minecraft.nbt.TagParser; + +import java.io.IOException; +import java.util.UUID; + +final class NBTLegacyHoverEventSerializer implements LegacyHoverEventSerializer { + public static final NBTLegacyHoverEventSerializer INSTANCE = new NBTLegacyHoverEventSerializer(); + private static final Codec SNBT_CODEC = Codec.codec(TagParser::parseTag, Tag::toString); + + static final String ITEM_TYPE = "id"; + static final String ITEM_COUNT = "Count"; + static final String ITEM_TAG = "tag"; + + static final String ENTITY_NAME = "name"; + static final String ENTITY_TYPE = "type"; + static final String ENTITY_ID = "id"; + + NBTLegacyHoverEventSerializer() { + } + + @Override + public HoverEvent.ShowItem deserializeShowItem(final Component input) throws IOException { + final String raw = PlainTextComponentSerializer.plainText().serialize(input); + try { + final CompoundTag contents = SNBT_CODEC.decode(raw); + final CompoundTag tag = contents.getCompound(ITEM_TAG); + return HoverEvent.ShowItem.of( + Key.key(contents.getString(ITEM_TYPE)), + contents.contains(ITEM_COUNT) ? contents.getByte(ITEM_COUNT) : 1, + tag.isEmpty() ? null : BinaryTagHolder.encode(tag, SNBT_CODEC) + ); + } catch (final CommandSyntaxException ex) { + throw new IOException(ex); + } + } + + @Override + public HoverEvent.ShowEntity deserializeShowEntity(final Component input, final Codec.Decoder componentCodec) throws IOException { + final String raw = PlainTextComponentSerializer.plainText().serialize(input); + try { + final CompoundTag contents = SNBT_CODEC.decode(raw); + return HoverEvent.ShowEntity.of( + Key.key(contents.getString(ENTITY_TYPE)), + UUID.fromString(contents.getString(ENTITY_ID)), + componentCodec.decode(contents.getString(ENTITY_NAME)) + ); + } catch (final CommandSyntaxException ex) { + throw new IOException(ex); + } + } + + @Override + public Component serializeShowItem(final HoverEvent.ShowItem input) throws IOException { + final CompoundTag tag = new CompoundTag(); + tag.putString(ITEM_TYPE, input.item().asString()); + tag.putByte(ITEM_COUNT, (byte) input.count()); + if (input.nbt() != null) { + try { + tag.put(ITEM_TAG, input.nbt().get(SNBT_CODEC)); + } catch (final CommandSyntaxException ex) { + throw new IOException(ex); + } + } + return Component.text(SNBT_CODEC.encode(tag)); + } + + @Override + public Component serializeShowEntity(final HoverEvent.ShowEntity input, final Codec.Encoder componentCodec) throws IOException { + final CompoundTag tag = new CompoundTag(); + tag.putString(ENTITY_ID, input.id().toString()); + tag.putString(ENTITY_TYPE, input.type().asString()); + if (input.name() != null) { + tag.putString(ENTITY_NAME, componentCodec.encode(input.name())); + } + return Component.text(SNBT_CODEC.encode(tag)); + } +} diff --git a/src/main/java/io/papermc/paper/adventure/providers/PlainTextComponentSerializerProviderImpl.java b/src/main/java/io/papermc/paper/adventure/providers/PlainTextComponentSerializerProviderImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..c0701d4f93a4d77a8177d2dd8d5076f9f781873d --- /dev/null +++ b/src/main/java/io/papermc/paper/adventure/providers/PlainTextComponentSerializerProviderImpl.java @@ -0,0 +1,23 @@ +package io.papermc.paper.adventure.providers; + +import io.papermc.paper.adventure.PaperAdventure; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import org.jetbrains.annotations.NotNull; + +import java.util.function.Consumer; + +@SuppressWarnings("UnstableApiUsage") // permitted provider +public class PlainTextComponentSerializerProviderImpl implements PlainTextComponentSerializer.Provider { + + @Override + public @NotNull PlainTextComponentSerializer plainTextSimple() { + return PlainTextComponentSerializer.builder() + .flattener(PaperAdventure.FLATTENER) + .build(); + } + + @Override + public @NotNull Consumer plainText() { + return builder -> builder.flattener(PaperAdventure.FLATTENER); + } +} diff --git a/src/main/java/net/kyori/adventure/bossbar/HackyBossBarPlatformBridge.java b/src/main/java/net/kyori/adventure/bossbar/HackyBossBarPlatformBridge.java new file mode 100644 index 0000000000000000000000000000000000000000..2dc92d8d2764d3e9b621d5c7d5e30c30367b3117 --- /dev/null +++ b/src/main/java/net/kyori/adventure/bossbar/HackyBossBarPlatformBridge.java @@ -0,0 +1,36 @@ +package net.kyori.adventure.bossbar; + +import io.papermc.paper.adventure.PaperAdventure; +import io.papermc.paper.adventure.VanillaBossBarListener; +import net.minecraft.server.level.ServerBossEvent; +import org.bukkit.craftbukkit.entity.CraftPlayer; + +public abstract class HackyBossBarPlatformBridge { + public ServerBossEvent vanilla$bar; + private VanillaBossBarListener vanilla$listener; + + public final void paper$playerShow(final CraftPlayer player) { + if (this.vanilla$bar == null) { + final BossBar $this = (BossBar) this; + this.vanilla$bar = new ServerBossEvent( + PaperAdventure.asVanilla($this.name()), + PaperAdventure.asVanilla($this.color()), + PaperAdventure.asVanilla($this.overlay()) + ); + this.vanilla$bar.adventure = $this; + this.vanilla$listener = new VanillaBossBarListener(this.vanilla$bar::broadcast); + $this.addListener(this.vanilla$listener); + } + this.vanilla$bar.addPlayer(player.getHandle()); + } + + public final void paper$playerHide(final CraftPlayer player) { + if (this.vanilla$bar != null) { + this.vanilla$bar.removePlayer(player.getHandle()); + if (this.vanilla$bar.getPlayers().isEmpty()) { + ((BossBar) this).removeListener(this.vanilla$listener); + this.vanilla$bar = null; + } + } + } +} diff --git a/src/main/java/net/minecraft/ChatFormatting.java b/src/main/java/net/minecraft/ChatFormatting.java index 98f2def9125d6faf5859572a004fa8d2fa066417..436f381c727cda72c04859c540dce4715b445390 100644 --- a/src/main/java/net/minecraft/ChatFormatting.java +++ b/src/main/java/net/minecraft/ChatFormatting.java @@ -113,6 +113,18 @@ public enum ChatFormatting implements StringRepresentable { return name == null ? null : FORMATTING_BY_NAME.get(cleanName(name)); } + // Paper start + @Nullable public static ChatFormatting getByHexValue(int i) { + for (ChatFormatting value : values()) { + if (value.getColor() != null && value.getColor() == i) { + return value; + } + } + + return null; + } + // Paper end + @Nullable public static ChatFormatting getById(int colorIndex) { if (colorIndex < 0) { diff --git a/src/main/java/net/minecraft/commands/CommandSourceStack.java b/src/main/java/net/minecraft/commands/CommandSourceStack.java index d476bf8435ee585d8c4faa431716524774527acc..36bbe7d0b2089361beda89097c15eca9ab48a57d 100644 --- a/src/main/java/net/minecraft/commands/CommandSourceStack.java +++ b/src/main/java/net/minecraft/commands/CommandSourceStack.java @@ -62,6 +62,7 @@ public class CommandSourceStack implements SharedSuggestionProvider { private final CommandSigningContext signingContext; private final TaskChainer chatMessageChainer; public volatile CommandNode currentCommand; // CraftBukkit + public boolean bypassSelectorPermissions = false; // Paper public CommandSourceStack(CommandSource output, Vec3 pos, Vec2 rot, ServerLevel world, int level, String name, Component displayName, MinecraftServer server, @Nullable Entity entity) { this(output, pos, rot, world, level, name, displayName, server, entity, false, (commandcontext, flag, j) -> { diff --git a/src/main/java/net/minecraft/commands/arguments/MessageArgument.java b/src/main/java/net/minecraft/commands/arguments/MessageArgument.java index 42242735f8f85b1852381a9f77368527203172b4..4d0694c478d476717fd11f8975955c1741b47abf 100644 --- a/src/main/java/net/minecraft/commands/arguments/MessageArgument.java +++ b/src/main/java/net/minecraft/commands/arguments/MessageArgument.java @@ -50,10 +50,10 @@ public class MessageArgument implements SignedArgument private static void resolveSignedMessage(Consumer callback, CommandSourceStack source, PlayerChatMessage message) { MinecraftServer minecraftServer = source.getServer(); CompletableFuture completableFuture = filterPlainText(source, message); - CompletableFuture completableFuture2 = minecraftServer.getChatDecorator().decorate(source.getPlayer(), message.decoratedContent()); + CompletableFuture completableFuture2 = minecraftServer.getChatDecorator().decorate(source.getPlayer(), source, message.decoratedContent()); // Paper source.getChatMessageChainer().append((executor) -> { return CompletableFuture.allOf(completableFuture, completableFuture2).thenAcceptAsync((void_) -> { - PlayerChatMessage playerChatMessage2 = message.withUnsignedContent(completableFuture2.join()).filter(completableFuture.join().mask()); + PlayerChatMessage playerChatMessage2 = message.withUnsignedContent(completableFuture2.join().component()).filter(completableFuture.join().mask()); // Paper callback.accept(playerChatMessage2); }, executor); }); @@ -61,10 +61,10 @@ public class MessageArgument implements SignedArgument private static void resolveDisguisedMessage(Consumer callback, CommandSourceStack source, PlayerChatMessage message) { MinecraftServer minecraftServer = source.getServer(); - CompletableFuture completableFuture = minecraftServer.getChatDecorator().decorate(source.getPlayer(), message.decoratedContent()); + CompletableFuture completableFuture = minecraftServer.getChatDecorator().decorate(source.getPlayer(), source, message.decoratedContent()); // Paper source.getChatMessageChainer().append((executor) -> { return completableFuture.thenAcceptAsync((content) -> { - callback.accept(message.withUnsignedContent(content)); + callback.accept(message.withUnsignedContent(content.component())); // Paper }, executor); }); } diff --git a/src/main/java/net/minecraft/commands/arguments/selector/EntitySelector.java b/src/main/java/net/minecraft/commands/arguments/selector/EntitySelector.java index ca5d08eb4115817f846b312fe35f4ab28a099401..f25b9330e068c7d9e12cb57a7761cfef9ebaf7bc 100644 --- a/src/main/java/net/minecraft/commands/arguments/selector/EntitySelector.java +++ b/src/main/java/net/minecraft/commands/arguments/selector/EntitySelector.java @@ -92,7 +92,7 @@ public class EntitySelector { } private void checkPermissions(CommandSourceStack source) throws CommandSyntaxException { - if (this.usesSelector && !source.hasPermission(2, "minecraft.command.selector")) { // CraftBukkit + if (source.bypassSelectorPermissions || (this.usesSelector && !source.hasPermission(2, "minecraft.command.selector"))) { // CraftBukkit // Paper throw EntityArgument.ERROR_SELECTORS_NOT_ALLOWED.create(); } } diff --git a/src/main/java/net/minecraft/network/FriendlyByteBuf.java b/src/main/java/net/minecraft/network/FriendlyByteBuf.java index 5fb11741ca75b06322de00624353687c28df81a2..9020bc6d9ff6bc0c9b3f00470813f3258554cf45 100644 --- a/src/main/java/net/minecraft/network/FriendlyByteBuf.java +++ b/src/main/java/net/minecraft/network/FriendlyByteBuf.java @@ -22,6 +22,7 @@ import io.netty.handler.codec.EncoderException; import io.netty.util.ByteProcessor; import it.unimi.dsi.fastutil.ints.IntArrayList; import it.unimi.dsi.fastutil.ints.IntList; +import io.papermc.paper.adventure.PaperAdventure; // Paper import java.io.DataOutput; import java.io.IOException; import java.io.InputStream; @@ -89,6 +90,7 @@ public class FriendlyByteBuf extends ByteBuf { private static final int MAX_VARLONG_SIZE = 10; public static final int DEFAULT_NBT_QUOTA = 2097152; private final ByteBuf source; + public java.util.Locale adventure$locale; // Paper public static final short MAX_STRING_LENGTH = 32767; public static final int MAX_COMPONENT_STRING_LENGTH = 262144; private static final int PUBLIC_KEY_SIZE = 256; @@ -542,8 +544,15 @@ public class FriendlyByteBuf extends ByteBuf { } } + // Paper start + public FriendlyByteBuf writeComponent(final net.kyori.adventure.text.Component component) { + return this.writeUtf(PaperAdventure.asJsonString(component, this.adventure$locale), 262144); + } + // Paper end + public FriendlyByteBuf writeComponent(Component text) { - return this.writeUtf(Component.Serializer.toJson(text), 262144); + //return this.a(IChatBaseComponent.ChatSerializer.a(ichatbasecomponent), 262144); // Paper - comment + return this.writeUtf(PaperAdventure.asJsonString(text, this.adventure$locale), 262144); // Paper } public > T readEnum(Class enumClass) { diff --git a/src/main/java/net/minecraft/network/PacketEncoder.java b/src/main/java/net/minecraft/network/PacketEncoder.java index a63e7ee5c42bd51312155feab31c6ec4232e1bc7..42828edf81bd475b673a9d143f79c0d0711f14f5 100644 --- a/src/main/java/net/minecraft/network/PacketEncoder.java +++ b/src/main/java/net/minecraft/network/PacketEncoder.java @@ -4,6 +4,7 @@ import com.mojang.logging.LogUtils; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.MessageToByteEncoder; +import io.papermc.paper.adventure.PaperAdventure; // Paper import java.io.IOException; import net.minecraft.network.protocol.Packet; import net.minecraft.network.protocol.PacketFlow; @@ -33,6 +34,7 @@ public class PacketEncoder extends MessageToByteEncoder> { } else { FriendlyByteBuf friendlyByteBuf = new FriendlyByteBuf(byteBuf); friendlyByteBuf.writeVarInt(i); + friendlyByteBuf.adventure$locale = channelHandlerContext.channel().attr(PaperAdventure.LOCALE_ATTRIBUTE).get(); // Paper try { int j = friendlyByteBuf.writerIndex(); diff --git a/src/main/java/net/minecraft/network/chat/ChatDecorator.java b/src/main/java/net/minecraft/network/chat/ChatDecorator.java index 825ab7534f1ad9787ae2a6c2bf9a300f52cbfc95..53be8a43d784db5e8450c242adeb06f3fab2717a 100644 --- a/src/main/java/net/minecraft/network/chat/ChatDecorator.java +++ b/src/main/java/net/minecraft/network/chat/ChatDecorator.java @@ -10,5 +10,64 @@ public interface ChatDecorator { return CompletableFuture.completedFuture(message); }; + @io.papermc.paper.annotation.DoNotUse @Deprecated // Paper CompletableFuture decorate(@Nullable ServerPlayer sender, Component message); + + // Paper start + default CompletableFuture decorate(@Nullable ServerPlayer sender, @Nullable net.minecraft.commands.CommandSourceStack commandSourceStack, Component message) { + throw new UnsupportedOperationException("Must override this implementation"); + } + + static ChatDecorator create(ImprovedChatDecorator delegate) { + return new ChatDecorator() { + @Override + public CompletableFuture decorate(@Nullable ServerPlayer sender, Component message) { + return this.decorate(sender, null, message).thenApply(Result::component); + } + + @Override + public CompletableFuture decorate(@Nullable ServerPlayer sender, @Nullable net.minecraft.commands.CommandSourceStack commandSourceStack, Component message) { + return delegate.decorate(sender, commandSourceStack, message); + } + }; + } + + @FunctionalInterface + interface ImprovedChatDecorator { + CompletableFuture decorate(@Nullable ServerPlayer sender, @Nullable net.minecraft.commands.CommandSourceStack commandSourceStack, Component message); + } + + interface Result { + boolean hasNoFormatting(); + + Component component(); + + MessagePair message(); + + boolean modernized(); + } + + record MessagePair(net.kyori.adventure.text.Component component, String legacyMessage) { } + + record LegacyResult(Component component, String format, MessagePair message, boolean hasNoFormatting, boolean modernized) implements Result { + public LegacyResult(net.kyori.adventure.text.Component component, String format, MessagePair message, boolean hasNoFormatting, boolean modernified) { + this(io.papermc.paper.adventure.PaperAdventure.asVanilla(component), format, message, hasNoFormatting, modernified); + } + public LegacyResult { + component = component instanceof io.papermc.paper.adventure.AdventureComponent adventureComponent ? adventureComponent.deepConverted() : component; + } + } + + record ModernResult(Component component, boolean hasNoFormatting, boolean modernized) implements Result { + public ModernResult(net.kyori.adventure.text.Component component, boolean hasNoFormatting, boolean modernized) { + this(io.papermc.paper.adventure.PaperAdventure.asVanilla(component), hasNoFormatting, modernized); + } + + @Override + public MessagePair message() { + final net.kyori.adventure.text.Component adventureComponent = io.papermc.paper.adventure.PaperAdventure.WRAPPER_AWARE_SERIALIZER.deserialize(this.component); + return new MessagePair(adventureComponent, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(adventureComponent)); + } + } + // Paper end } diff --git a/src/main/java/net/minecraft/network/chat/Component.java b/src/main/java/net/minecraft/network/chat/Component.java index 8f5e07047f88138422ae82143a80427be869a760..37fc353c3e59dd5af2fd6c58ac084fb0e6e155d7 100644 --- a/src/main/java/net/minecraft/network/chat/Component.java +++ b/src/main/java/net/minecraft/network/chat/Component.java @@ -1,6 +1,7 @@ package net.minecraft.network.chat; import com.google.common.collect.Lists; +import io.papermc.paper.adventure.AdventureComponent; // Paper import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonArray; @@ -224,6 +225,7 @@ public interface Component extends Message, FormattedText, Iterable { GsonBuilder gsonbuilder = new GsonBuilder(); gsonbuilder.disableHtmlEscaping(); + gsonbuilder.registerTypeAdapter(AdventureComponent.class, new AdventureComponent.Serializer()); // Paper gsonbuilder.registerTypeHierarchyAdapter(Component.class, new Component.Serializer()); gsonbuilder.registerTypeHierarchyAdapter(Style.class, new Style.Serializer()); gsonbuilder.registerTypeAdapterFactory(new LowerCaseEnumTypeAdapterFactory()); @@ -401,6 +403,7 @@ public interface Component extends Message, FormattedText, Iterable { } public JsonElement serialize(Component ichatbasecomponent, Type type, JsonSerializationContext jsonserializationcontext) { + if (ichatbasecomponent instanceof AdventureComponent) return jsonserializationcontext.serialize(ichatbasecomponent); // Paper JsonObject jsonobject = new JsonObject(); if (!ichatbasecomponent.getStyle().isEmpty()) { diff --git a/src/main/java/net/minecraft/network/chat/ComponentUtils.java b/src/main/java/net/minecraft/network/chat/ComponentUtils.java index ea30dad0134644a8ad292a892450404203f3535e..584a58659fae6ba3d8b53858890bc6ec509ffb0e 100644 --- a/src/main/java/net/minecraft/network/chat/ComponentUtils.java +++ b/src/main/java/net/minecraft/network/chat/ComponentUtils.java @@ -42,6 +42,11 @@ public class ComponentUtils { if (depth > 100) { return text.copy(); } else { + // Paper start + if (text instanceof io.papermc.paper.adventure.AdventureComponent adventureComponent) { + text = adventureComponent.deepConverted(); + } + // Paper end MutableComponent mutableComponent = text.getContents().resolve(source, sender, depth + 1); for(Component component : text.getSiblings()) { diff --git a/src/main/java/net/minecraft/network/chat/MessageSignature.java b/src/main/java/net/minecraft/network/chat/MessageSignature.java index df9997873c4bbec184379ec14dca1bf4566eb89d..e2812cdce3b1170b7b7d0f52209e8b4fd2b64c61 100644 --- a/src/main/java/net/minecraft/network/chat/MessageSignature.java +++ b/src/main/java/net/minecraft/network/chat/MessageSignature.java @@ -13,11 +13,12 @@ import net.minecraft.util.SignatureUpdater; import net.minecraft.util.SignatureValidator; public record MessageSignature(byte[] bytes) { + public net.kyori.adventure.chat.SignedMessage.Signature adventure() { return () -> this.bytes; } // Paper public static final Codec CODEC = ExtraCodecs.BASE64_STRING.xmap(MessageSignature::new, MessageSignature::bytes); public static final int BYTES = 256; public MessageSignature { - Preconditions.checkState(bs.length == 256, "Invalid message signature size"); + Preconditions.checkState(bytes.length == 256, "Invalid message signature size"); // Paper - decompile fix } public static MessageSignature read(FriendlyByteBuf buf) { diff --git a/src/main/java/net/minecraft/network/chat/OutgoingChatMessage.java b/src/main/java/net/minecraft/network/chat/OutgoingChatMessage.java index f8773f2982e6cd40661d138a7c32f219cda9225c..74cf1c043beef03cfd5adf481414a5ee78bef2a6 100644 --- a/src/main/java/net/minecraft/network/chat/OutgoingChatMessage.java +++ b/src/main/java/net/minecraft/network/chat/OutgoingChatMessage.java @@ -7,6 +7,12 @@ public interface OutgoingChatMessage { void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params); + // Paper start + default void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params, @javax.annotation.Nullable Component unsigned) { + this.sendToPlayer(sender, filterMaskEnabled, params); + } + // Paper end + static OutgoingChatMessage create(PlayerChatMessage message) { return (OutgoingChatMessage)(message.isSystem() ? new OutgoingChatMessage.Disguised(message.decoratedContent()) : new OutgoingChatMessage.Player(message)); } @@ -14,7 +20,12 @@ public interface OutgoingChatMessage { public static record Disguised(Component content) implements OutgoingChatMessage { @Override public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params) { - sender.connection.sendDisguisedChatMessage(this.content, params); + // Paper start + this.sendToPlayer(sender, filterMaskEnabled, params, null); + } + public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params, @javax.annotation.Nullable Component unsigned) { + sender.connection.sendDisguisedChatMessage(unsigned != null ? unsigned : this.content, params); + // Paper end } } @@ -26,7 +37,13 @@ public interface OutgoingChatMessage { @Override public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params) { + // Paper start + this.sendToPlayer(sender, filterMaskEnabled, params, null); + } + public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params, @javax.annotation.Nullable Component unsigned) { + // Paper end PlayerChatMessage playerChatMessage = this.message.filter(filterMaskEnabled); + playerChatMessage = unsigned != null ? playerChatMessage.withUnsignedContent(unsigned) : playerChatMessage; // Paper if (!playerChatMessage.isFullyFiltered()) { sender.connection.sendPlayerChatMessage(playerChatMessage, params); } diff --git a/src/main/java/net/minecraft/network/chat/PlayerChatMessage.java b/src/main/java/net/minecraft/network/chat/PlayerChatMessage.java index b3a44ed8f365daf1031d46d879c84d2ea15cd951..ed92592e4d9e3d88b7300ea7a315541bfb430231 100644 --- a/src/main/java/net/minecraft/network/chat/PlayerChatMessage.java +++ b/src/main/java/net/minecraft/network/chat/PlayerChatMessage.java @@ -15,7 +15,53 @@ import net.minecraft.util.ExtraCodecs; import net.minecraft.util.SignatureUpdater; import net.minecraft.util.SignatureValidator; -public record PlayerChatMessage(SignedMessageLink link, @Nullable MessageSignature signature, SignedMessageBody signedBody, @Nullable Component unsignedContent, FilterMask filterMask) { +// Paper start +public record PlayerChatMessage(SignedMessageLink link, @Nullable MessageSignature signature, SignedMessageBody signedBody, @Nullable Component unsignedContent, FilterMask filterMask, @Nullable net.minecraft.network.chat.ChatDecorator.Result result) { + public PlayerChatMessage(SignedMessageLink link, @Nullable MessageSignature signature, SignedMessageBody signedBody, @Nullable Component unsignedContent, FilterMask filterMask) { + this(link, signature, signedBody, unsignedContent, filterMask, null); + } + public PlayerChatMessage withResult(net.minecraft.network.chat.ChatDecorator.Result result) { + final PlayerChatMessage msg = this.withUnsignedContent(result.component()); + return new PlayerChatMessage(msg.link, msg.signature, msg.signedBody, msg.unsignedContent, msg.filterMask, result); + } + public net.minecraft.network.chat.ChatDecorator.Result requireResult() { + return Objects.requireNonNull(this.result, "Requires a decoration result to be set here"); + } + public final class AdventureView implements net.kyori.adventure.chat.SignedMessage { + private AdventureView() { + } + @Override + public @org.jetbrains.annotations.NotNull Instant timestamp() { + return PlayerChatMessage.this.timeStamp(); + } + @Override + public long salt() { + return PlayerChatMessage.this.salt(); + } + @Override + public @org.jetbrains.annotations.Nullable Signature signature() { + return PlayerChatMessage.this.signature == null ? null : PlayerChatMessage.this.signature.adventure(); + } + @Override + public net.kyori.adventure.text.@org.jetbrains.annotations.Nullable Component unsignedContent() { + return PlayerChatMessage.this.unsignedContent() == null ? null : io.papermc.paper.adventure.PaperAdventure.asAdventure(PlayerChatMessage.this.unsignedContent()); + } + @Override + public @org.jetbrains.annotations.NotNull String message() { + return PlayerChatMessage.this.signedContent(); + } + @Override + public @org.jetbrains.annotations.NotNull net.kyori.adventure.identity.Identity identity() { + return net.kyori.adventure.identity.Identity.identity(PlayerChatMessage.this.sender()); + } + public PlayerChatMessage playerChatMessage() { + return PlayerChatMessage.this; + } + } + public AdventureView adventureView() { + return new AdventureView(); + } + // Paper end public static final MapCodec MAP_CODEC = RecordCodecBuilder.mapCodec((instance) -> { return instance.group(SignedMessageLink.CODEC.fieldOf("link").forGetter(PlayerChatMessage::link), MessageSignature.CODEC.optionalFieldOf("signature").forGetter((message) -> { return Optional.ofNullable(message.signature); @@ -40,7 +86,7 @@ public record PlayerChatMessage(SignedMessageLink link, @Nullable MessageSignatu } public PlayerChatMessage withUnsignedContent(Component unsignedContent) { - Component component = !unsignedContent.equals(Component.literal(this.signedContent())) ? unsignedContent : null; + Component component = !(unsignedContent instanceof io.papermc.paper.adventure.AdventureComponent advComponent ? advComponent.deepConverted() : unsignedContent).equals(Component.literal(this.signedContent())) ? unsignedContent : null; // Paper return new PlayerChatMessage(this.link, this.signature, this.signedBody, component, this.filterMask); } diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetActionBarTextPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetActionBarTextPacket.java index 02183c810f9968621b9b20c1f7b54258b620c507..32ef3edebe94a2014168b7e438752a80b2687e5f 100644 --- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetActionBarTextPacket.java +++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetActionBarTextPacket.java @@ -6,6 +6,7 @@ import net.minecraft.network.protocol.Packet; public class ClientboundSetActionBarTextPacket implements Packet { private final Component text; + public net.kyori.adventure.text.Component adventure$text; // Paper public ClientboundSetActionBarTextPacket(Component message) { this.text = message; @@ -17,6 +18,11 @@ public class ClientboundSetActionBarTextPacket implements Packet { private final Component text; + public net.kyori.adventure.text.Component adventure$text; // Paper public ClientboundSetSubtitleTextPacket(Component subtitle) { this.text = subtitle; @@ -17,6 +18,11 @@ public class ClientboundSetSubtitleTextPacket implements Packet { private final Component text; + public net.kyori.adventure.text.Component adventure$text; // Paper public ClientboundSetTitleTextPacket(Component title) { this.text = title; @@ -17,6 +18,11 @@ public class ClientboundSetTitleTextPacket implements Packet { +public record ClientboundSystemChatPacket(@javax.annotation.Nullable net.kyori.adventure.text.Component adventure$content, @javax.annotation.Nullable String content, boolean overlay) implements Packet { // Paper - Adventure + @io.papermc.paper.annotation.DoNotUse // Paper - No locale context public ClientboundSystemChatPacket(Component content, boolean overlay) { - this(Component.Serializer.toJson(content), overlay); + this(null, Component.Serializer.toJson(content), overlay); // Paper - Adventure } public ClientboundSystemChatPacket(net.md_5.bungee.api.chat.BaseComponent[] content, boolean overlay) { - this(net.md_5.bungee.chat.ComponentSerializer.toString(content), overlay); + this(null, net.md_5.bungee.chat.ComponentSerializer.toString(content), overlay); // Paper - Adventure } // Spigot end + // Paper start + public ClientboundSystemChatPacket { + com.google.common.base.Preconditions.checkArgument(!(adventure$content == null && content == null), "Component adventure$content and String (json) content cannot both be null"); + } + + public ClientboundSystemChatPacket(net.kyori.adventure.text.Component content, boolean overlay) { + this(content, null, overlay); + } + // Paper end public ClientboundSystemChatPacket(FriendlyByteBuf buf) { - this(buf.readComponent(), buf.readBoolean()); + this(null, io.papermc.paper.adventure.PaperAdventure.asJsonString(buf.readComponent(), buf.adventure$locale), buf.readBoolean()); // Paper - Adventure } @Override public void write(FriendlyByteBuf buf) { + // Paper start + if (this.adventure$content != null) { + buf.writeComponent(this.adventure$content); + } else if (this.content != null) { buf.writeUtf(this.content, 262144); // Spigot + } else { + throw new IllegalArgumentException("Must supply either adventure component or string json content"); + } + // Paper end buf.writeBoolean(this.overlay); } diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundTabListPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundTabListPacket.java index 762a9392ffac3042356709dddd15bb3516048bed..3544e2dc2522e9d6305d727d56e73490015662c2 100644 --- a/src/main/java/net/minecraft/network/protocol/game/ClientboundTabListPacket.java +++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundTabListPacket.java @@ -7,6 +7,10 @@ import net.minecraft.network.protocol.Packet; public class ClientboundTabListPacket implements Packet { public final Component header; public final Component footer; + // Paper start + public net.kyori.adventure.text.Component adventure$header; + public net.kyori.adventure.text.Component adventure$footer; + // Paper end public ClientboundTabListPacket(Component header, Component footer) { this.header = header; @@ -20,6 +24,13 @@ public class ClientboundTabListPacket implements Packet { loader.getSecond().load(resourceManager, registryInfoLookup); + // Paper start + if (loader.getFirst().key() == Registries.CHAT_TYPE) { + Registry.register((Registry) loader.getFirst(), ChatType.RAW, new ChatType(new net.minecraft.network.chat.ChatTypeDecoration("%s", List.of(net.minecraft.network.chat.ChatTypeDecoration.Parameter.CONTENT), net.minecraft.network.chat.Style.EMPTY), new net.minecraft.network.chat.ChatTypeDecoration("%s", List.of(net.minecraft.network.chat.ChatTypeDecoration.Parameter.CONTENT), net.minecraft.network.chat.Style.EMPTY))); // CraftBukkit + } + // Paper end }); list.forEach((loader) -> { Registry registry = loader.getFirst(); diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java index 5725631835ea68802c75934cd85d5c1b1a78d358..0b859ebcc2c53e74615feca5c864136586c1523b 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -244,6 +244,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop { - // SPIGOT-7127: Console /say and similar - if (entityplayer == null) { - return CompletableFuture.completedFuture(ichatbasecomponent); - } - - return CompletableFuture.supplyAsync(() -> { - AsyncPlayerChatPreviewEvent event = new AsyncPlayerChatPreviewEvent(true, entityplayer.getBukkitEntity(), CraftChatMessage.fromComponent(ichatbasecomponent), new LazyPlayerSet(this)); - String originalFormat = event.getFormat(), originalMessage = event.getMessage(); - this.server.getPluginManager().callEvent(event); - - if (originalFormat.equals(event.getFormat()) && originalMessage.equals(event.getMessage()) && event.getPlayer().getName().equalsIgnoreCase(event.getPlayer().getDisplayName())) { - return ichatbasecomponent; - } - - return CraftChatMessage.fromStringOrNull(String.format(event.getFormat(), event.getPlayer().getDisplayName(), event.getMessage())); - }, chatExecutor); - }; + // Paper start - moved to ChatPreviewProcessor + return ChatDecorator.create((sender, commandSourceStack, message) -> { + final io.papermc.paper.adventure.ChatDecorationProcessor processor = new io.papermc.paper.adventure.ChatDecorationProcessor(this, sender, commandSourceStack, message); + return processor.process(); + }); + // Paper end // CraftBukkit end } diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java index 7efd4be91e6ff0abf087bf4d322fd6ac694b7010..531d0b0dcd499adf0d973bf336272aa1966069f3 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java @@ -161,6 +161,7 @@ import net.minecraft.world.scores.Score; import net.minecraft.world.scores.Scoreboard; import net.minecraft.world.scores.Team; import net.minecraft.world.scores.criteria.ObjectiveCriteria; +import io.papermc.paper.adventure.PaperAdventure; // Paper import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.WeatherType; @@ -240,6 +241,7 @@ public class ServerPlayer extends Player { // CraftBukkit start public String displayName; + public net.kyori.adventure.text.Component adventure$displayName; // Paper public Component listName; public org.bukkit.Location compassTarget; public int newExp = 0; @@ -323,6 +325,7 @@ public class ServerPlayer extends Player { // CraftBukkit start this.displayName = this.getScoreboardName(); + this.adventure$displayName = net.kyori.adventure.text.Component.text(this.getScoreboardName()); // Paper this.bukkitPickUpLoot = true; this.maxHealthCache = this.getMaxHealth(); } @@ -816,22 +819,17 @@ public class ServerPlayer extends Player { String deathmessage = defaultMessage.getString(); this.keepLevel = keepInventory; // SPIGOT-2222: pre-set keepLevel - org.bukkit.event.entity.PlayerDeathEvent event = CraftEventFactory.callPlayerDeathEvent(this, loot, deathmessage, keepInventory); + org.bukkit.event.entity.PlayerDeathEvent event = CraftEventFactory.callPlayerDeathEvent(this, loot, PaperAdventure.asAdventure(defaultMessage), defaultMessage.getString(), keepInventory); // Paper - Adventure // SPIGOT-943 - only call if they have an inventory open if (this.containerMenu != this.inventoryMenu) { this.closeContainer(); } - String deathMessage = event.getDeathMessage(); + net.kyori.adventure.text.Component deathMessage = event.deathMessage() != null ? event.deathMessage() : net.kyori.adventure.text.Component.empty(); // Paper - Adventure - if (deathMessage != null && deathMessage.length() > 0 && flag) { // TODO: allow plugins to override? - Component ichatbasecomponent; - if (deathMessage.equals(deathmessage)) { - ichatbasecomponent = this.getCombatTracker().getDeathMessage(); - } else { - ichatbasecomponent = org.bukkit.craftbukkit.util.CraftChatMessage.fromStringOrNull(deathMessage); - } + if (deathMessage != null && deathMessage != net.kyori.adventure.text.Component.empty() && flag) { // Paper - Adventure // TODO: allow plugins to override? + Component ichatbasecomponent = PaperAdventure.asVanilla(deathMessage); // Paper - Adventure this.connection.send(new ClientboundPlayerCombatKillPacket(this.getCombatTracker(), ichatbasecomponent), PacketSendListener.exceptionallySend(() -> { boolean flag1 = true; @@ -1758,13 +1756,13 @@ public class ServerPlayer extends Player { public void sendSystemMessage(Component message, boolean overlay) { if (this.acceptsSystemMessages(overlay)) { - this.connection.send(new ClientboundSystemChatPacket(message, overlay), PacketSendListener.exceptionallySend(() -> { + this.connection.send(new ClientboundSystemChatPacket(PaperAdventure.asAdventure(message), overlay), PacketSendListener.exceptionallySend(() -> { // Paper - Adventure if (this.acceptsSystemMessages(false)) { boolean flag1 = true; String s = message.getString(256); MutableComponent ichatmutablecomponent = Component.literal(s).withStyle(ChatFormatting.YELLOW); - return new ClientboundSystemChatPacket(Component.translatable("multiplayer.message_not_delivered", ichatmutablecomponent).withStyle(ChatFormatting.RED), false); + return new ClientboundSystemChatPacket(PaperAdventure.asAdventure(Component.translatable("multiplayer.message_not_delivered", ichatmutablecomponent).withStyle(ChatFormatting.RED)), false); // Paper - Adventure } else { return null; } @@ -1773,8 +1771,13 @@ public class ServerPlayer extends Player { } public void sendChatMessage(OutgoingChatMessage message, boolean filterMaskEnabled, ChatType.Bound params) { + // Paper start + this.sendChatMessage(message, filterMaskEnabled, params, null); + } + public void sendChatMessage(OutgoingChatMessage message, boolean filterMaskEnabled, ChatType.Bound params, @Nullable Component unsigned) { + // Paper end if (this.acceptsChatMessages()) { - message.sendToPlayer(this, filterMaskEnabled, params); + message.sendToPlayer(this, filterMaskEnabled, params, unsigned); // Paper } } @@ -1792,6 +1795,7 @@ public class ServerPlayer extends Player { } public String locale = "en_us"; // CraftBukkit - add, lowercase + public java.util.Locale adventure$locale = java.util.Locale.US; // Paper public void updateOptions(ServerboundClientInformationPacket packet) { // CraftBukkit start if (getMainArm() != packet.mainHand()) { @@ -1803,6 +1807,10 @@ public class ServerPlayer extends Player { this.server.server.getPluginManager().callEvent(event); } this.locale = packet.language; + // Paper start + this.adventure$locale = net.kyori.adventure.translation.Translator.parseLocale(this.locale); + this.connection.connection.channel.attr(PaperAdventure.LOCALE_ATTRIBUTE).set(this.adventure$locale); + // Paper end this.clientViewDistance = packet.viewDistance; // CraftBukkit end this.chatVisibility = packet.chatVisibility(); diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java index 000fd11480d783eab80a93fedde48f66e6b1298b..b3b6121dcfb6451d177431d51fa8a3e0975e4fbf 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java @@ -187,6 +187,8 @@ import net.minecraft.world.phys.shapes.VoxelShape; import org.slf4j.Logger; // CraftBukkit start +import io.papermc.paper.adventure.ChatProcessor; // Paper +import io.papermc.paper.adventure.PaperAdventure; // Paper import com.mojang.datafixers.util.Pair; import java.util.Arrays; import java.util.concurrent.ExecutionException; @@ -250,7 +252,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic private static final int NO_BLOCK_UPDATES_TO_ACK = -1; private static final int TRACKED_MESSAGE_DISCONNECT_THRESHOLD = 4096; private static final Component CHAT_VALIDATION_FAILED = Component.translatable("multiplayer.disconnect.chat_validation_failed"); - private final Connection connection; + public final Connection connection; // Paper private final MinecraftServer server; public ServerPlayer player; private int tickCount; @@ -438,14 +440,17 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic return this.server.isSingleplayerOwner(this.player.getGameProfile()); } - // CraftBukkit start - @Deprecated - public void disconnect(Component reason) { - this.disconnect(CraftChatMessage.fromComponent(reason)); + public void disconnect(String s) { + // Paper start + this.disconnect(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(s)); } - // CraftBukkit end - public void disconnect(String s) { + public void disconnect(final Component reason) { + this.disconnect(PaperAdventure.asAdventure(reason)); + } + + public void disconnect(net.kyori.adventure.text.Component reason) { + // Paper end // CraftBukkit start - fire PlayerKickEvent if (this.processedDisconnect) { return; @@ -454,7 +459,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic Waitable waitable = new Waitable() { @Override protected Object evaluate() { - ServerGamePacketListenerImpl.this.disconnect(s); + ServerGamePacketListenerImpl.this.disconnect(reason); // Paper - adventure return null; } }; @@ -471,9 +476,9 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic return; } - String leaveMessage = ChatFormatting.YELLOW + this.player.getScoreboardName() + " left the game."; + net.kyori.adventure.text.Component leaveMessage = net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? this.player.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(this.player.getScoreboardName())); // Paper - Adventure - PlayerKickEvent event = new PlayerKickEvent(this.player.getBukkitEntity(), s, leaveMessage); + PlayerKickEvent event = new PlayerKickEvent(this.player.getBukkitEntity(), reason, leaveMessage); // Paper - Adventure if (this.cserver.getServer().isRunning()) { this.cserver.getPluginManager().callEvent(event); @@ -485,7 +490,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic } this.player.kickLeaveMessage = event.getLeaveMessage(); // CraftBukkit - SPIGOT-3034: Forward leave message to PlayerQuitEvent // Send the possibly modified leave message - final Component ichatbasecomponent = CraftChatMessage.fromString(event.getReason(), true)[0]; + final Component ichatbasecomponent = PaperAdventure.asVanilla(event.reason()); // Paper - Adventure // CraftBukkit end this.connection.send(new ClientboundDisconnectPacket(ichatbasecomponent), PacketSendListener.thenRun(() -> { @@ -1782,9 +1787,11 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic */ this.player.disconnect(); - String quitMessage = this.server.getPlayerList().remove(this.player); - if ((quitMessage != null) && (quitMessage.length() > 0)) { - this.server.getPlayerList().broadcastMessage(CraftChatMessage.fromString(quitMessage)); + // Paper start - Adventure + net.kyori.adventure.text.Component quitMessage = this.server.getPlayerList().remove(this.player); + if ((quitMessage != null) && !quitMessage.equals(net.kyori.adventure.text.Component.empty())) { + this.server.getPlayerList().broadcastSystemMessage(PaperAdventure.asVanilla(quitMessage), false); + // Paper end } // CraftBukkit end this.player.getTextFilter().leave(); @@ -1881,11 +1888,11 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic } CompletableFuture completablefuture = this.filterTextPacket(playerchatmessage.signedContent()); - CompletableFuture completablefuture1 = this.server.getChatDecorator().decorate(this.player, playerchatmessage.decoratedContent()); + CompletableFuture completablefuture1 = this.server.getChatDecorator().decorate(this.player, null, playerchatmessage.decoratedContent()); // Paper this.chatMessageChain.append((executor) -> { return CompletableFuture.allOf(completablefuture, completablefuture1).thenAcceptAsync((ovoid) -> { - PlayerChatMessage playerchatmessage1 = playerchatmessage.withUnsignedContent((Component) completablefuture1.join()).filter(((FilteredText) completablefuture.join()).mask()); + PlayerChatMessage playerchatmessage1 = playerchatmessage.filter(((FilteredText) completablefuture.join()).mask()).withResult(completablefuture1.join()); // Paper this.broadcastChatMessage(playerchatmessage1); }, this.server.chatExecutor); // CraftBukkit - async chat @@ -1985,7 +1992,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic Optional optional = this.unpackAndApplyLastSeen(acknowledgment); if (this.player.isRemoved() || this.player.getChatVisibility() == ChatVisiblity.HIDDEN) { // CraftBukkit - dead men tell no tales - this.send(new ClientboundSystemChatPacket(Component.translatable("chat.disabled.options").withStyle(ChatFormatting.RED), false)); + this.send(new ClientboundSystemChatPacket(PaperAdventure.asAdventure(Component.translatable("chat.disabled.options").withStyle(ChatFormatting.RED)), false)); // Paper - Adventure return Optional.empty(); } else { this.player.resetLastActionTime(); @@ -2043,7 +2050,12 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic this.handleCommand(s); } else if (this.player.getChatVisibility() == ChatVisiblity.SYSTEM) { // Do nothing, this is coming from a plugin - } else { + // Paper start + } else if (true) { + final ChatProcessor cp = new ChatProcessor(this.server, this.player, original, async); + cp.process(); + // Paper end + } else if (false) { // Paper Player player = this.getCraftPlayer(); AsyncPlayerChatEvent event = new AsyncPlayerChatEvent(async, player, s, new LazyPlayerSet(this.server)); String originalFormat = event.getFormat(), originalMessage = event.getMessage(); @@ -2173,7 +2185,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic } }); } else if (this.player.getChatVisibility() == ChatVisiblity.SYSTEM) { // Re-add "Command Only" flag check - this.send(new ClientboundSystemChatPacket(Component.translatable("chat.cannotSend").withStyle(ChatFormatting.RED), false)); + this.send(new ClientboundSystemChatPacket(PaperAdventure.asAdventure(Component.translatable("chat.cannotSend").withStyle(ChatFormatting.RED)), false)); // Paper - Adventure } else { this.chat(s, message, true); } @@ -2995,30 +3007,30 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic return; } - // CraftBukkit start + // CraftBukkit start // Paper start - Adventure Player player = this.player.getBukkitEntity(); int x = packet.getPos().getX(); int y = packet.getPos().getY(); int z = packet.getPos().getZ(); - String[] lines = new String[4]; + List lines = new java.util.ArrayList<>(); for (int i = 0; i < signText.size(); ++i) { FilteredText filteredtext = (FilteredText) signText.get(i); if (this.player.isTextFilteringEnabled()) { - lines[i] = ChatFormatting.stripFormatting(filteredtext.filteredOrEmpty()); + lines.add(net.kyori.adventure.text.Component.text(filteredtext.filteredOrEmpty())); // Paper - adventure } else { - lines[i] = ChatFormatting.stripFormatting(filteredtext.raw()); + lines.add(net.kyori.adventure.text.Component.text(filteredtext.raw())); // Paper - adventure } } SignChangeEvent event = new SignChangeEvent((org.bukkit.craftbukkit.block.CraftBlock) player.getWorld().getBlockAt(x, y, z), this.player.getBukkitEntity(), lines); this.cserver.getPluginManager().callEvent(event); if (!event.isCancelled()) { - Component[] components = org.bukkit.craftbukkit.block.CraftSign.sanitizeLines(event.getLines()); - for (int i = 0; i < components.length; i++) { - tileentitysign.setMessage(i, components[i]); + for (int i = 0; i < 4; i++) { + tileentitysign.setMessage(i, PaperAdventure.asVanilla(event.line(i))); } + // Paper end tileentitysign.isEditable = false; } // CraftBukkit end diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java index 1aae5c4c85efbaab626fa3776252b046618ae1cc..7983033160b77e28eb8135f8709dacd6b806ebe3 100644 --- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java @@ -323,7 +323,7 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener, if (PlayerPreLoginEvent.getHandlerList().getRegisteredListeners().length != 0) { final PlayerPreLoginEvent event = new PlayerPreLoginEvent(playerName, address, uniqueId); if (asyncEvent.getResult() != PlayerPreLoginEvent.Result.ALLOWED) { - event.disallow(asyncEvent.getResult(), asyncEvent.getKickMessage()); + event.disallow(asyncEvent.getResult(), asyncEvent.kickMessage()); // Paper - Adventure } Waitable waitable = new Waitable() { @Override @@ -334,12 +334,12 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener, ServerLoginPacketListenerImpl.this.server.processQueue.add(waitable); if (waitable.get() != PlayerPreLoginEvent.Result.ALLOWED) { - ServerLoginPacketListenerImpl.this.disconnect(event.getKickMessage()); + ServerLoginPacketListenerImpl.this.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(event.kickMessage())); // Paper - Adventure return; } } else { if (asyncEvent.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) { - ServerLoginPacketListenerImpl.this.disconnect(asyncEvent.getKickMessage()); + ServerLoginPacketListenerImpl.this.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(asyncEvent.kickMessage())); // Paper - Adventure return; } } diff --git a/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java index 1cb95db25a20d38faacd99a5805630c1598e9db3..d99b2235038eb1aba8cda474c4aa51e207149ef4 100644 --- a/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java @@ -57,7 +57,7 @@ public class ServerStatusPacketListenerImpl implements ServerStatusPacketListene CraftIconCache icon = server.server.getServerIcon(); ServerListPingEvent() { - super(connection.hostname, ((InetSocketAddress) ServerStatusPacketListenerImpl.this.connection.getRemoteAddress()).getAddress(), server.getMotd(), server.getPlayerList().getMaxPlayers()); + super(connection.hostname, ((InetSocketAddress) ServerStatusPacketListenerImpl.this.connection.getRemoteAddress()).getAddress(), server.server.motd(), server.getPlayerList().getMaxPlayers()); // Paper - Adventure } @Override diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java index 6529064505dc3de875be1764f88897736b85975d..d19d1f1595a226ce0472be5e2efafbc0e3e1729f 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -8,6 +8,7 @@ import com.mojang.logging.LogUtils; import com.mojang.serialization.DataResult; import com.mojang.serialization.Dynamic; import io.netty.buffer.Unpooled; +import io.papermc.paper.adventure.PaperAdventure; import java.io.File; import java.net.SocketAddress; import java.nio.file.Path; @@ -273,7 +274,7 @@ public abstract class PlayerList { } // CraftBukkit start ichatmutablecomponent.withStyle(ChatFormatting.YELLOW); - String joinMessage = CraftChatMessage.fromComponent(ichatmutablecomponent); + Component joinMessage = ichatmutablecomponent; // Paper - Adventure playerconnection.teleport(player.getX(), player.getY(), player.getZ(), player.getYRot(), player.getXRot()); ServerStatus serverping = this.server.getStatus(); @@ -294,19 +295,18 @@ public abstract class PlayerList { // Ensure that player inventory is populated with its viewer player.containerMenu.transferTo(player.containerMenu, bukkitPlayer); - PlayerJoinEvent playerJoinEvent = new PlayerJoinEvent(bukkitPlayer, joinMessage); + PlayerJoinEvent playerJoinEvent = new PlayerJoinEvent(bukkitPlayer, PaperAdventure.asAdventure(ichatmutablecomponent)); // Paper - Adventure this.cserver.getPluginManager().callEvent(playerJoinEvent); if (!player.connection.isAcceptingMessages()) { return; } - joinMessage = playerJoinEvent.getJoinMessage(); + final net.kyori.adventure.text.Component jm = playerJoinEvent.joinMessage(); - if (joinMessage != null && joinMessage.length() > 0) { - for (Component line : org.bukkit.craftbukkit.util.CraftChatMessage.fromString(joinMessage)) { - this.server.getPlayerList().broadcastSystemMessage(line, false); - } + if (jm != null && !jm.equals(net.kyori.adventure.text.Component.empty())) { // Paper - Adventure + joinMessage = PaperAdventure.asVanilla(jm); // Paper - Adventure + this.server.getPlayerList().broadcastSystemMessage(joinMessage, false); // Paper - Adventure } // CraftBukkit end @@ -503,7 +503,7 @@ public abstract class PlayerList { } - public String remove(ServerPlayer entityplayer) { // CraftBukkit - return string + public net.kyori.adventure.text.Component remove(ServerPlayer entityplayer) { // Paper - return Component ServerLevel worldserver = entityplayer.getLevel(); entityplayer.awardStat(Stats.LEAVE_GAME); @@ -514,7 +514,7 @@ public abstract class PlayerList { entityplayer.closeContainer(); } - PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), entityplayer.kickLeaveMessage != null ? entityplayer.kickLeaveMessage : "\u00A7e" + entityplayer.getScoreboardName() + " left the game"); + PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? entityplayer.getBukkitEntity().displayName() : PaperAdventure.asAdventure(entityplayer.getDisplayName()))); // Paper - Adventure this.cserver.getPluginManager().callEvent(playerQuitEvent); entityplayer.getBukkitEntity().disconnect(playerQuitEvent.getQuitMessage()); @@ -567,7 +567,7 @@ public abstract class PlayerList { this.cserver.getScoreboardManager().removePlayer(entityplayer.getBukkitEntity()); // CraftBukkit end - return playerQuitEvent.getQuitMessage(); // CraftBukkit + return playerQuitEvent.quitMessage(); // Paper - Adventure } // CraftBukkit start - Whole method, SocketAddress to LoginListener, added hostname to signature, return EntityPlayer @@ -613,10 +613,10 @@ public abstract class PlayerList { } // return chatmessage; - event.disallow(PlayerLoginEvent.Result.KICK_BANNED, CraftChatMessage.fromComponent(ichatmutablecomponent)); + event.disallow(PlayerLoginEvent.Result.KICK_BANNED, PaperAdventure.asAdventure(ichatmutablecomponent)); // Paper - Adventure } else if (!this.isWhiteListed(gameprofile)) { ichatmutablecomponent = Component.translatable("multiplayer.disconnect.not_whitelisted"); - event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, org.spigotmc.SpigotConfig.whitelistMessage); // Spigot + event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.whitelistMessage)); // Spigot // Paper - Adventure } else if (this.getIpBans().isBanned(socketaddress) && !this.getIpBans().get(socketaddress).hasExpired()) { IpBanListEntry ipbanentry = this.ipBans.get(socketaddress); @@ -626,17 +626,17 @@ public abstract class PlayerList { } // return chatmessage; - event.disallow(PlayerLoginEvent.Result.KICK_BANNED, CraftChatMessage.fromComponent(ichatmutablecomponent)); + event.disallow(PlayerLoginEvent.Result.KICK_BANNED, PaperAdventure.asAdventure(ichatmutablecomponent)); // Paper - Adventure } else { // return this.players.size() >= this.maxPlayers && !this.canBypassPlayerLimit(gameprofile) ? IChatBaseComponent.translatable("multiplayer.disconnect.server_full") : null; if (this.players.size() >= this.maxPlayers && !this.canBypassPlayerLimit(gameprofile)) { - event.disallow(PlayerLoginEvent.Result.KICK_FULL, org.spigotmc.SpigotConfig.serverFullMessage); // Spigot + event.disallow(PlayerLoginEvent.Result.KICK_FULL, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.serverFullMessage)); // Spigot // Paper - Adventure } } this.cserver.getPluginManager().callEvent(event); if (event.getResult() != PlayerLoginEvent.Result.ALLOWED) { - loginlistener.disconnect(event.getKickMessage()); + loginlistener.disconnect(PaperAdventure.asVanilla(event.kickMessage())); // Paper - Adventure return null; } return entity; @@ -1147,7 +1147,7 @@ public abstract class PlayerList { public void removeAll() { // CraftBukkit start - disconnect safely for (ServerPlayer player : this.players) { - player.connection.disconnect(this.server.server.getShutdownMessage()); // CraftBukkit - add custom shutdown message + player.connection.disconnect(this.server.server.shutdownMessage()); // CraftBukkit - add custom shutdown message // Paper - Adventure } // CraftBukkit end @@ -1188,24 +1188,43 @@ public abstract class PlayerList { } public void broadcastChatMessage(PlayerChatMessage message, ServerPlayer sender, ChatType.Bound params) { + // Paper start + this.broadcastChatMessage(message, sender, params, null); + } + public void broadcastChatMessage(PlayerChatMessage message, ServerPlayer sender, ChatType.Bound params, @Nullable Function unsignedFunction) { + // Paper end Objects.requireNonNull(sender); - this.broadcastChatMessage(message, sender::shouldFilterMessageTo, sender, params); + this.broadcastChatMessage(message, sender::shouldFilterMessageTo, sender, params, unsignedFunction); // Paper } private void broadcastChatMessage(PlayerChatMessage message, Predicate shouldSendFiltered, @Nullable ServerPlayer sender, ChatType.Bound params) { + // Paper start + this.broadcastChatMessage(message, shouldSendFiltered, sender, params, null); + } + public void broadcastChatMessage(PlayerChatMessage message, Predicate shouldSendFiltered, @Nullable ServerPlayer sender, ChatType.Bound params, @Nullable Function unsignedFunction) { + // Paper end boolean flag = this.verifyChatTrusted(message); - this.server.logChatMessage(message.decoratedContent(), params, flag ? null : "Not Secure"); + this.server.logChatMessage((unsignedFunction == null ? message.decoratedContent() : unsignedFunction.apply(this.server.console)), params, flag ? null : "Not Secure"); // Paper OutgoingChatMessage outgoingchatmessage = OutgoingChatMessage.create(message); boolean flag1 = false; boolean flag2; + Packet disguised = sender != null && unsignedFunction == null ? new net.minecraft.network.protocol.game.ClientboundDisguisedChatPacket(outgoingchatmessage.content(), params.toNetwork(sender.level.registryAccess())) : null; // Paper - don't send player chat packets from vanished players for (Iterator iterator = this.players.iterator(); iterator.hasNext(); flag1 |= flag2 && message.isFullyFiltered()) { ServerPlayer entityplayer1 = (ServerPlayer) iterator.next(); flag2 = shouldSendFiltered.test(entityplayer1); - entityplayer1.sendChatMessage(outgoingchatmessage, flag2, params); + // Paper start - don't send player chat packets from vanished players + if (sender != null && !entityplayer1.getBukkitEntity().canSee(sender.getBukkitEntity())) { + entityplayer1.connection.send(unsignedFunction != null + ? new net.minecraft.network.protocol.game.ClientboundDisguisedChatPacket(unsignedFunction.apply(entityplayer1.getBukkitEntity()), params.toNetwork(sender.level.registryAccess())) + : disguised); + continue; + } + // Paper end + entityplayer1.sendChatMessage(outgoingchatmessage, flag2, params, unsignedFunction == null ? null : unsignedFunction.apply(entityplayer1.getBukkitEntity())); // Paper } if (flag1 && sender != null) { @@ -1214,7 +1233,7 @@ public abstract class PlayerList { } - private boolean verifyChatTrusted(PlayerChatMessage message) { + public boolean verifyChatTrusted(PlayerChatMessage message) { // Paper - private -> public return message.hasSignature() && !message.hasExpiredServer(Instant.now()); } diff --git a/src/main/java/net/minecraft/world/BossEvent.java b/src/main/java/net/minecraft/world/BossEvent.java index 4c62df5a3781ec9df4a5c5f1b528649e6e8a62d1..affd1b8c7589ba59330dc0b6fc803cce4ee57397 100644 --- a/src/main/java/net/minecraft/world/BossEvent.java +++ b/src/main/java/net/minecraft/world/BossEvent.java @@ -13,6 +13,7 @@ public abstract class BossEvent { protected boolean darkenScreen; protected boolean playBossMusic; protected boolean createWorldFog; + public net.kyori.adventure.bossbar.BossBar adventure; // Paper public BossEvent(UUID uuid, Component name, BossEvent.BossBarColor color, BossEvent.BossBarOverlay style) { this.id = uuid; @@ -27,61 +28,75 @@ public abstract class BossEvent { } public Component getName() { + if (this.adventure != null) return io.papermc.paper.adventure.PaperAdventure.asVanilla(this.adventure.name()); // Paper return this.name; } public void setName(Component name) { + if (this.adventure != null) this.adventure.name(io.papermc.paper.adventure.PaperAdventure.asAdventure(name)); // Paper this.name = name; } public float getProgress() { + if (this.adventure != null) return this.adventure.progress(); // Paper return this.progress; } public void setProgress(float percent) { + if (this.adventure != null) this.adventure.progress(percent); // Paper this.progress = percent; } public BossEvent.BossBarColor getColor() { + if (this.adventure != null) return io.papermc.paper.adventure.PaperAdventure.asVanilla(this.adventure.color()); // Paper return this.color; } public void setColor(BossEvent.BossBarColor color) { + if (this.adventure != null) this.adventure.color(io.papermc.paper.adventure.PaperAdventure.asAdventure(color)); // Paper this.color = color; } public BossEvent.BossBarOverlay getOverlay() { + if (this.adventure != null) return io.papermc.paper.adventure.PaperAdventure.asVanilla(this.adventure.overlay()); // Paper return this.overlay; } public void setOverlay(BossEvent.BossBarOverlay style) { + if (this.adventure != null) this.adventure.overlay(io.papermc.paper.adventure.PaperAdventure.asAdventure(style)); // Paper this.overlay = style; } public boolean shouldDarkenScreen() { + if (this.adventure != null) return this.adventure.hasFlag(net.kyori.adventure.bossbar.BossBar.Flag.DARKEN_SCREEN); // Paper return this.darkenScreen; } public BossEvent setDarkenScreen(boolean darkenSky) { + if (this.adventure != null) io.papermc.paper.adventure.PaperAdventure.setFlag(this.adventure, net.kyori.adventure.bossbar.BossBar.Flag.DARKEN_SCREEN, darkenSky); // Paper this.darkenScreen = darkenSky; return this; } public boolean shouldPlayBossMusic() { + if (this.adventure != null) return this.adventure.hasFlag(net.kyori.adventure.bossbar.BossBar.Flag.PLAY_BOSS_MUSIC); // Paper return this.playBossMusic; } public BossEvent setPlayBossMusic(boolean dragonMusic) { + if (this.adventure != null) io.papermc.paper.adventure.PaperAdventure.setFlag(this.adventure, net.kyori.adventure.bossbar.BossBar.Flag.PLAY_BOSS_MUSIC, dragonMusic); // Paper this.playBossMusic = dragonMusic; return this; } public BossEvent setCreateWorldFog(boolean thickenFog) { + if (this.adventure != null) io.papermc.paper.adventure.PaperAdventure.setFlag(this.adventure, net.kyori.adventure.bossbar.BossBar.Flag.CREATE_WORLD_FOG, thickenFog); // Paper this.createWorldFog = thickenFog; return this; } public boolean shouldCreateWorldFog() { + if (this.adventure != null) return this.adventure.hasFlag(net.kyori.adventure.bossbar.BossBar.Flag.CREATE_WORLD_FOG); // Paper return this.createWorldFog; } diff --git a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java index 3800205f28a00572b4ab757cc56e24eefa61e6fe..fe14c0d03a0bbd5cbf0608ea88d499984b54d2ed 100644 --- a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java +++ b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java @@ -33,6 +33,7 @@ import net.minecraft.world.level.saveddata.SavedData; import org.slf4j.Logger; // CraftBukkit start +import io.papermc.paper.adventure.PaperAdventure; // Paper import java.util.UUID; import org.bukkit.Bukkit; import org.bukkit.craftbukkit.CraftServer; @@ -598,7 +599,7 @@ public class MapItemSavedData extends SavedData { for (org.bukkit.map.MapCursor cursor : render.cursors) { if (cursor.isVisible()) { - icons.add(new MapDecoration(MapDecoration.Type.byIcon(cursor.getRawType()), cursor.getX(), cursor.getY(), cursor.getDirection(), CraftChatMessage.fromStringOrNull(cursor.getCaption()))); + icons.add(new MapDecoration(MapDecoration.Type.byIcon(cursor.getRawType()), cursor.getX(), cursor.getY(), cursor.getDirection(), PaperAdventure.asVanilla(cursor.caption()))); // Paper - Adventure } } collection = icons; diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java index 059ba63319f6ca04750a7d6b095e6179cae68b4f..cb2dc6db887856c5f60d127f5999a0785702f2f4 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -600,8 +600,10 @@ public final class CraftServer implements Server { } @Override + @Deprecated // Paper start public int broadcastMessage(String message) { return this.broadcast(message, BROADCAST_CHANNEL_USERS); + // Paper end } @Override @@ -1439,7 +1441,15 @@ public final class CraftServer implements Server { return this.configuration.getInt("settings.spawn-radius", -1); } + // Paper start + @Override + public net.kyori.adventure.text.Component shutdownMessage() { + String msg = getShutdownMessage(); + return msg != null ? net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(msg) : null; + } + // Paper end @Override + @Deprecated // Paper public String getShutdownMessage() { return this.configuration.getString("settings.shutdown-message"); } @@ -1607,7 +1617,20 @@ public final class CraftServer implements Server { } @Override + @Deprecated // Paper public int broadcast(String message, String permission) { + // Paper start - Adventure + return this.broadcast(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(message), permission); + } + + @Override + public int broadcast(net.kyori.adventure.text.Component message) { + return this.broadcast(message, BROADCAST_CHANNEL_USERS); + } + + @Override + public int broadcast(net.kyori.adventure.text.Component message, String permission) { + // Paper end Set recipients = new HashSet<>(); for (Permissible permissible : this.getPluginManager().getPermissionSubscriptions(permission)) { if (permissible instanceof CommandSender && permissible.hasPermission(permission)) { @@ -1615,14 +1638,14 @@ public final class CraftServer implements Server { } } - BroadcastMessageEvent broadcastMessageEvent = new BroadcastMessageEvent(!Bukkit.isPrimaryThread(), message, recipients); + BroadcastMessageEvent broadcastMessageEvent = new BroadcastMessageEvent(!Bukkit.isPrimaryThread(), message, recipients); // Paper - Adventure this.getPluginManager().callEvent(broadcastMessageEvent); if (broadcastMessageEvent.isCancelled()) { return 0; } - message = broadcastMessageEvent.getMessage(); + message = broadcastMessageEvent.message(); // Paper - Adventure for (CommandSender recipient : recipients) { recipient.sendMessage(message); @@ -1873,6 +1896,14 @@ public final class CraftServer implements Server { return CraftInventoryCreator.INSTANCE.createInventory(owner, type); } + // Paper start + @Override + public Inventory createInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) { + Validate.isTrue(type.isCreatable(), "Cannot open an inventory of type ", type); + return CraftInventoryCreator.INSTANCE.createInventory(owner, type, title); + } + // Paper end + @Override public Inventory createInventory(InventoryHolder owner, InventoryType type, String title) { Validate.isTrue(type.isCreatable(), "Cannot open an inventory of type ", type); @@ -1885,13 +1916,28 @@ public final class CraftServer implements Server { return CraftInventoryCreator.INSTANCE.createInventory(owner, size); } + // Paper start + @Override + public Inventory createInventory(InventoryHolder owner, int size, net.kyori.adventure.text.Component title) throws IllegalArgumentException { + Validate.isTrue(9 <= size && size <= 54 && size % 9 == 0, "Size for custom inventory must be a multiple of 9 between 9 and 54 slots (got " + size + ")"); + return CraftInventoryCreator.INSTANCE.createInventory(owner, size, title); + } + // Paper end + @Override public Inventory createInventory(InventoryHolder owner, int size, String title) throws IllegalArgumentException { Validate.isTrue(9 <= size && size <= 54 && size % 9 == 0, "Size for custom inventory must be a multiple of 9 between 9 and 54 slots (got " + size + ")"); return CraftInventoryCreator.INSTANCE.createInventory(owner, size, title); } + // Paper start + @Override + public Merchant createMerchant(net.kyori.adventure.text.Component title) { + return new org.bukkit.craftbukkit.inventory.CraftMerchantCustom(title == null ? InventoryType.MERCHANT.defaultTitle() : title); + } + // Paper end @Override + @Deprecated // Paper public Merchant createMerchant(String title) { return new CraftMerchantCustom(title == null ? InventoryType.MERCHANT.getDefaultTitle() : title); } @@ -1956,6 +2002,12 @@ public final class CraftServer implements Server { return Thread.currentThread().equals(console.serverThread) || this.console.hasStopped() || !org.spigotmc.AsyncCatcher.enabled; // All bets are off if we have shut down (e.g. due to watchdog) } + // Paper start + @Override + public net.kyori.adventure.text.Component motd() { + return console.getComponentMotd(); + } + // Paper end @Override public String getMotd() { return this.console.getMotd(); @@ -2382,4 +2434,15 @@ public final class CraftServer implements Server { return this.spigot; } // Spigot end + + // Paper start + private Iterable adventure$audiences; + @Override + public Iterable audiences() { + if (this.adventure$audiences == null) { + this.adventure$audiences = com.google.common.collect.Iterables.concat(java.util.Collections.singleton(this.getConsoleSender()), this.getOnlinePlayers()); + } + return this.adventure$audiences; + } + // Paper end } diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java index 3b9e42adb657d0feb99de4b55dc0c628e9cd5afd..253f965e52cd488af88d55cdd09f1bad0ddbeb56 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java @@ -149,6 +149,7 @@ public class CraftWorld extends CraftRegionAccessor implements World { private final BlockMetadataStore blockMetadata = new BlockMetadataStore(this); private final Object2IntOpenHashMap spawnCategoryLimit = new Object2IntOpenHashMap<>(); private final CraftPersistentDataContainer persistentDataContainer = new CraftPersistentDataContainer(CraftWorld.DATA_TYPE_REGISTRY); + private net.kyori.adventure.pointer.Pointers adventure$pointers; // Paper - implement pointers private static final Random rand = new Random(); @@ -1986,5 +1987,18 @@ public class CraftWorld extends CraftRegionAccessor implements World { return ret; } + + // Paper start - implement pointers + @Override + public net.kyori.adventure.pointer.Pointers pointers() { + if (this.adventure$pointers == null) { + this.adventure$pointers = net.kyori.adventure.pointer.Pointers.builder() + .withDynamic(net.kyori.adventure.identity.Identity.NAME, this::getName) + .withDynamic(net.kyori.adventure.identity.Identity.UUID, this::getUID) + .build(); + } + + return this.adventure$pointers; + } // Paper end } diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java index 7fc066ee281662192aad826840573e4181f5ceff..6569c9db3fa026ee4fbfaceac0e4f6a15c1fbe16 100644 --- a/src/main/java/org/bukkit/craftbukkit/Main.java +++ b/src/main/java/org/bukkit/craftbukkit/Main.java @@ -20,6 +20,12 @@ public class Main { public static boolean useConsole = true; public static void main(String[] args) { + // Paper start + final String warnWhenLegacyFormattingDetected = String.join(".", "net", "kyori", "adventure", "text", "warnWhenLegacyFormattingDetected"); + if (false && System.getProperty(warnWhenLegacyFormattingDetected) == null) { + System.setProperty(warnWhenLegacyFormattingDetected, String.valueOf(true)); + } + // Paper end // Todo: Installation script OptionParser parser = new OptionParser() { { diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBeacon.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBeacon.java index 9d55f36f146435f0cfb4e62ffa7c94eab404a596..c186a44b927188ed222f8b2f8f76aaef35d9c654 100644 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftBeacon.java +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBeacon.java @@ -68,6 +68,19 @@ public class CraftBeacon extends CraftBlockEntityState implem this.getSnapshot().secondaryPower = (effect != null) ? MobEffect.byId(effect.getId()) : null; } + // Paper start + @Override + public net.kyori.adventure.text.Component customName() { + final BeaconBlockEntity be = this.getSnapshot(); + return be.name != null ? io.papermc.paper.adventure.PaperAdventure.asAdventure(be.name) : null; + } + + @Override + public void customName(final net.kyori.adventure.text.Component customName) { + this.getSnapshot().setCustomName(customName != null ? io.papermc.paper.adventure.PaperAdventure.asVanilla(customName) : null); + } + // Paper end + @Override public String getCustomName() { BeaconBlockEntity beacon = this.getSnapshot(); diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftCommandBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftCommandBlock.java index 02fc6b189541fdedd0acef6700722eb7e53346c4..c4ea6760f489e6171f9e6e170160b932597f842f 100644 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftCommandBlock.java +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftCommandBlock.java @@ -30,4 +30,16 @@ public class CraftCommandBlock extends CraftBlockEntityState public void setName(String name) { getSnapshot().getCommandBlock().setName(CraftChatMessage.fromStringOrNull(name != null ? name : "@")); } + + // Paper start + @Override + public net.kyori.adventure.text.Component name() { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(getSnapshot().getCommandBlock().getName()); + } + + @Override + public void name(net.kyori.adventure.text.Component name) { + getSnapshot().getCommandBlock().setName(name == null ? net.minecraft.network.chat.Component.literal("@") : io.papermc.paper.adventure.PaperAdventure.asVanilla(name)); + } + // Paper end } diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftContainer.java b/src/main/java/org/bukkit/craftbukkit/block/CraftContainer.java index 05f37f306d623280823c7cf9516027189659f902..65104a0506131373b6b33433a118c7e1cd3696dc 100644 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftContainer.java +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftContainer.java @@ -27,6 +27,19 @@ public abstract class CraftContainer extends this.getSnapshot().lockKey = (key == null) ? LockCode.NO_LOCK : new LockCode(key); } + // Paper start + @Override + public net.kyori.adventure.text.Component customName() { + final T be = this.getSnapshot(); + return be.hasCustomName() ? io.papermc.paper.adventure.PaperAdventure.asAdventure(be.getCustomName()) : null; + } + + @Override + public void customName(final net.kyori.adventure.text.Component customName) { + this.getSnapshot().setCustomName(customName != null ? io.papermc.paper.adventure.PaperAdventure.asVanilla(customName) : null); + } + // Paper end + @Override public String getCustomName() { T container = this.getSnapshot(); diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftEnchantingTable.java b/src/main/java/org/bukkit/craftbukkit/block/CraftEnchantingTable.java index 0beb96dc896f63003e1b1ae458b73902bdbe648a..102eb86bad3000f258775ac06ecd1a6dad174b0a 100644 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftEnchantingTable.java +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftEnchantingTable.java @@ -11,6 +11,19 @@ public class CraftEnchantingTable extends CraftBlockEntityState extends CraftBlockEntityState implements Sign { // Lazily initialized only if requested: - private String[] originalLines = null; - private String[] lines = null; + // Paper start + private java.util.ArrayList originalLines = null; // ArrayList for RandomAccess + private java.util.ArrayList lines = null; // ArrayList for RandomAccess + // Paper end public CraftSign(World world, T tileEntity) { super(world, tileEntity); } + // Paper start @Override - public String[] getLines() { - if (this.lines == null) { - // Lazy initialization: - SignBlockEntity sign = this.getSnapshot(); - this.lines = new String[sign.messages.length]; - System.arraycopy(CraftSign.revertComponents(sign.messages), 0, lines, 0, lines.length); - this.originalLines = new String[lines.length]; - System.arraycopy(lines, 0, originalLines, 0, originalLines.length); - } + public java.util.List lines() { + this.loadLines(); return this.lines; } + @Override + public net.kyori.adventure.text.Component line(int index) { + this.loadLines(); + return this.lines.get(index); + } + + @Override + public void line(int index, net.kyori.adventure.text.Component line) { + this.loadLines(); + this.lines.set(index, line); + } + + private void loadLines() { + if (lines != null) { + return; + } + // Lazy initialization: + SignBlockEntity sign = this.getSnapshot(); + lines = io.papermc.paper.adventure.PaperAdventure.asAdventure(com.google.common.collect.Lists.newArrayList(sign.messages)); + originalLines = new java.util.ArrayList<>(lines); + } + // Paper end + @Override + public String[] getLines() { + this.loadLines(); + return this.lines.stream().map(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection()::serialize).toArray(String[]::new); // Paper + } + @Override public String getLine(int index) throws IndexOutOfBoundsException { - return this.getLines()[index]; + this.loadLines(); + return net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(this.lines.get(index)); // Paper } @Override public void setLine(int index, String line) throws IndexOutOfBoundsException { - this.getLines()[index] = line; + this.loadLines(); + this.lines.set(index, line != null ? net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(line) : net.kyori.adventure.text.Component.empty()); // Paper } @Override @@ -78,13 +104,16 @@ public class CraftSign extends CraftBlockEntityState< super.applyTo(sign); if (this.lines != null) { - for (int i = 0; i < lines.length; i++) { - String line = (this.lines[i] == null) ? "" : this.lines[i]; - if (line.equals(this.originalLines[i])) { + // Paper start + for (int i = 0; i < this.lines.size(); ++i) { + net.kyori.adventure.text.Component component = this.lines.get(i); + net.kyori.adventure.text.Component origComp = this.originalLines.get(i); + if (component.equals(origComp)) { continue; // The line contents are still the same, skip. } - sign.setMessage(i, CraftChatMessage.fromString(line)[0]); + sign.setMessage(i, io.papermc.paper.adventure.PaperAdventure.asVanilla(component)); } + // Paper end } } @@ -99,6 +128,20 @@ public class CraftSign extends CraftBlockEntityState< ((CraftPlayer) player).getHandle().openTextEdit(handle); } + // Paper start + public static Component[] sanitizeLines(java.util.List lines) { + Component[] components = new Component[4]; + for (int i = 0; i < 4; i++) { + if (i < lines.size() && lines.get(i) != null) { + components[i] = io.papermc.paper.adventure.PaperAdventure.asVanilla(lines.get(i)); + } else { + components[i] = net.minecraft.network.chat.Component.literal(""); + } + } + return components; + } + // Paper end + public static Component[] sanitizeLines(String[] lines) { Component[] components = new Component[4]; diff --git a/src/main/java/org/bukkit/craftbukkit/command/CraftBlockCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/CraftBlockCommandSender.java index 3de88112bdb08d6bd0d28f20582c4090bfd8dbfe..87f2cea36d852c81fdb0a1bc21162d41377ab2e7 100644 --- a/src/main/java/org/bukkit/craftbukkit/command/CraftBlockCommandSender.java +++ b/src/main/java/org/bukkit/craftbukkit/command/CraftBlockCommandSender.java @@ -45,6 +45,18 @@ public class CraftBlockCommandSender extends ServerCommandSender implements Bloc return this.block.getTextName(); } + // Paper start + @Override + public void sendMessage(net.kyori.adventure.identity.Identity identity, net.kyori.adventure.text.Component message, net.kyori.adventure.audience.MessageType type) { + block.source.sendSystemMessage(io.papermc.paper.adventure.PaperAdventure.asVanilla(message)); + } + + @Override + public net.kyori.adventure.text.Component name() { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(this.block.getDisplayName()); + } + // Paper end + @Override public boolean isOp() { return true; diff --git a/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java index f3cb4102ab223f379f60dac317df7da1fab812a8..324e6d1a4fadd3e557e4ba05f04e6a5891cc54df 100644 --- a/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java +++ b/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java @@ -46,6 +46,13 @@ public class CraftConsoleCommandSender extends ServerCommandSender implements Co return "CONSOLE"; } + // Paper start + @Override + public net.kyori.adventure.text.Component name() { + return net.kyori.adventure.text.Component.text(this.getName()); + } + // Paper end + @Override public boolean isOp() { return true; @@ -80,4 +87,11 @@ public class CraftConsoleCommandSender extends ServerCommandSender implements Co public boolean isConversing() { return this.conversationTracker.isConversing(); } + + // Paper start + @Override + public void sendMessage(final net.kyori.adventure.identity.Identity identity, final net.kyori.adventure.text.Component message, final net.kyori.adventure.audience.MessageType type) { + this.sendRawMessage(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(message)); + } + // Paper end } diff --git a/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java index 03027fe2b7ffe4c7ce7f1bb4f56051a4743c7f01..a6612cc0ea87aeb8e87521ff7b5fe58c7b06b9ef 100644 --- a/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java +++ b/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java @@ -29,6 +29,13 @@ public class CraftRemoteConsoleCommandSender extends ServerCommandSender impleme return "Rcon"; } + // Paper start + @Override + public net.kyori.adventure.text.Component name() { + return net.kyori.adventure.text.Component.text(this.getName()); + } + // Paper end + @Override public boolean isOp() { return true; diff --git a/src/main/java/org/bukkit/craftbukkit/command/ProxiedNativeCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/ProxiedNativeCommandSender.java index 53d6950ad270ba901de5226b9daecb683248ad05..3e7d14564f11a3ed0b0766444e9d681804597e9a 100644 --- a/src/main/java/org/bukkit/craftbukkit/command/ProxiedNativeCommandSender.java +++ b/src/main/java/org/bukkit/craftbukkit/command/ProxiedNativeCommandSender.java @@ -67,6 +67,13 @@ public class ProxiedNativeCommandSender implements ProxiedCommandSender { return this.getCallee().getName(); } + // Paper start + @Override + public net.kyori.adventure.text.Component name() { + return this.getCallee().name(); + } + // Paper end + @Override public boolean isPermissionSet(String name) { return this.getCaller().isPermissionSet(name); diff --git a/src/main/java/org/bukkit/craftbukkit/command/ServerCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/ServerCommandSender.java index 8107ed0d248ff2a1cf8e556b7610a68f6c197691..eaff8df6c8c12c64e005a68a02e2e35ed88f757c 100644 --- a/src/main/java/org/bukkit/craftbukkit/command/ServerCommandSender.java +++ b/src/main/java/org/bukkit/craftbukkit/command/ServerCommandSender.java @@ -14,6 +14,7 @@ import org.bukkit.plugin.Plugin; public abstract class ServerCommandSender implements CommandSender { private static PermissibleBase blockPermInst; private final PermissibleBase perm; + private net.kyori.adventure.pointer.Pointers adventure$pointers; // Paper - implement pointers public ServerCommandSender() { if (this instanceof CraftBlockCommandSender) { @@ -134,4 +135,18 @@ public abstract class ServerCommandSender implements CommandSender { return this.spigot; } // Spigot end + + // Paper start - implement pointers + @Override + public net.kyori.adventure.pointer.Pointers pointers() { + if (this.adventure$pointers == null) { + this.adventure$pointers = net.kyori.adventure.pointer.Pointers.builder() + .withDynamic(net.kyori.adventure.identity.Identity.DISPLAY_NAME, this::name) + .withStatic(net.kyori.adventure.permission.PermissionChecker.POINTER, this::permissionValue) + .build(); + } + + return this.adventure$pointers; + } + // Paper end } diff --git a/src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java b/src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java index f6c614bb1184f9c79121f64a2a030bf3f094b671..e8334e2264510f5101e80b4f130e7ae1442560d7 100644 --- a/src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java +++ b/src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java @@ -189,6 +189,12 @@ public class CraftEnchantment extends Enchantment { CraftEnchantment ench = (CraftEnchantment) other; return !this.target.isCompatibleWith(ench.target); } + // Paper start + @Override + public net.kyori.adventure.text.Component displayName(int level) { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(getHandle().getFullname(level)); + } + // Paper end public net.minecraft.world.item.enchantment.Enchantment getHandle() { return this.target; diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java index f4cdda9fabb3a13f7cc8b6056815bdbae704db9d..17c914088b467007aada17e3b2238a9c76fb532b 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java @@ -202,6 +202,7 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity { protected Entity entity; private EntityDamageEvent lastDamageEvent; private final CraftPersistentDataContainer persistentDataContainer = new CraftPersistentDataContainer(CraftEntity.DATA_TYPE_REGISTRY); + protected net.kyori.adventure.pointer.Pointers adventure$pointers; // Paper - implement pointers public CraftEntity(final CraftServer server, final Entity entity) { this.server = server; @@ -860,6 +861,32 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity { return this.getHandle().getVehicle().getBukkitEntity(); } + // Paper start + @Override + public net.kyori.adventure.text.Component customName() { + final Component name = this.getHandle().getCustomName(); + return name != null ? io.papermc.paper.adventure.PaperAdventure.asAdventure(name) : null; + } + + @Override + public void customName(final net.kyori.adventure.text.Component customName) { + this.getHandle().setCustomName(customName != null ? io.papermc.paper.adventure.PaperAdventure.asVanilla(customName) : null); + } + + @Override + public net.kyori.adventure.pointer.Pointers pointers() { + if (this.adventure$pointers == null) { + this.adventure$pointers = net.kyori.adventure.pointer.Pointers.builder() + .withDynamic(net.kyori.adventure.identity.Identity.DISPLAY_NAME, this::name) + .withDynamic(net.kyori.adventure.identity.Identity.UUID, this::getUniqueId) + .withStatic(net.kyori.adventure.permission.PermissionChecker.POINTER, this::permissionValue) + .build(); + } + + return this.adventure$pointers; + } + // Paper end + @Override public void setCustomName(String name) { // sane limit for name length @@ -939,6 +966,17 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity { public String getName() { return CraftChatMessage.fromComponent(this.getHandle().getName()); } + // Paper start + @Override + public net.kyori.adventure.text.@org.jetbrains.annotations.NotNull Component name() { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(this.getHandle().getName()); + } + + @Override + public net.kyori.adventure.text.@org.jetbrains.annotations.NotNull Component teamDisplayName() { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(this.getHandle().getDisplayName()); + } + // Paper end @Override public boolean isPermissionSet(String name) { diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java index aea8bdbfe0c16c664d787e8abcd189f1019fccce..e38c32708ac7969dbc342989d2a5a767e26e4c3d 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java @@ -321,9 +321,12 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity { container = CraftEventFactory.callInventoryOpenEvent(player, container); if (container == null) return; - String title = container.getBukkitView().getTitle(); + //String title = container.getBukkitView().getTitle(); // Paper - comment + net.kyori.adventure.text.Component adventure$title = container.getBukkitView().title(); // Paper + if (adventure$title == null) adventure$title = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(container.getBukkitView().getTitle()); // Paper - player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, CraftChatMessage.fromString(title)[0])); + //player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, CraftChatMessage.fromString(title)[0])); // Paper - comment + player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, io.papermc.paper.adventure.PaperAdventure.asVanilla(adventure$title))); // Paper player.containerMenu = container; player.initMenu(container); } @@ -392,8 +395,12 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity { // Now open the window MenuType windowType = CraftContainer.getNotchInventoryType(inventory.getTopInventory()); - String title = inventory.getTitle(); - player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, CraftChatMessage.fromString(title)[0])); + + //String title = inventory.getTitle(); // Paper - comment + net.kyori.adventure.text.Component adventure$title = inventory.title(); // Paper + if (adventure$title == null) adventure$title = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(inventory.getTitle()); // Paper + //player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, CraftChatMessage.fromString(title)[0])); // Paper - comment + player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, io.papermc.paper.adventure.PaperAdventure.asVanilla(adventure$title))); // Paper player.containerMenu = container; player.initMenu(container); } diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartCommand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartCommand.java index 446fdca49a5a6999626a7ee3a1d5c168b15a09dd..f9863e138994f6c7a7975a852f106faa96d52315 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartCommand.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartCommand.java @@ -65,6 +65,13 @@ public class CraftMinecartCommand extends CraftMinecart implements CommandMineca return CraftChatMessage.fromComponent(this.getHandle().getCommandBlock().getName()); } + // Paper start + @Override + public net.kyori.adventure.text.@org.jetbrains.annotations.NotNull Component name() { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(this.getHandle().getCommandBlock().getName()); + } + // Paper end + @Override public boolean isOp() { return true; diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java index 4d341db0daecb5f6ff1f0a1a9238f9dedb4b50d1..27cf140f8a7715caec5637d7b487720c2cc5742e 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java @@ -278,14 +278,39 @@ public class CraftPlayer extends CraftHumanEntity implements Player { @Override public String getDisplayName() { + if(true) return io.papermc.paper.adventure.DisplayNames.getLegacy(this); // Paper return this.getHandle().displayName; } @Override public void setDisplayName(final String name) { + this.getHandle().adventure$displayName = name != null ? net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(name) : net.kyori.adventure.text.Component.text(this.getName()); // Paper this.getHandle().displayName = name == null ? getName() : name; } + // Paper start + @Override + public void playerListName(net.kyori.adventure.text.Component name) { + getHandle().listName = name == null ? null : io.papermc.paper.adventure.PaperAdventure.asVanilla(name); + for (ServerPlayer player : server.getHandle().players) { + if (player.getBukkitEntity().canSee(this)) { + player.connection.send(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME, getHandle())); + } + } + } + @Override + public net.kyori.adventure.text.Component playerListName() { + return getHandle().listName == null ? net.kyori.adventure.text.Component.text(getName()) : io.papermc.paper.adventure.PaperAdventure.asAdventure(getHandle().listName); + } + @Override + public net.kyori.adventure.text.Component playerListHeader() { + return playerListHeader; + } + @Override + public net.kyori.adventure.text.Component playerListFooter() { + return playerListFooter; + } + // Paper end @Override public String getPlayerListName() { return this.getHandle().listName == null ? getName() : CraftChatMessage.fromComponent(this.getHandle().listName); @@ -304,42 +329,42 @@ public class CraftPlayer extends CraftHumanEntity implements Player { } } - private Component playerListHeader; - private Component playerListFooter; + private net.kyori.adventure.text.Component playerListHeader; // Paper - Adventure + private net.kyori.adventure.text.Component playerListFooter; // Paper - Adventure @Override public String getPlayerListHeader() { - return (this.playerListHeader == null) ? null : CraftChatMessage.fromComponent(playerListHeader); + return (this.playerListHeader == null) ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(playerListHeader); } @Override public String getPlayerListFooter() { - return (this.playerListFooter == null) ? null : CraftChatMessage.fromComponent(playerListFooter); + return (this.playerListFooter == null) ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(playerListFooter); // Paper - Adventure } @Override public void setPlayerListHeader(String header) { - this.playerListHeader = CraftChatMessage.fromStringOrNull(header, true); + this.playerListHeader = header == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(header); // Paper - Adventure this.updatePlayerListHeaderFooter(); } @Override public void setPlayerListFooter(String footer) { - this.playerListFooter = CraftChatMessage.fromStringOrNull(footer, true); + this.playerListFooter = footer == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(footer); // Paper - Adventure this.updatePlayerListHeaderFooter(); } @Override public void setPlayerListHeaderFooter(String header, String footer) { - this.playerListHeader = CraftChatMessage.fromStringOrNull(header, true); - this.playerListFooter = CraftChatMessage.fromStringOrNull(footer, true); + this.playerListHeader = header == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(header); // Paper - Adventure + this.playerListFooter = footer == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(footer); // Paper - Adventure this.updatePlayerListHeaderFooter(); } private void updatePlayerListHeaderFooter() { if (this.getHandle().connection == null) return; - ClientboundTabListPacket packet = new ClientboundTabListPacket((this.playerListHeader == null) ? Component.empty() : this.playerListHeader, (this.playerListFooter == null) ? Component.empty() : this.playerListFooter); + ClientboundTabListPacket packet = new ClientboundTabListPacket((this.playerListHeader == null) ? Component.empty() : io.papermc.paper.adventure.PaperAdventure.asVanilla(this.playerListHeader), (this.playerListFooter == null) ? Component.empty() : io.papermc.paper.adventure.PaperAdventure.asVanilla(this.playerListFooter)); // Paper - adventure this.getHandle().connection.send(packet); } @@ -371,6 +396,23 @@ public class CraftPlayer extends CraftHumanEntity implements Player { this.getHandle().connection.disconnect(message == null ? "" : message); } + // Paper start + private static final net.kyori.adventure.text.Component DEFAULT_KICK_COMPONENT = net.kyori.adventure.text.Component.translatable("multiplayer.disconnect.kicked"); + @Override + public void kick() { + this.kick(DEFAULT_KICK_COMPONENT); + } + + @Override + public void kick(final net.kyori.adventure.text.Component message) { + org.spigotmc.AsyncCatcher.catchOp("player kick"); + final ServerGamePacketListenerImpl connection = this.getHandle().connection; + if (connection != null) { + connection.disconnect(message == null ? net.kyori.adventure.text.Component.empty() : message); + } + } + // Paper end + @Override public void setCompassTarget(Location loc) { if (this.getHandle().connection == null) return; @@ -684,6 +726,35 @@ public class CraftPlayer extends CraftHumanEntity implements Player { this.getHandle().connection.send(packet); } + // Paper start + @Override + public void sendSignChange(Location loc, @Nullable List lines, DyeColor dyeColor, boolean hasGlowingText) { + if (getHandle().connection == null) { + return; + } + if (lines == null) { + lines = new java.util.ArrayList<>(4); + } + Validate.notNull(loc, "Location cannot be null"); + Validate.notNull(dyeColor, "DyeColor cannot be null"); + if (lines.size() < 4) { + throw new IllegalArgumentException("Must have at least 4 lines"); + } + Component[] components = CraftSign.sanitizeLines(lines); + this.sendSignChange0(components, loc, dyeColor, hasGlowingText); + } + + private void sendSignChange0(Component[] components, Location loc, DyeColor dyeColor, boolean hasGlowingText) { + SignBlockEntity sign = new SignBlockEntity(new BlockPos(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()), Blocks.OAK_SIGN.defaultBlockState()); + sign.setColor(net.minecraft.world.item.DyeColor.byId(dyeColor.getWoolData())); + sign.setHasGlowingText(hasGlowingText); + for (int i = 0; i < components.length; i++) { + sign.setMessage(i, components[i]); + } + + getHandle().connection.send(sign.getUpdatePacket()); + } + // Paper end @Override public void sendSignChange(Location loc, String[] lines) { this.sendSignChange(loc, lines, DyeColor.BLACK); @@ -711,14 +782,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player { } Component[] components = CraftSign.sanitizeLines(lines); - SignBlockEntity sign = new SignBlockEntity(new BlockPos(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()), Blocks.OAK_SIGN.defaultBlockState()); + /*SignBlockEntity sign = new SignBlockEntity(new BlockPos(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()), Blocks.OAK_SIGN.defaultBlockState()); sign.setColor(net.minecraft.world.item.DyeColor.byId(dyeColor.getWoolData())); sign.setHasGlowingText(hasGlowingText); for (int i = 0; i < components.length; i++) { sign.setMessage(i, components[i]); } - this.getHandle().connection.send(sign.getUpdatePacket()); + this.getHandle().connection.send(sign.getUpdatePacket());*/ // Paper + this.sendSignChange0(components, loc, dyeColor, hasGlowingText); // Paper } @Override @@ -1576,7 +1648,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { @Override public void setResourcePack(String url) { - this.setResourcePack(url, null); + this.setResourcePack(url, (byte[]) null); } @Override @@ -1591,7 +1663,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { @Override public void setResourcePack(String url, byte[] hash, boolean force) { - this.setResourcePack(url, hash, null, force); + this.setResourcePack(url, hash, (String) null, force); } @Override @@ -1607,6 +1679,21 @@ public class CraftPlayer extends CraftHumanEntity implements Player { } } + // Paper start + @Override + public void setResourcePack(String url, byte[] hashBytes, net.kyori.adventure.text.Component prompt, boolean force) { + Validate.notNull(url, "Resource pack URL cannot be null"); + final String hash; + if (hashBytes != null) { + Validate.isTrue(hashBytes.length == 20, "Resource pack hash should be 20 bytes long but was " + hashBytes.length); + hash = BaseEncoding.base16().lowerCase().encode(hashBytes); + } else { + hash = ""; + } + this.getHandle().sendTexturePack(url, hash, force, io.papermc.paper.adventure.PaperAdventure.asVanilla(prompt)); + } + // Paper end + public void addChannel(String channel) { Preconditions.checkState(this.channels.size() < 128, "Cannot register channel '%s'. Too many channels registered!", channel); channel = StandardMessenger.validateAndCorrectChannel(channel); @@ -2011,6 +2098,12 @@ public class CraftPlayer extends CraftHumanEntity implements Player { return (this.getHandle().clientViewDistance == null) ? Bukkit.getViewDistance() : this.getHandle().clientViewDistance; } + // Paper start + @Override + public java.util.Locale locale() { + return getHandle().adventure$locale; + } + // Paper end @Override public int getPing() { return this.getHandle().latency; @@ -2056,6 +2149,254 @@ public class CraftPlayer extends CraftHumanEntity implements Player { return this.getHandle().allowsListing(); } + // Paper start + @Override + public net.kyori.adventure.text.Component displayName() { + return this.getHandle().adventure$displayName; + } + + @Override + public void displayName(final net.kyori.adventure.text.Component displayName) { + this.getHandle().adventure$displayName = displayName != null ? displayName : net.kyori.adventure.text.Component.text(this.getName()); + this.getHandle().displayName = null; + } + + @Override + public void deleteMessage(net.kyori.adventure.chat.SignedMessage.Signature signature) { + if (getHandle().connection == null) return; + net.minecraft.network.chat.MessageSignature sig = new net.minecraft.network.chat.MessageSignature(signature.bytes()); + + this.getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundDeleteChatPacket(new net.minecraft.network.chat.MessageSignature.Packed(sig))); + } + + private net.minecraft.network.chat.ChatType.Bound toHandle(net.kyori.adventure.chat.ChatType.Bound boundChatType) { + net.minecraft.core.Registry chatTypeRegistry = this.getHandle().level.registryAccess().registryOrThrow(net.minecraft.core.registries.Registries.CHAT_TYPE); + + return new net.minecraft.network.chat.ChatType.Bound( + chatTypeRegistry.get(io.papermc.paper.adventure.PaperAdventure.asVanilla(boundChatType.type().key())), + io.papermc.paper.adventure.PaperAdventure.asVanilla(boundChatType.name()), + io.papermc.paper.adventure.PaperAdventure.asVanilla(boundChatType.target()) + ); + } + + @Override + public void sendMessage(net.kyori.adventure.text.Component message, net.kyori.adventure.chat.ChatType.Bound boundChatType) { + if (getHandle().connection == null) return; + + net.minecraft.network.chat.Component component = io.papermc.paper.adventure.PaperAdventure.asVanilla(message); + this.getHandle().sendChatMessage(new net.minecraft.network.chat.OutgoingChatMessage.Disguised(component), this.getHandle().isTextFilteringEnabled(), this.toHandle(boundChatType)); + } + + @Override + public void sendMessage(net.kyori.adventure.chat.SignedMessage signedMessage, net.kyori.adventure.chat.ChatType.Bound boundChatType) { + if (getHandle().connection == null) return; + + if (signedMessage instanceof PlayerChatMessage.AdventureView view) { + this.getHandle().sendChatMessage(net.minecraft.network.chat.OutgoingChatMessage.create(view.playerChatMessage()), this.getHandle().isTextFilteringEnabled(), this.toHandle(boundChatType)); + return; + } + net.kyori.adventure.text.Component message = signedMessage.unsignedContent() == null ? net.kyori.adventure.text.Component.text(signedMessage.message()) : signedMessage.unsignedContent(); + if (signedMessage.isSystem()) { + this.sendMessage(message, boundChatType); + } else { + super.sendMessage(signedMessage, boundChatType); + } +// net.minecraft.network.chat.PlayerChatMessage playerChatMessage = new net.minecraft.network.chat.PlayerChatMessage( +// null, // TODO: +// new net.minecraft.network.chat.MessageSignature(signedMessage.signature().bytes()), +// null, // TODO +// io.papermc.paper.adventure.PaperAdventure.asVanilla(signedMessage.unsignedContent()), +// net.minecraft.network.chat.FilterMask.PASS_THROUGH +// ); +// +// this.getHandle().sendChatMessage(net.minecraft.network.chat.OutgoingChatMessage.create(playerChatMessage), this.getHandle().isTextFilteringEnabled(), this.toHandle(boundChatType)); + } + + @Deprecated(forRemoval = true) + @Override + public void sendMessage(final net.kyori.adventure.identity.Identity identity, final net.kyori.adventure.text.Component message, final net.kyori.adventure.audience.MessageType type) { + if (getHandle().connection == null) return; + final net.minecraft.core.Registry chatTypeRegistry = this.getHandle().level.registryAccess().registryOrThrow(net.minecraft.core.registries.Registries.CHAT_TYPE); + this.getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundSystemChatPacket(message, false)); + } + + @Override + public void sendActionBar(final net.kyori.adventure.text.Component message) { + final net.minecraft.network.protocol.game.ClientboundSetActionBarTextPacket packet = new net.minecraft.network.protocol.game.ClientboundSetActionBarTextPacket((net.minecraft.network.chat.Component) null); + packet.adventure$text = message; + this.getHandle().connection.send(packet); + } + + @Override + public void sendPlayerListHeader(final net.kyori.adventure.text.Component header) { + this.playerListHeader = header; + this.adventure$sendPlayerListHeaderAndFooter(); + } + + @Override + public void sendPlayerListFooter(final net.kyori.adventure.text.Component footer) { + this.playerListFooter = footer; + this.adventure$sendPlayerListHeaderAndFooter(); + } + + @Override + public void sendPlayerListHeaderAndFooter(final net.kyori.adventure.text.Component header, final net.kyori.adventure.text.Component footer) { + this.playerListHeader = header; + this.playerListFooter = footer; + this.adventure$sendPlayerListHeaderAndFooter(); + } + + private void adventure$sendPlayerListHeaderAndFooter() { + final ServerGamePacketListenerImpl connection = this.getHandle().connection; + if (connection == null) return; + final ClientboundTabListPacket packet = new ClientboundTabListPacket(null, null); + packet.adventure$header = (this.playerListHeader == null) ? net.kyori.adventure.text.Component.empty() : this.playerListHeader; + packet.adventure$footer = (this.playerListFooter == null) ? net.kyori.adventure.text.Component.empty() : this.playerListFooter; + connection.send(packet); + } + + @Override + public void showTitle(final net.kyori.adventure.title.Title title) { + final ServerGamePacketListenerImpl connection = this.getHandle().connection; + final net.kyori.adventure.title.Title.Times times = title.times(); + if (times != null) { + connection.send(new ClientboundSetTitlesAnimationPacket(ticks(times.fadeIn()), ticks(times.stay()), ticks(times.fadeOut()))); + } + final ClientboundSetSubtitleTextPacket sp = new ClientboundSetSubtitleTextPacket((net.minecraft.network.chat.Component) null); + sp.adventure$text = title.subtitle(); + connection.send(sp); + final ClientboundSetTitleTextPacket tp = new ClientboundSetTitleTextPacket((net.minecraft.network.chat.Component) null); + tp.adventure$text = title.title(); + connection.send(tp); + } + + @Override + public void sendTitlePart(final net.kyori.adventure.title.TitlePart part, T value) { + java.util.Objects.requireNonNull(part, "part"); + java.util.Objects.requireNonNull(value, "value"); + if (part == net.kyori.adventure.title.TitlePart.TITLE) { + final ClientboundSetTitleTextPacket tp = new ClientboundSetTitleTextPacket((net.minecraft.network.chat.Component) null); + tp.adventure$text = (net.kyori.adventure.text.Component) value; + this.getHandle().connection.send(tp); + } else if (part == net.kyori.adventure.title.TitlePart.SUBTITLE) { + final ClientboundSetSubtitleTextPacket sp = new ClientboundSetSubtitleTextPacket((net.minecraft.network.chat.Component) null); + sp.adventure$text = (net.kyori.adventure.text.Component) value; + this.getHandle().connection.send(sp); + } else if (part == net.kyori.adventure.title.TitlePart.TIMES) { + final net.kyori.adventure.title.Title.Times times = (net.kyori.adventure.title.Title.Times) value; + this.getHandle().connection.send(new ClientboundSetTitlesAnimationPacket(ticks(times.fadeIn()), ticks(times.stay()), ticks(times.fadeOut()))); + } else { + throw new IllegalArgumentException("Unknown TitlePart"); + } + } + + private static int ticks(final java.time.Duration duration) { + if (duration == null) { + return -1; + } + return (int) (duration.toMillis() / 50L); + } + + @Override + public void clearTitle() { + this.getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundClearTitlesPacket(false)); + } + + // resetTitle implemented above + + @Override + public void showBossBar(final net.kyori.adventure.bossbar.BossBar bar) { + ((net.kyori.adventure.bossbar.HackyBossBarPlatformBridge) bar).paper$playerShow(this); + } + + @Override + public void hideBossBar(final net.kyori.adventure.bossbar.BossBar bar) { + ((net.kyori.adventure.bossbar.HackyBossBarPlatformBridge) bar).paper$playerHide(this); + } + + @Override + public void playSound(final net.kyori.adventure.sound.Sound sound) { + final Vec3 pos = this.getHandle().position(); + this.playSound(sound, pos.x, pos.y, pos.z); + } + + @Override + public void playSound(final net.kyori.adventure.sound.Sound sound, final double x, final double y, final double z) { + final long seed = sound.seed().orElseGet(this.getHandle().getRandom()::nextLong); + final ResourceLocation name = io.papermc.paper.adventure.PaperAdventure.asVanilla(sound.name()); + final java.util.Optional event = BuiltInRegistries.SOUND_EVENT.getOptional(name); + + final Holder soundHolder; + if (event.isPresent()) { + soundHolder = BuiltInRegistries.SOUND_EVENT.wrapAsHolder(event.get()); + } else { + soundHolder = Holder.direct(SoundEvent.createVariableRangeEvent(name)); + } + + this.getHandle().connection.send(new ClientboundSoundPacket(soundHolder, io.papermc.paper.adventure.PaperAdventure.asVanilla(sound.source()), x, y, z, sound.volume(), sound.pitch(), seed)); + } + + @Override + public void playSound(final net.kyori.adventure.sound.Sound sound, final net.kyori.adventure.sound.Sound.Emitter emitter) { + final Entity entity; + if (emitter == net.kyori.adventure.sound.Sound.Emitter.self()) { + entity = this.getHandle(); + } else if (emitter instanceof org.bukkit.entity.Entity) { + entity = ((CraftEntity) emitter).getHandle(); + } else { + throw new IllegalArgumentException("Sound emitter must be an Entity or self(), but was: " + emitter); + } + final long seed = sound.seed().orElseGet(this.getHandle().getRandom()::nextLong); + + final ResourceLocation name = io.papermc.paper.adventure.PaperAdventure.asVanilla(sound.name()); + final java.util.Optional event = BuiltInRegistries.SOUND_EVENT.getOptional(name); + final Holder soundHolder; + if (event.isPresent()) { + soundHolder = BuiltInRegistries.SOUND_EVENT.wrapAsHolder(event.get()); + } else { + soundHolder = Holder.direct(SoundEvent.createVariableRangeEvent(name)); + } + + this.getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundSoundEntityPacket(soundHolder, io.papermc.paper.adventure.PaperAdventure.asVanilla(sound.source()), entity, sound.volume(), sound.pitch(), seed)); + } + + @Override + public void stopSound(final net.kyori.adventure.sound.SoundStop stop) { + this.getHandle().connection.send(new ClientboundStopSoundPacket( + io.papermc.paper.adventure.PaperAdventure.asVanillaNullable(stop.sound()), + io.papermc.paper.adventure.PaperAdventure.asVanillaNullable(stop.source()) + )); + } + + @Override + public void openBook(final net.kyori.adventure.inventory.Book book) { + final java.util.Locale locale = this.getHandle().adventure$locale; + final net.minecraft.world.item.ItemStack item = io.papermc.paper.adventure.PaperAdventure.asItemStack(book, locale); + final ServerPlayer player = this.getHandle(); + final ServerGamePacketListenerImpl connection = player.connection; + final net.minecraft.world.entity.player.Inventory inventory = player.getInventory(); + final int slot = inventory.items.size() + inventory.selected; + final int stateId = getHandle().containerMenu.getStateId(); + connection.send(new net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket(0, stateId, slot, item)); + connection.send(new net.minecraft.network.protocol.game.ClientboundOpenBookPacket(net.minecraft.world.InteractionHand.MAIN_HAND)); + connection.send(new net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket(0, stateId, slot, inventory.getSelected())); + } + + @Override + public net.kyori.adventure.pointer.Pointers pointers() { + if (this.adventure$pointers == null) { + this.adventure$pointers = net.kyori.adventure.pointer.Pointers.builder() + .withDynamic(net.kyori.adventure.identity.Identity.DISPLAY_NAME, this::displayName) + .withDynamic(net.kyori.adventure.identity.Identity.NAME, this::getName) + .withDynamic(net.kyori.adventure.identity.Identity.UUID, this::getUniqueId) + .withStatic(net.kyori.adventure.permission.PermissionChecker.POINTER, this::permissionValue) + .withDynamic(net.kyori.adventure.identity.Identity.LOCALE, this::locale) + .build(); + } + + return this.adventure$pointers; + } + // Paper end // Spigot start private final Player.Spigot spigot = new Player.Spigot() { diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftTextDisplay.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftTextDisplay.java index b7f54a7d90a2a34e641f152eb8f5c3c62033e511..2d04443a9efd6e4b5eb1e360a727d8492323724b 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftTextDisplay.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftTextDisplay.java @@ -38,6 +38,17 @@ public class CraftTextDisplay extends CraftDisplay implements TextDisplay { public void setText(String text) { this.getHandle().setText(CraftChatMessage.fromString(text, true)[0]); } + // Paper start + @Override + public net.kyori.adventure.text.Component text() { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(this.getHandle().getText()); + } + + @Override + public void text(net.kyori.adventure.text.Component text) { + this.getHandle().setText(text == null ? net.minecraft.network.chat.Component.empty() : io.papermc.paper.adventure.PaperAdventure.asVanilla(text)); + } + // Paper end @Override public int getLineWidth() { diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java index f9499aa8fc5443b54617c8e84011af5d0325bd45..2c3518ea974be5fce424093e9b710c853fd52a7a 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java @@ -820,9 +820,9 @@ public class CraftEventFactory { return event; } - public static PlayerDeathEvent callPlayerDeathEvent(ServerPlayer victim, List drops, String deathMessage, boolean keepInventory) { + public static PlayerDeathEvent callPlayerDeathEvent(ServerPlayer victim, List drops, net.kyori.adventure.text.Component deathMessage, String stringDeathMessage, boolean keepInventory) { // Paper - Adventure CraftPlayer entity = victim.getBukkitEntity(); - PlayerDeathEvent event = new PlayerDeathEvent(entity, drops, victim.getExpReward(), 0, deathMessage); + PlayerDeathEvent event = new PlayerDeathEvent(entity, drops, victim.getExpReward(), 0, deathMessage, stringDeathMessage); // Paper - Adventure event.setKeepInventory(keepInventory); event.setKeepLevel(victim.keepLevel); // SPIGOT-2222: pre-set keepLevel org.bukkit.World world = entity.getWorld(); @@ -847,7 +847,7 @@ public class CraftEventFactory { * Server methods */ public static ServerListPingEvent callServerListPingEvent(Server craftServer, InetAddress address, String motd, int numPlayers, int maxPlayers) { - ServerListPingEvent event = new ServerListPingEvent("", address, motd, numPlayers, maxPlayers); + ServerListPingEvent event = new ServerListPingEvent("", address, craftServer.motd(), numPlayers, maxPlayers); // Paper - Adventure craftServer.getPluginManager().callEvent(event); return event; } diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java index a94bfca34ba87976a51c5572250059d393041f38..7d0d2cd4d34d6652eb45aa13442e1081a3a6bd56 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java @@ -68,6 +68,13 @@ public class CraftContainer extends AbstractContainerMenu { return inventory.getType(); } + // Paper start + @Override + public net.kyori.adventure.text.Component title() { + return inventory instanceof CraftInventoryCustom ? ((CraftInventoryCustom.MinecraftInventory) ((CraftInventory) inventory).getInventory()).title() : net.kyori.adventure.text.Component.text(inventory.getType().getDefaultTitle()); + } + // Paper end + @Override public String getTitle() { return inventory instanceof CraftInventoryCustom ? ((CraftInventoryCustom.MinecraftInventory) ((CraftInventory) inventory).getInventory()).getTitle() : inventory.getType().getDefaultTitle(); diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java index 6486a76466691f958349a4706d7c9caff9cb8f64..f3ebaefd949ae73afad3dcb69b8d9c632cc782f7 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java @@ -19,6 +19,12 @@ public class CraftInventoryCustom extends CraftInventory { super(new MinecraftInventory(owner, type)); } + // Paper start + public CraftInventoryCustom(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) { + super(new MinecraftInventory(owner, type, title)); + } + // Paper end + public CraftInventoryCustom(InventoryHolder owner, InventoryType type, String title) { super(new MinecraftInventory(owner, type, title)); } @@ -27,6 +33,12 @@ public class CraftInventoryCustom extends CraftInventory { super(new MinecraftInventory(owner, size)); } + // Paper start + public CraftInventoryCustom(InventoryHolder owner, int size, net.kyori.adventure.text.Component title) { + super(new MinecraftInventory(owner, size, title)); + } + // Paper end + public CraftInventoryCustom(InventoryHolder owner, int size, String title) { super(new MinecraftInventory(owner, size, title)); } @@ -36,9 +48,17 @@ public class CraftInventoryCustom extends CraftInventory { private int maxStack = MAX_STACK; private final List viewers; private final String title; + private final net.kyori.adventure.text.Component adventure$title; // Paper private InventoryType type; private final InventoryHolder owner; + // Paper start + public MinecraftInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) { + this(owner, type.getDefaultSize(), title); + this.type = type; + } + // Paper end + public MinecraftInventory(InventoryHolder owner, InventoryType type) { this(owner, type.getDefaultSize(), type.getDefaultTitle()); this.type = type; @@ -57,11 +77,24 @@ public class CraftInventoryCustom extends CraftInventory { Validate.notNull(title, "Title cannot be null"); this.items = NonNullList.withSize(size, ItemStack.EMPTY); this.title = title; + this.adventure$title = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(title); this.viewers = new ArrayList(); this.owner = owner; this.type = InventoryType.CHEST; } + // Paper start + public MinecraftInventory(final InventoryHolder owner, final int size, final net.kyori.adventure.text.Component title) { + Validate.notNull(title, "Title cannot be null"); + this.items = NonNullList.withSize(size, ItemStack.EMPTY); + this.title = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(title); + this.adventure$title = title; + this.viewers = new ArrayList(); + this.owner = owner; + this.type = InventoryType.CHEST; + } + // Paper end + @Override public int getContainerSize() { return this.items.size(); @@ -183,6 +216,12 @@ public class CraftInventoryCustom extends CraftInventory { return null; } + // Paper start + public net.kyori.adventure.text.Component title() { + return this.adventure$title; + } + // Paper end + public String getTitle() { return this.title; } diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryView.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryView.java index 6a64fbb8b4937f39d5fdc2e2cbec26c83c74c486..7d6b5fdb00a5c1614849735634262a36a4efbd66 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryView.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryView.java @@ -64,6 +64,13 @@ public class CraftInventoryView extends InventoryView { return CraftItemStack.asCraftMirror(this.container.getSlot(slot).getItem()); } + // Paper start + @Override + public net.kyori.adventure.text.Component title() { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(this.container.getTitle()); + } + // Paper end + @Override public String getTitle() { return CraftChatMessage.fromComponent(this.container.getTitle()); diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java index a7ef4a04358df3f848ace0e6e8b6f2d0a18dbc29..4c76692e222d8505558aade9c03b3686612f7c0c 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java @@ -417,4 +417,17 @@ public final class CraftItemFactory implements ItemFactory { public Material updateMaterial(ItemMeta meta, Material material) throws IllegalArgumentException { return ((CraftMetaItem) meta).updateMaterial(material); } + + // Paper start + @Override + public net.kyori.adventure.text.event.HoverEvent asHoverEvent(final ItemStack item, final java.util.function.UnaryOperator op) { + final net.minecraft.nbt.CompoundTag tag = CraftItemStack.asNMSCopy(item).getTag(); + return net.kyori.adventure.text.event.HoverEvent.showItem(op.apply(net.kyori.adventure.text.event.HoverEvent.ShowItem.of(item.getType().getKey(), item.getAmount(), io.papermc.paper.adventure.PaperAdventure.asBinaryTagHolder(tag)))); + } + + @Override + public net.kyori.adventure.text.@org.jetbrains.annotations.NotNull Component displayName(@org.jetbrains.annotations.NotNull ItemStack itemStack) { + return io.papermc.paper.adventure.PaperAdventure.asAdventure(CraftItemStack.asNMSCopy(itemStack).getDisplayName()); + } + // Paper end } diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantCustom.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantCustom.java index a0334ec0a80dfc4f1e68c2e338aa486faaefb29e..257776a12ca26c1e75be22a67c94b0aa012fd687 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantCustom.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantCustom.java @@ -13,10 +13,17 @@ import org.bukkit.craftbukkit.util.CraftChatMessage; public class CraftMerchantCustom extends CraftMerchant { + @Deprecated // Paper - Adventure public CraftMerchantCustom(String title) { super(new MinecraftMerchant(title)); this.getMerchant().craftMerchant = this; } + // Paper start + public CraftMerchantCustom(net.kyori.adventure.text.Component title) { + super(new MinecraftMerchant(title)); + getMerchant().craftMerchant = this; + } + // Paper end @Override public String toString() { @@ -35,10 +42,17 @@ public class CraftMerchantCustom extends CraftMerchant { private Player tradingPlayer; protected CraftMerchant craftMerchant; + @Deprecated // Paper - Adventure public MinecraftMerchant(String title) { Validate.notNull(title, "Title cannot be null"); this.title = CraftChatMessage.fromString(title)[0]; } + // Paper start + public MinecraftMerchant(net.kyori.adventure.text.Component title) { + Validate.notNull(title, "Title cannot be null"); + this.title = io.papermc.paper.adventure.PaperAdventure.asVanilla(title); + } + // Paper end @Override public CraftMerchant getCraftMerchant() { diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBook.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBook.java index 4154b4489be172f1ef1693b54368b7ffc8629c31..e8413ad360e9b6c4eef13edf9dd0095e7e64bce2 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBook.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBook.java @@ -1,8 +1,9 @@ package org.bukkit.craftbukkit.inventory; import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableMap.Builder; import com.google.common.collect.Lists; + +import com.google.common.collect.ImmutableMap; // Paper import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -261,6 +262,145 @@ public class CraftMetaBook extends CraftMetaItem implements BookMeta { this.generation = (generation == null) ? null : generation.ordinal(); } + // Paper start + @Override + public net.kyori.adventure.text.Component title() { + return this.title == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(this.title); + } + + @Override + public org.bukkit.inventory.meta.BookMeta title(net.kyori.adventure.text.Component title) { + this.setTitle(title == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(title)); + return this; + } + + @Override + public net.kyori.adventure.text.Component author() { + return this.author == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(this.author); + } + + @Override + public org.bukkit.inventory.meta.BookMeta author(net.kyori.adventure.text.Component author) { + this.setAuthor(author == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(author)); + return this; + } + + @Override + public net.kyori.adventure.text.Component page(final int page) { + Validate.isTrue(isValidPage(page), "Invalid page number"); + return this instanceof CraftMetaBookSigned ? net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson().deserialize(pages.get(page - 1)) : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(pages.get(page - 1)); + } + + @Override + public void page(final int page, net.kyori.adventure.text.Component data) { + if (!isValidPage(page)) { + throw new IllegalArgumentException("Invalid page number " + page + "/" + pages.size()); + } + if (data == null) { + data = net.kyori.adventure.text.Component.empty(); + } + pages.set(page - 1, this instanceof CraftMetaBookSigned ? net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson().serialize(data) : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(data)); + } + + @Override + public List pages() { + if (this.pages == null) return ImmutableList.of(); + if (this instanceof CraftMetaBookSigned) + return pages.stream().map(net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson()::deserialize).collect(ImmutableList.toImmutableList()); + else + return pages.stream().map(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection()::deserialize).collect(ImmutableList.toImmutableList()); + } + + @Override + public BookMeta pages(List pages) { + if (this.pages != null) this.pages.clear(); + for (net.kyori.adventure.text.Component page : pages) { + addPages(page); + } + return this; + } + + @Override + public BookMeta pages(net.kyori.adventure.text.Component... pages) { + if (this.pages != null) this.pages.clear(); + addPages(pages); + return this; + } + + @Override + public void addPages(net.kyori.adventure.text.Component... pages) { + if (this.pages == null) this.pages = new ArrayList<>(); + for (net.kyori.adventure.text.Component page : pages) { + if (this.pages.size() >= MAX_PAGES) { + return; + } + + if (page == null) { + page = net.kyori.adventure.text.Component.empty(); + } + + this.pages.add(this instanceof CraftMetaBookSigned ? net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson().serialize(page) : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(page)); + } + } + + private CraftMetaBook(net.kyori.adventure.text.Component title, net.kyori.adventure.text.Component author, List pages) { + super((org.bukkit.craftbukkit.inventory.CraftMetaItem) org.bukkit.Bukkit.getItemFactory().getItemMeta(org.bukkit.Material.WRITABLE_BOOK)); + this.title = title == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(title); + this.author = author == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(author); + this.pages = pages.subList(0, Math.min(MAX_PAGES, pages.size())).stream().map(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection()::serialize).collect(java.util.stream.Collectors.toList()); + } + + static class CraftMetaBookBuilder implements BookMetaBuilder { + private net.kyori.adventure.text.Component title = null; + private net.kyori.adventure.text.Component author = null; + private final List pages = new java.util.ArrayList<>(); + + @Override + public BookMetaBuilder title(net.kyori.adventure.text.Component title) { + this.title = title; + return this; + } + + @Override + public BookMetaBuilder author(net.kyori.adventure.text.Component author) { + this.author = author; + return this; + } + + @Override + public BookMetaBuilder addPage(net.kyori.adventure.text.Component page) { + this.pages.add(page); + return this; + } + + @Override + public BookMetaBuilder pages(net.kyori.adventure.text.Component... pages) { + java.util.Collections.addAll(this.pages, pages); + return this; + } + + @Override + public BookMetaBuilder pages(java.util.Collection pages) { + this.pages.addAll(pages); + return this; + } + + @Override + public BookMeta build() { + return this.build(title, author, pages); + } + + protected BookMeta build(net.kyori.adventure.text.Component title, net.kyori.adventure.text.Component author, java.util.List pages) { + return new CraftMetaBook(title, author, pages); + } + } + + @Override + public BookMetaBuilder toBuilder() { + return new CraftMetaBookBuilder(); + } + + // Paper end @Override public String getPage(final int page) { Validate.isTrue(this.isValidPage(page), "Invalid page number"); @@ -405,7 +545,7 @@ public class CraftMetaBook extends CraftMetaItem implements BookMeta { } @Override - Builder serialize(Builder builder) { + ImmutableMap.Builder serialize(ImmutableMap.Builder builder) { super.serialize(builder); if (this.hasTitle()) { diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBookSigned.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBookSigned.java index 507fa96a3fb904b74429df5756c9a6378ec8c5b7..abb9e88abc74135284b941e040d4058690a82b27 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBookSigned.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBookSigned.java @@ -1,6 +1,6 @@ package org.bukkit.craftbukkit.inventory; -import com.google.common.collect.ImmutableMap.Builder; +import com.google.common.collect.ImmutableMap; // Paper import java.util.Map; import net.minecraft.nbt.CompoundTag; import org.bukkit.Material; @@ -78,8 +78,29 @@ class CraftMetaBookSigned extends CraftMetaBook implements BookMeta { } @Override - Builder serialize(Builder builder) { + ImmutableMap.Builder serialize(ImmutableMap.Builder builder) { super.serialize(builder); return builder; } + + // Paper start - adventure + private CraftMetaBookSigned(net.kyori.adventure.text.Component title, net.kyori.adventure.text.Component author, java.util.List pages) { + super((org.bukkit.craftbukkit.inventory.CraftMetaItem) org.bukkit.Bukkit.getItemFactory().getItemMeta(Material.WRITABLE_BOOK)); + this.title = title == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(title); + this.author = author == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(author); + this.pages = io.papermc.paper.adventure.PaperAdventure.asJson(pages.subList(0, Math.min(MAX_PAGES, pages.size()))); + } + + static final class CraftMetaBookSignedBuilder extends CraftMetaBookBuilder { + @Override + protected BookMeta build(net.kyori.adventure.text.Component title, net.kyori.adventure.text.Component author, java.util.List pages) { + return new CraftMetaBookSigned(title, author, pages); + } + } + + @Override + public BookMetaBuilder toBuilder() { + return new CraftMetaBookSignedBuilder(); + } + // Paper end } diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java index 8ed06dc812fbda72667352fa42c03f9d9ae7ca7e..78029398774f1060e3522e4613259be894d68c22 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java @@ -747,6 +747,18 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { return !(this.hasDisplayName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isUnbreakable() || this.hasDamage() || this.hasAttributeModifiers()); } + // Paper start + @Override + public net.kyori.adventure.text.Component displayName() { + return displayName == null ? null : net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson().deserialize(displayName); + } + + @Override + public void displayName(final net.kyori.adventure.text.Component displayName) { + this.displayName = displayName == null ? null : net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson().serialize(displayName); + } + // Paper end + @Override public String getDisplayName() { return CraftChatMessage.fromJSONComponent(displayName); @@ -782,6 +794,18 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { return this.lore != null && !this.lore.isEmpty(); } + // Paper start + @Override + public List lore() { + return this.lore != null ? io.papermc.paper.adventure.PaperAdventure.asAdventureFromJson(this.lore) : null; + } + + @Override + public void lore(final List lore) { + this.lore = lore != null ? io.papermc.paper.adventure.PaperAdventure.asJson(lore) : null; + } + // Paper end + @Override public boolean hasRepairCost() { return this.repairCost > 0; diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftCustomInventoryConverter.java b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftCustomInventoryConverter.java index ed4415f6dd588c08c922efd5beebb3b124beb9d6..78a7ac47f20e84ccd67ff44d0bc7a2f2faa0d476 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftCustomInventoryConverter.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftCustomInventoryConverter.java @@ -12,6 +12,13 @@ public class CraftCustomInventoryConverter implements CraftInventoryCreator.Inve return new CraftInventoryCustom(holder, type); } + // Paper start + @Override + public Inventory createInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) { + return new CraftInventoryCustom(owner, type, title); + } + // Paper end + @Override public Inventory createInventory(InventoryHolder owner, InventoryType type, String title) { return new CraftInventoryCustom(owner, type, title); @@ -21,6 +28,12 @@ public class CraftCustomInventoryConverter implements CraftInventoryCreator.Inve return new CraftInventoryCustom(owner, size); } + // Paper start + public Inventory createInventory(InventoryHolder owner, int size, net.kyori.adventure.text.Component title) { + return new CraftInventoryCustom(owner, size, title); + } + // Paper end + public Inventory createInventory(InventoryHolder owner, int size, String title) { return new CraftInventoryCustom(owner, size, title); } diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftInventoryCreator.java b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftInventoryCreator.java index e69d5635d1c81a3bed54d2cb1b0316efb522ab5d..d09fc01a20e8426f4094899060c70e011ff65887 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftInventoryCreator.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftInventoryCreator.java @@ -44,6 +44,12 @@ public final class CraftInventoryCreator { return this.converterMap.get(type).createInventory(holder, type); } + // Paper start + public Inventory createInventory(InventoryHolder holder, InventoryType type, net.kyori.adventure.text.Component title) { + return converterMap.get(type).createInventory(holder, type, title); + } + // Paper end + public Inventory createInventory(InventoryHolder holder, InventoryType type, String title) { return this.converterMap.get(type).createInventory(holder, type, title); } @@ -52,6 +58,12 @@ public final class CraftInventoryCreator { return this.DEFAULT_CONVERTER.createInventory(holder, size); } + // Paper start + public Inventory createInventory(InventoryHolder holder, int size, net.kyori.adventure.text.Component title) { + return DEFAULT_CONVERTER.createInventory(holder, size, title); + } + // Paper end + public Inventory createInventory(InventoryHolder holder, int size, String title) { return this.DEFAULT_CONVERTER.createInventory(holder, size, title); } @@ -60,6 +72,10 @@ public final class CraftInventoryCreator { Inventory createInventory(InventoryHolder holder, InventoryType type); + // Paper start + Inventory createInventory(InventoryHolder holder, InventoryType type, net.kyori.adventure.text.Component title); + // Paper end + Inventory createInventory(InventoryHolder holder, InventoryType type, String title); } } diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java index 1980240d3dc0331ddf2ff56e163e2bfbd3b231ab..7a7f3f53aef601f124d474d9890e23d87dd96900 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java @@ -31,6 +31,18 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat return this.getInventory(this.getTileEntity()); } + // Paper start + @Override + public Inventory createInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) { + Container te = getTileEntity(); + if (te instanceof RandomizableContainerBlockEntity) { + ((RandomizableContainerBlockEntity) te).setCustomName(io.papermc.paper.adventure.PaperAdventure.asVanilla(title)); + } + + return getInventory(te); + } + // Paper end + @Override public Inventory createInventory(InventoryHolder holder, InventoryType type, String title) { Container te = this.getTileEntity(); @@ -53,6 +65,15 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat return furnace; } + // Paper start + @Override + public Inventory createInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) { + Container tileEntity = getTileEntity(); + ((AbstractFurnaceBlockEntity) tileEntity).setCustomName(io.papermc.paper.adventure.PaperAdventure.asVanilla(title)); + return getInventory(tileEntity); + } + // Paper end + @Override public Inventory createInventory(InventoryHolder owner, InventoryType type, String title) { Container tileEntity = this.getTileEntity(); @@ -73,6 +94,18 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat return new BrewingStandBlockEntity(BlockPos.ZERO, Blocks.BREWING_STAND.defaultBlockState()); } + // Paper start + @Override + public Inventory createInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) { + // BrewingStand does not extend TileEntityLootable + Container tileEntity = getTileEntity(); + if (tileEntity instanceof BrewingStandBlockEntity) { + ((BrewingStandBlockEntity) tileEntity).setCustomName(io.papermc.paper.adventure.PaperAdventure.asVanilla(title)); + } + return getInventory(tileEntity); + } + // Paper end + @Override public Inventory createInventory(InventoryHolder holder, InventoryType type, String title) { // BrewingStand does not extend TileEntityLootable diff --git a/src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java b/src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java index b47f18b1e448807a17ca9f2ae9609680233da837..9683d7d103af66fffd68c11abc38fb4fd2f99482 100644 --- a/src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java +++ b/src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java @@ -42,7 +42,7 @@ public class CraftMapRenderer extends MapRenderer { } MapDecoration decoration = worldMap.decorations.get(key); - cursors.addCursor(decoration.getX(), decoration.getY(), (byte) (decoration.getRot() & 15), decoration.getType().getIcon(), true, CraftChatMessage.fromComponent(decoration.getName())); + cursors.addCursor(decoration.getX(), decoration.getY(), (byte) (decoration.getRot() & 15), decoration.getType().getIcon(), true, decoration.getName() == null ? null : io.papermc.paper.adventure.PaperAdventure.asAdventure(decoration.getName())); // Paper } } diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftObjective.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftObjective.java index 0d25c7c03f7ac21a4b21bb95b5bd921c43430cf9..b7f0277b50a0f45c32b818bf9fe1218874aa8533 100644 --- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftObjective.java +++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftObjective.java @@ -31,6 +31,21 @@ final class CraftObjective extends CraftScoreboardComponent implements Objective return this.objective.getName(); } + // Paper start + @Override + public net.kyori.adventure.text.Component displayName() throws IllegalStateException { + CraftScoreboard scoreboard = checkState(); + return io.papermc.paper.adventure.PaperAdventure.asAdventure(objective.getDisplayName()); + } + @Override + public void displayName(net.kyori.adventure.text.Component displayName) throws IllegalStateException, IllegalArgumentException { + if (displayName == null) { + displayName = net.kyori.adventure.text.Component.empty(); + } + CraftScoreboard scoreboard = checkState(); + objective.setDisplayName(io.papermc.paper.adventure.PaperAdventure.asVanilla(displayName)); + } + // Paper end @Override public String getDisplayName() throws IllegalStateException { CraftScoreboard scoreboard = this.checkState(); diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboard.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboard.java index c624867e28dd5187d58a6bcb9067b0c10ff7e733..f367261b119ab48c1d17b2b6552cce481c6effbb 100644 --- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboard.java +++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboard.java @@ -28,6 +28,34 @@ public final class CraftScoreboard implements org.bukkit.scoreboard.Scoreboard { public CraftObjective registerNewObjective(String name, String criteria) throws IllegalArgumentException { return this.registerNewObjective(name, criteria, name); } + // Paper start + @Override + public CraftObjective registerNewObjective(String name, String criteria, net.kyori.adventure.text.Component displayName) { + return registerNewObjective(name, CraftCriteria.getFromBukkit(criteria), displayName, RenderType.INTEGER); + } + @Override + public CraftObjective registerNewObjective(String name, String criteria, net.kyori.adventure.text.Component displayName, RenderType renderType) { + return registerNewObjective(name, CraftCriteria.getFromBukkit(criteria), displayName, renderType); + } + @Override + public CraftObjective registerNewObjective(String name, Criteria criteria, net.kyori.adventure.text.Component displayName) throws IllegalArgumentException { + return registerNewObjective(name, criteria, displayName, RenderType.INTEGER); + } + @Override + public CraftObjective registerNewObjective(String name, Criteria criteria, net.kyori.adventure.text.Component displayName, RenderType renderType) throws IllegalArgumentException { + if (displayName == null) { + displayName = net.kyori.adventure.text.Component.empty(); + } + Validate.notNull(name, "Objective name cannot be null"); + Validate.notNull(criteria, "Criteria cannot be null"); + Validate.notNull(displayName, "Display name cannot be null"); + Validate.notNull(renderType, "RenderType cannot be null"); + Validate.isTrue(name.length() <= Short.MAX_VALUE, "The name '" + name + "' is longer than the limit of 32767 characters"); + Validate.isTrue(board.getObjective(name) == null, "An objective of name '" + name + "' already exists"); + net.minecraft.world.scores.Objective objective = board.addObjective(name, ((CraftCriteria) criteria).criteria, io.papermc.paper.adventure.PaperAdventure.asVanilla(displayName), CraftScoreboardTranslations.fromBukkitRender(renderType)); + return new CraftObjective(this, objective); + } + // Paper end @Override public CraftObjective registerNewObjective(String name, String criteria, String displayName) throws IllegalArgumentException { @@ -46,16 +74,7 @@ public final class CraftScoreboard implements org.bukkit.scoreboard.Scoreboard { @Override public CraftObjective registerNewObjective(String name, Criteria criteria, String displayName, RenderType renderType) throws IllegalArgumentException { - Validate.notNull(name, "Objective name cannot be null"); - Validate.notNull(criteria, "Criteria cannot be null"); - Validate.notNull(displayName, "Display name cannot be null"); - Validate.notNull(renderType, "RenderType cannot be null"); - Validate.isTrue(name.length() <= Short.MAX_VALUE, "The name '" + name + "' is longer than the limit of 32767 characters"); - Validate.isTrue(displayName.length() <= 128, "The display name '" + displayName + "' is longer than the limit of 128 characters"); - Validate.isTrue(this.board.getObjective(name) == null, "An objective of name '" + name + "' already exists"); - - net.minecraft.world.scores.Objective objective = this.board.addObjective(name, ((CraftCriteria) criteria).criteria, CraftChatMessage.fromStringOrNull(displayName), CraftScoreboardTranslations.fromBukkitRender(renderType)); - return new CraftObjective(this, objective); + return registerNewObjective(name, criteria, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(displayName), renderType); // Paper } @Override diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java index 81f16dc1ed6e102af298600db75cab21a09bc00f..18d5a26c34c848241c306241b3ad9825b5a0b9a9 100644 --- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java +++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java @@ -28,6 +28,63 @@ final class CraftTeam extends CraftScoreboardComponent implements Team { return this.team.getName(); } + // Paper start + @Override + public net.kyori.adventure.text.Component displayName() throws IllegalStateException { + CraftScoreboard scoreboard = checkState(); + return io.papermc.paper.adventure.PaperAdventure.asAdventure(team.getDisplayName()); + } + @Override + public void displayName(net.kyori.adventure.text.Component displayName) throws IllegalStateException, IllegalArgumentException { + if (displayName == null) displayName = net.kyori.adventure.text.Component.empty(); + CraftScoreboard scoreboard = checkState(); + team.setDisplayName(io.papermc.paper.adventure.PaperAdventure.asVanilla(displayName)); + } + @Override + public net.kyori.adventure.text.Component prefix() throws IllegalStateException { + CraftScoreboard scoreboard = checkState(); + return io.papermc.paper.adventure.PaperAdventure.asAdventure(team.getPlayerPrefix()); + } + @Override + public void prefix(net.kyori.adventure.text.Component prefix) throws IllegalStateException, IllegalArgumentException { + if (prefix == null) prefix = net.kyori.adventure.text.Component.empty(); + CraftScoreboard scoreboard = checkState(); + team.setPlayerPrefix(io.papermc.paper.adventure.PaperAdventure.asVanilla(prefix)); + } + @Override + public net.kyori.adventure.text.Component suffix() throws IllegalStateException { + CraftScoreboard scoreboard = checkState(); + return io.papermc.paper.adventure.PaperAdventure.asAdventure(team.getPlayerSuffix()); + } + @Override + public void suffix(net.kyori.adventure.text.Component suffix) throws IllegalStateException, IllegalArgumentException { + if (suffix == null) suffix = net.kyori.adventure.text.Component.empty(); + CraftScoreboard scoreboard = checkState(); + team.setPlayerSuffix(io.papermc.paper.adventure.PaperAdventure.asVanilla(suffix)); + } + @Override + public boolean hasColor() { + CraftScoreboard scoreboard = checkState(); + return this.team.getColor().getColor() != null; + } + @Override + public net.kyori.adventure.text.format.TextColor color() throws IllegalStateException { + CraftScoreboard scoreboard = checkState(); + if (team.getColor().getColor() == null) throw new IllegalStateException("Team colors must have hex values"); + net.kyori.adventure.text.format.TextColor color = net.kyori.adventure.text.format.TextColor.color(team.getColor().getColor()); + if (!(color instanceof net.kyori.adventure.text.format.NamedTextColor)) throw new IllegalStateException("Team doesn't have a NamedTextColor"); + return (net.kyori.adventure.text.format.NamedTextColor) color; + } + @Override + public void color(net.kyori.adventure.text.format.NamedTextColor color) { + CraftScoreboard scoreboard = checkState(); + if (color == null) { + this.team.setColor(net.minecraft.ChatFormatting.RESET); + } else { + this.team.setColor(io.papermc.paper.adventure.PaperAdventure.asVanilla(color)); + } + } + // Paper end @Override public String getDisplayName() throws IllegalStateException { diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftChatMessage.java b/src/main/java/org/bukkit/craftbukkit/util/CraftChatMessage.java index 78ea79b66cc9e90402ef5cdc2e5e04e0c74b1c26..4fede2161792ba3e7cdf0cc5a1f533188becc6f7 100644 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftChatMessage.java +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftChatMessage.java @@ -291,6 +291,7 @@ public final class CraftChatMessage { public static String fromComponent(Component component) { if (component == null) return ""; + if (component instanceof io.papermc.paper.adventure.AdventureComponent) component = ((io.papermc.paper.adventure.AdventureComponent) component).deepConverted(); StringBuilder out = new StringBuilder(); boolean hadFormat = false; diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java index eff182a54cbb84693d6cad96b51f743b08049b43..91cf7e26de7d3595e151f7c52683ef82715420ad 100644 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java @@ -72,6 +72,43 @@ public final class CraftMagicNumbers implements UnsafeValues { private CraftMagicNumbers() {} + // Paper start + @Override + public net.kyori.adventure.text.flattener.ComponentFlattener componentFlattener() { + return io.papermc.paper.adventure.PaperAdventure.FLATTENER; + } + + @Override + public net.kyori.adventure.text.serializer.gson.GsonComponentSerializer colorDownsamplingGsonComponentSerializer() { + return net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.colorDownsamplingGson(); + } + + @Override + public net.kyori.adventure.text.serializer.gson.GsonComponentSerializer gsonComponentSerializer() { + return net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson(); + } + + @Override + public net.kyori.adventure.text.serializer.plain.PlainComponentSerializer plainComponentSerializer() { + return io.papermc.paper.adventure.PaperAdventure.PLAIN; + } + + @Override + public net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer plainTextSerializer() { + return net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer.plainText(); + } + + @Override + public net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer legacyComponentSerializer() { + return net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection(); + } + + @Override + public net.kyori.adventure.text.Component resolveWithContext(final net.kyori.adventure.text.Component component, final org.bukkit.command.CommandSender context, final org.bukkit.entity.Entity scoreboardSubject, final boolean bypassPermissions) throws IOException { + return io.papermc.paper.adventure.PaperAdventure.resolveWithContext(component, context, scoreboardSubject, bypassPermissions); + } + // Paper end + public static BlockState getBlock(MaterialData material) { return CraftMagicNumbers.getBlock(material.getItemType(), material.getData()); } diff --git a/src/main/java/org/bukkit/craftbukkit/util/LazyHashSet.java b/src/main/java/org/bukkit/craftbukkit/util/LazyHashSet.java index 62c66e3179b9557cdba46242df0fb15bce7e7710..73a37638abacdffbff8274291a64ea6cd0be7a5e 100644 --- a/src/main/java/org/bukkit/craftbukkit/util/LazyHashSet.java +++ b/src/main/java/org/bukkit/craftbukkit/util/LazyHashSet.java @@ -80,7 +80,7 @@ public abstract class LazyHashSet implements Set { return this.reference = this.makeReference(); } - abstract Set makeReference(); + protected abstract Set makeReference(); // Paper - protected public boolean isLazy() { return this.reference == null; diff --git a/src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java b/src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java index 838d5b877c01be3ef353f434d98e27b46c0a3fb4..5c4c0ba05f10d2d83b22d3e86805cfa85c3b50a9 100644 --- a/src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java +++ b/src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java @@ -15,11 +15,17 @@ public class LazyPlayerSet extends LazyHashSet { } @Override - HashSet makeReference() { + protected HashSet makeReference() { // Paper - protected if (reference != null) { throw new IllegalStateException("Reference already created!"); } List players = this.server.getPlayerList().players; + // Paper start + return makePlayerSet(this.server); + } + public static HashSet makePlayerSet(final MinecraftServer server) { + // Paper end + List players = server.getPlayerList().players; HashSet reference = new HashSet(players.size()); for (ServerPlayer player : players) { reference.add(player.getBukkitEntity()); diff --git a/src/main/resources/META-INF/services/net.kyori.adventure.text.event.ClickCallback$Provider b/src/main/resources/META-INF/services/net.kyori.adventure.text.event.ClickCallback$Provider new file mode 100644 index 0000000000000000000000000000000000000000..845711e03c41c6b6a03d541f1c43d37b24c11733 --- /dev/null +++ b/src/main/resources/META-INF/services/net.kyori.adventure.text.event.ClickCallback$Provider @@ -0,0 +1 @@ +io.papermc.paper.adventure.providers.ClickCallbackProviderImpl diff --git a/src/main/resources/META-INF/services/net.kyori.adventure.text.logger.slf4j.ComponentLoggerProvider b/src/main/resources/META-INF/services/net.kyori.adventure.text.logger.slf4j.ComponentLoggerProvider new file mode 100644 index 0000000000000000000000000000000000000000..399bde6e57cd82b50d3ebe0f51a3958fa2d52d43 --- /dev/null +++ b/src/main/resources/META-INF/services/net.kyori.adventure.text.logger.slf4j.ComponentLoggerProvider @@ -0,0 +1 @@ +io.papermc.paper.adventure.providers.ComponentLoggerProviderImpl diff --git a/src/main/resources/META-INF/services/net.kyori.adventure.text.minimessage.MiniMessage$Provider b/src/main/resources/META-INF/services/net.kyori.adventure.text.minimessage.MiniMessage$Provider new file mode 100644 index 0000000000000000000000000000000000000000..6ce632b6c9dc5e4b3b978331df51c0ffd1526471 --- /dev/null +++ b/src/main/resources/META-INF/services/net.kyori.adventure.text.minimessage.MiniMessage$Provider @@ -0,0 +1 @@ +io.papermc.paper.adventure.providers.MiniMessageProviderImpl diff --git a/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.gson.GsonComponentSerializer$Provider b/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.gson.GsonComponentSerializer$Provider new file mode 100644 index 0000000000000000000000000000000000000000..bc9f7398a0fe158af05b562a8ded9e74a22eae9b --- /dev/null +++ b/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.gson.GsonComponentSerializer$Provider @@ -0,0 +1 @@ +io.papermc.paper.adventure.providers.GsonComponentSerializerProviderImpl diff --git a/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer$Provider b/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer$Provider new file mode 100644 index 0000000000000000000000000000000000000000..820f381981a91754b7f0c5106f93b773d885e321 --- /dev/null +++ b/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer$Provider @@ -0,0 +1 @@ +io.papermc.paper.adventure.providers.LegacyComponentSerializerProviderImpl diff --git a/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer$Provider b/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer$Provider new file mode 100644 index 0000000000000000000000000000000000000000..28d777610b52ba74f808bf3245d73b8333d01fa7 --- /dev/null +++ b/src/main/resources/META-INF/services/net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer$Provider @@ -0,0 +1 @@ +io.papermc.paper.adventure.providers.PlainTextComponentSerializerProviderImpl diff --git a/src/test/java/io/papermc/paper/adventure/ComponentServicesTest.java b/src/test/java/io/papermc/paper/adventure/ComponentServicesTest.java new file mode 100644 index 0000000000000000000000000000000000000000..b6c4f8e2d375396a0ef3300a8bc324d77f23a768 --- /dev/null +++ b/src/test/java/io/papermc/paper/adventure/ComponentServicesTest.java @@ -0,0 +1,23 @@ +package io.papermc.paper.adventure; + +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.format.NamedTextColor; +import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class ComponentServicesTest { + + @Test + public void testPlainTextComponentSerializerProvider() { + assertEquals("Done", PlainTextComponentSerializer.plainText().serialize(Component.translatable("narrator.loading.done"))); + } + + @Test + public void testLegacyComponentSerializerProvider() { + assertEquals("§cDone", LegacyComponentSerializer.legacySection().serialize(Component.translatable("narrator.loading.done", NamedTextColor.RED))); + assertEquals("&cDone", LegacyComponentSerializer.legacyAmpersand().serialize(Component.translatable("narrator.loading.done", NamedTextColor.RED))); + } +}