[ci skip] spotlessApply with the new settings

This commit is contained in:
Raven Szewczyk committed 2023-01-29 11:36:41 +00:00
1 parent 6b208b98bc
commit a309488cdf
214 files changed
+9283 -9265

No files matched your search

+329 -361
View File
@@ -1,5 +1,15 @@
package minetweaker;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import minetweaker.annotations.BracketHandler;
import minetweaker.annotations.ModOnly;
import minetweaker.api.client.IClient;
@@ -26,427 +36,385 @@ import stanhebben.zenscript.symbols.SymbolJavaStaticMethod;
import stanhebben.zenscript.type.natives.IJavaMethod;
import stanhebben.zenscript.type.natives.JavaMethod;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Provides access to the MineTweaker API.
*
* An implementing platform needs to do the following: - Set a logger - Set the
* ore dictionary - Set the recipe manager - Set the furnace manager - Set event
* manager - Set resource manager
* An implementing platform needs to do the following: - Set a logger - Set the ore dictionary - Set the recipe manager
* - Set the furnace manager - Set event manager - Set resource manager
*
* - Register additional global symbols to the GlobalRegistry (recipes,
* minetweaker, oreDict, logger, as well as the official set of functions) -
* Register native classes using the GlobalRegistry - Register bracket handlers
* to resolve block/item/... references using the bracket syntax
* - Register additional global symbols to the GlobalRegistry (recipes, minetweaker, oreDict, logger, as well as the
* official set of functions) - Register native classes using the GlobalRegistry - Register bracket handlers to resolve
* block/item/... references using the bracket syntax
*
* @author Stan Hebben
*/
public class MineTweakerAPI {
public static final String[] COLOR_NAMES = {
"White",
"Orange",
"Magenta",
"Light Blue",
"Yellow",
"Lime",
"Pink",
"Gray",
"Light Gray",
"Cyan",
"Purple",
"Blue",
"Brown",
"Green",
"Red",
"Black"
};
public static final String[] COLOR_NAMES = { "White", "Orange", "Magenta", "Light Blue", "Yellow", "Lime", "Pink",
"Gray", "Light Gray", "Cyan", "Purple", "Blue", "Brown", "Green", "Red", "Black" };
private static IJEIRecipeRegistry ijeiRecipeRegistry = new DummyJEIRecipeRegistry();
static {
registerClassRegistry(ClassRegistry.class, "MT-API");
registerClassRegistry(ClassRegistry.class, "MT-API");
registerGlobalSymbol("logger", getJavaStaticGetterSymbol(MineTweakerAPI.class, "getLogger"));
registerGlobalSymbol("recipes", getJavaStaticFieldSymbol(MineTweakerAPI.class, "recipes"));
// registerGlobalSymbol("brewing", getJavaStaticFieldSymbol(MineTweakerAPI.class, "brewing"));
registerGlobalSymbol("logger", getJavaStaticGetterSymbol(MineTweakerAPI.class, "getLogger"));
registerGlobalSymbol("recipes", getJavaStaticFieldSymbol(MineTweakerAPI.class, "recipes"));
// registerGlobalSymbol("brewing", getJavaStaticFieldSymbol(MineTweakerAPI.class, "brewing"));
registerGlobalSymbol("furnace", getJavaStaticFieldSymbol(MineTweakerAPI.class, "furnace"));
registerGlobalSymbol("oreDict", getJavaStaticFieldSymbol(MineTweakerAPI.class, "oreDict"));
registerGlobalSymbol("events", getJavaStaticFieldSymbol(MineTweakerAPI.class, "events"));
registerGlobalSymbol("server", getJavaStaticFieldSymbol(MineTweakerAPI.class, "server"));
registerGlobalSymbol("client", getJavaStaticFieldSymbol(MineTweakerAPI.class, "client"));
registerGlobalSymbol("game", getJavaStaticFieldSymbol(MineTweakerAPI.class, "game"));
registerGlobalSymbol("loadedMods", getJavaStaticFieldSymbol(MineTweakerAPI.class, "loadedMods"));
registerGlobalSymbol("format", getJavaStaticFieldSymbol(MineTweakerAPI.class, "format"));
registerGlobalSymbol("vanilla", getJavaStaticFieldSymbol(MineTweakerAPI.class, "vanilla"));
}
registerGlobalSymbol("oreDict", getJavaStaticFieldSymbol(MineTweakerAPI.class, "oreDict"));
registerGlobalSymbol("events", getJavaStaticFieldSymbol(MineTweakerAPI.class, "events"));
registerGlobalSymbol("server", getJavaStaticFieldSymbol(MineTweakerAPI.class, "server"));
registerGlobalSymbol("client", getJavaStaticFieldSymbol(MineTweakerAPI.class, "client"));
registerGlobalSymbol("game", getJavaStaticFieldSymbol(MineTweakerAPI.class, "game"));
registerGlobalSymbol("loadedMods", getJavaStaticFieldSymbol(MineTweakerAPI.class, "loadedMods"));
registerGlobalSymbol("format", getJavaStaticFieldSymbol(MineTweakerAPI.class, "format"));
registerGlobalSymbol("vanilla", getJavaStaticFieldSymbol(MineTweakerAPI.class, "vanilla"));
}
private MineTweakerAPI() {
private MineTweakerAPI() {
}
}
/**
* The Tweaker is where you apply undoable actions. Any kind of action that
* reloads with the scripts should always be submitted to the tweaker.
*/
@Deprecated
public static final ITweaker tweaker = new MTTweaker();
/**
* The Tweaker is where you apply undoable actions. Any kind of action that reloads with the scripts should always
* be submitted to the tweaker.
*/
@Deprecated
public static final ITweaker tweaker = new MTTweaker();
/**
* The logger can be used to write logging messages to the client. Error and
* warning messages should be relayed to admins for further handling.
*
* @return
*/
public static final ILogger getLogger() {
return MineTweakerImplementationAPI.logger;
}
/**
* The logger can be used to write logging messages to the client. Error and warning messages should be relayed to
* admins for further handling.
*
* @return
*/
public static final ILogger getLogger() {
return MineTweakerImplementationAPI.logger;
}
/**
* Access point to the ore dictionary.
*/
public static IOreDict oreDict = null;
/**
* Access point to the ore dictionary.
*/
public static IOreDict oreDict = null;
/**
* Access point to the recipe manager.
*/
public static IRecipeManager recipes = null;
/**
* Access point to the recipe manager.
*/
public static IRecipeManager recipes = null;
// /**
// * Access point to the brewing manager.
// */
// public static IBrewingManager brewing = null;
// /**
// * Access point to the brewing manager.
// */
// public static IBrewingManager brewing = null;
/**
* Access point to the furnace manager.
*/
public static IFurnaceManager furnace = null;
/**
* Access point to the furnace manager.
*/
public static IFurnaceManager furnace = null;
/**
* Access point to the events manager.
*/
public static final IEventManager events = MineTweakerImplementationAPI.events;
/**
* Access point to the events manager.
*/
public static final IEventManager events = MineTweakerImplementationAPI.events;
/**
* Access point to the server, if any.
*/
public static IServer server = null;
/**
* Access point to the server, if any.
*/
public static IServer server = null;
/**
* Access point to the client, if any.
*/
public static IClient client = null;
/**
* Access point to the client, if any.
*/
public static IClient client = null;
/**
* Access point to general game data, such as items.
*/
public static IGame game = null;
/**
* Access point to general game data, such as items.
*/
public static IGame game = null;
/**
* Access point to mods list.
*/
public static ILoadedMods loadedMods = null;
/**
* Access point to mods list.
*/
public static ILoadedMods loadedMods = null;
/**
* Access point to the text formatter.
*/
public static IFormatter format = null;
/**
* Access point to the text formatter.
*/
public static IFormatter format = null;
/**
* Access point to the vanilla functions and data.
*/
public static IVanilla vanilla = null;
/**
* Access point to the vanilla functions and data.
*/
public static IVanilla vanilla = null;
/**
* Applies this given action.
*
* @param action action object
*/
public static void apply(IUndoableAction action) {
tweaker.apply(action);
}
/**
* Applies this given action.
*
* @param action action object
*/
public static void apply(IUndoableAction action) {
tweaker.apply(action);
}
/**
* Logs a command message. Commands messages are those generated as output
* in response to a command.
*
* @param message command message
*/
public static void logCommand(String message) {
getLogger().logCommand(message);
}
/**
* Logs a command message. Commands messages are those generated as output in response to a command.
*
* @param message command message
*/
public static void logCommand(String message) {
getLogger().logCommand(message);
}
/**
* Logs an info message. Info messages have low priority and will only be
* displayed in the log files, but not directly to players in-game.
*
* @param message info message
*/
public static void logInfo(String message) {
getLogger().logInfo(message);
}
/**
* Logs an info message. Info messages have low priority and will only be displayed in the log files, but not
* directly to players in-game.
*
* @param message info message
*/
public static void logInfo(String message) {
getLogger().logInfo(message);
}
/**
* Logs a warning message. Warning messages are displayed to admins and
* indicate that there is an issue. However, the issue is not a large
* problem, and everything should run fine - besides perhaps a few things
* not entirely working as expected.
*
* @param message warning message
*/
public static void logWarning(String message) {
getLogger().logWarning(message);
}
/**
* Logs a warning message. Warning messages are displayed to admins and indicate that there is an issue. However,
* the issue is not a large problem, and everything should run fine - besides perhaps a few things not entirely
* working as expected.
*
* @param message warning message
*/
public static void logWarning(String message) {
getLogger().logWarning(message);
}
/**
* Logs an error message. Error messages indicate a real problem and
* indicate that things won't run properly. The scripting system will still
* make a best-effort attempt at executing the rest of the scripts, but that
* might cause additional errors and issues.
*
* @param message error message
*/
public static void logError(String message) {
getLogger().logError(message);
}
/**
* Logs an error message. Error messages indicate a real problem and indicate that things won't run properly. The
* scripting system will still make a best-effort attempt at executing the rest of the scripts, but that might cause
* additional errors and issues.
*
* @param message error message
*/
public static void logError(String message) {
getLogger().logError(message);
}
/**
* Logs an error message. Error messages indicate a real problem and
* indicate that things won't run properly. The scripting system will still
* make a best-effort attempt at executing the rest of the scripts, but that
* might cause additional errors and issues.
*
* @param message error message
* @param exception exception that was caught related to the error
*/
public static void logError(String message, Throwable exception) {
getLogger().logError(message, exception);
}
/**
* Logs an error message. Error messages indicate a real problem and indicate that things won't run properly. The
* scripting system will still make a best-effort attempt at executing the rest of the scripts, but that might cause
* additional errors and issues.
*
* @param message error message
* @param exception exception that was caught related to the error
*/
public static void logError(String message, Throwable exception) {
getLogger().logError(message, exception);
}
// ###################################
// ### Plugin registration methods ###
// ###################################
// ###################################
// ### Plugin registration methods ###
// ###################################
/**
* Register a class registry class. Such class must have (at least) a public
* static method called "getClasses" with accepts a List of classes and
* which stores its classes into that list.
*
* @param registryClass
*/
public static void registerClassRegistry(Class registryClass) {
registerClassRegistry(registryClass, null);
}
/**
* Register a class registry class. Such class must have (at least) a public static method called "getClasses" with
* accepts a List of classes and which stores its classes into that list.
*
* @param registryClass
*/
public static void registerClassRegistry(Class registryClass) {
registerClassRegistry(registryClass, null);
}
/**
* Register a class registry class. Such class must have (at least) a public
* static method called "getClasses" with accepts a List of classes and
* which stores its classes into that list.
*
* @param registryClass
* @param description
*/
public static void registerClassRegistry(Class registryClass, String description) {
try {
Method method = registryClass.getMethod("getClasses", List.class);
if ((method.getModifiers() & Modifier.STATIC) == 0) {
logError("ERROR: getClasses method in " + registryClass.getName() + " isn't static");
} else {
List<Class> classes = new ArrayList<Class>();
method.invoke(null, classes);
/**
* Register a class registry class. Such class must have (at least) a public static method called "getClasses" with
* accepts a List of classes and which stores its classes into that list.
*
* @param registryClass
* @param description
*/
public static void registerClassRegistry(Class registryClass, String description) {
try {
Method method = registryClass.getMethod("getClasses", List.class);
if ((method.getModifiers() & Modifier.STATIC) == 0) {
logError("ERROR: getClasses method in " + registryClass.getName() + " isn't static");
} else {
List<Class> classes = new ArrayList<Class>();
method.invoke(null, classes);
outer: for (Class cls : classes) {
for (Annotation annotation : cls.getAnnotations()) {
if (annotation instanceof ModOnly) {
String[] value = ((ModOnly) annotation).value();
String version = ((ModOnly) annotation).version();
outer: for (Class cls : classes) {
for (Annotation annotation : cls.getAnnotations()) {
if (annotation instanceof ModOnly) {
String[] value = ((ModOnly) annotation).value();
String version = ((ModOnly) annotation).version();
for (String mod : value) {
if (!loadedMods.contains(mod))
continue outer;
for (String mod : value) {
if (!loadedMods.contains(mod)) continue outer;
if (!loadedMods.get(mod).getVersion().startsWith(version))
continue outer;
}
}
}
if (!loadedMods.get(mod).getVersion().startsWith(version)) continue outer;
}
}
}
MineTweakerAPI.registerClass(cls);
}
MineTweakerAPI.registerClass(cls);
}
if (description != null)
logInfo("Loaded class registry: " + description);
}
} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
if(ex.getCause() instanceof NoClassDefFoundError) {
logInfo("Classes for registry " + registryClass + " not found, skipping");
if (description != null) logInfo("Loaded class registry: " + description);
}
} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
if (ex.getCause() instanceof NoClassDefFoundError) {
logInfo("Classes for registry " + registryClass + " not found, skipping");
} else {
logError("Error registering class registry", ex);
}
}
}
}
/**
* Registers a class registry. Will attempt to resolve the given class name.
* Does nothing if the class could not be loaded.
*
* @param className class name to be loaded
* @return true if registration was successful
*/
public static boolean registerClassRegistry(String className) {
return registerClassRegistry(className, null);
}
/**
* Registers a class registry. Will attempt to resolve the given class name. Does nothing if the class could not be
* loaded.
*
* @param className class name to be loaded
* @return true if registration was successful
*/
public static boolean registerClassRegistry(String className) {
return registerClassRegistry(className, null);
}
/**
* Registers a class registry. Will attempt to resolve the given class name.
* Does nothing if the class could not be loaded.
*
* @param className class name to be loaded
* @param description
* @return true if registration was successful
*/
public static boolean registerClassRegistry(String className, String description) {
try {
registerClassRegistry(Class.forName(className), description);
return true;
} catch (ClassNotFoundException ex) {
return false;
}
}
/**
* Registers a class registry. Will attempt to resolve the given class name. Does nothing if the class could not be
* loaded.
*
* @param className class name to be loaded
* @param description
* @return true if registration was successful
*/
public static boolean registerClassRegistry(String className, String description) {
try {
registerClassRegistry(Class.forName(className), description);
return true;
} catch (ClassNotFoundException ex) {
return false;
}
}
/**
* Registers an annotated class. A class is annotated with either @ZenClass
* or @ZenExpansion. Classes not annotated with either of these will be
* ignored.
*
* @param annotatedClass
*/
public static void registerClass(Class annotatedClass) {
// System.out.println("Registering " + annotatedClass.getName());
/**
* Registers an annotated class. A class is annotated with either @ZenClass or @ZenExpansion. Classes not annotated
* with either of these will be ignored.
*
* @param annotatedClass
*/
public static void registerClass(Class annotatedClass) {
// System.out.println("Registering " + annotatedClass.getName());
for (Annotation annotation : annotatedClass.getAnnotations()) {
if (annotation instanceof ZenExpansion) {
GlobalRegistry.registerExpansion(annotatedClass);
}
for (Annotation annotation : annotatedClass.getAnnotations()) {
if (annotation instanceof ZenExpansion) {
GlobalRegistry.registerExpansion(annotatedClass);
}
if (annotation instanceof ZenClass) {
GlobalRegistry.registerNativeClass(annotatedClass);
}
if ((annotation instanceof BracketHandler) && IBracketHandler.class.isAssignableFrom(annotatedClass)) {
try {
IBracketHandler bracketHandler = (IBracketHandler) annotatedClass.newInstance();
registerBracketHandler(bracketHandler);
} catch (InstantiationException ex) {
Logger.getLogger(MineTweakerAPI.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(MineTweakerAPI.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
if (annotation instanceof ZenClass) {
GlobalRegistry.registerNativeClass(annotatedClass);
}
if ((annotation instanceof BracketHandler) && IBracketHandler.class.isAssignableFrom(annotatedClass)) {
try {
IBracketHandler bracketHandler = (IBracketHandler) annotatedClass.newInstance();
registerBracketHandler(bracketHandler);
} catch (InstantiationException ex) {
Logger.getLogger(MineTweakerAPI.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(MineTweakerAPI.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
/**
* Registers a global symbol. Global symbols are immediately accessible from
* anywhere in the scripts.
*
* @param name symbol name
* @param symbol symbol
*/
public static void registerGlobalSymbol(String name, IZenSymbol symbol) {
GlobalRegistry.registerGlobal(name, symbol);
}
/**
* Registers a global symbol. Global symbols are immediately accessible from anywhere in the scripts.
*
* @param name symbol name
* @param symbol symbol
*/
public static void registerGlobalSymbol(String name, IZenSymbol symbol) {
GlobalRegistry.registerGlobal(name, symbol);
}
/**
* Registers a recipe remover. Removers are called when the global
* minetweaker.remove() function is called.
*
* @param remover recipe remover
*/
public static void registerRemover(IRecipeRemover remover) {
GlobalRegistry.registerRemover(remover);
}
/**
* Registers a recipe remover. Removers are called when the global minetweaker.remove() function is called.
*
* @param remover recipe remover
*/
public static void registerRemover(IRecipeRemover remover) {
GlobalRegistry.registerRemover(remover);
}
/**
* Registers a bracket handler. Is capable of converting the bracket syntax
* to an actual value. This new handler will be added last - it can thus not
* intercept values that are already handled by the system.
*
* @param handler bracket handler to be added
*/
public static void registerBracketHandler(IBracketHandler handler) {
GlobalRegistry.registerBracketHandler(handler);
}
/**
* Registers a bracket handler. Is capable of converting the bracket syntax to an actual value. This new handler
* will be added last - it can thus not intercept values that are already handled by the system.
*
* @param handler bracket handler to be added
*/
public static void registerBracketHandler(IBracketHandler handler) {
GlobalRegistry.registerBracketHandler(handler);
}
/**
* Creates a symbol that refers to a java method.
*
* @param cls class that contains the method
* @param name method name
* @param arguments method argument types
* @return corresponding symbol
*/
public static IZenSymbol getJavaStaticMethodSymbol(Class cls, String name, Class... arguments) {
IJavaMethod method = JavaMethod.get(GlobalRegistry.getTypeRegistry(), cls, name, arguments);
return new SymbolJavaStaticMethod(method);
}
/**
* Creates a symbol that refers to a java method.
*
* @param cls class that contains the method
* @param name method name
* @param arguments method argument types
* @return corresponding symbol
*/
public static IZenSymbol getJavaStaticMethodSymbol(Class cls, String name, Class... arguments) {
IJavaMethod method = JavaMethod.get(GlobalRegistry.getTypeRegistry(), cls, name, arguments);
return new SymbolJavaStaticMethod(method);
}
/**
* Creates a symbol that refers to a java getter. The getter must be a
* method with no arguments. The given symbol will act as a variable of
* which the value can be retrieved but not set.
*
* @param cls class that contains the getter method
* @param name name of the method
* @return corresponding symbol
*/
public static IZenSymbol getJavaStaticGetterSymbol(Class cls, String name) {
IJavaMethod method = JavaMethod.get(GlobalRegistry.getTypeRegistry(), cls, name);
return new SymbolJavaStaticGetter(method);
}
/**
* Creates a symbol that refers to a java getter. The getter must be a method with no arguments. The given symbol
* will act as a variable of which the value can be retrieved but not set.
*
* @param cls class that contains the getter method
* @param name name of the method
* @return corresponding symbol
*/
public static IZenSymbol getJavaStaticGetterSymbol(Class cls, String name) {
IJavaMethod method = JavaMethod.get(GlobalRegistry.getTypeRegistry(), cls, name);
return new SymbolJavaStaticGetter(method);
}
/**
* Creates a symbol that refers to a static field. The field must be an
* existing public field in the given class. The field will act as a
* variable that can be retrieved but not set.
*
* @param cls class that contains the field
* @param name field name (must be public)
* @return corresponding symbol
*/
public static IZenSymbol getJavaStaticFieldSymbol(Class cls, String name) {
try {
Field field = cls.getField(name);
return new SymbolJavaStaticField(cls, field, GlobalRegistry.getTypeRegistry());
} catch (NoSuchFieldException ex) {
return null;
} catch (SecurityException ex) {
return null;
}
}
/**
* Creates a symbol that refers to a static field. The field must be an existing public field in the given class.
* The field will act as a variable that can be retrieved but not set.
*
* @param cls class that contains the field
* @param name field name (must be public)
* @return corresponding symbol
*/
public static IZenSymbol getJavaStaticFieldSymbol(Class cls, String name) {
try {
Field field = cls.getField(name);
return new SymbolJavaStaticField(cls, field, GlobalRegistry.getTypeRegistry());
} catch (NoSuchFieldException ex) {
return null;
} catch (SecurityException ex) {
return null;
}
}
/**
* Loads a Java method from an existing class.
*
* @param cls method class
* @param name method name
* @param arguments argument types
* @return java method
*/
public static IJavaMethod getJavaMethod(Class cls, String name, Class... arguments) {
return JavaMethod.get(GlobalRegistry.getTypeRegistry(), cls, name, arguments);
}
/**
* Loads a Java method from an existing class.
*
* @param cls method class
* @param name method name
* @param arguments argument types
* @return java method
*/
public static IJavaMethod getJavaMethod(Class cls, String name, Class... arguments) {
return JavaMethod.get(GlobalRegistry.getTypeRegistry(), cls, name, arguments);
}
public static IJEIRecipeRegistry getIjeiRecipeRegistry() {
return ijeiRecipeRegistry;
}
public static void setIjeiRecipeRegistry(IJEIRecipeRegistry ijeiRecipeRegistry) {
MineTweakerAPI.ijeiRecipeRegistry = ijeiRecipeRegistry;
}