[Util] Version independent NMSPacket class

I wrote this some time ago because I needed to use packets, but I really didn't want to go through importing NMS and making the plugin version-specific.

It's completely version-independent and does not rely on external libraries or CraftBukkit.

Variables inside of it:

• packageName - Used to get the NMS version.
• version - The version. See above.
• packet - The packet itself; note that it's an Object.
• nmsPacket - The packet class.

Methods:

• NMSPacket(String packetName) - Constructs a NMSPacket; use the full name of the Packet, example: new NMSPacket("Packet201PlayerInfo")
• setField(String, Object) - Sets a non-private field to Object. (Using this on a private member would throw a FieldNotFoundException)
• setDeclaredField(String, Object) - Sets a private field.
• getField(String) - Get's a non-private variable inside of the packet.
• getDeclaredField - Get's a private variable.
• getPacketClass - Returns the packet class.
• getPacket - Returns the packet object.
• isUsable - Checks if "packet" is not null; useful if you're working with user-input or something similar.

Note that getField and getDeclaredField will return null and print an exception if it cannot find the field. setField and setDeclaredField will only print an exception.

Code:java

package com.tenko.nms;
 
import java.lang.reflect.Field;
 
public class NMSPacket {
 
    private static String packageName = Bukkit.getServer().getClass().getPackage().getName();
    private static String version = packageName.substring(packageName.lastIndexOf(".") + 1);
 
    private Object packet;
    private Class<?> nmsPacket;
 
    public NMSPacket(String packetName){
        try {
            nmsPacket = Class.forName("net.minecraft.server." + version + "." + packetName);
            packet = nmsPacket.newInstance();
        } catch (Exception e){
            e.printStackTrace();
            packet = null;
            nmsPacket = null;
        }
 
    }
    public void setField(String fieldName, Object value){
        try {
            Field f = packet.getClass().getField(fieldName);
            f.setAccessible(true);
            f.set(packet, value);
            f.setAccessible(false);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
 
    public void setDeclaredField(String fieldName, Object value){
        try {
            Field f = packet.getClass().getDeclaredField(fieldName);
            f.setAccessible(true);
            f.set(packet, value);
            f.setAccessible(false);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
 
    public Object getField(String fieldName){
        try {
            Field f = packet.getClass().getField(fieldName);
            f.setAccessible(true);
            Object s = f.get(packet);
            f.setAccessible(false);
            return s;
        } catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
 
    public Object getDeclaredField(String fieldName){
        try {
            Field f = packet.getClass().getDeclaredField(fieldName);
            f.setAccessible(true);
            Object s = f.get(packet);
            f.setAccessible(false);
            return s;
        } catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
 
    public Class<?> getPacketClass(){
        return nmsPacket;
    }
 
    public Object getPacket(){
        return packet;
    }
 
    public boolean isUsable(){
        return packet != null;
    }
 
}

You can send these packet objects like so:

Code:java

    public static void sendPacket(Player plyr, Object o){
        try {
            Class<?> packet = Class.forName("net.minecraft.server." + version + ".Packet");
            Class<?> craftPlayer = Class.forName("org.bukkit.craftbukkit." + version + ".entity.CraftPlayer");
 
            if(!packet.isAssignableFrom(o.getClass())){
                throw new IllegalArgumentException("Object o wasn't a packet!");
            }
 
            Object cp = craftPlayer.cast(plyr);
            Object handle = craftPlayer.getMethod("getHandle").invoke(cp);
            Object con = handle.getClass().getField("playerConnection").get(handle);
            con.getClass().getMethod("sendPacket", packet).invoke(con, o);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
 
    public static void sendPackets(Object o){
        try {
            Class<?> packet = Class.forName("net.minecraft.server." + version + ".Packet");
            Class<?> craftPlayer = Class.forName("org.bukkit.craftbukkit." + version + ".entity.CraftPlayer");
            for (Player plyr : Bukkit.getOnlinePlayers()){
                if(!packet.isAssignableFrom(o.getClass())){
                    throw new IllegalArgumentException("Object o wasn't a packet!");
                }
 
                Object cp = craftPlayer.cast(plyr);
                Object handle = craftPlayer.getMethod("getHandle").invoke(cp);
                Object con = handle.getClass().getField("playerConnection").get(handle);
                con.getClass().getMethod("sendPacket", packet).invoke(con, o);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }

Example:

Code:java

NMSPacket packet = new NMSPacket("Packet0KeepAlive");
packet.setField("a", 9);
//Send the packet to every player
sendPackets(packet.getPacket());
//Send packet to only Cirno
sendPackets(Bukkit.getExactPlayer("Cirno"));

I edited this a bit and did a bit of double-checking, but if there is a mistake, please report it

 

I don't think this is allowed. I believe one of the rules for when they started using the dynamic package names was that you can't create a work around like this as the point in the dynamic package names was so that plugin developers are somewhat forced to look through all of their NMS code for changes so as to avoid plugins breaking servers from careless developers.

 

Jogy34 Well yeah, that was the actual point of the version in the package name, but most of the developers don't like to update their plugin every time a new bukkit version comes out, because it always takes some time until the new version is approved by mods! It's not safe though as you said that method names can change and this will be break the plugin, but NMS methods are rarely changed so it's not a big problem. I think the only advantage of importing NMS classes and using is that you can see in Eclipse when something has changed and you can easily correct it, on the other hand you'd also see that something isn't working anymore if you test your plugin (which uses reflection) after a new bukkit version comes out.

 

A lot of NMS methods change on every minecraft version release. I run into problems on my own plugins that use a lot of NMS code to where I have to end up going through the updated NMS classes and search for the method that did one thing before but another thing now. Minecraft uses some sort of generalization thing with its code. That's why you see the classes a, aa, aaa, ab, b, bc, etc... and all the methods in there are also changed in a simmilar way to where the methods are a(), a(someObject), a(someOtherObject), b(), etc... and although the methods themselves may not change the name that they use can easily change between minecraft versions.

 

Jogy34 They use Obfuscation...