net.kyori.adventure.platform.bukkit.CraftBukkitFacet Maven / Gradle / Ivy

Go to download
/*
 * This file is part of adventure-platform, licensed under the MIT License.
 *
 * Copyright (c) 2018-2020 KyoriPowered
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
package net.kyori.adventure.platform.bukkit;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.invoke.MethodHandle;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import net.kyori.adventure.audience.MessageType;
import net.kyori.adventure.identity.Identity;
import net.kyori.adventure.nbt.BinaryTagIO;
import net.kyori.adventure.nbt.BinaryTagTypes;
import net.kyori.adventure.nbt.CompoundBinaryTag;
import net.kyori.adventure.nbt.ListBinaryTag;
import net.kyori.adventure.nbt.StringBinaryTag;
import net.kyori.adventure.platform.facet.Facet;
import net.kyori.adventure.platform.facet.FacetBase;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextComponent;
import net.kyori.adventure.text.serializer.craftbukkit.MinecraftComponentSerializer;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Damageable;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Wither;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.plugin.Plugin;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import static java.lang.invoke.MethodHandles.dropArguments;
import static java.lang.invoke.MethodType.methodType;
import static net.kyori.adventure.platform.facet.Knob.isEnabled;
import static net.kyori.adventure.platform.facet.Knob.logError;
import static net.kyori.adventure.text.serializer.craftbukkit.BukkitComponentSerializer.gson;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findClass;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findConstructor;
import static net.kyori.adventure.text.serializer.craftbukkit.BukkitComponentSerializer.legacy;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findCraftClass;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findEnum;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findField;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findMcClass;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findMcClassName;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findMethod;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findNmsClass;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findNmsClassName;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findSetterOf;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.findStaticMethod;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.lookup;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.needClass;
import static net.kyori.adventure.text.serializer.craftbukkit.MinecraftReflection.needField;

class CraftBukkitFacet extends FacetBase {
  protected CraftBukkitFacet(final @Nullable Class viewerClass) {
    super(viewerClass);
  }

  @Override
  public boolean isSupported() {
    return super.isSupported() && SUPPORTED;
  }

  private static final Class CLASS_NMS_ENTITY = findClass(
    findNmsClassName("Entity"),
    findMcClassName("world.entity.Entity")
  );
  private static final Class CLASS_CRAFT_ENTITY = findCraftClass("entity.CraftEntity");
  private static final MethodHandle CRAFT_ENTITY_GET_HANDLE = findMethod(CLASS_CRAFT_ENTITY, "getHandle", CLASS_NMS_ENTITY);
  static final @Nullable Class CLASS_CRAFT_PLAYER = findCraftClass("entity.CraftPlayer", Player.class);
  private static final @Nullable MethodHandle CRAFT_PLAYER_GET_HANDLE;
  private static final @Nullable MethodHandle ENTITY_PLAYER_GET_CONNECTION;
  private static final @Nullable MethodHandle PLAYER_CONNECTION_SEND_PACKET;

  static {
    final Class craftPlayerClass = findCraftClass("entity.CraftPlayer");
    final Class packetClass = findClass(
      findNmsClassName("Packet"),
      findMcClassName("network.protocol.Packet")
    );

    MethodHandle craftPlayerGetHandle = null;
    MethodHandle entityPlayerGetConnection = null;
    MethodHandle playerConnectionSendPacket = null;
    if(craftPlayerClass != null && packetClass != null) {
      try {
        final Method getHandleMethod = craftPlayerClass.getMethod("getHandle");
        final Class entityPlayerClass = getHandleMethod.getReturnType();
        craftPlayerGetHandle = lookup().unreflect(getHandleMethod);
        final Field playerConnectionField = findField(entityPlayerClass, "playerConnection", "connection");
        Class playerConnectionClass = null;
        if(playerConnectionField != null) { // fields are named
          entityPlayerGetConnection = lookup().unreflectGetter(playerConnectionField);
          playerConnectionClass = playerConnectionField.getType();
        } else { // fields are obf, let's discover the field by type
          final Class serverGamePacketListenerImpl = findClass(
            findNmsClassName("PlayerConnection"),
            findMcClassName("server.network.PlayerConnection"),
            findMcClassName("server.network.ServerGamePacketListenerImpl")
          );
          for(final Field field : entityPlayerClass.getDeclaredFields()) {
            final int modifiers = field.getModifiers();
            if(Modifier.isPublic(modifiers) && !Modifier.isFinal(modifiers)) {
              if(serverGamePacketListenerImpl == null || field.getType().equals(serverGamePacketListenerImpl)) {
                entityPlayerGetConnection = lookup().unreflectGetter(field);
                playerConnectionClass = field.getType();
              }
            }
          }
        }
        playerConnectionSendPacket = findMethod(playerConnectionClass, new String[]{"sendPacket", "send"}, void.class, packetClass);
      } catch(final Throwable error) {
        logError(error, "Failed to initialize CraftBukkit sendPacket");
      }
    }

    CRAFT_PLAYER_GET_HANDLE = craftPlayerGetHandle;
    ENTITY_PLAYER_GET_CONNECTION = entityPlayerGetConnection;
    PLAYER_CONNECTION_SEND_PACKET = playerConnectionSendPacket;
  }

  private static final boolean SUPPORTED = isEnabled("craftbukkit", true)
    && MinecraftComponentSerializer.isSupported()
    && CRAFT_PLAYER_GET_HANDLE != null && ENTITY_PLAYER_GET_CONNECTION != null && PLAYER_CONNECTION_SEND_PACKET != null;

  static class PacketFacet extends CraftBukkitFacet implements Facet.Message {
    @SuppressWarnings("unchecked")
    protected PacketFacet() {
      super((Class) CLASS_CRAFT_PLAYER);
    }

    public void sendPacket(final @NotNull Player player, final @Nullable Object packet) {
      if(packet == null) return;

      try {
        PLAYER_CONNECTION_SEND_PACKET.invoke(ENTITY_PLAYER_GET_CONNECTION.invoke(CRAFT_PLAYER_GET_HANDLE.invoke(player)), packet);
      } catch(final Throwable error) {
        logError(error, "Failed to invoke CraftBukkit sendPacket: %s", packet);
      }
    }

    public void sendMessage(final @NotNull V player, final @Nullable Object packet) {
      this.sendPacket((Player) player, packet);
    }

    @Nullable
    @Override
    public Object createMessage(final @NotNull V viewer, final @NotNull Component message) {
      try {
        return MinecraftComponentSerializer.get().serialize(message);
      } catch(final Throwable error) {
        logError(error, "Failed to serialize net.minecraft.server IChatBaseComponent: %s", message);
        return null;
      }
    }
  }

  private static final @Nullable Class CLASS_CHAT_COMPONENT = findClass(
    findNmsClassName("IChatBaseComponent"),
    findMcClassName("network.chat.IChatBaseComponent"),
    findMcClassName("network.chat.Component")
  );
  private static final @Nullable Class CLASS_MESSAGE_TYPE = findClass(
    findNmsClassName("ChatMessageType"),
    findMcClassName("network.chat.ChatMessageType"),
    findMcClassName("network.chat.ChatType")
  );
  private static final @Nullable Object MESSAGE_TYPE_CHAT = findEnum(CLASS_MESSAGE_TYPE, "CHAT", 0);
  private static final @Nullable Object MESSAGE_TYPE_SYSTEM = findEnum(CLASS_MESSAGE_TYPE, "SYSTEM", 1);
  private static final @Nullable Object MESSAGE_TYPE_ACTIONBAR = findEnum(CLASS_MESSAGE_TYPE, "GAME_INFO", 2);

  private static final @Nullable MethodHandle LEGACY_CHAT_PACKET_CONSTRUCTOR; // (IChatBaseComponent, byte)
  private static final @Nullable MethodHandle CHAT_PACKET_CONSTRUCTOR; // (ChatMessageType, IChatBaseComponent, UUID) -> PacketPlayOutChat

  static {
    MethodHandle legacyChatPacketConstructor = null;
    MethodHandle chatPacketConstructor = null;

    try {
      if(CLASS_CHAT_COMPONENT != null) {
        final Class chatPacketClass = needClass(
          findNmsClassName("PacketPlayOutChat"),
          findMcClassName("network.protocol.game.PacketPlayOutChat"),
          findMcClassName("network.protocol.game.ClientboundChatPacket")
        );
        // ClientboundChatPacket constructor changed for 1.16
        chatPacketConstructor = findConstructor(chatPacketClass, CLASS_CHAT_COMPONENT);
        if(chatPacketConstructor == null) {
          if(CLASS_MESSAGE_TYPE != null) {
            chatPacketConstructor = findConstructor(chatPacketClass, CLASS_CHAT_COMPONENT, CLASS_MESSAGE_TYPE, UUID.class);
          }
        } else {
          // Create a function that ignores the message type and sender id arguments to call the underlying one-argument constructor
          chatPacketConstructor = dropArguments(chatPacketConstructor, 1, CLASS_MESSAGE_TYPE == null ? Object.class : CLASS_MESSAGE_TYPE, UUID.class);
        }
        legacyChatPacketConstructor = findConstructor(chatPacketClass, CLASS_CHAT_COMPONENT, byte.class);
        if(legacyChatPacketConstructor == null) { // 1.7 paper protocol hack?
          legacyChatPacketConstructor = findConstructor(chatPacketClass, CLASS_CHAT_COMPONENT, int.class);
        }
      }
    } catch(final Throwable error) {
      logError(error, "Failed to initialize ClientboundChatPacket constructor");
    }

    CHAT_PACKET_CONSTRUCTOR = chatPacketConstructor;
    LEGACY_CHAT_PACKET_CONSTRUCTOR = legacyChatPacketConstructor;
  }

  static class Chat extends PacketFacet implements Facet.Chat {
    @Override
    public boolean isSupported() {
      return super.isSupported() && CHAT_PACKET_CONSTRUCTOR != null;
    }

    @Override
    public void sendMessage(final @NotNull CommandSender viewer, final @NotNull Identity source, final @NotNull Object message, final @NotNull MessageType type) {
      final Object messageType = type == MessageType.CHAT ? MESSAGE_TYPE_CHAT : MESSAGE_TYPE_SYSTEM;
      try {
        this.sendMessage(viewer, CHAT_PACKET_CONSTRUCTOR.invoke(message, messageType, source.uuid()));
      } catch(final Throwable error) {
        logError(error, "Failed to invoke PacketPlayOutChat constructor: %s %s", message, messageType);
      }
    }
  }

  private static final @Nullable Class CLASS_TITLE_PACKET = findClass(
    findNmsClassName("PacketPlayOutTitle"),
    findMcClassName("network.protocol.game.PacketPlayOutTitle")
  );
  private static final @Nullable Class CLASS_TITLE_ACTION = findClass(
    findNmsClassName("PacketPlayOutTitle$EnumTitleAction"), // welcome to spigot, where we can't name classes? i guess?
    findMcClassName("network.protocol.game.PacketPlayOutTitle$EnumTitleAction")
  );
  private static final MethodHandle CONSTRUCTOR_TITLE_MESSAGE = findConstructor(CLASS_TITLE_PACKET, CLASS_TITLE_ACTION, CLASS_CHAT_COMPONENT); // (EnumTitleAction, IChatBaseComponent)
  private static final @Nullable MethodHandle CONSTRUCTOR_TITLE_TIMES = findConstructor(CLASS_TITLE_PACKET, int.class, int.class, int.class);
  private static final @Nullable Object TITLE_ACTION_TITLE = findEnum(CLASS_TITLE_ACTION, "TITLE", 0);
  private static final @Nullable Object TITLE_ACTION_SUBTITLE = findEnum(CLASS_TITLE_ACTION, "SUBTITLE", 1);
  private static final @Nullable Object TITLE_ACTION_ACTIONBAR = findEnum(CLASS_TITLE_ACTION, "ACTIONBAR");
  private static final @Nullable Object TITLE_ACTION_CLEAR = findEnum(CLASS_TITLE_ACTION, "CLEAR");
  private static final @Nullable Object TITLE_ACTION_RESET = findEnum(CLASS_TITLE_ACTION, "RESET");

  static class ActionBar_1_17 extends PacketFacet implements Facet.ActionBar {
    private static final @Nullable Class CLASS_SET_ACTION_BAR_TEXT_PACKET = findMcClass("network.protocol.game.ClientboundSetActionBarTextPacket");
    private static final @Nullable MethodHandle CONSTRUCTOR_ACTION_BAR = findConstructor(CLASS_SET_ACTION_BAR_TEXT_PACKET, CLASS_CHAT_COMPONENT);

    @Override
    public boolean isSupported() {
      return super.isSupported() && CONSTRUCTOR_ACTION_BAR != null;
    }

    @Nullable
    @Override
    public Object createMessage(final @NotNull Player viewer, final @NotNull Component message) {
      try {
        return CONSTRUCTOR_ACTION_BAR.invoke(super.createMessage(viewer, message));
      } catch(final Throwable error) {
        logError(error, "Failed to invoke PacketPlayOutTitle constructor: %s", message);
        return null;
      }
    }
  }

  static class ActionBar extends PacketFacet implements Facet.ActionBar {
    @Override
    public boolean isSupported() {
      return super.isSupported() && TITLE_ACTION_ACTIONBAR != null;
    }

    @Nullable
    @Override
    public Object createMessage(final @NotNull Player viewer, final @NotNull Component message) {
      try {
        return CONSTRUCTOR_TITLE_MESSAGE.invoke(TITLE_ACTION_ACTIONBAR, super.createMessage(viewer, message));
      } catch(final Throwable error) {
        logError(error, "Failed to invoke PacketPlayOutTitle constructor: %s", message);
        return null;
      }
    }
  }

  static class ActionBarLegacy extends PacketFacet implements Facet.ActionBar {
    @Override
    public boolean isSupported() {
      return super.isSupported() && LEGACY_CHAT_PACKET_CONSTRUCTOR != null;
    }

    @Nullable
    @Override
    public Object createMessage(final @NotNull Player viewer, final @NotNull Component message) {
      // Due to a Minecraft client bug, Action bars through the chat packet don't properly support formatting
      final TextComponent legacyMessage = Component.text(legacy().serialize(message));
      try {
        return LEGACY_CHAT_PACKET_CONSTRUCTOR.invoke(super.createMessage(viewer, legacyMessage), (byte) 2);
      } catch(final Throwable error) {
        logError(error, "Failed to invoke PacketPlayOutChat constructor: %s", legacyMessage);
        return null;
      }
    }
  }

  static class EntitySound extends PacketFacet implements Facet.EntitySound {
    private static final Class CLASS_CLIENTBOUND_ENTITY_SOUND = findClass(
      findNmsClassName("PacketPlayOutEntitySound"),
      findMcClassName("network.protocol.game.PacketPlayOutEntitySound"),
      findMcClassName("network.protocol.game.ClientboundEntitySoundPacket")
    );
    private static final Class CLASS_REGISTRY = findClass(
      findNmsClassName("IRegistry"),
      findMcClassName("core.IRegistry"),
      findMcClassName("core.Registry")
    );
    private static final Class CLASS_WRITABLE_REGISTRY = findClass(
      findNmsClassName("IRegistryWritable"),
      findMcClassName("core.IRegistryWritable"),
      findMcClassName("core.WritableRegistry")
    );
    private static final Class CLASS_RESOURCE_LOCATION = findClass(
      findNmsClassName("MinecraftKey"),
      findMcClassName("resources.MinecraftKey"),
      findMcClassName("resources.ResourceLocation")
    );
    private static final Class CLASS_SOUND_EFFECT = findClass(
      findNmsClassName("SoundEffect"),
      findMcClassName("sounds.SoundEffect"),
      findMcClassName("sounds.SoundEvent")
    );
    private static final Class CLASS_SOUND_SOURCE = findClass(
      findNmsClassName("SoundCategory"),
      findMcClassName("sounds.SoundCategory"),
      findMcClassName("sounds.SoundSource")
    );

    private static final MethodHandle NEW_CLIENTBOUND_ENTITY_SOUND = findConstructor(CLASS_CLIENTBOUND_ENTITY_SOUND, CLASS_SOUND_EFFECT, CLASS_SOUND_SOURCE, CLASS_NMS_ENTITY, float.class, float.class);
    private static final MethodHandle NEW_RESOURCE_LOCATION = findConstructor(CLASS_RESOURCE_LOCATION, String.class, String.class);
    private static final MethodHandle REGISTRY_GET_OPTIONAL = findMethod(CLASS_REGISTRY, "getOptional", Optional.class, CLASS_RESOURCE_LOCATION);
    private static final MethodHandle SOUND_SOURCE_GET_NAME;
    private static final Object REGISTRY_SOUND_EVENT;

    static {
      Object registrySoundEvent = null;
      MethodHandle soundSourceGetName = null;
      if(CLASS_SOUND_SOURCE != null) {
        for(final Method method : CLASS_SOUND_SOURCE.getDeclaredMethods()) {
          if(
            method.getReturnType().equals(String.class)
              && method.getParameterCount() == 0
              && !"name".equals(method.getName())
              && Modifier.isPublic(method.getModifiers())
          ) {
            try {
              soundSourceGetName = lookup().unreflect(method);
            } catch(final IllegalAccessException ex) {
              // ignored, getName is public
            }
            break;
          }
        }
      }
      if(CLASS_REGISTRY != null) {
        // we don't have always field names, so:
        // first: try to find SOUND_EVENT field
        try {
          final Field soundEventField = findField(CLASS_REGISTRY, "SOUND_EVENT");
          if(soundEventField != null) {
            registrySoundEvent = soundEventField.get(null);
          } else {
            // then, if not found:
            // iterate through fields, find the `protected static final` field
            // it's IRegistryWritable, the registry root
            // then we'll getOptional(NEW_RESOURCE_LOCATION.invoke("minecraft", "sound_event"))
            Object rootRegistry = null;
            for(final Field field : CLASS_REGISTRY.getDeclaredFields()) {
              final int mask = Modifier.PROTECTED | Modifier.STATIC | Modifier.FINAL;
              if((field.getModifiers() & mask) == mask
                && field.getType().equals(CLASS_WRITABLE_REGISTRY)) {
                // we've found the root registry
                field.setAccessible(true);
                rootRegistry = field.get(null);
                break;
              }
            }

            if(rootRegistry != null) {
              registrySoundEvent = ((Optional) REGISTRY_GET_OPTIONAL.invoke(rootRegistry, NEW_RESOURCE_LOCATION.invoke("minecraft", "sound_event"))).orElse(null);
            }
          }
        } catch(final Throwable thr) {
          logError(thr, "Failed to initialize EntitySound CraftBukkit facet");
        }
      }
      REGISTRY_SOUND_EVENT = registrySoundEvent;
      SOUND_SOURCE_GET_NAME = soundSourceGetName;
    }

    private static final Map MC_SOUND_SOURCE_BY_NAME = new ConcurrentHashMap<>();

    @Override
    public boolean isSupported() {
      return super.isSupported() && NEW_CLIENTBOUND_ENTITY_SOUND != null && NEW_RESOURCE_LOCATION != null && REGISTRY_SOUND_EVENT != null && REGISTRY_GET_OPTIONAL != null && CRAFT_ENTITY_GET_HANDLE != null && SOUND_SOURCE_GET_NAME != null;
    }

    @Override
    public Object createForSelf(final Player viewer, final net.kyori.adventure.sound.@NotNull Sound sound) {
      return this.createForEntity(sound, viewer);
    }

    @Override
    public Object createForEmitter(final net.kyori.adventure.sound.@NotNull Sound sound, final net.kyori.adventure.sound.Sound.@NotNull Emitter emitter) {
      final Entity entity;
      if(emitter instanceof BukkitEmitter) {
        entity = ((BukkitEmitter) emitter).entity;
      } else if(emitter instanceof Entity) { // how? but just in case
        entity = (Entity) emitter;
      } else {
        return null;
      }
      return this.createForEntity(sound, entity);
    }

    private Object createForEntity(final net.kyori.adventure.sound.Sound sound, final Entity entity) {
      try {
        final Object nmsEntity = this.toNativeEntity(entity);
        if(nmsEntity == null) return null;

        final Object soundCategory = this.toVanilla(sound.source());
        if(soundCategory == null) return null;
        final Object nameRl = NEW_RESOURCE_LOCATION.invoke(sound.name().namespace(), sound.name().value());
        final java.util.Optional event = (Optional) REGISTRY_GET_OPTIONAL.invoke(REGISTRY_SOUND_EVENT, nameRl);
        if(event.isPresent()) {
          return NEW_CLIENTBOUND_ENTITY_SOUND.invoke(event.get(), soundCategory, nmsEntity, sound.volume(), sound.pitch());
        }
      } catch(final Throwable error) {
        logError(error, "Failed to send sound tracking an entity");
      }
      return null;
    }

    private Object toNativeEntity(final Entity entity) throws Throwable {
      if(!CLASS_CRAFT_ENTITY.isInstance(entity)) return null;

      return CRAFT_ENTITY_GET_HANDLE.invoke(entity);
    }

    private Object toVanilla(final net.kyori.adventure.sound.Sound.Source source) throws Throwable {
      if(MC_SOUND_SOURCE_BY_NAME.isEmpty()) {
        for(final Object enumConstant : CLASS_SOUND_SOURCE.getEnumConstants()) {
          MC_SOUND_SOURCE_BY_NAME.put((String) SOUND_SOURCE_GET_NAME.invoke(enumConstant), enumConstant);
        }
      }

      return MC_SOUND_SOURCE_BY_NAME.get(net.kyori.adventure.sound.Sound.Source.NAMES.key(source));
    }

    @Override
    public void playSound(final @NotNull Player viewer, final Object message) {
      this.sendPacket(viewer, message);
    }
  }

  static class Title_1_17 extends PacketFacet implements Facet.Title> {

    private static final Class PACKET_SET_TITLE = findMcClass("network.protocol.game.ClientboundSetTitleTextPacket");
    private static final Class PACKET_SET_SUBTITLE = findMcClass("network.protocol.game.ClientboundSetSubtitleTextPacket");
    private static final Class PACKET_SET_TITLE_ANIMATION = findMcClass("network.protocol.game.ClientboundSetTitlesAnimationPacket");
    private static final Class PACKET_CLEAR_TITLES = findMcClass("network.protocol.game.ClientboundClearTitlesPacket");

    private static final MethodHandle CONSTRUCTOR_SET_TITLE = findConstructor(PACKET_SET_TITLE, CLASS_CHAT_COMPONENT);
    private static final MethodHandle CONSTRUCTOR_SET_SUBTITLE = findConstructor(PACKET_SET_SUBTITLE, CLASS_CHAT_COMPONENT);
    private static final MethodHandle CONSTRUCTOR_SET_TITLE_ANIMATION = findConstructor(PACKET_SET_TITLE_ANIMATION, int.class, int.class, int.class);
    private static final MethodHandle CONSTRUCTOR_CLEAR_TITLES = findConstructor(PACKET_CLEAR_TITLES, boolean.class);

    @Override
    public boolean isSupported() {
      return super.isSupported() && CONSTRUCTOR_SET_TITLE != null && CONSTRUCTOR_SET_SUBTITLE != null && CONSTRUCTOR_SET_TITLE_ANIMATION != null && CONSTRUCTOR_CLEAR_TITLES != null;
    }

    @Override
    public @Nullable List createTitle(final @Nullable Object title, final @Nullable Object subTitle, final int inTicks, final int stayTicks, final int outTicks) {
      final List