diff --git a/build-logic/src/main/kotlin/via.shadow-conventions.gradle.kts b/build-logic/src/main/kotlin/via.shadow-conventions.gradle.kts index 8021f6fcb..fc4171962 100644 --- a/build-logic/src/main/kotlin/via.shadow-conventions.gradle.kts +++ b/build-logic/src/main/kotlin/via.shadow-conventions.gradle.kts @@ -25,7 +25,6 @@ tasks { publishShadowJar() fun ShadowJar.configureRelocations() { - relocate("javassist", "com.viaversion.viaversion.libs.javassist") relocate("com.google.gson", "com.viaversion.viaversion.libs.gson") relocate("com.github.steveice10.opennbt", "com.viaversion.viaversion.libs.opennbt") relocate("it.unimi.dsi.fastutil", "com.viaversion.viaversion.libs.fastutil") diff --git a/bukkit/build.gradle.kts b/bukkit/build.gradle.kts index 3affbc8e2..abc00209f 100644 --- a/bukkit/build.gradle.kts +++ b/bukkit/build.gradle.kts @@ -1,10 +1,10 @@ dependencies { implementation(projects.viaversionBukkitLegacy) implementation(projects.viaversionCommon) - implementation(libs.javassist) compileOnly(libs.paper) { exclude("junit", "junit") exclude("com.google.code.gson", "gson") exclude("javax.persistence", "persistence-api") } + compileOnly(projects.compat.protocolsupportCompat) } diff --git a/bukkit/src/main/java/com/viaversion/viaversion/ViaVersionPlugin.java b/bukkit/src/main/java/com/viaversion/viaversion/ViaVersionPlugin.java index d50177afa..405399fa7 100644 --- a/bukkit/src/main/java/com/viaversion/viaversion/ViaVersionPlugin.java +++ b/bukkit/src/main/java/com/viaversion/viaversion/ViaVersionPlugin.java @@ -26,7 +26,6 @@ import com.viaversion.viaversion.api.data.MappingDataLoader; import com.viaversion.viaversion.api.platform.PlatformTask; import com.viaversion.viaversion.api.platform.UnsupportedSoftware; import com.viaversion.viaversion.api.platform.ViaPlatform; -import com.viaversion.viaversion.bukkit.classgenerator.ClassGenerator; import com.viaversion.viaversion.bukkit.commands.BukkitCommandHandler; import com.viaversion.viaversion.bukkit.commands.BukkitCommandSender; import com.viaversion.viaversion.bukkit.platform.BukkitViaAPI; @@ -49,7 +48,6 @@ import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.UUID; -import java.util.logging.Level; public class ViaVersionPlugin extends JavaPlugin implements ViaPlatform { private static ViaVersionPlugin instance; @@ -90,12 +88,6 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaPlatform MappingDataLoader.enableMappingsCache(); } - try { - ClassGenerator.generate(); - } catch (Exception e) { - getLogger().log(Level.WARNING, "Error generating classes for compatibility layer", e); - } - lateBind = !((BukkitViaInjector) Via.getManager().getInjector()).isBinded(); getLogger().info("ViaVersion " + getDescription().getVersion() + " is now loaded" + (lateBind ? ", waiting for boot. (late-bind)" : ", injecting!")); diff --git a/bukkit/src/main/java/com/viaversion/viaversion/bukkit/classgenerator/ClassGenerator.java b/bukkit/src/main/java/com/viaversion/viaversion/bukkit/classgenerator/ClassGenerator.java deleted file mode 100644 index dd6fabb68..000000000 --- a/bukkit/src/main/java/com/viaversion/viaversion/bukkit/classgenerator/ClassGenerator.java +++ /dev/null @@ -1,207 +0,0 @@ -/* - * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion - * Copyright (C) 2016-2022 ViaVersion and contributors - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ -package com.viaversion.viaversion.bukkit.classgenerator; - -import com.viaversion.viaversion.ViaVersionPlugin; -import com.viaversion.viaversion.api.Via; -import com.viaversion.viaversion.bukkit.util.NMSUtil; -import com.viaversion.viaversion.classgenerator.generated.HandlerSupplier; -import javassist.CannotCompileException; -import javassist.ClassPool; -import javassist.CtClass; -import javassist.CtField; -import javassist.CtNewConstructor; -import javassist.CtNewMethod; -import javassist.LoaderClassPath; -import org.bukkit.Bukkit; -import org.bukkit.event.Event; -import org.bukkit.event.EventException; -import org.bukkit.event.EventPriority; -import org.bukkit.event.Listener; -import org.bukkit.plugin.EventExecutor; -import org.bukkit.plugin.Plugin; -import org.checkerframework.checker.nullness.qual.NonNull; - -import java.lang.reflect.Method; - -//TODO maybe clean this up a bit 👀 -public final class ClassGenerator { - private static final boolean useModules = hasModuleMethod(); - private static Class psConnectListener; - - public static void generate() { - if (ViaVersionPlugin.getInstance().isProtocolSupport() && isMultiplatformPS()) { - ClassPool pool = ClassPool.getDefault(); - pool.insertClassPath(new LoaderClassPath(Bukkit.class.getClassLoader())); - for (Plugin p : Bukkit.getPluginManager().getPlugins()) { - pool.insertClassPath(new LoaderClassPath(p.getClass().getClassLoader())); - } - - Via.getPlatform().getLogger().info("Generating ProtocolSupport compatibility connect listener..."); - psConnectListener = makePSConnectListener(pool); - } - } - - private static Class makePSConnectListener(ClassPool pool) { - HandshakeProtocolType type = handshakeVersionMethod(); - try { - // Reference classes - CtClass toExtend = pool.get("protocolsupport.api.Connection$PacketListener"); - CtClass connectListenerClazz = pool.makeClass("com.viaversion.viaversion.classgenerator.generated.ProtocolSupportConnectListener"); - connectListenerClazz.setSuperclass(toExtend); - // Import packages - pool.importPackage("java.util.Arrays"); - pool.importPackage("protocolsupport.api.ProtocolVersion"); - pool.importPackage("protocolsupport.api.ProtocolType"); - pool.importPackage("protocolsupport.api.Connection"); - pool.importPackage("protocolsupport.api.Connection.PacketListener"); - pool.importPackage("protocolsupport.api.Connection.PacketListener.PacketEvent"); - pool.importPackage("protocolsupport.protocol.ConnectionImpl"); - pool.importPackage(NMSUtil.nms( - "PacketHandshakingInSetProtocol", - "net.minecraft.network.protocol.handshake.PacketHandshakingInSetProtocol" - ).getName()); - // Add connection reference field - connectListenerClazz.addField(CtField.make("private ConnectionImpl connection;", connectListenerClazz)); - // Bake constructor - connectListenerClazz.addConstructor(CtNewConstructor.make( - "public ProtocolSupportConnectListener (ConnectionImpl connection) {\n" - + " this.connection = connection;\n" - + "}", connectListenerClazz)); - // Add the listening method - connectListenerClazz.addMethod(CtNewMethod.make( - // On packet receive - "public void onPacketReceiving(protocolsupport.api.Connection.PacketListener.PacketEvent event) {\n" - // Check if we are getting handshake packet. - + " if (event.getPacket() instanceof PacketHandshakingInSetProtocol) {\n" - // Get protocol version. - + " PacketHandshakingInSetProtocol packet = (PacketHandshakingInSetProtocol) event.getPacket();\n" - + " int protoVersion = packet." + type.methodName() + "();\n" - // ViaVersion has at this point already spoofed the connectionversion. (Since it is higher up the pipeline) - // If via has put the protoVersion to the server we can spoof ProtocolSupport's version. - + " if (connection.getVersion() == ProtocolVersion.MINECRAFT_FUTURE && protoVersion == com.viaversion.viaversion.api.Via.getAPI().getServerVersion().lowestSupportedVersion()) {\n" - + " connection.setVersion(ProtocolVersion.getLatest(ProtocolType.PC));\n" - + " }\n" - + " }\n" - // Id version is not serverversion viaversion will not spoof. ProtocolSupport will handle the rest. - // In any case, remove the packet listener and wrap up. - + " connection.removePacketListener(this);\n" - + "}", connectListenerClazz)); - return toClass(connectListenerClazz); - } catch (Exception e) { - e.printStackTrace(); - } - return null; - } - - public static void registerPSConnectListener(ViaVersionPlugin plugin) { - if (psConnectListener != null) { - try { - Class connectionOpenEvent = (Class) Class.forName("protocolsupport.api.events.ConnectionOpenEvent"); - Bukkit.getPluginManager().registerEvent(connectionOpenEvent, new Listener() { - }, EventPriority.HIGH, new EventExecutor() { - @Override - public void execute(@NonNull Listener listener, @NonNull Event event) throws EventException { - try { - Object connection = event.getClass().getMethod("getConnection").invoke(event); - Object connectListener = psConnectListener.getConstructor(connection.getClass()).newInstance(connection); - Method addConnectListener = connection.getClass().getMethod("addPacketListener", Class.forName("protocolsupport.api.Connection$PacketListener")); - addConnectListener.invoke(connection, connectListener); - } catch (Exception e) { - e.printStackTrace(); - } - } - }, plugin); - } catch (Exception e) { - e.printStackTrace(); - } - } - } - - public static Class getPSConnectListener() { - return psConnectListener; - } - - public static boolean isMultiplatformPS() { - try { - Class.forName("protocolsupport.zplatform.impl.spigot.network.pipeline.SpigotPacketEncoder"); - return true; - } catch (ClassNotFoundException e) { - return false; - } - } - - public static HandshakeProtocolType handshakeVersionMethod() { - Class clazz = null; - // Check for the mapped method - try { - clazz = NMSUtil.nms( - "PacketHandshakingInSetProtocol", - "net.minecraft.network.protocol.handshake.PacketHandshakingInSetProtocol" - ); - clazz.getMethod("getProtocolVersion"); - return HandshakeProtocolType.MAPPED; - } catch (ClassNotFoundException e) { - throw new RuntimeException(e); - } catch (NoSuchMethodException ignored) { - } - - // Check for obfusacted b/c methods - try { - if (clazz.getMethod("b").getReturnType() == int.class) { - return HandshakeProtocolType.OBFUSCATED_OLD; - } else if (clazz.getMethod("c").getReturnType() == int.class) { - return HandshakeProtocolType.OBFUSCATED_NEW; - } - throw new UnsupportedOperationException("Protocol version method not found in " + clazz.getSimpleName()); - } catch (ReflectiveOperationException e) { - throw new RuntimeException(e); - } - } - - @SuppressWarnings("deprecation") - private static Class toClass(CtClass ctClass) throws CannotCompileException { - return useModules ? ctClass.toClass(HandlerSupplier.class) : ctClass.toClass(HandlerSupplier.class.getClassLoader()); - } - - private static boolean hasModuleMethod() { - try { - Class.class.getDeclaredMethod("getModule"); - return true; - } catch (NoSuchMethodException e) { - return false; - } - } - - private enum HandshakeProtocolType { - - MAPPED("getProtocolVersion"), - OBFUSCATED_OLD("b"), - OBFUSCATED_NEW("c"); - - private final String methodName; - - HandshakeProtocolType(String methodName) { - this.methodName = methodName; - } - - public String methodName() { - return methodName; - } - } -} diff --git a/bukkit/src/main/java/com/viaversion/viaversion/bukkit/compat/ProtocolSupportCompat.java b/bukkit/src/main/java/com/viaversion/viaversion/bukkit/compat/ProtocolSupportCompat.java new file mode 100644 index 000000000..67100ecd4 --- /dev/null +++ b/bukkit/src/main/java/com/viaversion/viaversion/bukkit/compat/ProtocolSupportCompat.java @@ -0,0 +1,107 @@ +/* + * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion + * Copyright (C) 2016-2022 ViaVersion and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.viaversion.viaversion.bukkit.compat; + +import com.viaversion.viaversion.ViaVersionPlugin; +import com.viaversion.viaversion.api.Via; +import com.viaversion.viaversion.bukkit.util.NMSUtil; +import org.bukkit.Bukkit; +import org.bukkit.event.Event; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; + +import java.util.logging.Level; + +public final class ProtocolSupportCompat { + + public static void registerPSConnectListener(ViaVersionPlugin plugin) { + if (isMultiplatformPS()) { + Via.getPlatform().getLogger().info("Registering ProtocolSupport compat connection listener"); + try { + //noinspection unchecked + Class connectionOpenEvent = (Class) Class.forName("protocolsupport.api.events.ConnectionOpenEvent"); + Bukkit.getPluginManager().registerEvent(connectionOpenEvent, new Listener() { + }, EventPriority.HIGH, (listener, event) -> { + try { + Object connection = event.getClass().getMethod("getConnection").invoke(event); + ProtocolSupportConnectionListener connectListener = new ProtocolSupportConnectionListener(connection); + ProtocolSupportConnectionListener.ADD_PACKET_LISTENER_METHOD.invoke(connection, connectListener); + } catch (Exception e) { + Via.getPlatform().getLogger().log(Level.WARNING, "Error when handling ProtocolSupport event", e); + } + }, plugin); + } catch (Exception e) { + Via.getPlatform().getLogger().log(Level.WARNING, "Unable to register ProtocolSupport listener", e); + } + } + } + + public static boolean isMultiplatformPS() { + try { + Class.forName("protocolsupport.zplatform.impl.spigot.network.pipeline.SpigotPacketEncoder"); + return true; + } catch (ClassNotFoundException e) { + return false; + } + } + + public static HandshakeProtocolType handshakeVersionMethod() { + Class clazz = null; + // Check for the mapped method + try { + clazz = NMSUtil.nms( + "PacketHandshakingInSetProtocol", + "net.minecraft.network.protocol.handshake.PacketHandshakingInSetProtocol" + ); + clazz.getMethod("getProtocolVersion"); + return HandshakeProtocolType.MAPPED; + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } catch (NoSuchMethodException ignored) { + } + + // Check for obfusacted b/c methods + try { + if (clazz.getMethod("b").getReturnType() == int.class) { + return HandshakeProtocolType.OBFUSCATED_B; + } else if (clazz.getMethod("c").getReturnType() == int.class) { + return HandshakeProtocolType.OBFUSCATED_C; + } + throw new UnsupportedOperationException("Protocol version method not found in " + clazz.getSimpleName()); + } catch (ReflectiveOperationException e) { + throw new RuntimeException(e); + } + } + + public enum HandshakeProtocolType { + + MAPPED("getProtocolVersion"), + OBFUSCATED_B("b"), + OBFUSCATED_C("c"); + + private final String methodName; + + HandshakeProtocolType(String methodName) { + this.methodName = methodName; + } + + public String methodName() { + return methodName; + } + } +} diff --git a/bukkit/src/main/java/com/viaversion/viaversion/bukkit/compat/ProtocolSupportConnectionListener.java b/bukkit/src/main/java/com/viaversion/viaversion/bukkit/compat/ProtocolSupportConnectionListener.java new file mode 100644 index 000000000..2dada8e77 --- /dev/null +++ b/bukkit/src/main/java/com/viaversion/viaversion/bukkit/compat/ProtocolSupportConnectionListener.java @@ -0,0 +1,93 @@ +/* + * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion + * Copyright (C) 2016-2022 ViaVersion and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.viaversion.viaversion.bukkit.compat; + +import com.viaversion.viaversion.api.Via; +import com.viaversion.viaversion.bukkit.util.NMSUtil; +import protocolsupport.api.Connection; + +import java.lang.reflect.Method; + +final class ProtocolSupportConnectionListener extends Connection.PacketListener { + + static final Method ADD_PACKET_LISTENER_METHOD; + private static final Class HANDSHAKE_PACKET_CLASS; + private static final Method GET_VERSION_METHOD; + private static final Method SET_VERSION_METHOD; + private static final Method REMOVE_PACKET_LISTENER_METHOD; + private static final Method GET_LATEST_METHOD; + private static final Object PROTOCOL_VERSION_MINECRAFT_FUTURE; + private static final Object PROTOCOL_TYPE_PC; + + static { + try { + HANDSHAKE_PACKET_CLASS = NMSUtil.nms( + "PacketHandshakingInSetProtocol", + "net.minecraft.network.protocol.handshake.PacketHandshakingInSetProtocol" + ); + + final Class connectionImplClass = Class.forName("protocolsupport.protocol.ConnectionImpl"); + final Class connectionClass = Class.forName("protocolsupport.api.Connection"); + final Class packetListenerClass = Class.forName("protocolsupport.api.Connection$PacketListener"); + final Class protocolVersionClass = Class.forName("protocolsupport.api.ProtocolVersion"); + final Class protocolTypeClass = Class.forName("protocolsupport.api.ProtocolType"); + GET_VERSION_METHOD = connectionClass.getDeclaredMethod("getVersion"); + SET_VERSION_METHOD = connectionImplClass.getDeclaredMethod("setVersion", protocolVersionClass); + PROTOCOL_VERSION_MINECRAFT_FUTURE = protocolVersionClass.getDeclaredField("MINECRAFT_FUTURE").get(null); + GET_LATEST_METHOD = protocolVersionClass.getDeclaredMethod("getLatest", protocolTypeClass); + PROTOCOL_TYPE_PC = protocolTypeClass.getDeclaredField("PC").get(null); + ADD_PACKET_LISTENER_METHOD = connectionClass.getDeclaredMethod("addPacketListener", packetListenerClass); + REMOVE_PACKET_LISTENER_METHOD = connectionClass.getDeclaredMethod("removePacketListener", packetListenerClass); + } catch (final ReflectiveOperationException e) { + throw new RuntimeException(e); + } + } + + private final Object connection; + + ProtocolSupportConnectionListener(final Object connection) { + this.connection = connection; + } + + @Override + public void onPacketReceiving(final Connection.PacketListener.PacketEvent event) { + try { + // Check if we are getting handshake packet. + if (HANDSHAKE_PACKET_CLASS.isInstance(event.getPacket()) && GET_VERSION_METHOD.invoke(connection) == PROTOCOL_VERSION_MINECRAFT_FUTURE) { + final Object packet = event.getPacket(); + final int protocolVersion; + try { + protocolVersion = (int) HANDSHAKE_PACKET_CLASS.getDeclaredMethod(ProtocolSupportCompat.handshakeVersionMethod().methodName()).invoke(packet); + } catch (final ReflectiveOperationException e) { + throw new RuntimeException(e); + } + + // ViaVersion has at this point already spoofed the connectionversion. (Since it is higher up the pipeline) + // If via has put the protoVersion to the server we can spoof ProtocolSupport's version. + if (protocolVersion == Via.getAPI().getServerVersion().lowestSupportedVersion()) { + SET_VERSION_METHOD.invoke(connection, GET_LATEST_METHOD.invoke(null, PROTOCOL_TYPE_PC)); + } + } + // Id version is not serverversion viaversion will not spoof. ProtocolSupport will handle the rest. + // In any case, remove the packet listener and wrap up. + REMOVE_PACKET_LISTENER_METHOD.invoke(connection, this); + } catch (final ReflectiveOperationException e) { + throw new RuntimeException(e); + } + } +} diff --git a/bukkit/src/main/java/com/viaversion/viaversion/bukkit/platform/BukkitViaLoader.java b/bukkit/src/main/java/com/viaversion/viaversion/bukkit/platform/BukkitViaLoader.java index 4a95abca9..03ae1f0c4 100644 --- a/bukkit/src/main/java/com/viaversion/viaversion/bukkit/platform/BukkitViaLoader.java +++ b/bukkit/src/main/java/com/viaversion/viaversion/bukkit/platform/BukkitViaLoader.java @@ -23,7 +23,7 @@ import com.viaversion.viaversion.api.connection.UserConnection; import com.viaversion.viaversion.api.minecraft.item.Item; import com.viaversion.viaversion.api.platform.ViaPlatformLoader; import com.viaversion.viaversion.api.protocol.version.ProtocolVersion; -import com.viaversion.viaversion.bukkit.classgenerator.ClassGenerator; +import com.viaversion.viaversion.bukkit.compat.ProtocolSupportCompat; import com.viaversion.viaversion.bukkit.listeners.JoinListener; import com.viaversion.viaversion.bukkit.listeners.UpdateListener; import com.viaversion.viaversion.bukkit.listeners.multiversion.PlayerSneakListener; @@ -88,7 +88,10 @@ public class BukkitViaLoader implements ViaPlatformLoader { final ViaVersionPlugin plugin = (ViaVersionPlugin) Bukkit.getPluginManager().getPlugin("ViaVersion"); // Add ProtocolSupport ConnectListener if necessary. - ClassGenerator.registerPSConnectListener(plugin); + if (plugin.isProtocolSupport()) { + ProtocolSupportCompat.registerPSConnectListener(plugin); + } + int serverProtocolVersion = Via.getAPI().getServerVersion().lowestSupportedVersion(); /* 1.9 client to 1.8 server */ diff --git a/bungee/build.gradle.kts b/bungee/build.gradle.kts index e205d25d1..83847db20 100644 --- a/bungee/build.gradle.kts +++ b/bungee/build.gradle.kts @@ -1,5 +1,5 @@ dependencies { implementation(projects.viaversionCommon) - implementation(projects.javaCompat) + implementation(projects.compat) compileOnly(libs.bungee) } diff --git a/compat/build.gradle.kts b/compat/build.gradle.kts new file mode 100644 index 000000000..2fcada132 --- /dev/null +++ b/compat/build.gradle.kts @@ -0,0 +1,4 @@ +dependencies { + api(projects.compat.javaCompatCommon) + api(projects.compat.javaCompatUnsafe) +} diff --git a/java-compat/java-compat-common/build.gradle.kts b/compat/java-compat-common/build.gradle.kts similarity index 100% rename from java-compat/java-compat-common/build.gradle.kts rename to compat/java-compat-common/build.gradle.kts diff --git a/java-compat/java-compat-common/src/main/java/com/viaversion/viaversion/compatibility/ForcefulFieldModifier.java b/compat/java-compat-common/src/main/java/com/viaversion/viaversion/compatibility/ForcefulFieldModifier.java similarity index 100% rename from java-compat/java-compat-common/src/main/java/com/viaversion/viaversion/compatibility/ForcefulFieldModifier.java rename to compat/java-compat-common/src/main/java/com/viaversion/viaversion/compatibility/ForcefulFieldModifier.java diff --git a/compat/java-compat-unsafe/build.gradle.kts b/compat/java-compat-unsafe/build.gradle.kts new file mode 100644 index 000000000..e92b04640 --- /dev/null +++ b/compat/java-compat-unsafe/build.gradle.kts @@ -0,0 +1,3 @@ +dependencies { + api(projects.compat.javaCompatCommon) +} diff --git a/java-compat/java-compat-unsafe/src/main/java/com/viaversion/viaversion/compatibility/unsafe/UnsafeBackedForcefulFieldModifier.java b/compat/java-compat-unsafe/src/main/java/com/viaversion/viaversion/compatibility/unsafe/UnsafeBackedForcefulFieldModifier.java similarity index 100% rename from java-compat/java-compat-unsafe/src/main/java/com/viaversion/viaversion/compatibility/unsafe/UnsafeBackedForcefulFieldModifier.java rename to compat/java-compat-unsafe/src/main/java/com/viaversion/viaversion/compatibility/unsafe/UnsafeBackedForcefulFieldModifier.java diff --git a/compat/protocolsupport-compat/build.gradle.kts b/compat/protocolsupport-compat/build.gradle.kts new file mode 100644 index 000000000..7d82dc72f --- /dev/null +++ b/compat/protocolsupport-compat/build.gradle.kts @@ -0,0 +1,2 @@ +dependencies { +} diff --git a/compat/protocolsupport-compat/src/main/java/protocolsupport/api/Connection.java b/compat/protocolsupport-compat/src/main/java/protocolsupport/api/Connection.java new file mode 100644 index 000000000..8f9802603 --- /dev/null +++ b/compat/protocolsupport-compat/src/main/java/protocolsupport/api/Connection.java @@ -0,0 +1,18 @@ +package protocolsupport.api; + +public abstract class Connection { + + public abstract static class PacketListener { + + public void onPacketReceiving(PacketEvent event) { + throw new UnsupportedOperationException(); + } + + public static class PacketEvent { + + public Object getPacket() { + throw new UnsupportedOperationException(); + } + } + } +} diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 799d80632..6bba1f79f 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -7,7 +7,6 @@ gson = "2.8.8" fastutil = "8.5.6" flare = "2.0.0" openNBT = "2.1" -javassist = "3.28.0-GA" # Common provided netty = "4.0.20.Final" @@ -38,7 +37,6 @@ fastutil = { group = "it.unimi.dsi", name = "fastutil", version.ref = "fastutil" flare = { group = "space.vectrix.flare", name = "flare", version.ref = "flare" } flareFastutil = { group = "space.vectrix.flare", name = "flare-fastutil", version.ref = "flare" } openNBT = { group = "com.viaversion", name = "opennbt", version.ref = "openNBT" } -javassist = { group = "org.javassist", name = "javassist", version.ref = "javassist" } netty = { group = "io.netty", name = "netty-all", version.ref = "netty" } guava = { group = "com.google.guava", name = "guava", version.ref = "guava" } diff --git a/java-compat/build.gradle.kts b/java-compat/build.gradle.kts deleted file mode 100644 index 25b99b661..000000000 --- a/java-compat/build.gradle.kts +++ /dev/null @@ -1,4 +0,0 @@ -dependencies { - api(projects.javaCompat.javaCompatCommon) - api(projects.javaCompat.javaCompatUnsafe) -} diff --git a/java-compat/java-compat-unsafe/build.gradle.kts b/java-compat/java-compat-unsafe/build.gradle.kts deleted file mode 100644 index 19c32d3eb..000000000 --- a/java-compat/java-compat-unsafe/build.gradle.kts +++ /dev/null @@ -1,3 +0,0 @@ -dependencies { - api(projects.javaCompat.javaCompatCommon) -} diff --git a/settings.gradle.kts b/settings.gradle.kts index 37e1ddff2..bd0133125 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -27,7 +27,7 @@ rootProject.name = "viaversion-parent" includeBuild("build-logic") include("adventure") -include("java-compat", "java-compat:java-compat-common", "java-compat:java-compat-unsafe") +include("compat", "compat:java-compat-common", "compat:java-compat-unsafe", "compat:protocolsupport-compat") setupViaSubproject("api") setupViaSubproject("api-legacy")