fixes

Author: dmulloy2

src/main/java/com/comphenix/protocol/events/AbstractStructure.java

@@ -845,6 +845,14 @@ public StructureModifier<PotionEffectType> getEffectTypes() {
                 BukkitConverters.getEffectTypeConverter());
     }
 
+    /**
+     * Retrieve a read/write structure for {@code Holder<DamageType>} fields.
+     * @return A modifier for DamageType Holder fields.
+     */
+    public StructureModifier<org.bukkit.damage.DamageType> getDamageTypes() {
+        return getHolders(MinecraftReflection.getDamageTypeClass(), BukkitConverters.getDamageTypeConverter());
+    }
+
     /**
      * Retrieve a read/write structure for the SoundCategory enum in 1.9.
      * @return A modifier for SoundCategory enum fields.

src/main/java/com/comphenix/protocol/injector/EquivalentConstructor.java

@@ -2,10 +2,13 @@
 
 import com.comphenix.protocol.PacketType;
 import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.FuzzyReflection;
 import com.comphenix.protocol.reflect.accessors.Accessors;
 import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
 import com.comphenix.protocol.utility.Tuple;
 
+import java.lang.reflect.Constructor;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -41,7 +44,10 @@ public Object create(Object... args) {
             for (int i = 0; i < converters.size(); i++) {
                 params[i] = converters.get(i).first();
             }
-            constructorAccessor = Accessors.getConstructorAccessor(packetType.getPacketClass(), params);
+
+            Constructor<?> ctor = FuzzyReflection.fromClass(packetType.getPacketClass(), true)
+                        .getConstructor(FuzzyMethodContract.newBuilder().parameterExactArray(params).build());
+            constructorAccessor = Accessors.getConstructorAccessor(ctor);
         }
 
         Object[] convertedArgs = new Object[args.length];

src/main/java/com/comphenix/protocol/utility/MinecraftReflection.java

@@ -928,6 +928,10 @@ public static Class<?> getMobEffectListClass() {
         return getMinecraftClass("world.effect.MobEffectList", "MobEffectList", "world.effect.MobEffect", "world.effect.MobEffects");
     }
 
+    public static Class<?> getDamageTypeClass() {
+        return getMinecraftClass("world.damagesource.DamageType");
+    }
+
     public static Class<?> getSoundEffectClass() {
         return getNullableNMS("sounds.SoundEffect", "sounds.SoundEvent", "SoundEffect", "sounds.SoundEvents");
     }

src/main/java/com/comphenix/protocol/wrappers/AutoWrapper.java

@@ -22,6 +22,7 @@
 import com.google.common.base.Defaults;
 import com.google.common.base.Preconditions;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -165,12 +166,26 @@ private void computeNmsConstructorAccess() {
                 nmsInstanceCreator = noArgs;
                 nmsDefaultArgs = NO_ARGS;
             } else {
-                // use the first constructor of the class
-                nmsInstanceCreator = Accessors.getConstructorAccessor(nmsClass.getDeclaredConstructors()[0]);
-                nmsDefaultArgs = Arrays
-                        .stream(nmsInstanceCreator.getConstructor().getParameterTypes())
-                        .map(type -> type.isPrimitive() ? Defaults.defaultValue(type) : null)
-                        .toArray(Object[]::new);
+                // No no-arg constructor. For records (and most NMS data classes) the canonical
+                // constructor has one parameter per non-static field; that's the one we want.
+                // Other constructors (e.g. FriendlyByteBuf decoders) take a single network-buffer
+                // argument and would call methods on it during construction, so they're unsafe to
+                // invoke with default values.
+                Constructor<?>[] ctors = nmsClass.getDeclaredConstructors();
+                Constructor<?> chosen = ctors[0];
+                for (int i = 1; i < ctors.length; i++) {
+                    if (ctors[i].getParameterCount() > chosen.getParameterCount()) {
+                        chosen = ctors[i];
+                    }
+                }
+                nmsInstanceCreator = Accessors.getConstructorAccessor(chosen);
+                Class<?>[] paramTypes = chosen.getParameterTypes();
+                nmsDefaultArgs = new Object[paramTypes.length];
+                for (int i = 0; i < paramTypes.length; i++) {
+                    nmsDefaultArgs[i] = paramTypes[i].isPrimitive()
+                            ? Defaults.defaultValue(paramTypes[i])
+                            : null;
+                }
             }
         }
     }

src/main/java/com/comphenix/protocol/wrappers/BukkitConverters.java

@@ -1428,6 +1428,47 @@ public PotionEffectType getSpecific(Object generic) {
         });
     }
 
+    private static MethodAccessor damageTypeToNms = null;
+    private static MethodAccessor damageTypeFromNms = null;
+
+    public static EquivalentConverter<org.bukkit.damage.DamageType> getDamageTypeConverter() {
+        return ignoreNull(new EquivalentConverter<org.bukkit.damage.DamageType>() {
+
+            @Override
+            public Class<org.bukkit.damage.DamageType> getSpecificType() {
+                return org.bukkit.damage.DamageType.class;
+            }
+
+            @Override
+            public Object getGeneric(org.bukkit.damage.DamageType specific) {
+                if (damageTypeToNms == null) {
+                    Class<?> craftDamageType = getCraftBukkitClass("damage.CraftDamageType");
+                    FuzzyReflection fuzzy = FuzzyReflection.fromClass(craftDamageType, false);
+                    damageTypeToNms = Accessors.getMethodAccessor(fuzzy.getMethod(FuzzyMethodContract.newBuilder()
+                            .parameterExactArray(org.bukkit.damage.DamageType.class)
+                            .returnTypeExact(MinecraftReflection.getDamageTypeClass())
+                            .requireModifier(Modifier.STATIC)
+                            .build()));
+                }
+                return damageTypeToNms.invoke(null, specific);
+            }
+
+            @Override
+            public org.bukkit.damage.DamageType getSpecific(Object generic) {
+                if (damageTypeFromNms == null) {
+                    Class<?> craftDamageType = getCraftBukkitClass("damage.CraftDamageType");
+                    FuzzyReflection fuzzy = FuzzyReflection.fromClass(craftDamageType, false);
+                    damageTypeFromNms = Accessors.getMethodAccessor(fuzzy.getMethod(FuzzyMethodContract.newBuilder()
+                            .parameterExactArray(MinecraftReflection.getDamageTypeClass())
+                            .returnTypeExact(org.bukkit.damage.DamageType.class)
+                            .requireModifier(Modifier.STATIC)
+                            .build()));
+                }
+                return (org.bukkit.damage.DamageType) damageTypeFromNms.invoke(null, generic);
+            }
+        });
+    }
+
     private static Class<?> dimensionManager;
     private static FauxEnumConverter<Dimension> dimensionConverter;
     private static FauxEnumConverter<DimensionImpl> dimensionImplConverter;