Resource Loader V2

libraries/branding/branding-mcin-20100206-2103-mca1.2.1_01/src/main/java/net/ornithemc/osl/branding/impl/BrandingPatchImpl.java

@@ -4,11 +4,10 @@
 import joptsimple.OptionSet;
 import joptsimple.OptionSpec;
 
-import net.fabricmc.loader.api.FabricLoader;
-
 import net.ornithemc.osl.branding.api.BrandingContext;
 import net.ornithemc.osl.branding.api.BrandingPatchEvents;
 import net.ornithemc.osl.branding.api.Operation;
+import net.ornithemc.osl.core.impl.util.MinecraftVersion;
 import net.ornithemc.osl.entrypoints.api.client.ClientModInitializer;
 import net.ornithemc.osl.entrypoints.api.launch.LaunchEvents;
 import net.ornithemc.osl.entrypoints.api.launch.OptionsConsumer;
@@ -21,7 +20,7 @@ public class BrandingPatchImpl implements ClientModInitializer {
 
 	public static String getGameVersion() {
 		if (gameVersion == null) {
-			gameVersion = FabricLoader.getInstance().getRawGameVersion();
+			gameVersion = MinecraftVersion.resolve().gameVersion();
 
 			if (gameVersion.charAt(0) == 'a') {
 				gameVersion = "Alpha v" + gameVersion.substring(1);

libraries/core/src/main/java/net/ornithemc/osl/core/api/util/Unit.java

@@ -0,0 +1,7 @@
+package net.ornithemc.osl.core.api.util;
+
+public enum Unit {
+
+	INSTANCE
+
+}

libraries/core/src/main/java/net/ornithemc/osl/core/api/util/function/IOSupplier.java

@@ -0,0 +1,9 @@
+package net.ornithemc.osl.core.api.util.function;
+
+import java.io.IOException;
+
+public interface IOSupplier<T> {
+
+	T get() throws IOException;
+
+}

libraries/core/src/main/java/net/ornithemc/osl/core/impl/util/MinecraftVersion.java

@@ -0,0 +1,77 @@
+package net.ornithemc.osl.core.impl.util;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import net.fabricmc.loader.api.FabricLoader;
+import net.fabricmc.loader.api.ModContainer;
+import net.fabricmc.loader.api.SemanticVersion;
+import net.fabricmc.loader.api.Version;
+import net.fabricmc.loader.api.VersionParsingException;
+import net.fabricmc.loader.impl.game.minecraft.McVersionLookup;
+
+public final class MinecraftVersion {
+
+	private static MinecraftVersion INSTANCE;
+
+	public static MinecraftVersion resolve() {
+		if (INSTANCE == null) {
+			Optional<ModContainer> mod = FabricLoader.getInstance().getModContainer("minecraft");
+
+			if (!mod.isPresent()) {
+				throw new IllegalStateException("Minecraft not loaded!");
+			}
+
+			ModContainer minecraft = mod.get();
+			String gameVersion = FabricLoader.getInstance().getRawGameVersion();
+			SemanticVersion semanticVersion = resolveSemanticVersion(minecraft.getMetadata().getVersion());
+
+			INSTANCE = new MinecraftVersion(gameVersion, semanticVersion);
+		}
+
+		return INSTANCE;
+	}
+
+	private final String gameVersion;
+	private final SemanticVersion semanticVersion;
+
+	// semantic versions for other game versions
+	private final Map<String, SemanticVersion> semanticVersions = new HashMap<>();
+
+	private MinecraftVersion(String gameVersion, SemanticVersion semanticVersion) {
+		this.gameVersion = gameVersion;
+		this.semanticVersion = semanticVersion;
+	}
+
+	public String gameVersion() {
+		return this.gameVersion;
+	}
+
+	public String semanticVersion() {
+		return this.semanticVersion.toString();
+	}
+
+	public int compareTo(String gameVersion) {
+		return this.semanticVersion.compareTo((Version) this.semanticVersions.computeIfAbsent(gameVersion, MinecraftVersion::resolveSemanticVersion));
+	}
+
+	private static SemanticVersion resolveSemanticVersion(Version gameVersion) {
+		if (gameVersion instanceof SemanticVersion) {
+			return (SemanticVersion) gameVersion;
+		} else {
+			return resolveSemanticVersion(gameVersion.toString());
+		}
+	}
+
+	private static SemanticVersion resolveSemanticVersion(String gameVersion) {
+		String releaseVersion = McVersionLookup.getRelease(gameVersion);
+		String normalizedVersion = McVersionLookup.normalizeVersion(gameVersion, releaseVersion);
+
+		try {
+			return SemanticVersion.parse(normalizedVersion);
+		} catch (VersionParsingException e) {
+			throw new IllegalStateException("Unable to parse Minecraft version " + gameVersion, e);
+		}
+	}
+}

libraries/core/src/main/java/net/ornithemc/osl/core/impl/util/ModLoader.java

@@ -0,0 +1,48 @@
+package net.ornithemc.osl.core.impl.util;
+
+import net.fabricmc.loader.api.FabricLoader;
+
+public enum ModLoader {
+
+	FABRIC("fabric", "fabricloader", "Fabric"),
+	QUILT ("quilt" , "quilt_loader", "Quilt");
+
+	public static ModLoader INSTANCE;
+
+	public static ModLoader resolve() {
+		if (INSTANCE == null) {
+			// Quilt also provides fabricloader as a mod so quiltloader must be checked first
+			if (FabricLoader.getInstance().isModLoaded(QUILT.modId)) {
+				INSTANCE = QUILT;
+			} else if (FabricLoader.getInstance().isModLoaded(FABRIC.modId)) {
+				INSTANCE = FABRIC;
+			} else {
+				throw new RuntimeException("Neither Fabric Loader nor Quilt Loader are loaded?! How is this even running?!");
+			}
+		}
+
+		return INSTANCE;
+	}
+
+	private final String id;
+	private final String modId;
+	private final String displayName;
+
+	private ModLoader(String id, String modId, String displayName) {
+		this.id = id;
+		this.modId = modId;
+		this.displayName = displayName;
+	}
+
+	public String id() {
+		return this.id;
+	}
+
+	public String modId() {
+		return this.modId;
+	}
+
+	public String displayName() {
+		return this.displayName;
+	}
+}

libraries/core/src/main/java/net/ornithemc/osl/core/impl/util/Util.java

@@ -0,0 +1,30 @@
+package net.ornithemc.osl.core.impl.util;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public final class Util {
+
+	public static <V> CompletableFuture<List<V>> sequence(List<? extends CompletableFuture<? extends V>> futures) {
+		List<V> results = new ArrayList<>(futures.size());
+
+		CompletableFuture<?>[] sequence = new CompletableFuture[futures.size()];
+		CompletableFuture<Void> failure = new CompletableFuture<>();
+
+		futures.forEach(future -> {
+			int i = results.size();
+			results.add(null);
+
+			sequence[i] = future.whenComplete((result, exception) -> {
+				if (exception != null) {
+					failure.completeExceptionally(exception);
+				} else {
+					results.set(i, result);
+				}
+			});
+		});
+
+		return CompletableFuture.allOf(sequence).applyToEither(failure, v -> results);
+	}
+}