Packets auf mehrern Spigot version

Wenn ihr bei eurem Plugin nicht weiter kommt, könnt ihr hier euer Problem beschreiben und um Hilfe bitten.

Packets auf mehrern Spigot version

Beitragvon Homerlator » Mo 10. Apr 2017, 16:40

Hey liebe Community,
wenn man einem Spieler ein Packet senden will steht bei den import oben zum Beispiel:
Code: Alles auswählen
  1. import net.minecraft.server.v1_8_R3.Vec3D;


Jetzt meine Frage:
Weiß jemand von euch wie man das Plugin auch auf anderen Spigot versionen laufen lassen kann.

Danke schonmal im vorraus.
Benutzeravatar
Homerlator
 
Beiträge: 41
Registriert: Fr 25. Mär 2016, 22:33
Wohnort: Gemünden

Re: Packets auf mehrern Spigot version

Beitragvon TheMeyss » Mo 10. Apr 2017, 20:25

Würde mich auch mal interessieren
Benutzeravatar
TheMeyss
 
Beiträge: 14
Registriert: Do 8. Sep 2016, 18:35

Re: Packets auf mehrern Spigot version

Beitragvon Kampfprofessor » Di 11. Apr 2017, 13:51

Code: Alles auswählen
  1. public final class Packets {
  2.    
  3.    private String version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
  4.    public void sendPacket(Player player, Object packet) {
  5.       try {
  6.          Object entityPlayer = player.getClass().getMethod("getHandle").invoke(player);
  7.          Object playerConnection = entityPlayer.getClass().getField("playerConnection").get(entityPlayer);
  8.          playerConnection.getClass().getMethod("sendPacket", Class.forName("net.minecraft.server." + version + ".Packet")).invoke(playerConnection, packet);
  9.       } catch (Exception e) {
  10.          e.printStackTrace();
  11.       }
  12.    }
  13.    
  14.    public void example(Player player) {
  15.       try {
  16.          Object chatComponentText = Class.forName("net.minecraft.server." + version + ".ChatComponentText").getConstructor(String.class).newInstance("This is a test!");
  17.          Object packetPlayOutKickDisconnect = Class.forName("net.minecraft.server." + version + ".PacketPlayOutKickDisconnect").getConstructor(Class.forName("net.minecraft.server." + version + ".IChatBaseComponent")).newInstance(chatComponentText);
  18.          sendPacket(player, packetPlayOutKickDisconnect);
  19.       } catch (Exception e) {
  20.          e.printStackTrace();
  21.       }
  22.    }
  23. }


Müsste funktionieren, habe ich jedoch nicht ausprobiert.
Benutzeravatar
Kampfprofessor
 
Beiträge: 71
Registriert: Fr 12. Feb 2016, 15:48

Re: Packets auf mehrern Spigot version

Beitragvon Knadda » Mi 12. Apr 2017, 19:38

Da musst du mit Reflections arbeiten. Das ist meine Reflectionsklasse. Die kannst du benutzen :D :
Code: Alles auswählen
  1. package org.tab;
  2. import java.lang.reflect.Array;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  6. import java.lang.reflect.Modifier;
  7. import java.util.Arrays;
  8. import java.util.HashMap;
  9. import java.util.Iterator;
  10. import java.util.List;
  11. import java.util.Map;
  12. import org.bukkit.Bukkit;
  13. import com.google.common.collect.Lists;
  14. public final class Reflections {
  15.    
  16.    private static final String NMS_PATH = "net.minecraft.server.[VERSION]";
  17.    private static final String BUKKIT_PATH = "org.bukkit.craftbukkit.[VERSION]";
  18.    public static final ClassPacket NMS = new ClassPacket(NMS_PATH);
  19.    public static final ReflectBukkitPacket BUKKIT = new ReflectBukkitPacket(BUKKIT_PATH);
  20.    public static final MethodManager METHODS = new MethodManager();
  21.    public static final FieldManager FIELDS = new FieldManager();
  22.    public static final ObjectManager OBJECTS = new ObjectManager();
  23.  
  24.    public static final class ReflectBukkitPacket extends ClassPacket {
  25.       
  26.       public final Reflections.ClassPacket BLOCK;
  27.       public final Reflections.ClassPacket BOSSBAR;
  28.       public final Reflections.ReflectBukkitPacketCommand COMMAND;
  29.        public final Reflections.ClassPacket ENCHANT;
  30.        public final Reflections.ClassPacket ENTITY;
  31.        public final Reflections.ClassPacket EVENT;
  32.        public final Reflections.ClassPacket GENERATOR;
  33.        public final Reflections.ClassPacket HELP;
  34.        public final Reflections.ClassPacket INVENTORY;
  35.        public final Reflections.ClassPacket MAP;
  36.        public final Reflections.ClassPacket METADATA;
  37.        public final Reflections.ClassPacket POTION;
  38.        public final Reflections.ClassPacket PROJECTILES;
  39.        public final Reflections.ClassPacket SCHEDULER;
  40.        public final Reflections.ClassPacket SCOREBOARD;
  41.        public final Reflections.ReflectBukkitPacketUtil UTIL;
  42.       
  43.        ReflectBukkitPacket(final String arg0) {
  44.           super(arg0);
  45.           this.BLOCK = new Reflections.ClassPacket(this.path + ".block");
  46.           this.BOSSBAR = new Reflections.ClassPacket(this.path + ".boss");
  47.           this.COMMAND = new Reflections.ReflectBukkitPacketCommand(this.path + ".command");
  48.           this.ENCHANT = new Reflections.ClassPacket(this.path + ".enchantments");
  49.           this.ENTITY = new Reflections.ClassPacket(this.path + ".entity");
  50.           this.EVENT = new Reflections.ClassPacket(this.path + ".event");
  51.           this.GENERATOR = new Reflections.ClassPacket(this.path + ".generator");
  52.           this.HELP = new Reflections.ClassPacket(this.path + ".help");
  53.           this.INVENTORY = new Reflections.ClassPacket(this.path + ".inventory");
  54.           this.MAP = new Reflections.ClassPacket(this.path + ".map");
  55.           this.METADATA = new Reflections.ClassPacket(this.path + ".metadata");
  56.           this.POTION = new Reflections.ClassPacket(this.path + ".potion");
  57.           this.PROJECTILES = new Reflections.ClassPacket(this.path + ".projectiles");
  58.           this.SCHEDULER = new Reflections.ClassPacket(this.path + ".scheduler");
  59.           this.SCOREBOARD = new Reflections.ClassPacket(this.path + ".scoreboard");
  60.           this.UTIL = new Reflections.ReflectBukkitPacketUtil(this.path + ".util");
  61.        }
  62.        @Override
  63.       public String toString() {
  64.           return this.path;
  65.        }
  66.    }
  67.    public static String getPackageVersion() {
  68.       return Bukkit.getServer().getClass().getPackage().getName().substring(23);
  69.    }
  70.    public static int getServerVersion() {
  71.       return Integer.valueOf(String.valueOf(getPackageVersion().split("_")[1])).intValue();
  72.    }
  73.    public static int getReleaseVersion() {
  74.       return Integer.valueOf(String.valueOf(getPackageVersion().split("_")[2].substring(1))).intValue();
  75.    }
  76.    public static boolean instanceOf(final Object arg0, final Class<?> arg1) {
  77.       return arg1.isInstance(arg0);
  78.    }
  79.    public static ClassPacket getPackage(final String arg0) {
  80.       return new ClassPacket(arg0);
  81.    }
  82.    public static final class ReflectBukkitPacketCommand extends ClassPacket {
  83.       
  84.       public final ClassPacket DEFAULTS;
  85.    
  86.       ReflectBukkitPacketCommand(final String arg0) {
  87.          super(arg0);
  88.          this.DEFAULTS = new Reflections.ClassPacket(this + ".defaults");
  89.       }
  90.    }
  91.    public static final class ReflectBukkitPacketUtil extends ClassPacket {
  92.       
  93.       public final Reflections.ClassPacket PERMISSION;
  94.    
  95.       ReflectBukkitPacketUtil(final String arg0) {
  96.          super(arg0);
  97.          this.PERMISSION = new Reflections.ClassPacket(this + ".permissions");
  98.       }
  99.    }
  100.    public static class ClassPacket {
  101.     
  102.       protected final String path;
  103.    
  104.       ClassPacket(final String arg0) {
  105.          this.path = arg0.replace("[VERSION]", Reflections.getPackageVersion());
  106.       }
  107.       public synchronized boolean hasClass(final String className) {
  108.          return this.getClass(className) != null;
  109.       }
  110.       public synchronized Class<?> getClass(final String className) {
  111.          try {
  112.             if (className.contains(".")) {
  113.                final String[] strings = className.replace(".", "@").split("@");
  114.                final String[] raw = new String[strings.length - 1];
  115.                for (int i = 1; i < strings.length; i++) {
  116.                   raw[i - 1] = strings[i];
  117.                }
  118.                Class<?> target = this.getClass(strings[0]);
  119.                Class<?> searched = null;
  120.                final List<Class<?>> classes = Lists.newArrayList();
  121.                classes.addAll(Arrays.asList(target.getClasses()));
  122.                classes.addAll(Arrays.asList(target.getDeclaredClasses()));
  123.                if (target != null) {
  124.                   int index = 0;
  125.                   final Iterator<Class<?>> localIterator = classes.iterator();
  126.                      for (; searched == null && index < raw.length; localIterator.hasNext()) {
  127.                         if (classes.size() < 1 || index >= raw.length) {
  128.                            break;
  129.                         }
  130.                         final Class<?> class1 = localIterator.next();
  131.                         if (class1.getSimpleName().equals(raw[index])) {
  132.                            if (index == raw.length - 1) {
  133.                               searched = class1;
  134.                            } else {
  135.                               index++;
  136.                               target = class1;
  137.                            }
  138.                         }
  139.                      }
  140.                   }
  141.                   return searched;
  142.             }
  143.             return Class.forName(this.path + "." + className);
  144.          }
  145.          catch (final Exception localException) {}
  146.          return null;
  147.       }
  148.       public Object getClassEnum(final String arg0, final String arg1) {
  149.          final Class<?> clazz = this.getClass(arg0);
  150.          if (clazz != null && clazz.isEnum()) {
  151.             for (final Object object : clazz.getEnumConstants()) {
  152.                if (object.toString().equalsIgnoreCase(arg1)) {
  153.                   return object;
  154.                }
  155.             }
  156.          }
  157.          return null;
  158.       }
  159.       @Override
  160.       public String toString() {
  161.          return this.path;
  162.       }
  163.    }
  164.    public static final class MethodManager {
  165.     
  166.       private synchronized Method getMethod(final Class<?> clazz, final String methodName, final Class<?>... parameterTypes) {
  167.          final Class<?>[] primitiveTypes = Data.getPrimitive(parameterTypes);
  168.          Method method = null;
  169.          for (final Method method2 : clazz.getDeclaredMethods()) {
  170.             if (Data.compare(Data.getPrimitive(method2.getParameterTypes()), primitiveTypes) && method2.getName().equals(methodName)) {
  171.                method2.setAccessible(true);
  172.                return method2;
  173.             }
  174.          }
  175.          if (method == null && clazz.getSuperclass() != null) {
  176.             method = this.getMethod(clazz.getSuperclass(), methodName, parameterTypes);
  177.          }
  178.          return method;
  179.       }
  180.       public synchronized Object invoke(final Object instance, final String methodName, final Object... parameterTypes) {
  181.          if (instance != null) {
  182.             final Method method = this.getMethod(instance.getClass(), methodName, Data.getPrimitive(parameterTypes));
  183.             if (method != null) {
  184.                this.setMethodModifiers(method, Modifiers.PUBLIC);
  185.                try {
  186.                   return method.invoke(instance, parameterTypes);
  187.                } catch (final Exception e) {
  188.                   e.printStackTrace();
  189.                }
  190.             }
  191.          }
  192.          return null;
  193.       }
  194.       public synchronized Object invokeStatic(final Class<?> instance, final String methodName, final Object... parameterTypes) {
  195.          final Method method = this.getMethod(instance, methodName, Data.getPrimitive(parameterTypes));
  196.          if (method != null && Modifier.isStatic(method.getModifiers())) {
  197.             this.setMethodModifiers(method, Modifiers.PUBLIC, Modifiers.STATIC);
  198.             try {
  199.                return method.invoke(null, parameterTypes);
  200.             } catch (final Exception e) {
  201.                e.printStackTrace();
  202.             }
  203.          }
  204.          return null;
  205.       }
  206.       private synchronized void setMethodModifiers(final Method method, final Modifiers... modifiers) {
  207.          try {
  208.             final Field modifiersField = Method.class.getDeclaredField("modifiers");
  209.             modifiersField.setAccessible(true);
  210.             method.setAccessible(true);
  211.             int value = 0;
  212.             for (final Modifiers modifier : modifiers) {
  213.                value += modifier.getValue();
  214.             }
  215.             modifiersField.setInt(method, value);
  216.          } catch (final Exception e) {
  217.             e.printStackTrace();
  218.          }
  219.       }
  220.    }
  221.    public static final class FieldManager {
  222.       
  223.       private synchronized Field getField(final Class<?> clazz, final String fieldName) {
  224.          Field field = null;
  225.          for (final Field field2 : clazz.getDeclaredFields()) {
  226.             if (field2.getName().equals(fieldName)) {
  227.                field2.setAccessible(true);
  228.                field = field2;
  229.             }
  230.          }
  231.          if (clazz.getSuperclass() != null && field == null) {
  232.             field = this.getField(clazz.getSuperclass(), fieldName);
  233.          }
  234.          return field;
  235.       }
  236.       private List<Field> getFields(final Class<?> clazz, final Object instance) {
  237.          final List<Field> fields = Lists.newArrayList();
  238.          for (final Field field : clazz.getDeclaredFields()) {
  239.             field.setAccessible(true);
  240.             if (Modifier.isStatic(field.getModifiers())) {
  241.                this.setFieldModifiers(field, Modifiers.PUBLIC, Modifiers.STATIC);
  242.                try {
  243.                   fields.add(field);
  244.                } catch (final Exception e) {
  245.                   e.printStackTrace();
  246.                }
  247.             } else {
  248.                this.setFieldModifiers(field, Modifiers.PUBLIC);
  249.                try {
  250.                   fields.add(field);
  251.                }
  252.                catch (final Exception e) {
  253.                   e.printStackTrace();
  254.                }
  255.             }
  256.          }
  257.          if (clazz.getSuperclass() != null) {
  258.             fields.addAll(this.getFields(clazz.getSuperclass(), instance));
  259.          }
  260.          return fields;
  261.       }
  262.       private synchronized Field getField(final Class<?> clazz, final Object instance, final Class<?> fieldType) {
  263.          for (final Field field : this.getFields(clazz, instance)) {
  264.             if (field.getType().equals(fieldType)) {
  265.                return field;
  266.             }
  267.          }
  268.          return null;
  269.       }
  270.       public synchronized Object getValue(final Object instance, final Class<?> fieldType) {
  271.          return this.getValue(instance.getClass(), instance, fieldType);
  272.       }
  273.       public synchronized Object getValue(final Class<?> clazz, final Object instance, final Class<?> fieldType) {
  274.          final Field field = this.getField(clazz, instance, fieldType);
  275.          if (field != null) {
  276.             if (Modifier.isStatic(field.getModifiers())) {
  277.                this.setFieldModifiers(field, Modifiers.PUBLIC, Modifiers.STATIC);
  278.                try {
  279.                   return field.get(null);
  280.                }
  281.                catch (final Exception e) {
  282.                   e.printStackTrace();
  283.                }
  284.             } else {
  285.                this.setFieldModifiers(field, Modifiers.PUBLIC);
  286.                try {
  287.                   return field.get(instance);
  288.                }
  289.                catch (final Exception e) {
  290.                   e.printStackTrace();
  291.                }
  292.             }
  293.          }
  294.          else if (clazz.getSuperclass() != null) {
  295.             return this.getValue(clazz.getSuperclass(), instance, fieldType);
  296.          }
  297.          return null;
  298.       }
  299.       public synchronized void setValue(final Object instance, final Class<?> fieldType, final Object value) {
  300.          this.setValue(instance.getClass(), instance, fieldType, value);
  301.       }
  302.       public synchronized void setValue(final Class<?> clazz, final Object instance, final Class<?> fieldType, final Object value) {
  303.          final Field field = this.getField(clazz, instance, fieldType);
  304.          if (field != null) {
  305.             if (Modifier.isStatic(field.getModifiers())) {
  306.                this.setFieldModifiers(field, Modifiers.PUBLIC, Modifiers.STATIC);
  307.                try {
  308.                   field.set(null, value);
  309.                }
  310.                catch (final Exception e) {
  311.                   e.printStackTrace();
  312.                }
  313.             } else {
  314.                this.setFieldModifiers(field, Modifiers.PUBLIC);
  315.                try {
  316.                   field.set(instance, value);
  317.                } catch (final Exception e) {
  318.                   e.printStackTrace();
  319.                }
  320.             }
  321.          }
  322.          else if (clazz.getSuperclass() != null && field == null) {
  323.             this.setValue(clazz.getSuperclass(), instance, fieldType, value);
  324.          }
  325.       }
  326.       public synchronized Object getValue(final Object instance, final String fieldName) {
  327.          return this.getValue(instance.getClass(), instance, fieldName);
  328.       }
  329.       public synchronized Object getValue(final Class<?> clazz, final Object instance, final String fieldName) {
  330.          final Field field = this.getField(clazz, fieldName);
  331.          if (field != null) {
  332.             if (Modifier.isStatic(field.getModifiers())) {
  333.                this.setFieldModifiers(field, Modifiers.PUBLIC, Modifiers.STATIC);
  334.                try {
  335.                   return field.get(null);
  336.                } catch (final Exception e) {
  337.                   e.printStackTrace();
  338.                }
  339.             } else {
  340.                this.setFieldModifiers(field, Modifiers.PUBLIC);
  341.                try {
  342.                   return field.get(instance);
  343.                } catch (final Exception e) {
  344.                   e.printStackTrace();
  345.                }
  346.             }
  347.          }
  348.          else if (clazz.getSuperclass() != null) {
  349.             return this.getValue(clazz.getSuperclass(), instance, fieldName);
  350.          }
  351.          return null;
  352.       }
  353.       public synchronized void setValue(final Object instance, final String fieldName, final Object value) {
  354.          this.setValue(instance.getClass(), instance, fieldName, value);
  355.       }
  356.       public synchronized void setValue(final Class<?> clazz, final Object instance, final String fieldName, final Object value) {
  357.          final Field field = this.getField(clazz, fieldName);
  358.          if (field != null) {
  359.             if (Modifier.isStatic(field.getModifiers())) {
  360.                this.setFieldModifiers(field, Modifiers.PUBLIC, Modifiers.STATIC);
  361.                try {
  362.                   field.set(null, value);
  363.                } catch (final Exception e) {
  364.                   e.printStackTrace();
  365.                }
  366.             } else {
  367.                this.setFieldModifiers(field, Modifiers.PUBLIC);
  368.                try {
  369.                   field.set(instance, value);
  370.                } catch (final Exception e) {
  371.                   e.printStackTrace();
  372.                }
  373.             }
  374.          }
  375.          else if (clazz.getSuperclass() != null && field == null) {
  376.             this.setValue(clazz.getSuperclass(), instance, fieldName, value);
  377.          }
  378.       }
  379.       private synchronized void setFieldModifiers(final Field field, final Modifiers... modifiers) {
  380.          try {
  381.             final Field modifiersField = Field.class.getDeclaredField("modifiers");
  382.             modifiersField.setAccessible(true);
  383.             field.setAccessible(true);
  384.             int value = 0;
  385.             for (final Modifiers modifier : modifiers) {
  386.                value += modifier.getValue();
  387.             }
  388.             modifiersField.setInt(field, value);
  389.          } catch (final Exception e) {
  390.             e.printStackTrace();
  391.          }
  392.       }
  393.    }
  394.    public static final class ObjectManager {
  395.       
  396.       private synchronized Constructor<?> getConstructor(final Class<?> clazz, final Class<?>... parameterTypes) {
  397.          final Class<?>[] primitiveTypes = Data.getPrimitive(parameterTypes);
  398.          for (final Constructor<?> constructor : clazz.getDeclaredConstructors()) {
  399.             if (Data.compare(Data.getPrimitive(constructor.getParameterTypes()), primitiveTypes)) {
  400.                constructor.setAccessible(true);
  401.                return constructor;
  402.             }
  403.          }
  404.          return null;
  405.       }
  406.       public synchronized Object getObject(final Class<?> clazz, final Object... arguments) {
  407.          try {
  408.             final Constructor<?> con = this.getConstructor(clazz, Data.getPrimitive(arguments));
  409.             if (con != null) {
  410.                this.setObjectModifiers(con, Modifiers.PUBLIC);
  411.                return con.newInstance(arguments);
  412.             }
  413.          } catch (final Exception e) {
  414.             e.printStackTrace();
  415.          }
  416.          return null;
  417.       }
  418.       public synchronized Object[] getObjectArray(final Object... values) {
  419.          try {
  420.             if (values != null && values.length >= 1) {
  421.                final Object[] array = (Object[])Array.newInstance(values[0].getClass(), values.length);
  422.                for (int i = 0; i < values.length; i++) {
  423.                   Array.set(array, i, values[i]);
  424.                }
  425.                return array;
  426.             }
  427.          } catch (final Exception e) {
  428.             e.printStackTrace();
  429.          }
  430.          return null;
  431.       }
  432.       private synchronized void setObjectModifiers(final Constructor<?> constructor, final Modifiers... modifiers) {
  433.          try {
  434.             final Field modifiersField = Constructor.class.getDeclaredField("modifiers");
  435.             modifiersField.setAccessible(true);
  436.             constructor.setAccessible(true);
  437.             int value = 0;
  438.             for (final Modifiers modifier : modifiers) {
  439.                value += modifier.getValue();
  440.             }
  441.             modifiersField.setInt(constructor, value);
  442.          } catch (final Exception e) {
  443.             e.printStackTrace();
  444.          }
  445.       }
  446.    }
  447.    public static enum Modifiers {   
  448.       ABSTRACT(1024),
  449.       FINAL(16),
  450.       INTERFACE(512),
  451.       NATIVE(256),
  452.       PRIVATE(2),
  453.       PROTECTED(4),
  454.       PUBLIC(1),
  455.       STATIC(8),
  456.       STRICT(2048),
  457.       SYNCHRONIZED(32),
  458.       TRANSIENT(128),
  459.       VOLATILE(64);
  460.    
  461.       private final int value;
  462.    
  463.       private Modifiers(final int arg0) {
  464.          this.value = arg0;
  465.       }
  466.       public int getValue() {
  467.          return this.value;
  468.       }
  469.       public boolean isPublic(final Field arg0) {
  470.          return arg0.getModifiers() == PUBLIC.value;
  471.       }
  472.       public boolean isPrivate(final Field arg0) {
  473.          return arg0.getModifiers() == PRIVATE.value;
  474.       }
  475.       public boolean isProtected(final Field arg0) {
  476.          return arg0.getModifiers() == PROTECTED.value;
  477.       }
  478.       @Override
  479.       public String toString() {
  480.          return String.valueOf(this.value);
  481.       }
  482.    }
  483.    protected static enum Data {
  484.       BYTE(Byte.TYPE, Byte.class),
  485.       SHORT(Short.TYPE, Short.class),
  486.       INTEGER(Integer.TYPE, Integer.class),
  487.       LONG(Long.TYPE, Long.class),
  488.       CHARACTER(Character.TYPE, Character.class),
  489.       FLOAT(Float.TYPE, Float.class),
  490.       DOUBLE(Double.TYPE, Double.class),
  491.       BOOLEAN(Boolean.TYPE, Boolean.class);
  492.    
  493.       private static Map<Class<?>, Data> CLASS_MAP;
  494.       private final Class<?> primitive;
  495.       private final Class<?> reference;
  496.    
  497.       static {
  498.          CLASS_MAP = new HashMap<Class<?>, Data>();
  499.          for (final Data type : values()) {
  500.             CLASS_MAP.put(type.primitive, type);
  501.             CLASS_MAP.put(type.reference, type);
  502.          }
  503.       }
  504.       private Data(final Class<?> primitive, final Class<?> reference) {
  505.          this.primitive = primitive;
  506.          this.reference = reference;
  507.       }
  508.       public Class<?> getPrimitive() {
  509.          return this.primitive;
  510.       }
  511.       public Class<?> getReference() {
  512.          return this.reference;
  513.       }
  514.       public static Data fromClass(final Class<?> clazz) {
  515.          return CLASS_MAP.get(clazz);
  516.       }
  517.       public static Class<?> getPrimitive(final Class<?> clazz) {
  518.          final Data type = fromClass(clazz);
  519.          return type == null ? clazz : type.getPrimitive();
  520.       }
  521.       public static Class<?> getReference(final Class<?> clazz) {
  522.          final Data type = fromClass(clazz);
  523.          return type == null ? clazz : type.getReference();
  524.       }
  525.       public static Class<?>[] getPrimitive(final Class<?>[] classes) {
  526.          final int length = classes == null ? 0 : classes.length;
  527.          final Class<?>[] types = new Class[length];
  528.          for (int index = 0; index < length; index++) {
  529.             types[index] = getPrimitive(classes[index]);
  530.          }
  531.          return types;
  532.       }
  533.       public static Class<?>[] getReference(final Class<?>[] classes) {
  534.          final int length = classes == null ? 0 : classes.length;
  535.          final Class<?>[] types = new Class[length];
  536.          for (int index = 0; index < length; index++) {
  537.             types[index] = getReference(classes[index]);
  538.          }
  539.          return types;
  540.       }
  541.       public static Class<?>[] getPrimitive(final Object[] objects) {
  542.          final int length = objects == null ? 0 : objects.length;
  543.          final Class<?>[] types = new Class[length];
  544.          for (int index = 0; index < length; index++) {
  545.             types[index] = getPrimitive(objects[index].getClass());
  546.          }
  547.          return types;
  548.       }
  549.       public static Class<?>[] getReference(final Object[] objects) {
  550.          final int length = objects == null ? 0 : objects.length;
  551.          final Class<?>[] types = new Class[length];
  552.          for (int index = 0; index < length; index++) {
  553.             types[index] = getReference(objects[index].getClass());
  554.          }
  555.          return types;
  556.       }
  557.       public static boolean compare(final Class<?>[] primary, final Class<?>[] secondary) {
  558.          if (primary == null || secondary == null || primary.length != secondary.length) {
  559.             return false;
  560.          }
  561.          for (int index = 0; index < primary.length; index++) {
  562.             final Class<?> primaryClass = primary[index];
  563.             final Class<?> secondaryClass = secondary[index];
  564.             if (!primaryClass.equals(secondaryClass) && !primaryClass.isAssignableFrom(secondaryClass)) {
  565.                return false;
  566.             }
  567.          }
  568.          return true;
  569.       }
  570.    }
  571. }


Beispiel:
Title an Spieler "player" senden

Code: Alles auswählen
  1.          final Player player = null;
  2.          final Object action = Reflections.NMS.getClassEnum("PacketPlayOutTitle.EnumTitleAction", "TITLE");
  3.          final Object component = Reflections.OBJECTS.getObject(Reflections.NMS.getClass("ChatComponentText"), ChatColor.translateAlternateColorCodes('&', "&6Hier könnte ihre Werbung stehen"));
  4.          final Object packet = Reflections.OBJECTS.getObject(Reflections.NMS.getClass("PacketPlayOutTitle"), action, component);
  5.          Reflections.METHODS.invoke(Reflections.FIELDS.getValue(Reflections.METHODS.invoke(player, "getHandle"), "playerConnection"), "sendPacket", packet);
Benutzeravatar
Knadda
 
Beiträge: 49
Registriert: Mo 1. Aug 2016, 07:06

Re: Packets auf mehrern Spigot version

Beitragvon Homerlator » Mo 17. Apr 2017, 20:06

Danke für die Antworten :)

Knadda könntest du mir das vielleicht anhand diesem Packet mal erklären?

Code: Alles auswählen
  1. ((CraftPlayer)target).getHandle().playerConnection.sendPacket(new PacketPlayOutExplosion(1D, 2D, 3D, 4F, Collections.EMPTY_LIST, new Vec3D(1D, 2D, 3D)));
Benutzeravatar
Homerlator
 
Beiträge: 41
Registriert: Fr 25. Mär 2016, 22:33
Wohnort: Gemünden


Zurück zu Hilfe und Support

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 8 Gäste