New NMS and OBC Reflection utility classes

This commit is contained in:
Marc Baloup 2022-02-07 12:45:18 +01:00
parent 774b5f9e47
commit 06b89bd271
5 changed files with 855 additions and 8 deletions

View File

@ -16,6 +16,10 @@
<id>papermc</id>
<url>https://papermc.io/repo/repository/maven-public/</url>
</repository>
<repository>
<id>fabricmc</id>
<url>https://maven.fabricmc.net/</url>
</repository>
</repositories>
<dependencies>
@ -36,20 +40,27 @@
</exclusions>
</dependency>
<!-- Paper (1.16 and before) -->
<!-- <dependency>
<groupId>com.destroystokyo.paper</groupId>
<artifactId>paper-api</artifactId>
<version>${paper.version}-SNAPSHOT</version>
<scope>compile</scope>
</dependency> -->
<!-- Paper (1.17+) -->
<!-- Paper -->
<dependency>
<groupId>io.papermc.paper</groupId>
<artifactId>paper-api</artifactId>
<version>${paper.version}-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>io.papermc.paper</groupId>
<artifactId>paper-mojangapi</artifactId>
<version>${paper.version}-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
<!-- Needed to read obfuscation mapping file. Already included in Paper -->
<dependency>
<groupId>net.fabricmc</groupId>
<artifactId>mapping-io</artifactId>
<version>0.3.0</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>

View File

@ -0,0 +1,465 @@
package fr.pandacube.lib.paper.reflect;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeMap;
import java.util.stream.Collectors;
import org.bukkit.Bukkit;
import fr.pandacube.lib.core.util.Log;
import fr.pandacube.lib.core.util.Reflect;
import fr.pandacube.lib.core.util.Reflect.ReflectClass;
import fr.pandacube.lib.core.util.Reflect.ReflectField;
import fr.pandacube.lib.core.util.Reflect.ReflectMethod;
import net.fabricmc.mappingio.MappingReader;
import net.fabricmc.mappingio.format.MappingFormat;
import net.fabricmc.mappingio.tree.MappingTree;
import net.fabricmc.mappingio.tree.MemoryMappingTree;
public class NMSReflect {
private static ReflectClass<?> PAPER_OBFHELPER_CLASS;
private static String OBF_NAMESPACE;
private static String MOJ_NAMESPACE;
/* package */ static final Map<String, ClassMapping> CLASSES_BY_OBF = new TreeMap<>();
/* package */ static final Map<String, ClassMapping> CLASSES_BY_MOJ = new TreeMap<>();
private static Boolean IS_SERVER_OBFUSCATED;
static {
try {
PAPER_OBFHELPER_CLASS = Reflect.ofClass("io.papermc.paper.util.ObfHelper");
OBF_NAMESPACE = (String) PAPER_OBFHELPER_CLASS.field("SPIGOT_NAMESPACE").getStaticValue();
MOJ_NAMESPACE = (String) PAPER_OBFHELPER_CLASS.field("MOJANG_PLUS_YARN_NAMESPACE").getStaticValue();
List<ClassMapping> mappings = loadMappings();
for (ClassMapping clazz : mappings) {
CLASSES_BY_OBF.put(clazz.obfName, clazz);
CLASSES_BY_MOJ.put(clazz.mojName, clazz);
}
// determine if the runtime server is obfuscated
ClassNotFoundException exIfUnableToDetermine = null;
for (ClassMapping clazz : CLASSES_BY_OBF.values()) {
if (clazz.obfName.equals(clazz.mojName) // avoid direct collision between obf and unobf class names
|| CLASSES_BY_MOJ.containsKey(clazz.obfName) // avoid indirect collision
|| CLASSES_BY_OBF.containsKey(clazz.mojName))// avoid indirect collision
continue;
try {
Class.forName(clazz.obfName);
IS_SERVER_OBFUSCATED = true;
Log.info("NMS classes are obfuscated.");
break;
} catch (ClassNotFoundException e) {
try {
Class.forName(clazz.mojName);
IS_SERVER_OBFUSCATED = false;
Log.info("NMS classes are using mojang mapping.");
break;
} catch (ClassNotFoundException ee) {
ee.addSuppressed(e);
if (exIfUnableToDetermine == null)
exIfUnableToDetermine = ee;
}
}
}
if (IS_SERVER_OBFUSCATED == null) {
CLASSES_BY_MOJ.clear();
CLASSES_BY_OBF.clear();
throw exIfUnableToDetermine;
}
for (ClassMapping clazz : mappings) {
clazz.cacheReflectClass();
}
} catch (ReflectiveOperationException e) {
Log.severe(e);
}
}
/**
* @param mojName the binary name of the desired class, on the mojang mapping.
* @throws NullPointerException if there is no mapping for the provided Mojang mapped class.
* @throws ClassNotFoundException if there is a mapping, but the runtime class was not found.
*/
public static ClassMapping mojClass(String mojName) throws ClassNotFoundException {
ClassMapping cm = Objects.requireNonNull(CLASSES_BY_MOJ.get(mojName), "Unable to find the Mojang mapped class '" + mojName + "'");
cm.cacheReflectClass();
return cm;
}
private static List<ClassMapping> loadMappings() {
try (final InputStream mappingsInputStream = PAPER_OBFHELPER_CLASS.get().getClassLoader().getResourceAsStream("META-INF/mappings/reobf.tiny")) {
if (mappingsInputStream == null) {
Log.severe("Unable to find the ofbuscation mapping file in the Paper jar.");
return Collections.emptyList();
}
MemoryMappingTree tree = new MemoryMappingTree();
MappingReader.read(new InputStreamReader(mappingsInputStream, StandardCharsets.UTF_8), MappingFormat.TINY_2, tree);
List<ClassMapping> classes = new ArrayList<>();
for (MappingTree.ClassMapping cls : tree.getClasses()) {
classes.add(new ClassMapping(cls));
}
return classes;
} catch (IOException e) {
Log.severe("Failed to load mappings.", e);
return Collections.emptyList();
}
}
public static void printHTMLMapping(PrintStream out) {
String title = "Obfuscation mapping - " + Bukkit.getName() + " version " + Bukkit.getVersion();
out.println("<!DOCTYPE html><html><head>\n"
+ "<title>" + title + "</title>\n"
+ """
<style>
table {
border-collapse: collapse;
width: 1880px;
max-width: 100%;
margin: auto;
}
tr:nth-child(2n) {
background-color: #eeeeee;
}
tr:hover {
background-color: lightgray;
}
tr > *:first-child {
text-align: right;
padding-right: .5em;
width: 6em;
}
tr > *:not(:first-child) {
font-family: monospace;
}
td {
padding-top: 0;
padding-bottom: 0;
}
th {
text-align: left;
font-size: 1.1em;
border-top: solid 1px black;
}
a, a:visited {
color: #222;
}
</style>
"""
+ "</head><body>\n"
+ "<h1>" + title + "</h1>\n"
+ "<table>");
out.println("<tr><th>Namespace</th><th>" + OBF_NAMESPACE + "</th><th>" + MOJ_NAMESPACE + "</th></tr>");
for (ClassMapping clazz : CLASSES_BY_OBF.values()) {
clazz.printHTML(out);
}
out.println("</table></body></html>");
}
public static class ClassMapping {
private static int nextID = 0;
/* package */ final int id = nextID++;
/* package */ final String obfName;
/* package */ final String mojName;
private final Map<MethodId, MemberMapping<MethodId>> methodsByObf = new TreeMap<>();
private final Map<MethodId, MemberMapping<MethodId>> methodsByMoj = new TreeMap<>();
private final Map<String, MemberMapping<String>> fieldsByObf = new TreeMap<>();
private final Map<String, MemberMapping<String>> fieldsByMoj = new TreeMap<>();
private ReflectClass<?> runtimeReflectClass = null;
private ClassMapping(MappingTree.ClassMapping cls) {
obfName = binaryClassName(cls.getName(OBF_NAMESPACE));
mojName = binaryClassName(cls.getName(MOJ_NAMESPACE));
cls.getMethods().stream().map(MemberMapping::of).forEach(method -> {
methodsByObf.put(method.obfDesc.identifier, method);
methodsByMoj.put(method.mojDesc.identifier, method);
});
cls.getFields().stream().map(MemberMapping::of).forEach(field -> {
fieldsByObf.put(field.obfDesc.identifier, field);
fieldsByMoj.put(field.mojDesc.identifier, field);
});
}
private synchronized void cacheReflectClass() throws ClassNotFoundException {
if (runtimeReflectClass == null)
runtimeReflectClass = Reflect.ofClass(IS_SERVER_OBFUSCATED ? obfName : mojName);
}
public ReflectClass<?> runtimeReflect() {
return runtimeReflectClass;
}
public Class<?> runtimeClass() {
return runtimeReflectClass.get();
}
/**
*
* @param mojName the Mojang mapped name of the method.
* @param mojParametersType the list of parameters of the method.
* Each parameter type must be an instance of one of the following type:
* {@link Type}, {@link Class}, {@link ReflectClass} or {@link ClassMapping}.
* @return
* @throws IllegalArgumentException if one of the parameter has an invalid type
* @throws NullPointerException if one of the parameter is null, or if there is no mapping for the provided Mojang mapped method.
* @throws ClassNotFoundException if there is no runtime class to represent one of the provided parametersType.
* @throws NoSuchMethodException if there is no runtime method to represent the provided method.
*/
public ReflectMethod<?> mojMethod(String mojName, Object... mojParametersType) throws ClassNotFoundException, NoSuchMethodException {
MethodId mId = new MethodId(mojName, Type.toTypeList(Arrays.asList(mojParametersType)));
MemberMapping<MethodId> mm = methodsByMoj.get(mId);
Objects.requireNonNull(mm, "Unable to find the Mojang mapped method " + mId);
MethodId reflectId = (IS_SERVER_OBFUSCATED ? mm.obfDesc : mm.mojDesc).identifier;
return runtimeReflectClass.method(reflectId.name, Type.toClassArray(reflectId.parametersType));
}
/**
*
* @param mojName the Mojang mapped name of the field.
* @return
* @throws NullPointerException if there is no mapping for the provided Mojang mapped field.
* @throws NoSuchFieldException if there is no runtime method to represent the provided method.
*/
public ReflectField<?> mojField(String mojName) throws NoSuchFieldException {
MemberMapping<String> fm = fieldsByMoj.get(mojName);
Objects.requireNonNull(fm, "Unable to find the Mojang mapped field '" + mojName + "'");
return runtimeReflectClass.field((IS_SERVER_OBFUSCATED ? fm.obfDesc : fm.mojDesc).identifier);
}
/* package */ String toClickableHTML(boolean isObfClass) {
String classToPrint = isObfClass ? obfName : mojName;
String classSimpleName = classToPrint.substring(classToPrint.lastIndexOf('.') + 1);
String htmlTitle = classSimpleName.equals(classToPrint) ? "" : (" title='" + classToPrint + "'");
String typeHTML = "<a href='#c" + id + "'" + htmlTitle + ">" + classSimpleName + "</a>";
return typeHTML;
}
/* package */ Type toType(boolean obf) {
return new Type(obf ? obfName : mojName, 0);
}
private void printHTML(PrintStream out) {
out.println("<tr id='c" + id + "'><th>" + classKind() + "</th><th>" + nameToHTML(true) + "</th><th>" + nameToHTML(false) + "</th></tr>");
fieldsByObf.values().forEach(f -> f.printHTML(out));
methodsByObf.values().forEach(m -> m.printHTML(out));
}
private String nameToHTML(boolean obf) {
String name = obf ? obfName : mojName;
Type superClass = superClass(obf);
String superClassHTML = superClass == null ? "" : (" extends " + superClass.toHTML(obf));
List<Type> superInterfaces = superInterfaces(obf);
String superInterfacesHTML = superInterfaces.isEmpty() ? ""
: (" implements " + superInterfaces.stream().map(t -> t.toHTML(obf)).collect(Collectors.joining(", ")));
return name + superClassHTML + superInterfacesHTML;
}
private Type superClass(boolean obf) {
Class<?> superClass = runtimeClass().getSuperclass();
if (superClass == null)
return null;
ClassMapping cm = (IS_SERVER_OBFUSCATED ? CLASSES_BY_OBF : CLASSES_BY_MOJ).get(superClass.getName());
return (cm != null) ? cm.toType(obf) : Type.of(superClass);
}
private List<Type> superInterfaces(boolean obf) {
Class<?>[] interfaces = runtimeClass().getInterfaces();
List<Type> types = new ArrayList<>(interfaces.length);
for (Class<?> interfce : interfaces) {
ClassMapping cm = (IS_SERVER_OBFUSCATED ? CLASSES_BY_OBF : CLASSES_BY_MOJ).get(interfce.getName());
types.add((cm != null) ? cm.toType(obf) : Type.of(interfce));
}
return types;
}
private String classKind() {
Class<?> clazz = runtimeClass();
if (clazz.isEnum())
return "Enum";
if (clazz.isAnnotation())
return "Annotation";
if (clazz.isInterface())
return "Interface";
if (clazz.isRecord())
return "Record";
if (clazz.isPrimitive())
return "Primitive";
return "Class";
}
}
private static record MethodId(String name, List<Type> parametersType) implements Comparable<MethodId> {
@Override
public int compareTo(MethodId o) {
int cmp = name.compareTo(o.name);
if (cmp != 0)
return cmp;
return toString().compareTo(o.toString());
}
private String toHTML(boolean isObfClass) {
String paramsHTML = parametersType.stream().map(p -> p.toHTML(isObfClass)).collect(Collectors.joining(", "));
String identifierHTML = "<b>" + name + "</b>(" + paramsHTML + ")";
return identifierHTML;
}
public String toString() {
String paramsStr = parametersType.stream().map(Type::toString).collect(Collectors.joining(", "));
return name + "(" + paramsStr + ")";
}
}
private static record MemberDesc<I extends Comparable<I>>(I identifier, Type returnType) {
private String toHTML(boolean isObfClass) {
String identifierHTML = "";
if (identifier instanceof MethodId mId)
identifierHTML = mId.toHTML(isObfClass);
else if (identifier instanceof String n)
identifierHTML = "<b>" + n + "</b>";
return returnType.toHTML(isObfClass) + " " + identifierHTML;
}
private static MemberDesc<MethodId> of(MappingTree.MethodMapping member, String namespace) {
String desc = member.getDesc(namespace);
try (StringReader descReader = new StringReader(desc)) {
char r = (char) descReader.read();
if (r != '(')
throw new IllegalArgumentException("Invalid method description '" + desc + "'. Must start with '('.");
List<Type> paramsType = new ArrayList<>();
while ((r = (char) descReader.read()) != ')') {
descReader.skip(-1);
paramsType.add(Type.parse(descReader));
}
Type retType = Type.parse(descReader);
return new MemberDesc<>(new MethodId(member.getName(namespace), Collections.unmodifiableList(paramsType)), retType);
} catch (IOException e) {
throw new RuntimeException("StringReader read error", e);
}
}
private static MemberDesc<String> of(MappingTree.FieldMapping member, String namespace) {
StringReader descReader = new StringReader(member.getDesc(namespace));
return new MemberDesc<>(member.getName(namespace), Type.parse(descReader));
}
}
private static class MemberMapping<I extends Comparable<I>> {
private String type;
/* package */ MemberDesc<I> obfDesc, mojDesc;
private MemberMapping(String type, MemberDesc<I> obfDesc, MemberDesc<I> mojDesc) {
this.obfDesc = obfDesc;
this.mojDesc = mojDesc;
}
/* package */ void printHTML(PrintStream out) {
out.println("<tr><td>" + type + "</td><td>" + obfDesc.toHTML(true) + "</td><td>" + mojDesc.toHTML(false) + "</td></tr>");
}
private static MemberMapping<MethodId> of(MappingTree.MethodMapping mioMapping) {
return new MemberMapping<>("Method", MemberDesc.of(mioMapping, OBF_NAMESPACE), MemberDesc.of(mioMapping, MOJ_NAMESPACE));
}
private static MemberMapping<String> of(MappingTree.FieldMapping mioMapping) {
return new MemberMapping<>("Field", MemberDesc.of(mioMapping, OBF_NAMESPACE), MemberDesc.of(mioMapping, MOJ_NAMESPACE));
}
}
/* package */ static String binaryClassName(String cl) {
return cl.replace('/', '.');
}
}

View File

@ -0,0 +1,31 @@
package fr.pandacube.lib.paper.reflect;
import org.bukkit.Bukkit;
import fr.pandacube.lib.core.util.Reflect;
import fr.pandacube.lib.core.util.Reflect.ReflectClass;
public class OBCReflect {
private static final String OBC_PACKAGE_PREFIX = "org.bukkit.craftbukkit.";
private static final String OBC_PACKAGE_VERSION;
static {
String name = Bukkit.getServer().getClass().getName()
.substring(OBC_PACKAGE_PREFIX.length());
name = name.substring(0, name.indexOf("."));
OBC_PACKAGE_VERSION = name;
}
public static ReflectClass<?> ofClass(String obcClass) throws ClassNotFoundException {
return Reflect.ofClass(OBC_PACKAGE_PREFIX + OBC_PACKAGE_VERSION + "." + obcClass);
}
}

View File

@ -0,0 +1,144 @@
package fr.pandacube.lib.paper.reflect;
import org.bukkit.NamespacedKey;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import com.mojang.brigadier.tree.CommandNode;
import fr.pandacube.lib.core.util.Reflect;
import fr.pandacube.lib.core.util.Reflect.ReflectClass;
import fr.pandacube.lib.core.util.Reflect.ReflectConstructor;
import fr.pandacube.lib.core.util.Reflect.ReflectField;
import fr.pandacube.lib.core.util.Reflect.ReflectMethod;
import fr.pandacube.lib.paper.reflect.NMSReflect.ClassMapping;
public class ReflectRegistry {
public static final ClassMapping NMS_SHAREDCONSTANTS = wrapEx(() -> NMSReflect.mojClass("net.minecraft.SharedConstants"));
public static final ReflectMethod<?> NMS_SHAREDCONSTANTS_GETCURRENTVERSION = wrapEx(() -> NMS_SHAREDCONSTANTS.mojMethod("getCurrentVersion"));
public static final ClassMapping NMS_WORLDVERSION = wrapEx(() -> NMSReflect.mojClass("net.minecraft.WorldVersion"));
public static final ReflectMethod<?> NMS_WORLDVERSION_GETPROTOCOLVERSION = wrapEx(() -> NMS_WORLDVERSION.runtimeReflect().method("getProtocolVersion"));
public static final ClassMapping NMS_DEDICATEDSERVER = wrapEx(() -> NMSReflect.mojClass("net.minecraft.server.dedicated.DedicatedServer"));
public static final ReflectField<?> NMS_DEDICATEDSERVER_VANILLACOMMANDDISPATCHER = wrapEx(() -> NMS_DEDICATEDSERVER.runtimeReflect().field("vanillaCommandDispatcher"));
public static final ClassMapping NMS_COMMANDS = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.Commands"));
public static final ReflectField<?> NMS_COMMANDS_DISPATCHER = wrapEx(() -> NMS_DEDICATEDSERVER.mojField("dispatcher"));
public static final ClassMapping NMS_VEC3 = wrapEx(() -> NMSReflect.mojClass("net.minecraft.world.phys.Vec3"));
public static final ClassMapping NMS_COMPONENT = wrapEx(() -> NMSReflect.mojClass("net.minecraft.network.chat.Component"));
public static final ClassMapping NMS_COMMANDSOURCESTACK = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.CommandSourceStack"));
public static final ClassMapping NMS_ENTITYARGUMENT = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.EntityArgument"));
public static final ReflectConstructor<?> NMS_ENTITYARGUMENT_CONSTRUCTOR = wrapEx(() -> NMS_ENTITYARGUMENT.runtimeReflect().constructor(boolean.class, boolean.class));
public static final ClassMapping NMS_ENTITYSELECTOR = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.selector.EntitySelector"));
public static final ReflectMethod<?> NMS_ENTITYSELECTOR_FINDENTITIES = wrapEx(() -> NMS_ENTITYSELECTOR.mojMethod("findEntities", NMS_COMMANDSOURCESTACK));
public static final ReflectMethod<?> NMS_ENTITYSELECTOR_FINDPLAYERS = wrapEx(() -> NMS_ENTITYSELECTOR.mojMethod("findPlayers", NMS_COMMANDSOURCESTACK));
public static final ReflectMethod<?> NMS_ENTITYSELECTOR_FINDSINGLEENTITY = wrapEx(() -> NMS_ENTITYSELECTOR.mojMethod("findSingleEntity", NMS_COMMANDSOURCESTACK));
public static final ReflectMethod<?> NMS_ENTITYSELECTOR_FINDSINGLEPLAYER = wrapEx(() -> NMS_ENTITYSELECTOR.mojMethod("findSinglePlayer", NMS_COMMANDSOURCESTACK));
public static final ClassMapping NMS_ENTITY = wrapEx(() -> NMSReflect.mojClass("net.minecraft.world.entity.Entity"));
public static final ReflectMethod<?> NMS_ENTITY_GETBUKKITENTITY = wrapEx(() -> NMS_ENTITY.runtimeReflect().method("getBukkitEntity"));
public static final ClassMapping NMS_COMPONENTARGUMENT = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.ComponentArgument"));
public static final ReflectConstructor<?> NMS_COMPONENTARGUMENT_CONSTRUCTOR = wrapEx(() -> NMS_COMPONENTARGUMENT.runtimeReflect().constructor());
public static final ClassMapping NMS_BLOCKSTATEARGUMENT = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.blocks.BlockStateArgument"));
public static final ReflectConstructor<?> NMS_BLOCKSTATEARGUMENT_CONSTRUCTOR = wrapEx(() -> NMS_BLOCKSTATEARGUMENT.runtimeReflect().constructor());
public static final ClassMapping NMS_VEC3ARGUMENT = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.coordinates.Vec3Argument"));
public static final ReflectMethod<?> NMS_VEC3ARGUMENT_VEC3 = wrapEx(() -> NMS_VEC3ARGUMENT.mojMethod("vec3", boolean.class));
public static final ClassMapping NMS_COORDINATES = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.coordinates.Coordinates"));
public static final ReflectMethod<?> NMS_COORDINATES_GETPOSITION = wrapEx(() -> NMS_COORDINATES.mojMethod("getPosition", NMS_COMMANDSOURCESTACK));
public static final ReflectMethod<?> NMS_COORDINATES_GETBLOCKPOS = wrapEx(() -> NMS_COORDINATES.mojMethod("getBlockPos", NMS_COMMANDSOURCESTACK));
public static final ClassMapping NMS_BLOCKPOSARGUMENT = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.coordinates.BlockPosArgument"));
public static final ReflectMethod<?> NMS_BLOCKPOSARGUMENT_BLOCKPOS = wrapEx(() -> NMS_BLOCKPOSARGUMENT.mojMethod("blockPos"));
public static final ClassMapping NMS_BLOCKPOS = wrapEx(() -> NMSReflect.mojClass("net.minecraft.core.BlockPos"));
public static final ReflectMethod<?> NMS_BLOCKPOS_GETX = wrapEx(() -> NMS_BLOCKPOS.mojMethod("getX"));
public static final ReflectMethod<?> NMS_BLOCKPOS_GETY = wrapEx(() -> NMS_BLOCKPOS.mojMethod("getY"));
public static final ReflectMethod<?> NMS_BLOCKPOS_GETZ = wrapEx(() -> NMS_BLOCKPOS.mojMethod("getZ"));
public static final ClassMapping NMS_RESOURCELOCATIONARGUMENT = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.ResourceLocationArgument"));
public static final ReflectConstructor<?> NMS_RESOURCELOCATIONARGUMENT_CONSTRUCTOR = wrapEx(() -> NMS_RESOURCELOCATIONARGUMENT.runtimeReflect().constructor());
public static final ClassMapping NMS_RESOURCELOCATION = wrapEx(() -> NMSReflect.mojClass("net.minecraft.resources.ResourceLocation"));
public static final ClassMapping NMS_GAMEPROFILEARGUMENT = wrapEx(() -> NMSReflect.mojClass("net.minecraft.commands.arguments.GameProfileArgument"));
public static final ReflectConstructor<?> NMS_GAMEPROFILEARGUMENT_CONSTRUCTOR = wrapEx(() -> NMS_GAMEPROFILEARGUMENT.runtimeReflect().constructor());
public static final ReflectClass<?> OBC_CRAFTSERVER = wrapEx(() -> OBCReflect.ofClass("CraftServer"));
public static final ReflectMethod<?> OBC_CRAFTSERVER_GETSERVER = wrapEx(() -> OBC_CRAFTSERVER.method("getServer"));
public static final ReflectClass<?> OBC_VANILLACOMMANDWRAPPER = wrapEx(() -> OBCReflect.ofClass("command.VanillaCommandWrapper"));
@SuppressWarnings("unchecked")
public static final ReflectConstructor<? extends Command> OBC_VANILLACOMMANDWRAPPER_CONSTRUCTOR =
(ReflectConstructor<? extends Command>) wrapEx(() -> OBC_VANILLACOMMANDWRAPPER.constructor(
NMS_COMMANDS.runtimeClass(),
CommandNode.class
));
public static final ReflectField<?> OBC_VANILLACOMMANDWRAPPER_VANILLACOMMAND = wrapEx(() -> OBC_VANILLACOMMANDWRAPPER.field("vanillaCommand"));
public static final ReflectMethod<?> OBC_VANILLACOMMANDWRAPPER_GETLISTENER = wrapEx(() -> OBC_VANILLACOMMANDWRAPPER.method("getListener", CommandSender.class));
public static final ReflectClass<?> OBC_CRAFTNAMESPACEDKEY = wrapEx(() -> OBCReflect.ofClass("util.CraftNamespacedKey"));
public static final ReflectMethod<?> OBC_CRAFTNAMESPACEDKEY_TOMINECRAFT = wrapEx(() -> OBC_CRAFTNAMESPACEDKEY.method("toMinecraft", NamespacedKey.class));
public static final ReflectMethod<?> OBC_CRAFTNAMESPACEDKEY_FROMMINECRAFT = wrapEx(() -> OBC_CRAFTNAMESPACEDKEY.method("fromMinecraft", NMS_RESOURCELOCATION.runtimeClass()));
public static final ReflectClass<?> OBC_CRAFTVECTOR = wrapEx(() -> OBCReflect.ofClass("util.CraftVector"));
public static final ReflectMethod<?> OBC_CRAFTVECTOR_TOBUKKIT_VEC3 = wrapEx(() -> OBC_VANILLACOMMANDWRAPPER.method("toBukkit", NMS_VEC3.runtimeClass()));
public static final ReflectClass<?> PAPER_PAPERADVENTURE = wrapEx(() -> Reflect.ofClass("io.papermc.paper.adventure.PaperAdventure"));
public static final ReflectMethod<?> PAPER_PAPERADVENTURE_ASADVENTURE = wrapEx(() -> PAPER_PAPERADVENTURE.method("asAdventure", NMS_COMPONENT.runtimeClass()));
public static final ReflectClass<?> BRIGADIER_COMMANDNODE = Reflect.ofClass(CommandNode.class);
public static final ReflectMethod<?> BRIGADIER_COMMANDNODE_REMOVECOMMAND = wrapEx(() -> BRIGADIER_COMMANDNODE.method("removeCommand", String.class));
private interface SupplierException<T> {
public T get() throws Exception;
}
private static <T> T wrapEx(SupplierException<T> prv) {
try {
return prv.get();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}

View File

@ -0,0 +1,196 @@
package fr.pandacube.lib.paper.reflect;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import fr.pandacube.lib.core.util.Reflect.ReflectClass;
import fr.pandacube.lib.paper.reflect.NMSReflect.ClassMapping;
public class Type implements Comparable<Type> {
private final String type;
private final int arrayDepth;
/* package */ Type(String type, int arrayDepth) {
this.type = type;
this.arrayDepth = arrayDepth;
}
@Override
public boolean equals(Object obj) {
return obj != null && obj instanceof Type ot && type.equals(ot.type) && arrayDepth == ot.arrayDepth;
}
@Override
public int hashCode() {
return type.hashCode() ^ arrayDepth;
}
@Override
public int compareTo(Type o) {
return toString().compareTo(o.toString());
}
Class<?> toClass() throws ClassNotFoundException {
Class<?> cl = switch(type) {
case "boolean" -> boolean.class;
case "byte" -> byte.class;
case "char" -> char.class;
case "double" -> double.class;
case "float" -> float.class;
case "int" -> int.class;
case "long" -> long.class;
case "short" -> short.class;
case "void" -> void.class;
default -> Class.forName(type);
};
for (int i = 0; i < arrayDepth; i++) {
cl = cl.arrayType();
}
return cl;
}
public Type arrayType() {
return new Type(type, arrayDepth + 1);
}
/* package */ static Type of(Class<?> cl) {
int arrayDepth = 0;
while (cl.isArray()) {
cl = cl.getComponentType();
arrayDepth++;
}
return new Type(cl.getName(), arrayDepth);
}
public static Type of(ReflectClass<?> rc) {
return arrayOf(rc, 0);
}
public static Type arrayOf(ReflectClass<?> rc, int arrayDepth) {
return new Type(rc.get().getName(), arrayDepth);
}
public static Type mojOf(ClassMapping cm) {
return arrayMojOf(cm, 0);
}
public static Type arrayMojOf(ClassMapping cm, int arrayDepth) {
return new Type(cm.mojName, arrayDepth);
}
/* package */ static Type toType(Object typeObj) {
Objects.requireNonNull(typeObj, "typeObj cannot be null");
if (typeObj instanceof Class<?> cl) {
return of(cl);
}
else if (typeObj instanceof ClassMapping cm) {
return mojOf(cm);
}
else if (typeObj instanceof ReflectClass<?> rc) {
return of(rc);
}
else if (typeObj instanceof Type t) {
return t;
}
else
throw new IllegalArgumentException("Unsupported object of type " + typeObj.getClass());
}
/* package */ String toHTML(boolean isObfClass) {
ClassMapping clMapping = (isObfClass ? NMSReflect.CLASSES_BY_OBF : NMSReflect.CLASSES_BY_MOJ).get(type);
String typeHTML;
if (clMapping != null) {
typeHTML = clMapping.toClickableHTML(isObfClass);
}
else {
String classToPrint = type;
String classSimpleName = classToPrint.substring(classToPrint.lastIndexOf('.') + 1);
String htmlTitle = classSimpleName.equals(classToPrint) ? "" : (" title='" + classToPrint + "'");
if (!htmlTitle.equals("")) {
typeHTML = "<span" + htmlTitle + ">" + classSimpleName + "</span>";
}
else {
typeHTML = classSimpleName;
}
}
return typeHTML + "[]".repeat(arrayDepth);
}
public String toString() {
return type + "[]".repeat(arrayDepth);
}
/* package */ static Type parse(StringReader desc) {
try {
StringBuilder sbRaw = new StringBuilder();
int arrayDepth = 0;
char c;
while ((c = (char) desc.read()) == '[') {
sbRaw.append(c);
arrayDepth++;
}
sbRaw.append(c);
String type = switch(c) {
case 'Z' -> "boolean";
case 'B' -> "byte";
case 'C' -> "char";
case 'D' -> "double";
case 'F' -> "float";
case 'I' -> "int";
case 'J' -> "long";
case 'S' -> "short";
case 'L' -> {
StringBuilder sbClass = new StringBuilder();
char r;
while ((r = (char) desc.read()) != ';') {
sbRaw.append(c);
sbClass.append(r);
}
sbRaw.append(c);
yield NMSReflect.binaryClassName(sbClass.toString());
}
default -> "void";
};
return new Type(type, arrayDepth);
} catch (IOException e) {
throw new RuntimeException("StringReader read error", e);
}
}
/* package */ static List<Type> toTypeList(List<Object> paramsType) {
List<Type> types = new ArrayList<>(paramsType.size());
for (int i = 0; i < types.size(); i++) {
Object param = paramsType.get(i);
try {
types.add(Type.toType(param));
} catch (NullPointerException|IllegalArgumentException e) {
throw new IllegalArgumentException("Invalid parameterType at index " + i, e);
}
}
return types;
}
/* package */ static Class<?>[] toClassArray(List<Type> types) throws ClassNotFoundException {
Class<?>[] classes = new Class<?>[types.size()];
for (int i = 0; i < types.size(); i++) {
classes[i] = types.get(i).toClass();
}
return classes;
}
}