.editorconfig

@@ -0,0 +1,28 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+tab_width = 4
+
+[*.gradle]
+indent_style = tab
+
+[*.java]
+indent_style = tab
+max_line_length = off
+ij_continuation_indent_size = 8 # IntelliJ default
+# Wrapping and Braces
+ij_java_keep_simple_blocks_in_one_line = true
+ij_java_keep_simple_classes_in_one_line = true
+ij_java_keep_simple_lambdas_in_one_line = true
+ij_java_keep_simple_methods_in_one_line = true
+
+[*.{json,properties}]
+indent_style = space
+indent_size = 2
+
+[.editorconfig]
+indent_style = space
+indent_size = 4

build.gradle

@@ -2,6 +2,7 @@ plugins {
 	id 'fabric-loom' version '1.7-SNAPSHOT'
 	id 'maven-publish'
 	id "me.modmuss50.mod-publish-plugin" version "0.7.2"
+	id "de.hysky.skyblocker.annotation-processor"
 }
 
 version = "${project.mod_version}+${project.minecraft_version}"
@@ -226,7 +227,7 @@ java {
 
 jar {
 	from("LICENSE") {
-		rename { "${it}_${base.archivesName.get()}"}
+		rename { "${it}_${base.archivesName.get()}" }
 	}
 }
 

buildSrc/build.gradle

@@ -0,0 +1,22 @@
+plugins {
+	id 'java-gradle-plugin'
+}
+
+repositories {
+	mavenCentral()
+}
+
+dependencies {
+	implementation "org.ow2.asm:asm:${project.asm_version}"
+	implementation "org.ow2.asm:asm-tree:${project.asm_version}"
+}
+
+gradlePlugin {
+	plugins {
+		simplePlugin {
+			id = 'de.hysky.skyblocker.annotation-processor'
+			// The plugin entry point could be changed to a different class that then appropriately calls the different processors when there's more than one.
+			implementationClass = 'de.hysky.skyblocker.init.InitProcessor'
+		}
+	}
+}

buildSrc/gradle.properties

@@ -0,0 +1 @@
+asm_version=9.7

buildSrc/src/main/java/de/hysky/skyblocker/init/InitInjectingClassVisitor.java

@@ -0,0 +1,41 @@
+package de.hysky.skyblocker.init;
+
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.util.List;
+
+public class InitInjectingClassVisitor extends ClassVisitor {
+	private final List<InitProcessor.MethodReference> methodSignatures;
+
+	public InitInjectingClassVisitor(ClassVisitor classVisitor, List<InitProcessor.MethodReference> methodSignatures) {
+		super(Opcodes.ASM9, classVisitor);
+		this.methodSignatures = methodSignatures;
+	}
+
+	@Override
+	public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+		MethodVisitor methodVisitor = super.visitMethod(access, name, descriptor, signature, exceptions);
+
+		// Limit replacing to the init method which is private, static, named init, has no args, and has a void return type
+		if ((access & Opcodes.ACC_PRIVATE) != 0 && (access & Opcodes.ACC_STATIC) != 0 && name.equals("init") && descriptor.equals("()V")) {
+			// Method node that we will overwrite the init method with
+			MethodNode methodNode = new MethodNode(Opcodes.ASM9, access, name, descriptor, signature, exceptions);
+
+			// Inject calls to each found @Init annotated method
+			for (InitProcessor.MethodReference methodCall : methodSignatures) {
+				methodNode.visitMethodInsn(Opcodes.INVOKESTATIC, methodCall.className(), methodCall.methodName(), methodCall.descriptor(), methodCall.itf());
+			}
+
+			// Return from the method
+			methodNode.visitInsn(Opcodes.RETURN);
+
+			// Apply our new method node to the visitor to replace the original one
+			methodNode.accept(methodVisitor);
+		}
+
+		return methodVisitor;
+	}
+}

buildSrc/src/main/java/de/hysky/skyblocker/init/InitProcessor.java

@@ -0,0 +1,112 @@
+package de.hysky.skyblocker.init;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.compile.JavaCompile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.objectweb.asm.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+@SuppressWarnings("unused")
+public abstract class InitProcessor implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		// https://docs.gradle.org/current/userguide/task_configuration_avoidance.html
+		// This only configures the `compileJava` task and not other `JavaCompile` tasks such as `compileTestJava`. https://stackoverflow.com/a/77047012
+        project.getTasks().withType(JavaCompile.class).named("compileJava").get().doLast(task -> {
+			long start = System.currentTimeMillis();
+			File classesDir = ((JavaCompile) task).getDestinationDirectory().get().getAsFile();
+			Map<MethodReference, Integer> methodSignatures = new HashMap<>();
+
+			//Find all methods with the @Init annotation
+			findInitMethods(classesDir, methodSignatures);
+
+			//Sort the methods by their priority. It's also converted to a list because the priority values are useless from here on
+			List<MethodReference> sortedMethodSignatures = methodSignatures.entrySet()
+					.stream()
+					.sorted(Map.Entry.<MethodReference, Integer>comparingByValue().thenComparing(entry -> entry.getKey().className()))
+					.map(Map.Entry::getKey)
+					.toList();
+
+			//Inject calls to the @Init annotated methods in the SkyblockerMod class
+			injectInitCalls(classesDir, sortedMethodSignatures);
+
+			System.out.println("Injecting init methods took: " + (System.currentTimeMillis() - start) + "ms");
+		});
+	}
+
+	public void findInitMethods(@NotNull File directory, Map<MethodReference, Integer> methodSignatures) {
+		try {
+			Files.walkFileTree(directory.toPath(), new SimpleFileVisitor<>() {
+				@Override
+				public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) {
+                    if (!path.toString().endsWith(".class")) return FileVisitResult.CONTINUE;
+					try (InputStream inputStream = Files.newInputStream(path)) {
+						ClassReader classReader = new ClassReader(inputStream);
+						classReader.accept(new InitReadingClassVisitor(classReader, methodSignatures), ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+					} catch (IOException e) {
+						e.printStackTrace();
+					}
+
+					return FileVisitResult.CONTINUE;
+				}
+			});
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void injectInitCalls(File directory, List<MethodReference> methodSignatures) {
+		Path mainClassFile = Objects.requireNonNull(findMainClass(directory), "SkyblockerMod class wasn't found :(").toPath();
+
+		try (InputStream inputStream = Files.newInputStream(mainClassFile)) {
+			ClassReader classReader = new ClassReader(inputStream);
+			ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+			classReader.accept(new InitInjectingClassVisitor(classWriter, methodSignatures), 0);
+			try (OutputStream outputStream = Files.newOutputStream(mainClassFile)) {
+				outputStream.write(classWriter.toByteArray());
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	// Find the main SkyblockerMod class
+	@Nullable
+	public File findMainClass(@NotNull File directory) {
+		if (!directory.isDirectory()) throw new IllegalArgumentException("Not a directory");
+		for (File file : Objects.requireNonNull(directory.listFiles())) {
+			if (file.isDirectory()) {
+				File foundFile = findMainClass(file);
+
+				if (foundFile != null) return foundFile;
+			} else if (file.getName().equals("SkyblockerMod.class")) {
+				return file;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * @param className  the class name (e.g. de/hysky/skyblocker/skyblock/ChestValue)
+	 * @param methodName the method's name (e.g. init)
+	 * @param descriptor the method's descriptor (only ()V for now)
+	 * @param itf        whether the target class is an {@code interface} or not
+	 */
+	public record MethodReference(String className, String methodName, String descriptor, boolean itf) {}
+}

buildSrc/src/main/java/de/hysky/skyblocker/init/InitReadingClassVisitor.java

@@ -0,0 +1,71 @@
+package de.hysky.skyblocker.init;
+
+import org.jetbrains.annotations.NotNull;
+import org.objectweb.asm.*;
+
+import java.util.Map;
+
+public class InitReadingClassVisitor extends ClassVisitor {
+	private final Map<InitProcessor.MethodReference, Integer> methodSignatures;
+	private final ClassReader classReader;
+
+	public InitReadingClassVisitor(ClassReader classReader, Map<InitProcessor.MethodReference, Integer> methodSignatures) {
+		super(Opcodes.ASM9);
+		this.classReader = classReader;
+		this.methodSignatures = methodSignatures;
+	}
+
+	@Override
+	public MethodVisitor visitMethod(int access, String methodName, String descriptor, String signature, String[] exceptions) {
+		return new MethodVisitor(Opcodes.ASM9) {
+			@Override
+			public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+				//This method visitor checks all methods and only acts upon those with the Init annotation.
+				//This lets us warn the user about invalid init methods and misuse of the annotation
+				if (!desc.equals("Lde/hysky/skyblocker/annotations/Init;")) return super.visitAnnotation(desc, visible);
+
+				//Delegates adding the method call to the map to the InitAnnotationVisitor since we don't have a value to put in the map here
+				return new InitAnnotationVisitor(methodSignatures, getMethodCall());
+			}
+
+			private @NotNull InitProcessor.MethodReference getMethodCall() {
+				String className = classReader.getClassName();
+				String methodCallString = className + "." + methodName;
+				if ((access & Opcodes.ACC_PUBLIC) == 0) throw new IllegalStateException(methodCallString + ": Initializer methods must be public");
+				if ((access & Opcodes.ACC_STATIC) == 0) throw new IllegalStateException(methodCallString + ": Initializer methods must be static");
+				if (!descriptor.equals("()V")) throw new IllegalStateException(methodCallString + ": Initializer methods must have no args and a void return type");
+
+				//Interface static methods need special handling, so we add a special marker for that
+				boolean itf = (classReader.getAccess() & Opcodes.ACC_INTERFACE) != 0;
+
+				return new InitProcessor.MethodReference(className, methodName, descriptor, itf);
+			}
+		};
+	}
+
+	static class InitAnnotationVisitor extends AnnotationVisitor {
+		private final Map<InitProcessor.MethodReference, Integer> methodSignatures;
+		private final InitProcessor.MethodReference methodCall;
+
+		protected InitAnnotationVisitor(Map<InitProcessor.MethodReference, Integer> methodSignatures, InitProcessor.MethodReference methodCall) {
+			super(Opcodes.ASM9);
+			this.methodSignatures = methodSignatures;
+			this.methodCall = methodCall;
+		}
+
+		@Override
+		public void visitEnd() {
+			//Annotations that use the default value for the priority field will not be called by the visit method, so we have to handle them here.
+			methodSignatures.putIfAbsent(methodCall, 0);
+			super.visitEnd();
+		}
+
+		@Override
+		public void visit(String name, Object value) {
+			if (name.equals("priority")) {
+				methodSignatures.put(methodCall, (int) value);
+			}
+			super.visit(name, value);
+		}
+	}
+}

gradle.properties

@@ -33,9 +33,9 @@ occlusionculling_version = 0.0.8-SNAPSHOT
 ## neu repoparser (https://repo.nea.moe/#/releases/moe/nea/neurepoparser/)
 repoparser_version = 1.6.0
 ## Networth Calculator (https://github.com/AzureAaron/networth-calculator)
-networth_calculator_version = 1.0.2
+networth_calculator_version = 1.0.5
 ## Legacy Item DFU (https://github.com/AzureAaron/legacy-item-dfu)
-legacy_item_dfu_version = 1.0.0+1.21.1
+legacy_item_dfu_version = 1.0.1+1.21.1
 
 # Other Libraries
 ## JGit (https://mvnrepository.com/artifact/org.eclipse.jgit/org.eclipse.jgit)