Basic compatibility with ProtocolSupport, doesn't seem to work with 1.6.4 due to issues with our Login Handler.

src/main/java/us/myles/ViaVersion/ViaVersionPlugin.java

@@ -9,6 +9,7 @@ import lombok.Getter;
 import lombok.NonNull;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginDescriptionFile;
 import org.bukkit.plugin.java.JavaPlugin;
 import us.myles.ViaVersion.api.Pair;
@@ -48,6 +49,7 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
     private boolean compatSpigotBuild = false;
     private boolean spigot = true;
     private boolean lateBind = false;
+    private boolean protocolSupport = false;
     @Getter
     private ViaConfig conf;
 
@@ -56,6 +58,7 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
         // Config magic
         conf = new ViaConfig(this);
         ViaVersion.setInstance(this);
+
         // Handle reloads
         if (System.getProperty("ViaVersion") != null) {
             if (Bukkit.getPluginManager().getPlugin("ProtocolLib") != null) {
@@ -69,19 +72,25 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
 
             }
         }
+
         // Spigot detector
         try {
             Class.forName("org.spigotmc.SpigotConfig");
         } catch (ClassNotFoundException e) {
             spigot = false;
         }
+
         // Check if it's a spigot build with a protocol mod
         try {
             compatSpigotBuild = ReflectionUtil.nms("PacketEncoder").getDeclaredField("version") != null;
         } catch (Exception e) {
             compatSpigotBuild = false;
         }
-        // Generate classes needed (only works if it's compat)
+
+        // Check if we're using protocol support too
+        protocolSupport = Bukkit.getPluginManager().getPlugin("ProtocolSupport") != null;
+
+        // Generate classes needed (only works if it's compat or ps)
         ClassGenerator.generate();
         lateBind = !isBinded();
 
@@ -435,6 +444,10 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
         }
     }
 
+    public boolean isProtocolSupport() {
+        return protocolSupport;
+    }
+
     public Map<UUID, UserConnection> getPortedPlayers() {
         return portedPlayers;
     }

src/main/java/us/myles/ViaVersion/api/ViaVersionAPI.java

@@ -125,4 +125,11 @@ public interface ViaVersionAPI {
      * @return True if spigot
      */
     boolean isSpigot();
+
+    /**
+     * Gets if protocol support is also being used.
+     *
+     * @return True if it is being used.
+     */
+    boolean isProtocolSupport();
 }

src/main/java/us/myles/ViaVersion/classgenerator/ClassGenerator.java

@@ -3,6 +3,8 @@ package us.myles.ViaVersion.classgenerator;
 import javassist.*;
 import javassist.expr.ConstructorCall;
 import javassist.expr.ExprEditor;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
 import us.myles.ViaVersion.api.ViaVersion;
 import us.myles.ViaVersion.handlers.ViaDecodeHandler;
 import us.myles.ViaVersion.handlers.ViaEncodeHandler;
@@ -10,20 +12,34 @@ import us.myles.ViaVersion.util.ReflectionUtil;
 
 public class ClassGenerator {
     private static HandlerConstructor constructor = new BasicHandlerConstructor();
+    private static String psPackage = null;
 
     public static HandlerConstructor getConstructor() {
         return constructor;
     }
 
     public static void generate() {
-        if(!ViaVersion.getInstance().isCompatSpigotBuild()) return; // Use Basic Handler as not needed.
-
+        if (ViaVersion.getInstance().isCompatSpigotBuild() || ViaVersion.getInstance().isProtocolSupport()) {
             try {
                 ClassPool pool = ClassPool.getDefault();
-            pool.insertClassPath(new LoaderClassPath(ClassGenerator.class.getClassLoader()));
+                for (Plugin p : Bukkit.getPluginManager().getPlugins()) {
+                    pool.insertClassPath(new LoaderClassPath(p.getClass().getClassLoader()));
+                }
+
+                if (ViaVersion.getInstance().isCompatSpigotBuild()) {
+                    Class decodeSuper = ReflectionUtil.nms("PacketDecoder");
+                    Class encodeSuper = ReflectionUtil.nms("PacketEncoder");
                     // Generate the classes
-            transformSuperclass(pool, ViaDecodeHandler.class, ReflectionUtil.nms("PacketDecoder"));
-            transformSuperclass(pool, ViaEncodeHandler.class, ReflectionUtil.nms("PacketEncoder"));
+                    addSpigotCompatibility(pool, ViaDecodeHandler.class, decodeSuper);
+                    addSpigotCompatibility(pool, ViaEncodeHandler.class, encodeSuper);
+                } else {
+                    Class decodeSuper = Class.forName(getPSPackage() + ".wrapped.WrappedDecoder");
+                    Class encodeSuper = Class.forName(getPSPackage() + ".wrapped.WrappedEncoder");
+                    // Generate the classes
+                    addPSCompatibility(pool, ViaDecodeHandler.class, decodeSuper);
+                    addPSCompatibility(pool, ViaEncodeHandler.class, encodeSuper);
+                }
+
 
                 // Implement Constructor
                 CtClass generated = pool.makeClass("us.myles.ViaVersion.classgenerator.generated.GeneratedConstructor");
@@ -56,16 +72,21 @@ public class ClassGenerator {
                 e.printStackTrace();
             }
         }
+    }
 
-    private static Class transformSuperclass(ClassPool pool, Class input, Class superclass) {
+    private static Class addSpigotCompatibility(ClassPool pool, Class input, Class superclass) {
         String newName = "us.myles.ViaVersion.classgenerator.generated." + input.getSimpleName();
 
         try {
-            CtClass toExtend = pool.get(superclass.getName());
             CtClass generated = pool.getAndRename(input.getName(), newName);
+            if (superclass != null) {
+                CtClass toExtend = pool.get(superclass.getName());
                 generated.setSuperclass(toExtend);
+
+                // If it's NMS satisfy constructor.
+                if (superclass.getName().startsWith("net.minecraft")) {
                     // Modify constructor to call super
-            if(generated.getConstructors().length != 0) {
+                    if (generated.getConstructors().length != 0) {
                         generated.getConstructors()[0].instrument(new ExprEditor() {
                             @Override
                             public void edit(ConstructorCall c) throws CannotCompileException {
@@ -77,6 +98,8 @@ public class ClassGenerator {
                             }
                         });
                     }
+                }
+            }
             return generated.toClass(HandlerConstructor.class.getClassLoader());
         } catch (NotFoundException e) {
             e.printStackTrace();
@@ -85,4 +108,58 @@ public class ClassGenerator {
         }
         return null;
     }
+
+    private static Class addPSCompatibility(ClassPool pool, Class input, Class superclass) {
+        String newName = "us.myles.ViaVersion.classgenerator.generated." + input.getSimpleName();
+
+        try {
+            CtClass generated = pool.getAndRename(input.getName(), newName);
+            if (superclass != null) {
+                CtClass toExtend = pool.get(superclass.getName());
+                generated.setSuperclass(toExtend);
+
+                // Override setRealEncoder / setRealDecoder
+                pool.importPackage(getPSPackage());
+                pool.importPackage(getPSPackage() + ".wrapped");
+                if (superclass.getName().endsWith("Decoder")) {
+                    // Decoder
+                    generated.addMethod(CtMethod.make("public void setRealDecoder(IPacketDecoder dec) {\n" +
+                            "        WrappedDecoder decoder = new WrappedDecoder();" +
+                            "        decoder.setRealDecoder(dec);\n" +
+                            "        this.minecraftDecoder = decoder;\n" +
+                            "    }", generated));
+                } else {
+                    // Encoder
+                    generated.addMethod(CtMethod.make("public void setRealEncoder(IPacketEncoder enc) {\n" +
+                            "        WrappedEncoder encoder = new WrappedEncoder();" +
+                            "        encoder.setRealEncoder(enc);\n" +
+                            "        this.minecraftEncoder = encoder;\n" +
+                            "    }", generated));
+                }
+            }
+            return generated.toClass(HandlerConstructor.class.getClassLoader());
+        } catch (NotFoundException e) {
+            e.printStackTrace();
+        } catch (CannotCompileException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static String getPSPackage() {
+        if (psPackage == null) {
+            try {
+                Class.forName("protocolsupport.protocol.core.IPacketDecoder");
+                psPackage = "protocolsupport.protocol.core";
+            } catch (ClassNotFoundException e) {
+                try {
+                    Class.forName("protocolsupport.protocol.pipeline.IPacketDecoder");
+                    psPackage = "protocolsupport.protocol.pipeline";
+                } catch (ClassNotFoundException e1) {
+                    psPackage = "unknown";
+                }
+            }
+        }
+        return psPackage;
+    }
 }

src/main/resources/plugin.yml

@@ -4,6 +4,7 @@ author: _MylesC
 version: ${project.version}
 load: postworld
 loadbefore: [ProtocolLib, ProxyPipe, SpigotLib, PacketListenerApi, SkinRestorer]
+softdepend: [ProtocolSupport]
 commands:
   viaversion:
     description: Shows ViaVersion Version and more.