Compare commits

...
93 Commits
Author SHA1 Message Date
4a2db246e0 1.21 Update
Co-authored-by: RealMangoRage <[email protected]>
Co-authored-by: Daniel Norris <[email protected]>
Co-authored-by: Ven <[email protected]>
2024-06-13 10:42:32 -07:00
Paint_Ninja 3d9e12a71d Cleanup FML Bindings (#10004) 2024-06-05 09:57:42 -07:00
LexManos cdeb786877 Fix NPE when calling ForgeHooks.getDefaultCreatorModId(ItemStack) on Spawn Eggs. Closes #10002 2024-06-04 15:48:07 -07:00
LexManos ff7085b95b Fix boat travel distance being incorrect. Closes #9997 2024-06-03 17:31:51 -07:00
LexManos 16dde4d551 1.20.6 RB 1
https://forums.minecraftforge.net/topic/149458-forge-501-minecraft-1206/
2024-06-03 13:15:55 -07:00
Paint_Ninja 60661350c6 Fix minor typo in MDK build.gradle 2024-06-03 20:53:10 +01:00
LexManos 7ee4a44c75 Fire EntityInteractSpecific on server side. Closes #9984 2024-06-03 12:33:53 -07:00
LexManos f22894cf70 Unlock wrapped registries when firing register events. 2024-06-03 12:31:59 -07:00
Paint_Ninja a3fce36942 Update Bootstrap to improve the Java version check error message (#9990) 2024-05-30 23:51:44 +01:00
Paint_Ninja 549dbe7df4 Minor cleanup to ModListScreen and VersionChecker (#9988) 2024-05-30 23:51:25 +01:00
Daniel Norris 5505e472aa Prevent the @OnlyIn being misused on @EventBusSubscriber and @Mod annotated classes (#9891) 2024-05-30 23:51:09 +01:00
Mysticdrew c2c7f9b656 Fix CustomizeGuiOverlayEvent.DebugText and CustomizeGuiOverlayEvent.Chat not being fired. (#9982) 2024-05-24 08:33:52 -07:00
LexManos fd8a0f9c8b Actually fix creative tab count, IDE didn't save the file before regenning patches. 2024-05-23 09:08:51 -07:00
LexManos 0ac873e296 Move Creative Inventory page count to fix issue with partially transparent tooltips. Closes #9983 2024-05-22 12:14:38 -07:00
LexManos 38b5b678cb Make OpenContainer and SpawnEntity packets process on main game thread. 2024-05-21 11:02:44 -07:00
LexManos 9a2bc1e7c2 Add File.exists check to ConfigFileTypeHandler. Closes #9976 2024-05-21 11:02:43 -07:00
RealMangoRage 95b49bedbc Fix crash when reloading a world that uses custom placed features. Closes #9979 2024-05-20 23:23:45 -07:00
LexManos 7c36115e3d Fix NPE in HurtByTargetGoal when mods set targets to null. Closes #7853 2024-05-20 16:21:17 -07:00
R0b0Li0n c037e6aca1 Fix RenderHandEvent firing with incorrect hand and item for offhand items. (#9977) 2024-05-20 11:50:09 -07:00
Mysticdrew e8f1b7ed6d Fix screen layering and re-add the test. (#9978) 2024-05-20 11:49:41 -07:00
RealMangoRage 5da16e6719 Add GatherComponentsEvent (#9944) 2024-05-14 23:02:58 -07:00
LexManos f0a82d79a6 Fix powered rails not propogating correctly. 2024-05-14 22:43:27 -07:00
LexManos 2b3a4137e1 Remove ICustomPacket and add PayloadChannel. (#9972)
New PayloadChannel that uses the vanilla payload Type for packet distinction
Implement the minecraft:register/unregister channels using the new PayloadChannel
New generic channel builder function allowing people to implement channels however they want.
2024-05-14 08:36:42 -07:00
LexManos 640c206117 Implement entity aware armor model and texture hooks. Closes #9960 2024-05-12 17:07:45 -07:00
LexManos 59a7bbdb57 Fix finalizeSpawn's return value not being used correctly. Closes #9964 2024-05-12 13:48:20 -07:00
LexManos be7ad14b4b Fix Biome patch change that caused our field redirect coremod to not function correctly. 2024-05-12 11:21:49 -07:00
LexManos c700b4ea9d Make RegistryObject.getHolder lazy, Should help cases where vanilla registries use holders from other vanilla registries. Closes #9961 2024-05-12 10:53:10 -07:00
LexManos dffa3dd4c9 Ignore jar files in the mods folder that are not Forge mods. Closes #9968 2024-05-12 03:36:22 -07:00
LexManos 4b934809c4 Fix canceling MobSpawnEvent.FinalizeSpawn causing a NPE closes #9971 2024-05-11 23:05:19 -07:00
LexManos ddf76db9b3 Fix potion brewing having arguments reversed. Closes #9970 2024-05-10 14:55:38 -07:00
LexManos 64d6b4f76a Fix Melons/Pumpkins not growing correctly. 2024-05-10 10:39:13 -07:00
Paint_Ninja 58012bfb17 Some patch cleanup (#9951) 2024-05-09 18:07:41 +01:00
LexManos 0cad6b14d9 Filter paths discovered by ServiceProvider in ClasspathLocator. Closes #9899 2024-05-09 09:39:25 -07:00
8848294210 Update SimpleChannel to make StreamCodecs easier (#9959)
Rework networking so that RegistryFriendlyByteBuf is useable for modders
Simple support for StreamCodec in SimpleChannel
Codecify all Forge packets
Make simpler builder pattern for SimpleChannel. Will eventually deprecate the old MessageBuilder as it's verbose and poorly written.

Co-authored-by: MrCrayfish <[email protected]>
Co-authored-by: Paint_Ninja <[email protected]>
2024-05-07 22:53:14 -07:00
LexManos 0e28336fc0 Fix shields not working correctly. Fixes #9966 2024-05-06 18:56:20 -07:00
LexManos 968fa9eeb5 Fix RenderTarget stencil patch location. Fixes #9965 2024-05-06 09:33:27 -07:00
EnZaXD 43768ea328 Add ModelLayers patch back (#9962) 2024-05-05 09:15:05 -07:00
LexManos 0e829630da Fix canApplyAtEnchantingTable null pointer, Closes #9956
Bump SecureModules for package info and multi-release jar fixes.
2024-05-03 14:10:17 -07:00
Paint_Ninja 0467d71466 Remove zombie chance config options (#9950) 2024-05-01 22:27:28 +01:00
Paint_Ninja 115eb5e4c8 Remove deprecated compressLanIPv6Addresses config option (#9949)
LAN IPv6 addresses are always compressed these days, so this config option is redundant
2024-05-01 22:27:16 +01:00
LexManos a7345372fd Fix custom payloads not being handled on the server in the game state. Closes #9948
Fix villagers not opening trade guis. Closes #9946
2024-05-01 13:16:41 -07:00
LexManos bd714b2f76 Fix MDK by bumping FG and disabling reobf tasks
Fix LAN server IPs being duplicated
Fix connecting to vanilla servers due to misapplied patch.
2024-05-01 11:28:43 -07:00
7b782e5b05 1.20.6 Initial Update
New Decompiler
Runtime Official mappings
ItemStacks arnt Capability providers anymore, use Vanilla's system.

Co-authored-by: RealMangoRage <[email protected]>
Co-authored-by: Paint_Ninja <[email protected]>
2024-04-30 11:42:52 -07:00
Paint_Ninja e1fa61080a Make non-Forge mods.toml detection more robust (#9935) 2024-04-25 22:36:56 +01:00
Paint_Ninja 381998c35c Fix early window crash when parsing some forms of options.txt (#9933) 2024-04-19 21:39:23 +01:00
Paint_Ninja 11ed2500a6 Fix edge-case regression with single-jar multiloader mods (#9931) 2024-04-19 21:38:57 +01:00
J-RAP a647237db4 Add ClientPauseChangeEvent (#9905) 2024-04-18 21:36:00 +01:00
Paint_Ninja e0dccae041 Improve mod loading errors (#9870) 2024-04-18 20:02:41 +01:00
Paint_Ninja e7a5c58907 Early display fixes/workarounds for buggy drivers (#9921) 2024-04-18 20:02:18 +01:00
oldkingOK e094eee54d Prevent registering null tiers (#9895)
Makes it easier to identify broken mods, as it moves the crash to when the broken mod in question registers the tier, rather than when any mod tries getting the tier.
2024-04-15 14:49:03 +01:00
Paint_NinjaandblockingHD a6adc58655 Add helper method to OnDatapackSyncEvent (#9901)
Co-authored-by: blockingHD <[email protected]>
2024-04-15 14:47:45 +01:00
J-RAP d31ea640f9 Fix NPE when acceptableValues in defineInList() does not allow nulls, fixes #9300 (#9903) 2024-04-13 12:47:35 +01:00
J-RAP 8e16765438 [1.20.x] Add ByteValue, ShortValue and FloatValue to ForgeConfigSpec, cleanup code (#9902) 2024-04-13 12:42:31 +01:00
Joseph T. McQuigg 73b0088cb4 Add Leaves method to ModelProvider.java (#9887) 2024-04-04 13:53:55 +01:00
LexManos 203fbbb742 Bump bootstrap 2024-03-18 18:31:29 -07:00
LexManos 46d78c8210 Fix level data not loading from existing worlds. Whole system needs a re-write. 2024-03-18 18:15:39 -07:00
LexManos cfba4381b6 Fix modlist size 2024-03-18 18:09:37 -07:00
LexManos 7113701322 Bump Bootstrap 2024-03-18 17:45:58 -07:00
Paint_Ninja 73e02c6add Optimize Entity capabilities a bit by reordering conditions (#9886) 2024-03-16 17:16:11 -07:00
Paint_Ninja 7f2b85d2ff [1.20.x] Make common config screen registration tasks easier (#9884) 2024-03-10 21:27:57 +00:00
Paint_Ninja 099d121c2c [1.20.4] Add CPU usage config option to early window, hide it by default (#9866) 2024-03-10 21:10:06 +00:00
Luis a6978eed68 Fix DatapackBuiltinEntriesProvider issues with forge registries, Fixes #9874 2024-03-01 13:26:00 -08:00
Luis 309116520b Readded DatapackBuiltinEntriesProvider (#9848) 2024-02-15 14:04:51 -08:00
Paint_NinjaandDennis C 3e358acbe1 Fix slightly offset mods screen link positioning (#9860)
Co-authored-by: Dennis C <[email protected]>
2024-02-15 14:04:05 -08:00
LexManos c243adf6aa Fix DNS SRV record lookup not working by hacking the module system. Closes #9846 2024-02-12 13:46:29 -08:00
LexManos 5d0047753d Add null check to DimensionDataStorage. Fixes #9859 2024-02-02 12:50:09 -08:00
LexManos aa6f268c74 Fix cases where LivingConversionEvents were not fired for vanilla conversions. Closes #9850 2024-01-29 13:13:28 -08:00
LexManos d21556a4da Update licenser plugin, and re-run it. Closes #9855 2024-01-29 12:27:45 -08:00
LexManos d4c998e311 Fix background music looping when it shouldn't 2024-01-29 12:16:46 -08:00
LexManos 25727a0e93 Fix Criterion Test Mod 2024-01-29 12:16:21 -08:00
Paint_Ninja 80286594c5 Improve help text on server Java check failure 2024-01-20 00:28:02 +00:00
Paint_Ninja 870e3ebcab [1.20.4] Restore the option of server run scripts (#9849)
Executable server jar is still a thing, but the run scripts are restored as an option for those that prefer it.
2024-01-19 20:55:00 +00:00
Paint_Ninja a4c26c9b2b [1.20.x] More buildscript clean-up (#9845) 2024-01-19 20:54:15 +00:00
Mostafa Mabrok 45b00b0004 Fixed Spelling error in credits.txt (#9694) 2024-01-09 11:42:01 -08:00
LexManos 4b1c5ddb2c Bump JarJar to fix more issues with UnionFileSystem assumptions. 2024-01-09 11:41:20 -08:00
DBotThePony 0966109602 Criterion test mod + unit test (#9744) 2024-01-09 11:40:02 -08:00
LexManos b31006534a Fix launcher version name missing - between forge and the version. Closes #9843 2024-01-08 13:43:46 -08:00
LexManos 740a5d5039 Bump JarJar and SecureModule to fix issue with jars containing [] in their name. Closes #9842 2024-01-08 13:42:36 -08:00
LexManos 817e20821d Only add sorted/deduplicated mods to the classpath.
Fixes some mods causing the Forge error displays to break. Closes #9833
2024-01-02 12:51:57 -08:00
Paint_Ninja fdb22d02cc Improve server panel compatibility (#9836) 2023-12-30 20:56:18 +00:00
Paint_Ninja f09fd1f05b Make common DisplayTest registration tasks easier (#9822) 2023-12-27 08:57:02 -08:00
LexManos ed2ba0f52c Cleanup Explosion patch but keep bin compatibility by using asm hacks. Closes #9817 2023-12-21 11:22:31 -08:00
LexManos b04118982f Bump SecureModules, Closes #9820 2023-12-18 14:24:59 -08:00
LexManos d44d0b8edc Support pack overlay system. Closes #9818 2023-12-13 14:42:49 -08:00
LexManos 6d7fda6a9b Fix Server bundle 2023-12-11 21:27:32 -08:00
Paint_Ninja 0303ca651e Optimise ForgeConfigSpec and make Range public (#9810) 2023-12-11 13:10:53 -08:00
Paint_Ninja 8445f73b2d Add clientSideOnly feature to mods.toml (#9804) 2023-12-11 13:10:33 -08:00
Paint_Ninja c7446a5180 Add impl. of IModFileInfo#showAsDataPack (#9802) 2023-12-11 13:08:50 -08:00
LexManos 5c15aa3322 Get rid of LibraryFinder 2023-12-11 12:27:23 -08:00
LexManos 588466f5e4 1.20.4 - Minor bug fix from Mojang 2023-12-07 11:35:53 -08:00
LexManos 470f03b2f9 Fix java version check in bootstrap shim 2023-12-06 16:29:53 -08:00
LexManos d2367d81fc 1.20.3 Initial Update
https://forums.minecraftforge.net/topic/139822-forge-490-minecraft-1203/
2023-12-06 10:38:20 -08:00
LexManos 6f9f0f0cfa Revive executable jars for the dedicated server
This has a minor change to development time build scripts. So developers, check the MDK
2023-12-06 10:33:58 -08:00
1807 changed files with 33627 additions and 36930 deletions

No files matched your search

+6 -3
View File
@@ -34,9 +34,10 @@
/projects/**/run/ /projects/**/run/
/projects/**/*.launch /projects/**/*.launch
/repo/ /repo/
src/generated/resources/**/.cache/ src/*/generated/**/.cache/
src/generated_test/resources/**/.cache/ # Generated by gradle every import
src/generated_mdk/resources/**/.cache/ **/src/main/resources/META-INF/MANIFEST.MF
/fmlloader/src/main/resources/forge_version.json
#Patch rejects #Patch rejects
#/patches-/ #/patches-/
@@ -49,3 +50,5 @@ changelog.txt
*.7z *.7z
/logs/ /logs/
/ForgeRoot.ipr
/ForgeRoot.iws
+2 -2
View File
@@ -36,8 +36,8 @@ project {
buildType(PullRequestCompatibility) buildType(PullRequestCompatibility)
params { params {
text("docker_jdk_version", "17", label = "Gradle version", description = "The version of the JDK to use during execution of tasks in a JDK.", display = ParameterDisplay.HIDDEN, allowEmpty = false) text("docker_jdk_version", "21", label = "Gradle version", description = "The version of the JDK to use during execution of tasks in a JDK.", display = ParameterDisplay.HIDDEN, allowEmpty = false)
text("docker_gradle_version", "7.5.1", label = "Gradle version", description = "The version of Gradle to use during execution of Gradle tasks.", display = ParameterDisplay.HIDDEN, allowEmpty = false) text("docker_gradle_version", "8.7", label = "Gradle version", description = "The version of Gradle to use during execution of Gradle tasks.", display = ParameterDisplay.HIDDEN, allowEmpty = false)
text("git_main_branch", "1.20.x", label = "Git Main Branch", description = "The git main or default branch to use in VCS operations.", display = ParameterDisplay.HIDDEN, allowEmpty = false) text("git_main_branch", "1.20.x", label = "Git Main Branch", description = "The git main or default branch to use in VCS operations.", display = ParameterDisplay.HIDDEN, allowEmpty = false)
text("git_branch_spec", """ text("git_branch_spec", """
+:refs/heads/(main*) +:refs/heads/(main*)
+4 -4
View File
@@ -3,7 +3,7 @@ Minecraft Forge: Credits/Thank You
Forge is a set of tools and modifications to the Minecraft base game code to assist Forge is a set of tools and modifications to the Minecraft base game code to assist
mod developers in creating new and exciting content. It has been in development for mod developers in creating new and exciting content. It has been in development for
several years now, but I would like to take this time thank a few people who have several years now, but I would like to take this time thank a few people who have
helped it along it's way. helped it along its way.
First, the people who originally created the Forge projects way back in Minecraft First, the people who originally created the Forge projects way back in Minecraft
alpha. Eloraam of RedPower, and SpaceToad of Buildcraft, without their acceptiance alpha. Eloraam of RedPower, and SpaceToad of Buildcraft, without their acceptiance
@@ -11,7 +11,7 @@ of me taking over the project, who knows what Minecraft modding would be today.
Secondly, someone who has worked with me, and developed some of the core features Secondly, someone who has worked with me, and developed some of the core features
that allow modding to be as functional, and as simple as it is, cpw. For developing that allow modding to be as functional, and as simple as it is, cpw. For developing
FML, which stabelized the client and server modding ecosystem. As well as the base FML, which stabilized the client and server modding ecosystem. As well as the base
loading system that allows us to modify Minecraft's code as elegently as possible. loading system that allows us to modify Minecraft's code as elegently as possible.
Mezz, who has stepped up as the issue and pull request manager. Helping to keep me Mezz, who has stepped up as the issue and pull request manager. Helping to keep me
@@ -45,11 +45,11 @@ and minecraft clients.
The code is authored by cpw. The code is authored by cpw.
It began by partially implementing an API defined by the client side ModLoader, authored by Risugami. It began by partially implementing an API defined by the client side ModLoader, authored by Risugami.
http://www.minecraftforum.net/topic/75440- https://www.minecraftforum.net/topic/75440-
This support has been dropped as of Minecraft release 1.7, as Risugami no longer maintains ModLoader. This support has been dropped as of Minecraft release 1.7, as Risugami no longer maintains ModLoader.
It also contains suggestions and hints and generous helpings of code from LexManos, author of MinecraftForge. It also contains suggestions and hints and generous helpings of code from LexManos, author of MinecraftForge.
http://www.minecraftforge.net/ https://minecraftforge.net/
Additionally, it contains an implementation of topological sort based on that Additionally, it contains an implementation of topological sort based on that
published at http://keithschwarz.com/interesting/code/?dir=topological-sort published at http://keithschwarz.com/interesting/code/?dir=topological-sort
+16 -1281
View File
File diff suppressed because it is too large. Load diff
+6 -6
View File
@@ -1,13 +1,13 @@
repositories { repositories {
maven { url = 'https://maven.minecraftforge.net/' } maven { url = 'https://maven.minecraftforge.net/' }
mavenCentral() mavenCentral()
} }
dependencies { dependencies {
implementation 'org.ow2.asm:asm:9.5' implementation 'org.ow2.asm:asm:9.7'
implementation 'org.ow2.asm:asm-tree:9.5' implementation 'org.ow2.asm:asm-tree:9.7'
implementation 'net.minecraftforge:srgutils:0.5.+' implementation 'net.minecraftforge:srgutils:0.5.10'
implementation 'commons-io:commons-io:2.12.0' implementation 'commons-io:commons-io:2.13.0'
implementation 'com.google.code.gson:gson:2.10.1' implementation 'com.google.code.gson:gson:2.10.1'
implementation 'org.eclipse.jgit:org.eclipse.jgit:6.5.0.202303070854-r' implementation 'org.eclipse.jgit:org.eclipse.jgit:6.5.0.202303070854-r'
} }
@@ -0,0 +1,70 @@
package net.minecraftforge.forge.tasks
import org.gradle.api.tasks.*
import org.gradle.api.DefaultTask
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.tasks.bundling.AbstractArchiveTask
import java.util.zip.ZipFile
abstract class BundleList extends DefaultTask {
@InputFiles abstract ConfigurableFileCollection getConfig()
@InputFiles abstract ConfigurableFileCollection getConfigExtra()
@InputFile abstract RegularFileProperty getServerBundle()
@OutputFile abstract RegularFileProperty getOutput()
BundleList() {
config.setFrom(project.configurations.installer)
configExtra.setFrom(project.configurations.installerextra)
output.convention(project.layout.buildDirectory.file("$name/output.list"))
configure {
dependsOn(project.tasks.universalJar)
inputs.file(project.tasks.universalJar.archiveFile)
}
}
@TaskAction
void run() {
def entries = [:] as TreeMap
def resolved = project.configurations.installer.resolvedConfiguration.resolvedArtifacts
for (def dep : resolved) {
def info = Util.getMavenInfoFromDep(dep)
//println("$dep.file.sha1\t$info.name\t$info.path")
entries.put("$info.art.group:$info.art.name", "$dep.file.sha256\t$info.name\t$info.path")
}
resolved = project.configurations.installerextra.resolvedConfiguration.resolvedArtifacts
for (def dep : resolved) {
def info = Util.getMavenInfoFromDep(dep)
//println("$dep.file.sha1\t$info.name\t$info.path")
entries.put("$info.art.group:$info.art.name", "$dep.file.sha256\t$info.name\t$info.path")
}
var packed = (AbstractArchiveTask) project.tasks.universalJar
var info = Util.getMavenInfoFromTask(packed)
def file = packed.archiveFile.get().asFile
entries.put("$info.art.group:$info.art.name:$info.art.classifier", "$file.sha256\t$info.name\t$info.path")
var classifier = 'server'
var genned = project.tasks.applyServerBinPatches
info = Util.getMavenInfoFromTask(genned, classifier)
file = genned.output.get().asFile
entries.put("$info.art.group:$info.art.name:$info.art.classifier", "$file.sha256\t$info.name\t$info.path")
try (def zip = new ZipFile(serverBundle.get().asFile)) {
def entry = zip.getEntry('META-INF/libraries.list')
def data = zip.getInputStream(entry).text.split('\n')
for (def line : data) {
def (sha, artifact, path) = line.split('\t')
def (group, name, other) = artifact.split(':', 3)
//println("Group: $group Name: $name")
def key = "$group:$name"
if (!entries.containsKey(key))
entries.put(key, line)
}
}
output.get().asFile.text = entries.values().join('\n')
}
}
@@ -1,6 +1,7 @@
package net.minecraftforge.forge.tasks package net.minecraftforge.forge.tasks
import groovy.json.JsonBuilder import groovy.json.JsonBuilder
import groovy.transform.CompileStatic
import org.gradle.api.DefaultTask import org.gradle.api.DefaultTask
import org.gradle.api.file.RegularFileProperty import org.gradle.api.file.RegularFileProperty
import org.gradle.api.tasks.InputFile import org.gradle.api.tasks.InputFile
@@ -10,6 +11,7 @@ import org.objectweb.asm.tree.ClassNode
import org.objectweb.asm.tree.FieldNode import org.objectweb.asm.tree.FieldNode
import org.objectweb.asm.tree.MethodNode import org.objectweb.asm.tree.MethodNode
@CompileStatic
abstract class BytecodeFinder extends DefaultTask { abstract class BytecodeFinder extends DefaultTask {
@InputFile abstract RegularFileProperty getJar() @InputFile abstract RegularFileProperty getJar()
// It should be fine to mark the output as internal as we want to control when we run it anyways. // It should be fine to mark the output as internal as we want to control when we run it anyways.
@@ -24,13 +26,13 @@ abstract class BytecodeFinder extends DefaultTask {
protected void exec() { protected void exec() {
Util.init() Util.init()
def outputFile = output.get().asFile var outputFile = output.get().asFile
if (outputFile.exists()) if (outputFile.exists())
outputFile.delete() outputFile.delete()
pre() pre()
Util.processClassNodes(jar.get().asFile, this::process) Util.processClassNodes(jar.get().asFile, this.&process)
post() post()
outputFile.text = new JsonBuilder(getData()).toPrettyString() outputFile.text = new JsonBuilder(getData()).toPrettyString()
@@ -38,8 +40,8 @@ abstract class BytecodeFinder extends DefaultTask {
protected process(ClassNode node) { protected process(ClassNode node) {
if (node.fields != null) node.fields.each { process(node, it) } if (node.fields !== null) node.fields.each { process(node, it) }
if (node.methods != null) node.methods.each { process(node, it) } if (node.methods !== null) node.methods.each { process(node, it) }
} }
protected pre() {} protected pre() {}
@@ -12,7 +12,7 @@ abstract class BytecodePredicateFinder extends BytecodeFinder {
@Internal @Internal
abstract Property<Closure<Boolean>> getPredicate() abstract Property<Closure<Boolean>> getPredicate()
private final Set<String> matches = new HashSet() private final Set<String> matches = new HashSet<>()
@Override @Override
protected process(ClassNode parent, MethodNode node) { protected process(ClassNode parent, MethodNode node) {
@@ -1,5 +1,8 @@
package net.minecraftforge.forge.tasks; package net.minecraftforge.forge.tasks;
import groovy.transform.CompileDynamic;
import groovy.transform.CompileStatic;
import java.util.Properties; import java.util.Properties;
import java.util.Enumeration; import java.util.Enumeration;
import java.util.Map; import java.util.Map;
@@ -26,6 +29,7 @@ import java.util.Set;
* This does the same thing, as well as sorting alphabetically. * This does the same thing, as well as sorting alphabetically.
* It also ignores all comments. We can add them latter if someone cares. * It also ignores all comments. We can add them latter if someone cares.
*/ */
@CompileStatic
public class CleanProperties extends Properties { public class CleanProperties extends Properties {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private static final String LINE_SEP = System.getProperty("line.separator"); private static final String LINE_SEP = System.getProperty("line.separator");
@@ -58,6 +62,7 @@ public class CleanProperties extends Properties {
return Collections.enumeration(ret); return Collections.enumeration(ret);
} }
@CompileDynamic
@Override @Override
public Set<Map.Entry<Object, Object>> entrySet() { public Set<Map.Entry<Object, Object>> entrySet() {
Set<Map.Entry<Object, Object>> ret = new TreeSet<>((l, r) -> ((String)l.getKey()).compareTo((String)r.getKey())); Set<Map.Entry<Object, Object>> ret = new TreeSet<>((l, r) -> ((String)l.getKey()).compareTo((String)r.getKey()));
@@ -1,5 +1,7 @@
package net.minecraftforge.forge.tasks package net.minecraftforge.forge.tasks
import groovy.transform.stc.FirstParam
import java.util.function.BiConsumer import java.util.function.BiConsumer
public class ClosureHelper { public class ClosureHelper {
@@ -22,7 +24,7 @@ public class ClosureHelper {
} }
} }
static <T> T apply(T obj, Closure cl) { static <T> T apply(T obj, @DelegatesTo(value = FirstParam, strategy = Closure.DELEGATE_FIRST) Closure cl) {
cl.delegate = obj cl.delegate = obj
cl.resolveStrategy = Closure.DELEGATE_FIRST cl.resolveStrategy = Closure.DELEGATE_FIRST
cl() cl()
@@ -1,67 +0,0 @@
package net.minecraftforge.forge.tasks
import org.gradle.api.tasks.*
import org.gradle.api.DefaultTask
import org.gradle.api.file.RegularFileProperty
import groovy.json.JsonSlurper
import java.util.zip.ZipEntry
import java.util.zip.ZipFile
import java.util.zip.ZipOutputStream
abstract class DevInstallerJar extends DefaultTask {
@OutputFile abstract RegularFileProperty getOutput()
@InputFile abstract RegularFileProperty getInput()
DevInstallerJar() {
output.convention(project.layout.buildDirectory.file('libs/' + project.name + '-' + project.version + '-installer-dev.jar'))
}
@TaskAction
protected void exec() {
try (def zos = new ZipOutputStream(output.get().asFile.newDataOutputStream())) {
def seen = [] as Set
def deps = [:] as java.util.TreeMap
try (def base = new ZipFile(input.get().asFile)) {
base.entries().each { entry ->
zos.putNextEntry(entry)
def data = base.getInputStream(entry).bytes
zos.write(data)
if (entry.name == 'install_profile.json' || entry.name == 'version.json') {
def json = new JsonSlurper().parse(data)
json.libraries.each { lib ->
deps.put(lib.name, lib.downloads.artifact)
}
}
if (entry.name.startsWith('maven/'))
seen.add(entry.name.substring(6))
}
}
def resolved = project.configurations.installer.resolvedConfiguration.resolvedArtifacts
deps.each { name, info ->
if (seen.contains(info.path))
return
def art = resolved.find { "${it.moduleVersion.id.group}:${it.moduleVersion.id.name}:${it.moduleVersion.id.version}" == name }
def file = null
if (art != null) {
if (!Util.checkExists(info.url))
file = art.file
} else {
// TODO download missing things
}
if (file != null) {
//println('maven/' + info.path)
zos.putNextEntry(new ZipEntry('maven/' + info.path))
zos.write(file.bytes)
seen.add(info.path)
}
}
}
}
}
@@ -27,7 +27,7 @@ abstract class DownloadLibraries extends DefaultTask {
def run() { def run() {
Util.init() Util.init()
File outputDir = output.get().asFile File outputDir = output.get().asFile
def libraries = new ArrayList() var libraries = new ArrayList<String>()
def json = input.get().asFile.json().libraries.each { lib -> def json = input.get().asFile.json().libraries.each { lib ->
//TODO: Thread? //TODO: Thread?
@@ -35,7 +35,7 @@ abstract class DownloadLibraries extends DefaultTask {
artifacts.each{ art -> artifacts.each{ art ->
def target = new File(outputDir, art.path) def target = new File(outputDir, art.path)
libraries.add(target.absolutePath) libraries.add(target.absolutePath)
if (!target.exists() || !art.sha1.equals(target.sha1())) { if (!target.exists() || art.sha1 != target.sha1()) {
project.logger.lifecycle("Downloading ${art.url}") project.logger.lifecycle("Downloading ${art.url}")
if (!target.parentFile.exists()) { if (!target.parentFile.exists()) {
target.parentFile.mkdirs() target.parentFile.mkdirs()
@@ -43,7 +43,7 @@ abstract class DownloadLibraries extends DefaultTask {
new URL(art.url).withInputStream { i -> new URL(art.url).withInputStream { i ->
target.withOutputStream { it << i } target.withOutputStream { it << i }
} }
if (!art.sha1.equals(target.sha1())) { if (art.sha1 != target.sha1()) {
throw new IllegalStateException("Failed to download ${art.url} to ${target.canonicalPath} SHA Mismatch") throw new IllegalStateException("Failed to download ${art.url} to ${target.canonicalPath} SHA Mismatch")
} }
} }
@@ -0,0 +1,28 @@
package net.minecraftforge.forge.tasks
import groovy.transform.CompileStatic
import org.gradle.api.DefaultTask
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.Property
import org.gradle.api.tasks.*
import java.util.zip.ZipFile
@CompileStatic
abstract class ExtractFile extends DefaultTask {
@InputFile abstract RegularFileProperty getInput()
@Input abstract Property<String> getTarget()
@OutputFile abstract RegularFileProperty getOutput()
@TaskAction
protected void exec() {
var zip = new ZipFile(input.get().asFile);
var entry = zip.getEntry(target.get())
if (entry == null)
throw new IllegalStateException(input.get().asFile.absolutePath + " does not contain " + target.get())
var stream = zip.getInputStream(entry)
output.get().asFile.withOutputStream { out ->
stream.transferTo(out)
}
}
}
@@ -1,20 +1,11 @@
package net.minecraftforge.forge.tasks package net.minecraftforge.forge.tasks
import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode import groovy.transform.EqualsAndHashCode
import java.util.ArrayList
import java.util.HashMap
import java.util.TreeMap
import java.util.TreeSet
import java.util.function.BiConsumer
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.* import org.gradle.api.tasks.*
import org.objectweb.asm.tree.AbstractInsnNode
import org.objectweb.asm.Opcodes
import org.objectweb.asm.Type
import org.objectweb.asm.tree.ClassNode import org.objectweb.asm.tree.ClassNode
import org.objectweb.asm.tree.FieldNode
import org.objectweb.asm.tree.MethodNode import org.objectweb.asm.tree.MethodNode
import static org.objectweb.asm.Opcodes.* import static org.objectweb.asm.Opcodes.*
@@ -34,17 +25,17 @@ abstract class FieldCompareFinder extends BytecodeFinder {
@Override @Override
protected process(ClassNode parent, MethodNode node) { protected process(ClassNode parent, MethodNode node) {
def last = null AbstractInsnNode last = null
def parentInstance = new ObjectTarget(owner: parent.name, name: '', desc: '') def parentInstance = new ObjectTarget(owner: parent.name, name: '', desc: '')
for (int x = 0; x < node.instructions.size(); x++) { for (int x = 0; x < node.instructions.size(); x++) {
def current = node.instructions.get(x) def current = node.instructions.get(x)
if (current.opcode == IF_ACMPEQ || current.opcode == IF_ACMPNE) { if (current.opcode === IF_ACMPEQ || current.opcode === IF_ACMPNE) {
if (last != null && (last.opcode == GETSTATIC || last.opcode == GETFIELD)) { if (last !== null && (last.opcode === GETSTATIC || last.opcode === GETFIELD)) {
def target = new Search(cls: last.owner, name: last.name) def target = new Search(cls: last.owner, name: last.name)
def wanted = fieldsReverse.get(target) def wanted = fieldsReverse.get(target)
def original = fields.get(wanted) def original = fields.get(wanted)
def instance = new ObjectTarget(owner: parent.name, name: node.name, desc: node.desc) def instance = new ObjectTarget(owner: parent.name, name: node.name, desc: node.desc)
if (wanted != null && (original.blacklist == null || (!original.blacklist.contains(instance) && !original.blacklist.contains(parentInstance)))) { if (wanted !== null && (original.blacklist === null || (!original.blacklist.contains(instance) && !original.blacklist.contains(parentInstance)))) {
targets.computeIfAbsent(wanted, { k -> new TreeSet() }).add(instance) targets.computeIfAbsent(wanted, { k -> new TreeSet() }).add(instance)
} }
} }
@@ -68,9 +59,10 @@ abstract class FieldCompareFinder extends BytecodeFinder {
} }
return ret return ret
} }
@CompileStatic
@EqualsAndHashCode(excludes = ['replacement', 'blacklist']) @EqualsAndHashCode(excludes = ['replacement', 'blacklist'])
public static class Search { static class Search {
@Input @Input
String cls String cls
@@ -89,17 +81,17 @@ abstract class FieldCompareFinder extends BytecodeFinder {
return cls + '.' + name return cls + '.' + name
} }
def blacklist(def owner, def name, def desc) { def blacklist(String owner, String name, String desc) {
if (blacklist == null) if (blacklist === null)
blacklist = new HashSet() blacklist = new HashSet<>()
blacklist.add(new ObjectTarget(owner: owner, name: name, desc: desc)) blacklist.add(new ObjectTarget(owner: owner, name: name, desc: desc))
} }
def blacklist(def owner) { def blacklist(String owner) {
blacklist(owner, '', '') blacklist(owner, '', '')
} }
} }
def fields(Closure cl) { void fields(Closure cl) {
new ClosureHelper(cl, {name, ccl -> new ClosureHelper(cl, {name, ccl ->
def search = ClosureHelper.apply(new Search(), ccl) def search = ClosureHelper.apply(new Search(), ccl)
this.fields.put(name, search) this.fields.put(name, search)
@@ -1,44 +1,158 @@
package net.minecraftforge.forge.tasks package net.minecraftforge.forge.tasks
import org.gradle.api.file.DuplicatesStrategy
import org.gradle.api.tasks.bundling.AbstractArchiveTask
import org.gradle.api.tasks.bundling.Zip import org.gradle.api.tasks.bundling.Zip
import org.gradle.api.tasks.* import org.gradle.api.tasks.*
import org.gradle.api.provider.SetProperty import org.gradle.api.DefaultTask
import org.gradle.api.provider.Property
import groovy.json.JsonSlurper
abstract class InstallerJar extends Zip { abstract class InstallerJar extends Zip {
@Input @Optional abstract SetProperty<String> getPackedDependencies() @Input @Optional abstract Property<Boolean> getFat()
@Input @Optional abstract Property<Boolean> getOffline()
InstallerJar() { InstallerJar() {
archiveClassifier.set('installer') archiveClassifier.set('installer')
archiveExtension.set('jar') // Needs to be Zip task to not override Manifest, so set extension archiveExtension.set('jar') // Needs to be Zip task to not override Manifest, so set extension
destinationDirectory.set(project.layout.buildDirectory.dir('libs')) destinationDirectory.set(project.layout.buildDirectory.dir('libs'))
fat.convention(false)
offline.convention(false)
def installerJson = project.tasks.installerJson def installerJson = project.tasks.installerJson
def launcherJson = project.tasks.launcherJson def launcherJson = project.tasks.launcherJson
def downloadInstaller = project.tasks.downloadInstaller def downloadInstaller = project.tasks.downloadInstaller
dependsOn(installerJson, launcherJson, downloadInstaller) dependsOn(installerJson, launcherJson, downloadInstaller, project.configurations.installer)
from(installerJson, launcherJson) from(installerJson, launcherJson)
from(project.rootProject.file('/src/main/resources/url.png')) from(project.rootProject.file('/src/main/resources/url.png'))
project.afterEvaluate { project.afterEvaluate {
from(project.zipTree(downloadInstaller.output)) { from(project.zipTree(downloadInstaller.output)) {
duplicatesStrategy = 'exclude' duplicatesStrategy = DuplicatesStrategy.EXCLUDE
} }
if (!System.env.TEAMCITY_VERSION) { if (fat.get() || offline.get()) {
dependsOn(project.universalJar) def cfg = project.tasks.register(name + "Config", Configure)
from(project.universalJar) { cfg.get().configure {
into '/maven/' + project.group.replace('.', '/') + '/' + project.universalJar.archiveBaseName.get() + '/' + project.version + '/' parent = this
dependsOn(project.tasks.installerJson, project.tasks.launcherJson)
} }
dependsOn(cfg)
packedDependencies.get().forEach { } else {
def jarTask = project.rootProject.getTasks().findByPath(it) // Things we ALWAYS bundle, this just the server shim jar, because the installer spec only says to extract the file.
dependsOn(jarTask) // I should make it allow downloads but thats a spec break, and this is just a ~14KB jar
from(jarTask) { [
into '/maven/' + jarTask.project.group.replace('.', '/') + '/' + jarTask.archiveBaseName.get() + '/' + jarTask.project.version + '/' project.tasks.serverShimJar // Server bootstrap executable jar
].forEach { AbstractArchiveTask packed ->
def path = Util.getMavenInfoFromTask(packed).path
from(packed) {
rename { "maven/$path" }
} }
} }
} }
} }
} }
static abstract class Configure extends DefaultTask {
public Zip parent
private int count = 0;
@TaskAction
protected void exec() {
def deps = [:] as java.util.TreeMap
// Gather all things that need downloading
[
project.tasks.installerJson,
project.tasks.launcherJson
].each { task ->
def json = task.output.get().asFile.json
json.libraries.each { lib ->
if (lib.downloads?.artifact?.url !== null && !lib.downloads.artifact.url.isEmpty())
deps.put(lib.name, lib.downloads.artifact)
}
}
// First find things we build in this project.
[
project.tasks.universalJar, // Forge runtime code
project.tasks.serverShimJar // Shim jar for dedicated server
].forEach { AbstractArchiveTask packed ->
def name = Util.getMavenInfoFromTask(packed).name
def info = deps.remove(name)
if (info !== null) {
println("Adding: $packed.path $name")
parent.from(packed) {
rename { "maven/$info.path" }
}
}
}
// Find any artifacts from the 'installer' config
// This config specifies the runtime files we intend for the interaller to have.
// And are typically what we would be developing and testing alongside Forge.
// So we may have local modified versions
def cfg = project.configurations.installer
while (cfg != null) {
//println('')
def resolved = cfg.resolvedConfiguration.resolvedArtifacts
int found = 0
for (def dep : resolved) {
def name = Util.getMavenInfoFromDep(dep).name
def info = deps.remove(name)
if (info == null) {
//println("Skipping: $name")
continue
}
//println("-$name")
found++
addFile(dep.file, info)
}
if (deps.isEmpty()) {
cfg = null
continue
}
// Prevent infinite loops if something fucky happens
if (found == 0)
throw new IllegalStateException("Failed to find any installer dependencies")
def seen = [] as Set
cfg = project.configurations.detachedConfiguration()
cfg.transitive = false
for (def key : deps.keySet()) {
def (group, artifact, other) = key.split(':', 3)
// Only resolve unique group:artifact so we don't get version overrides
if (seen.add(group + ':' + artifact)) {
//println("+$key")
cfg.dependencies.add(project.dependencies.create(key))
}
}
}
}
void addFile(file, info) {
boolean pack = parent.offline.get() || info.url.isEmpty()
// If it's a offline jar just always pack
if (!pack) {
try {
var remote = new URL("${info.url}.sha1").getText('UTF-8')
pack = info.sha1 != remote
} catch (FileNotFoundException e) {
pack = !info.url.startsWith('https://libraries.minecraft.net/')
// Oh noes its not there!
}
}
if (pack) {
println("Adding: $file.absolutePath")
parent.from(file) {
rename { "maven/$info.path" }
}
}
}
}
} }
@@ -7,13 +7,13 @@ import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.Property import org.gradle.api.provider.Property
import org.gradle.api.provider.SetProperty import org.gradle.api.provider.SetProperty
import org.gradle.api.tasks.* import org.gradle.api.tasks.*
import org.gradle.api.tasks.bundling.AbstractArchiveTask
import java.nio.file.Files import java.nio.file.Files
abstract class InstallerJson extends DefaultTask { abstract class InstallerJson extends DefaultTask {
@OutputFile abstract RegularFileProperty getOutput() @OutputFile abstract RegularFileProperty getOutput()
@InputFiles abstract ConfigurableFileCollection getInput() @InputFiles abstract ConfigurableFileCollection getInput()
@Input @Optional abstract SetProperty<String> getPackedDependencies()
@Input @Optional final Map<String, Object> libraries = new LinkedHashMap<>() @Input @Optional final Map<String, Object> libraries = new LinkedHashMap<>()
@Input Map<String, Object> json = new LinkedHashMap<>() @Input Map<String, Object> json = new LinkedHashMap<>()
@InputFile abstract RegularFileProperty getIcon() @InputFile abstract RegularFileProperty getIcon()
@@ -23,29 +23,19 @@ abstract class InstallerJson extends DefaultTask {
@Input abstract Property<String> getWelcome() @Input abstract Property<String> getWelcome()
InstallerJson() { InstallerJson() {
getLauncherJsonName().convention('/version.json') launcherJsonName.convention('/version.json')
getLogo().convention('/big_logo.png') logo.convention('/big_logo.png')
getMirrors().convention('https://files.minecraftforge.net/mirrors-2.0.json') mirrors.convention('https://files.minecraftforge.net/mirrors-2.0.json')
getWelcome().convention("Welcome to the simple ${project.name.capitalize()} installer.") welcome.convention("Welcome to the ${project.name.capitalize()} installer.")
output.convention(project.layout.buildDirectory.file('libs/install_profile.json'))
getOutput().convention(project.layout.buildDirectory.file('install_profile.json'))
['client', 'server'].each { side ->
['slim', 'extra'].each { type ->
def tsk = project.tasks.getByName("download${side.capitalize()}${type.capitalize()}")
dependsOn(tsk)
input.from(tsk.output)
}
def tsk = project.tasks.getByName("create${side.capitalize()}SRG")
dependsOn(tsk)
input.from(tsk.output)
}
project.afterEvaluate { project.afterEvaluate {
(packedDependencies.get().collect{ project.rootProject.tasks.findByPath(it) } + [project.universalJar]).forEach { [
dependsOn(it) project.tasks.universalJar,
input.from it.archiveFile project.tasks.serverShimJar
].forEach { packed ->
dependsOn(packed)
input.from packed.archiveFile
} }
} }
} }
@@ -53,17 +43,19 @@ abstract class InstallerJson extends DefaultTask {
@TaskAction @TaskAction
protected void exec() { protected void exec() {
def libs = libraries def libs = libraries
for (def child : packedDependencies.get().collect{ project.rootProject.tasks.findByPath(it) } + [project.universalJar]) { [
def dep = Util.getMavenDep(child) project.tasks.universalJar,
def path = Util.getMavenPath(child) project.tasks.serverShimJar
libs.put(dep.toString(), [ ].forEach { AbstractArchiveTask packed ->
name: dep, def info = Util.getMavenInfoFromTask(packed)
libs.put(info.name, [
name: info.name,
downloads: [ downloads: [
artifact: [ artifact: [
path: path, path: info.path,
url: "https://maven.minecraftforge.net/${path}", url: "https://maven.minecraftforge.net/$info.path",
sha1: child.archiveFile.get().asFile.sha1(), sha1: packed.archiveFile.get().asFile.sha1(),
size: child.archiveFile.get().asFile.length() size: packed.archiveFile.get().asFile.length()
] ]
] ]
]) ])
@@ -6,6 +6,7 @@ import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.RegularFileProperty import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.SetProperty import org.gradle.api.provider.SetProperty
import org.gradle.api.tasks.* import org.gradle.api.tasks.*
import org.gradle.api.tasks.bundling.AbstractArchiveTask
import java.nio.file.Files import java.nio.file.Files
@@ -16,59 +17,80 @@ abstract class LauncherJson extends DefaultTask {
@OutputFile abstract RegularFileProperty getOutput() @OutputFile abstract RegularFileProperty getOutput()
@InputFiles abstract ConfigurableFileCollection getInput() @InputFiles abstract ConfigurableFileCollection getInput()
@Input Map<String, Object> json = new LinkedHashMap<>() @Input Map<String, Object> json = new LinkedHashMap<>()
@Input @Optional abstract SetProperty<String> getPackedDependencies()
@Internal final vanilla = project.project(':mcp').file('build/mcp/downloadJson/version.json')
@Internal final timestamp = iso8601Now()
@Internal final comment = [
"Please do not automate the download and installation of Forge.",
"Our efforts are supported by ads from the download page.",
"If you MUST automate this, please consider supporting the project through https://www.patreon.com/LexManos/"
]
@Internal final id = "${project.rootProject.ext.MC_VERSION}-${project.name}${project.version.substring(project.rootProject.ext.MC_VERSION.length())}"
LauncherJson() { LauncherJson() {
getOutput().convention(project.layout.buildDirectory.file('version.json')) output.convention(project.layout.buildDirectory.file('libs/version.json'))
dependsOn(':fmlloader:jar', 'universalJar') dependsOn(project.tasks.universalJar)
getInput().from(project.tasks.universalJar.archiveFile, input.from(project.tasks.universalJar.archiveFile)
project.project(':fmlloader').jar.archiveFile, input.from(project.configurations.installer)
vanilla) input.from(project.configurations.installerextra)
configure {
project.afterEvaluate { def mc = project.rootProject.ext.MC_VERSION
packedDependencies.get().forEach { def forge = project.rootProject.ext.FORGE_VERSION
def jarTask = project.rootProject.tasks.findByPath(it) def timestamp = iso8601Now()
dependsOn(jarTask) json.putAll([
input.from jarTask.archiveFile _comment: [
"Please do not automate the download and installation of Forge.",
"Our efforts are supported by ads from the download page.",
"If you MUST automate this, please consider supporting the project through https://www.patreon.com/LexManos/"
],
id: "$mc-$project.name-$forge",
time: timestamp,
releaseTime: timestamp,
inheritsFrom: mc,
type: 'release',
logging: [:],
mainClass: '',
libraries: []
] as LinkedHashMap)
[
project.tasks.universalJar
].forEach { packed ->
dependsOn(packed)
input.from packed.archiveFile
} }
def patched = project.tasks.applyClientBinPatches
dependsOn(patched)
input.from patched.output
} }
} }
@TaskAction @TaskAction
protected void exec() { protected void exec() {
if (!json.libraries) var packed = (AbstractArchiveTask) project.tasks.universalJar
json.libraries = [] def info = Util.getMavenInfoFromTask(packed)
def libs = [:] json.libraries.add([
getArtifacts(project, project.configurations.installer, false).each { key, lib -> libs[key] = lib } name: info.name,
getArtifacts(project, project.configurations.moduleonly, false).each { key, lib -> libs[key] = lib } downloads: [
artifact: [
packedDependencies.get().collect{ project.rootProject.tasks.findByPath(it) }.forEach { path: info.path,
def path = Util.getMavenPath(it) url: "https://maven.minecraftforge.net/$info.path",
def key = Util.getMavenDep(it) sha1: packed.archiveFile.get().asFile.sha1(),
size: packed.archiveFile.get().asFile.length()
libs[key] = [
name: key,
downloads: [
artifact: [
path: path,
url: "https://maven.minecraftforge.net/${path}",
sha1: it.archiveFile.get().asFile.sha1(),
size: it.archiveFile.get().asFile.length()
]
] ]
] ]
} ])
libs.each { key, lib -> json.libraries.add(lib) }
var classifier = 'client'
var genned = project.tasks.applyClientBinPatches
info = Util.getMavenInfoFromTask(genned, classifier)
json.libraries.add([
name: info.name,
downloads: [
artifact: [
path: info.path,
url: "",
sha1: genned.output.get().asFile.sha1(),
size: genned.output.get().asFile.length()
]
]
])
json.libraries.addAll(getArtifacts(project.configurations.installerextra).values())
json.libraries.addAll(getArtifacts(project.configurations.installer).values())
Files.writeString(output.get().asFile.toPath(), new JsonBuilder(json).toPrettyString()) Files.writeString(output.get().asFile.toPath(), new JsonBuilder(json).toPrettyString())
} }
} }
@@ -1,5 +1,6 @@
package net.minecraftforge.forge.tasks package net.minecraftforge.forge.tasks
import groovy.transform.CompileStatic
import org.apache.commons.io.IOUtils import org.apache.commons.io.IOUtils
import org.gradle.api.DefaultTask import org.gradle.api.DefaultTask
import org.gradle.api.file.ConfigurableFileCollection import org.gradle.api.file.ConfigurableFileCollection
@@ -12,6 +13,7 @@ import java.util.zip.ZipEntry
import java.util.zip.ZipInputStream import java.util.zip.ZipInputStream
import java.util.zip.ZipOutputStream import java.util.zip.ZipOutputStream
@CompileStatic
abstract class MergeJars extends DefaultTask { abstract class MergeJars extends DefaultTask {
MergeJars() { MergeJars() {
output.convention(project.layout.buildDirectory.dir(name).map { it.file('output.jar') }) output.convention(project.layout.buildDirectory.dir(name).map { it.file('output.jar') })
@@ -24,8 +26,8 @@ abstract class MergeJars extends DefaultTask {
try (ZipOutputStream zout = new ZipOutputStream(new FileOutputStream(output.get().asFile))) { try (ZipOutputStream zout = new ZipOutputStream(new FileOutputStream(output.get().asFile))) {
for (def jar : jars) { for (def jar : jars) {
try (ZipInputStream zin = new ZipInputStream(new FileInputStream(jar))) { try (ZipInputStream zin = new ZipInputStream(new FileInputStream(jar))) {
def entry ZipEntry entry
while ((entry = zin.getNextEntry()) != null) { while ((entry = zin.getNextEntry()) !== null) {
ZipEntry _new = new ZipEntry(entry.getName()) ZipEntry _new = new ZipEntry(entry.getName())
_new.setTime(0) //SHOULD be the same time as the main entry, but NOOOO _new.setTime(entry.getTime()) throws DateTimeException, so you get 0, screw you! _new.setTime(0) //SHOULD be the same time as the main entry, but NOOOO _new.setTime(entry.getTime()) throws DateTimeException, so you get 0, screw you!
zout.putNextEntry(_new) zout.putNextEntry(_new)
@@ -27,6 +27,6 @@ public class ObjectTarget implements Comparable<ObjectTarget> {
@Override @Override
int compareTo(ObjectTarget o) { int compareTo(ObjectTarget o) {
return toString().compareTo(o.toString()) return toString() <=> o.toString()
} }
} }
@@ -16,7 +16,7 @@ abstract class SetupCheckJarCompatibility extends DefaultTask {
SetupCheckJarCompatibility() { SetupCheckJarCompatibility() {
group = 'jar compatibility' group = 'jar compatibility'
onlyIf { onlyIf {
inputVersion.getOrNull() != null inputVersion.getOrNull() !== null
} }
outputs.upToDateWhen { false } // Never up to date, because this setup task should always run outputs.upToDateWhen { false } // Never up to date, because this setup task should always run
@@ -26,16 +26,6 @@ abstract class SetupCheckJarCompatibility extends DefaultTask {
@TaskAction @TaskAction
void run() { void run() {
def inputVersion = inputVersion.get() def inputVersion = inputVersion.get()
def fmlLibs = project.configurations.detachedConfiguration(project.PACKED_DEPS.collect {
def artifactId = it.split(':')[1]
return project.dependencies.create("net.minecraftforge:${artifactId}:${inputVersion}")
}.toArray(Dependency[]::new))
project.tasks.named('checkJarCompatibility') {
baseLibraries.from(project.provider {
fmlLibs.resolvedConfiguration.lenientConfiguration.files
})
}
def baseForgeUserdev = project.layout.buildDirectory.dir(name).map { it.file("forge-${inputVersion}-userdev.jar") }.get().asFile def baseForgeUserdev = project.layout.buildDirectory.dir(name).map { it.file("forge-${inputVersion}-userdev.jar") }.get().asFile
project.rootProject.extensions.download.run { project.rootProject.extensions.download.run {
@@ -2,159 +2,224 @@ package net.minecraftforge.forge.tasks
import groovy.json.JsonBuilder import groovy.json.JsonBuilder
import groovy.json.JsonSlurper import groovy.json.JsonSlurper
import groovy.transform.CompileStatic
import groovy.transform.stc.ClosureParams
import groovy.transform.stc.SimpleType
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.ResolvedArtifact
import org.gradle.api.tasks.bundling.AbstractArchiveTask
import org.objectweb.asm.ClassReader import org.objectweb.asm.ClassReader
import org.objectweb.asm.Opcodes import org.objectweb.asm.Opcodes
import org.objectweb.asm.tree.ClassNode import org.objectweb.asm.tree.ClassNode
import java.io.File import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.security.MessageDigest import java.security.MessageDigest
import java.text.SimpleDateFormat import java.text.SimpleDateFormat
import java.util.Date import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.Semaphore
import java.util.zip.ZipEntry import java.util.zip.ZipEntry
import java.util.zip.ZipInputStream import java.util.zip.ZipInputStream
public class Util { final class Util {
static final ASM_LEVEL = Opcodes.ASM9 public static final int ASM_LEVEL = Opcodes.ASM9
private static final HttpClient HTTP = HttpClient.newBuilder().build()
static void init() { static void init() {
File.metaClass.sha1 = { -> File.metaClass.sha1 = { ->
MessageDigest md = MessageDigest.getInstance('SHA-1') MessageDigest md = MessageDigest.getInstance('SHA-1')
delegate.eachByte 4096, {bytes, size -> delegate.eachByte(4096) { byte[] bytes, int size ->
md.update(bytes, 0, size) md.update(bytes, 0, size)
} }
return md.digest().collect {String.format "%02x", it}.join() return md.digest().collect(this.&toHex).join('')
} }
File.metaClass.getSha1 = { !delegate.exists() ? null : delegate.sha1() } File.metaClass.getSha1 = { !delegate.exists() ? null : delegate.sha1() }
File.metaClass.sha256 = { ->
MessageDigest md = MessageDigest.getInstance('SHA-256')
delegate.eachByte(4096) { byte[] bytes, int size ->
md.update(bytes, 0, size)
}
return md.digest().collect(this.&toHex).join('')
}
File.metaClass.getSha256 = { !delegate.exists() ? null : delegate.sha256() }
File.metaClass.json = { -> new JsonSlurper().parseText(delegate.text) } File.metaClass.json = { -> new JsonSlurper().parseText(delegate.text) }
File.metaClass.getJson = { return delegate.exists() ? new JsonSlurper().parse(delegate) : [:] } File.metaClass.getJson = { return delegate.exists() ? new JsonSlurper().parse(delegate) : [:] }
File.metaClass.setJson = { json -> delegate.text = new JsonBuilder(json).toPrettyString() } File.metaClass.setJson = { json -> delegate.text = new JsonBuilder(json).toPrettyString() }
Date.metaClass.iso8601 = { -> Date.metaClass.iso8601 = { ->
def format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ") var format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
def result = format.format(delegate) var result = format.format(delegate)
return result[0..21] + ':' + result[22..-1] return result[0..21] + ':' + result[22..-1]
} }
String.metaClass.rsplit = { String del, int limit = -1 -> String.metaClass.rsplit = { String del, int limit = -1 ->
def lst = new ArrayList() var lst = new ArrayList<String>()
def x = 0, idx int x = 0
def tmp = delegate int idx
while ((idx = tmp.lastIndexOf(del)) != -1 && (limit == -1 || x++ < limit)) { String tmp = delegate
while ((idx = tmp.lastIndexOf(del)) != -1 && (limit === -1 || x++ < limit)) {
lst.add(0, tmp.substring(idx + del.length(), tmp.length())) lst.add(0, tmp.substring(idx + del.length(), tmp.length()))
tmp = tmp.substring(0, idx) tmp = tmp.substring(0, idx)
} }
lst.add(0, tmp) lst.add(0, tmp)
return lst return lst
} }
}
public static String[] getClasspath(project, libs, artifact) {
def ret = []
artifactTree(project, artifact).each { key, lib ->
libs[lib.name] = lib
if (lib.name != artifact)
ret.add(lib.name)
}
return ret
}
public static def getArtifacts(project, config, classifiers) {
def ret = [:]
config.resolvedConfiguration.resolvedArtifacts.each {
def art = [
group: it.moduleVersion.id.group,
name: it.moduleVersion.id.name,
version: it.moduleVersion.id.version,
classifier: it.classifier,
extension: it.extension,
file: it.file
]
def key = art.group + ':' + art.name
def folder = "${art.group.replace('.', '/')}/${art.name}/${art.version}/"
def filename = "${art.name}-${art.version}"
if (art.classifier != null)
filename += "-${art.classifier}"
filename += ".${art.extension}"
def path = "${folder}${filename}"
def url = "https://libraries.minecraft.net/${path}"
if (!checkExists(url)) {
url = "https://maven.minecraftforge.net/${path}"
}
ret[key] = [
name: "${art.group}:${art.name}:${art.version}" + (art.classifier == null ? '' : ":${art.classifier}") + (art.extension == 'jar' ? '' : "@${art.extension}"),
downloads: [
artifact: [
path: path,
url: url,
sha1: sha1(art.file),
size: art.file.length()
]
]
]
}
return ret
}
public static def getMavenPath(task) {
def classifier = task.archiveClassifier.get()
def dep = "${task.project.group}:${task.project.name}:${task.project.version}" + (classifier == '' ? '' : ':' + classifier)
return "${task.project.group.replace('.', '/')}/${task.project.name}/${task.project.version}/${task.project.name}-${task.project.version}".toString() + (classifier == '' ? '' : '-' + classifier) + '.jar'
} }
public static def getMavenDep(task) { static String[] getClasspath(Project project, Map libs, String artifact) {
def classifier = task.archiveClassifier.get() def ret = []
return "${task.project.group}:${task.project.name}:${task.project.version}" + (classifier == '' ? '' : ':' + classifier) artifactTree(project, artifact).each { key, lib ->
libs[lib.name] = lib
if (lib.name != artifact)
ret.add(lib.name)
}
return ret
} }
public static def iso8601Now() { new Date().iso8601() } @CompileStatic
static Map getArtifacts(Configuration config) {
var ret = [:]
var semaphore = new Semaphore(1, true)
config.resolvedConfiguration.resolvedArtifacts.parallelStream().forEachOrdered(dep -> {
var info = getMavenInfoFromDep(dep)
var domain = 'libraries.minecraft.net'
var url = "https://$domain/$info.path"
if (!checkExists(url))
url.values[0] = 'maven.minecraftforge.net'
public static def sha1(file) { var sha1 = sha1(dep.file)
MessageDigest md = MessageDigest.getInstance('SHA-1')
file.eachByte 4096, {bytes, size ->
md.update(bytes, 0, size)
}
return md.digest().collect {String.format "%02x", it}.join()
}
private static def artifactTree(project, artifact) { semaphore.acquire()
if (!project.ext.has('tree_resolver')) ret[info.key] = [
project.ext.tree_resolver = 1 name: info.name,
def cfg = project.configurations.create('tree_resolver_' + project.ext.tree_resolver++) downloads: [
def dep = project.dependencies.create(artifact) artifact: [
cfg.dependencies.add(dep) path: info.path,
def files = cfg.resolve() url: url.toString(),
return getArtifacts(project, cfg, true) sha1: sha1,
} size: dep.file.length()
]
]
]
semaphore.release()
})
return ret
}
static boolean checkExists(url) { @CompileStatic
try { static Map getMavenInfoFromDep(ResolvedArtifact dep) {
def code = new URL(url).openConnection().with { return getMavenInfoFromMap([
requestMethod = 'HEAD' group: dep.moduleVersion.id.group,
connect() name: dep.moduleVersion.id.name,
responseCode version: dep.moduleVersion.id.version,
} classifier: dep.classifier,
return code == 200 extension: dep.extension
} catch (Exception e) { ])
if (e.toString().contains('unable to find valid certification path to requested target')) }
throw new RuntimeException('Failed to connect to ' + url + ': Missing certificate root authority, try updating java')
throw e
}
}
static String getLatestForgeVersion(mcVersion) { @CompileStatic
static Map getMavenInfoFromTask(AbstractArchiveTask task) {
return getMavenInfoFromMap([
group: task.project.group.toString(),
name: task.project.name,
version: task.project.version.toString(),
classifier: task.archiveClassifier.get(),
extension: task.archiveExtension.get()
])
}
@CompileStatic
static Map getMavenInfoFromTask(Task task, String classifier) {
return getMavenInfoFromMap([
group: task.project.group.toString(),
name: task.project.name,
version: task.project.version.toString(),
classifier: classifier,
extension: 'jar'
])
}
@CompileStatic
private static Map getMavenInfoFromMap(Map<String, String> art) {
var key = "$art.group:$art.name"
var name = "$art.group:$art.name:$art.version"
var path = "${art.group.replace('.', '/')}/$art.name/$art.version/$art.name-$art.version"
if (art.classifier !== null) {
name += ":$art.classifier"
path += "-$art.classifier"
}
if ('jar' != art.extension) {
name += "@$art.extension"
path += ".$art.extension"
} else {
path += ".jar"
}
return [
key: key.toString(),
name: name.toString(),
path: path.toString(),
art: art
]
}
static String iso8601Now() { new Date().iso8601() }
@CompileStatic
static String sha1(File file) {
MessageDigest md = MessageDigest.getInstance('SHA-1')
file.eachByte(4096) { byte[] bytes, int size ->
md.update(bytes, 0, size)
}
return md.digest().collect(this.&toHex).join('')
}
@CompileStatic
private static String toHex(byte bite) {
return String.format('%02x', bite)
}
private static Map artifactTree(Project project, String artifact, boolean transitive = true) {
if (!project.ext.has('tree_resolver'))
project.ext.tree_resolver = 1
def cfg = project.configurations.create('tree_resolver_' + project.ext.tree_resolver++)
cfg.transitive = transitive
def dep = project.dependencies.create(artifact)
cfg.dependencies.add(dep)
def files = cfg.resolve()
return getArtifacts(cfg)
}
@CompileStatic
static boolean checkExists(String url) {
try {
return HTTP.send(HttpRequest.newBuilder(new URI(url))
.method('HEAD', HttpRequest.BodyPublishers.noBody()).build(), HttpResponse.BodyHandlers.discarding()
).statusCode() === 200
} catch (Exception e) {
if (e.toString().contains('unable to find valid certification path to requested target'))
throw new RuntimeException("Failed to connect to $url: Missing certificate root authority, try updating Java")
throw e
}
}
static String getLatestForgeVersion(String mcVersion) {
final json = new JsonSlurper().parseText(new URL('https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json').getText('UTF-8')) final json = new JsonSlurper().parseText(new URL('https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json').getText('UTF-8'))
final ver = json.promos["$mcVersion-latest"] final ver = json.promos["$mcVersion-latest"]
ver === null ? null : (mcVersion + '-' + ver) ver === null ? null : (mcVersion + '-' + ver)
} }
static void processClassNodes(File file, Closure process) { @CompileStatic
static void processClassNodes(File file, @ClosureParams(value = SimpleType, options = 'org.objectweb.asm.tree.ClassNode') Closure process) {
file.withInputStream { i -> file.withInputStream { i ->
new ZipInputStream(i).withCloseable { zin -> new ZipInputStream(i).withCloseable { zin ->
ZipEntry zein ZipEntry zein
while ((zein = zin.nextEntry) != null) { while ((zein = zin.nextEntry) !== null) {
if (zein.name.endsWith('.class')) { if (zein.name.endsWith('.class')) {
def node = new ClassNode(ASM_LEVEL) var node = new ClassNode(ASM_LEVEL)
new ClassReader(zin).accept(node, 0) new ClassReader(zin).accept(node, 0)
process(node) process(node)
} }
@@ -162,4 +227,4 @@ public class Util {
} }
} }
} }
} }
@@ -5,6 +5,7 @@
package net.minecraftforge.forge.tasks package net.minecraftforge.forge.tasks
import groovy.transform.CompileStatic
import net.minecraftforge.srgutils.MinecraftVersion import net.minecraftforge.srgutils.MinecraftVersion
import org.gradle.api.DefaultTask import org.gradle.api.DefaultTask
import org.gradle.api.file.RegularFileProperty import org.gradle.api.file.RegularFileProperty
@@ -28,8 +29,8 @@ abstract class ValidateDeprecations extends DefaultTask {
@TaskAction @TaskAction
protected void exec() { protected void exec() {
def mcVer = MinecraftVersion.from(mcVersion.get()) var mcVer = MinecraftVersion.from(mcVersion.get())
def errors = [] List<String> errors = []
Util.processClassNodes(input.get().asFile) { Util.processClassNodes(input.get().asFile) {
processNode(mcVer, errors, it) processNode(mcVer, errors, it)
@@ -65,7 +66,7 @@ abstract class ValidateDeprecations extends DefaultTask {
} }
} }
private static void processAnnotations(AnnotationNode annotation, MinecraftVersion mcVer, List<String> errors, Closure context) { private static void processAnnotations(AnnotationNode annotation, MinecraftVersion mcVer, List<String> errors, Closure<String> context) {
def values = annotation.values def values = annotation.values
if (values === null) if (values === null)
return return
@@ -73,7 +74,7 @@ abstract class ValidateDeprecations extends DefaultTask {
int since = values.indexOf('since') int since = values.indexOf('since')
if (annotation.desc == 'Ljava/lang/Deprecated;' && forRemoval !== -1 && since !== -1 && values.size() >= 4 && values[forRemoval + 1] === true) { if (annotation.desc == 'Ljava/lang/Deprecated;' && forRemoval !== -1 && since !== -1 && values.size() >= 4 && values[forRemoval + 1] === true) {
def oldVersion = MinecraftVersion.from(values[since + 1]) def oldVersion = MinecraftVersion.from(values[since + 1])
def split = ValidateDeprecations.splitDots(oldVersion.toString()) int[] split = ValidateDeprecations.splitDots(oldVersion.toString())
if (split.length < 2) if (split.length < 2)
return return
def removeVersion = MinecraftVersion.from("${split[0]}.${split[1] + 1}") def removeVersion = MinecraftVersion.from("${split[0]}.${split[1] + 1}")
@@ -82,6 +83,7 @@ abstract class ValidateDeprecations extends DefaultTask {
} }
} }
@CompileStatic
private static int[] splitDots(String version) { private static int[] splitDots(String version) {
String[] pts = version.split('\\.') String[] pts = version.split('\\.')
int[] values = new int[pts.length] int[] values = new int[pts.length]
@@ -26,12 +26,12 @@ abstract class CheckExcs extends CheckTask {
excs.each { f -> excs.each { f ->
final lines = [] final lines = []
f.eachLine { line -> f.eachLine { line ->
def idx = line.indexOf('#') int idx = line.indexOf('#')
if (idx == 0 || line.isEmpty()) { if (idx === 0 || line.isEmpty()) {
return return
} }
if (idx != -1) line = line.substring(0, idx - 1) if (idx !== -1) line = line.substring(0, idx - 1)
if (!line.contains('=')) { if (!line.contains('=')) {
reporter.report("Invalid: $line") reporter.report("Invalid: $line")
@@ -58,6 +58,8 @@ abstract class CheckExcs extends CheckTask {
return return
} }
lines.add(line) lines.add(line)
return
} }
if (fix) f.text = lines.sort().join('\n') if (fix) f.text = lines.sort().join('\n')
@@ -6,4 +6,6 @@ import groovy.transform.CompileStatic
enum CheckMode { enum CheckMode {
CHECK, CHECK,
FIX FIX
CheckMode() {}
} }
@@ -36,13 +36,13 @@ abstract class CheckPatches extends CheckTask {
} }
} }
def accessChange(previous, current) { static boolean accessChange(String previous, String current) {
//return ACCESS_MAP[previous] < ACCESS_MAP[current] //return ACCESS_MAP[previous] < ACCESS_MAP[current]
return previous != current return previous != current
} }
void verifyPatch(Path patch, Reporter reporter, boolean fix, String patchPath, boolean hasS2SArtifact) { void verifyPatch(Path patch, Reporter reporter, boolean fix, String patchPath, boolean hasS2SArtifact) {
final oldFixedErrors = reporter.fixed.size() int oldFixedErrors = reporter.fixed.size()
final lines = Files.readAllLines(patch) final lines = Files.readAllLines(patch)
@@ -140,7 +140,7 @@ abstract class CheckPatches extends CheckTask {
final nextLineChange = i + 1 < lines.size() && lines[i + 1].startsWithAny('+','-') final nextLineChange = i + 1 < lines.size() && lines[i + 1].startsWithAny('+','-')
if (!prevLineChange && !nextLineChange) { if (!prevLineChange && !nextLineChange) {
reporter.report("Patch contains white space change in valid hunk at line ${i + 1}, file: $patchPath", false) reporter.report("Patch contains white space change in valid hunk at line ${i + 1}, file: $patchPath \n$prevLine\n$line\n${lines[i+1]}", false)
} }
} }
@@ -94,7 +94,7 @@ abstract class CheckSAS extends CheckTask {
} }
} }
protected static isSided(Annotatable annotatable) { protected static boolean isSided(Annotatable annotatable) {
if (annotatable === null) return false if (annotatable === null) return false
for (ann in annotatable.annotations) { for (ann in annotatable.annotations) {
if ('Lnet/minecraftforge/api/distmarker/OnlyIn;' == ann.desc) if ('Lnet/minecraftforge/api/distmarker/OnlyIn;' == ann.desc)
@@ -104,7 +104,7 @@ abstract class CheckSAS extends CheckTask {
} }
protected static findChildMethods(Map<String, InheritanceData> json, String cls, String desc) { protected static findChildMethods(Map<String, InheritanceData> json, String cls, String desc) {
return json.values().findAll{ it.methods != null && it.methods[desc] != null && it.methods[desc].override == cls && isSided(it.methods[desc]) } return json.values().findAll{ it.methods !== null && it.methods[desc] !== null && it.methods[desc].override == cls && isSided(it.methods[desc]) }
.collect { it.name + ' ' + desc.replace(' ', '') } as TreeSet .collect { it.name + ' ' + desc.replace(' ', '') } as TreeSet
} }
} }
@@ -1,6 +1,8 @@
package net.minecraftforge.forge.tasks.checks package net.minecraftforge.forge.tasks.checks
import groovy.transform.CompileStatic import groovy.transform.CompileStatic
import groovy.transform.stc.ClosureParams
import groovy.transform.stc.ThirdParam
import net.minecraftforge.forge.tasks.Util import net.minecraftforge.forge.tasks.Util
import org.gradle.api.Action import org.gradle.api.Action
import org.gradle.api.DefaultTask import org.gradle.api.DefaultTask
@@ -33,7 +35,7 @@ abstract class CheckTask extends DefaultTask implements VerificationTask {
void run() { void run() {
Util.init() Util.init()
final doFix = getMode().get() === CheckMode.FIX boolean doFix = getMode().get() === CheckMode.FIX
final Reporter reporter = new Reporter(doFix) final Reporter reporter = new Reporter(doFix)
check(reporter, doFix) check(reporter, doFix)
@@ -88,7 +90,8 @@ abstract class CheckTask extends DefaultTask implements VerificationTask {
} }
static <T extends CheckTask> void registerTask(TaskContainer tasks, String taskName, @DelegatesTo.Target('type') Class<T> clazz, static <T extends CheckTask> void registerTask(TaskContainer tasks, String taskName, @DelegatesTo.Target('type') Class<T> clazz,
@DelegatesTo(genericTypeIndex = 0, target = 'type') Closure configuration) { @DelegatesTo(genericTypeIndex = 0, target = 'type')
@ClosureParams(ThirdParam.FirstGenericType) Closure configuration) {
taskName = taskName.capitalize() taskName = taskName.capitalize()
tasks.register("check$taskName", clazz) { CheckTask task -> tasks.register("check$taskName", clazz) { CheckTask task ->
def castedTask = task as T def castedTask = task as T
+25 -3
View File
@@ -1,11 +1,18 @@
plugins { plugins {
id 'java-library' id 'java-library'
id 'eclipse' id 'net.minecraftforge.gradle.patcher'
id 'net.minecraftforge.gradle.patcher' version '[6.0.16,6.2)'
} }
evaluationDependsOn(':mcp') evaluationDependsOn(':mcp')
repositories {
mavenCentral()
maven gradleutils.forgeMaven
maven gradleutils.minecraftLibsMaven
}
java.toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
dependencies { dependencies {
implementation(libs.forgespi) implementation(libs.forgespi)
} }
@@ -44,8 +51,23 @@ patcher {
} }
} }
tasks.withType(JavaCompile).configureEach {
options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
options.warnings = false // Shutup deprecated for removal warnings
}
eclipse.classpath.file.whenMerged { eclipse.classpath.file.whenMerged {
// Disable optional warnings on the minecraft decompiled source code. It just muddies the warning window and hides warnings in our own codebase // Disable optional warnings on the minecraft decompiled source code. It just muddies the warning window and hides warnings in our own codebase
def src = entries.find { it.path == 'src/main/java' } def src = entries.find { it.path == 'src/main/java' }
src.entryAttributes['ignore_optional_problems'] = 'true' if (src == null) throw new IllegalStateException("You must run `setup` task before importing")
src.entryAttributes['ignore_optional_problems'] = 'true'
} }
tasks.named('genPatches').configure {
onlyIf { false }
}
tasks.named('extractRangeMap').configure {
onlyIf { false }
tool = 'net.minecraftforge:Srg2Source:8.1.0:fatjar'
}
+1095
View File
File diff suppressed because it is too large. Load diff
+76
View File
@@ -0,0 +1,76 @@
import net.minecraftforge.forge.tasks.CleanProperties
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'net.minecraftforge.gradleutils'
group = 'net.minecraftforge'
version = VERSION
println("Version: $version")
repositories {
mavenCentral()
maven gradleutils.forgeMaven
maven gradleutils.minecraftLibsMaven
//mavenLocal()
}
tasks.withType(Javadoc).configureEach {
options.tags = [
'apiNote:a:<em>API Note:</em>',
'implSpec:a:<em>Implementation Requirements:</em>',
'implNote:a:<em>Implementation Note:</em>'
]
options.addStringOption('Xdoclint:all,-missing', '-public')
}
// We need to write the manifest to the binary file so we have properly versioned packaged at dev time.
tasks.register('writeManifest') {
doLast {
if (plugins.findPlugin('net.minecraftforge.gradle.patcher')) // Forge project
universalJar.manifest.writeTo(rootProject.file('src/main/resources/META-INF/MANIFEST.MF'))
else
jar.manifest.writeTo(project.file('src/main/resources/META-INF/MANIFEST.MF'))
}
}
tasks.register('generateResources') {
dependsOn('writeManifest')
}
// Make sure out manifests get written before compiling the code, IDEA calls this task if you tell it to use the gradle build.
tasks.withType(JavaCompile).configureEach {
dependsOn 'generateResources'
dependsOn 'processResources' // Needed because we merge the output of this with the output of the compile task. And gradle detects downstream tasks using the output without a hard dep
options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
options.warnings = false // Shutup deprecated for removal warnings
}
// Merge the resources and classes into the same directory. We'll need to split them at runtime because
// Minecraft and Forge are in the same sourceSet as they are inter dependent.. for now..
sourceSets.each {
def dir = layout.buildDirectory.dir("classes/java/$it.name")
it.output.resourcesDir = dir
it.java.destinationDirectory = dir
}
tasks.register('copyEclipseSettings') {
doLast {
rootProject.fileTree('ide/eclipse/template/.settings/').matching { include '**/*.prefs' }.each { file ->
def target = project.file('.settings/' + file.name)
def temp = new CleanProperties().load(file)
def exst = new CleanProperties().load(target)
exst.put('eclipse.preferences.version', '1')
exst.putAll(temp)
exst.store(target)
}
}
}
// TODO: [Gradle][IntelliJ] Auto trigger these tasks on import.
eclipse {
// Run everytime eclipse builds the code
//autoBuildTasks writeManifest
// Run when importing the project
synchronizationTasks generateResources, copyEclipseSettings, eclipseClasspath, eclipseProject
}
+2 -2
View File
@@ -2,8 +2,8 @@
MinecraftForge MinecraftForge
============= =============
[![Stable Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Stable&prefix=1.20.2&query=$.promos["1.20.2-recommended"]&color=brightgreen&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtc3RhciBmYS13LTE4IiBhcmlhLWhpZGRlbj0idHJ1ZSIgZGF0YS1pY29uPSJzdGFyIiBkYXRhLXByZWZpeD0iZmFzIiBmb2N1c2FibGU9ImZhbHNlIiByb2xlPSJpbWciIHZpZXdCb3g9IjAgMCA1NzYgNTEyIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8cGF0aCBkPSJNMjU5LjMgMTcuOEwxOTQgMTUwLjIgNDcuOSAxNzEuNWMtMjYuMiAzLjgtMzYuNyAzNi4xLTE3LjcgNTQuNmwxMDUuNyAxMDMtMjUgMTQ1LjVjLTQuNSAyNi4zIDIzLjIgNDYgNDYuNCAzMy43TDI4OCA0MzkuNmwxMzAuNyA2OC43YzIzLjIgMTIuMiA1MC45LTcuNCA0Ni40LTMzLjdsLTI1LTE0NS41IDEwNS43LTEwM2MxOS0xOC41IDguNS01MC44LTE3LjctNTQuNkwzODIgMTUwLjIgMzE2LjcgMTcuOGMtMTEuNy0yMy42LTQ1LjYtMjMuOS01Ny40IDB6IiBmaWxsPSJ3aGl0ZSIvPgo8L3N2Zz4K)][Download] [![Stable Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Stable&prefix=1.20.6-&query=$.promos["1.20.6-recommended"]&color=brightgreen&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtc3RhciBmYS13LTE4IiBhcmlhLWhpZGRlbj0idHJ1ZSIgZGF0YS1pY29uPSJzdGFyIiBkYXRhLXByZWZpeD0iZmFzIiBmb2N1c2FibGU9ImZhbHNlIiByb2xlPSJpbWciIHZpZXdCb3g9IjAgMCA1NzYgNTEyIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8cGF0aCBkPSJNMjU5LjMgMTcuOEwxOTQgMTUwLjIgNDcuOSAxNzEuNWMtMjYuMiAzLjgtMzYuNyAzNi4xLTE3LjcgNTQuNmwxMDUuNyAxMDMtMjUgMTQ1LjVjLTQuNSAyNi4zIDIzLjIgNDYgNDYuNCAzMy43TDI4OCA0MzkuNmwxMzAuNyA2OC43YzIzLjIgMTIuMiA1MC45LTcuNCA0Ni40LTMzLjdsLTI1LTE0NS41IDEwNS43LTEwM2MxOS0xOC41IDguNS01MC44LTE3LjctNTQuNkwzODIgMTUwLjIgMzE2LjcgMTcuOGMtMTEuNy0yMy42LTQ1LjYtMjMuOS01Ny40IDB6IiBmaWxsPSJ3aGl0ZSIvPgo8L3N2Zz4K)][Download]
[![Latest Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Latest&prefix=1.20.2-&query=$.promos["1.20.2-latest"]&color=blue&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtYnVnIGZhLXctMTYiIGFyaWEtaGlkZGVuPSJ0cnVlIiBkYXRhLWljb249ImJ1ZyIgZGF0YS1wcmVmaXg9ImZhcyIgZm9jdXNhYmxlPSJmYWxzZSIgcm9sZT0iaW1nIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTUxMS45ODggMjg4LjljLS40NzggMTcuNDMtMTUuMjE3IDMxLjEtMzIuNjUzIDMxLjFINDI0djE2YzAgMjEuODY0LTQuODgyIDQyLjU4NC0xMy42IDYxLjE0NWw2MC4yMjggNjAuMjI4YzEyLjQ5NiAxMi40OTcgMTIuNDk2IDMyLjc1OCAwIDQ1LjI1NS0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDBsLTU0LjczNi01NC43MzZDMzQ1Ljg4NiA0NjcuOTY1IDMxNC4zNTEgNDgwIDI4MCA0ODBWMjM2YzAtNi42MjctNS4zNzMtMTItMTItMTJoLTI0Yy02LjYyNyAwLTEyIDUuMzczLTEyIDEydjI0NGMtMzQuMzUxIDAtNjUuODg2LTEyLjAzNS05MC42MzYtMzIuMTA4bC01NC43MzYgNTQuNzM2Yy0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDAtMTIuNDk2LTEyLjQ5Ny0xMi40OTYtMzIuNzU4IDAtNDUuMjU1bDYwLjIyOC02MC4yMjhDOTIuODgyIDM3OC41ODQgODggMzU3Ljg2NCA4OCAzMzZ2LTE2SDMyLjY2NkMxNS4yMyAzMjAgLjQ5MSAzMDYuMzMuMDEzIDI4OC45LS40ODQgMjcwLjgxNiAxNC4wMjggMjU2IDMyIDI1Nmg1NnYtNTguNzQ1bC00Ni42MjgtNDYuNjI4Yy0xMi40OTYtMTIuNDk3LTEyLjQ5Ni0zMi43NTggMC00NS4yNTUgMTIuNDk4LTEyLjQ5NyAzMi43NTgtMTIuNDk3IDQ1LjI1NiAwTDE0MS4yNTUgMTYwaDIyOS40ODlsNTQuNjI3LTU0LjYyN2MxMi40OTgtMTIuNDk3IDMyLjc1OC0xMi40OTcgNDUuMjU2IDAgMTIuNDk2IDEyLjQ5NyAxMi40OTYgMzIuNzU4IDAgNDUuMjU1TDQyNCAxOTcuMjU1VjI1Nmg1NmMxNy45NzIgMCAzMi40ODQgMTQuODE2IDMxLjk4OCAzMi45ek0yNTcgMGMtNjEuODU2IDAtMTEyIDUwLjE0NC0xMTIgMTEyaDIyNEMzNjkgNTAuMTQ0IDMxOC44NTYgMCAyNTcgMHoiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPgo= [![Latest Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Latest&prefix=1.20.6-&query=$.promos["1.20.6-latest"]&color=blue&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtYnVnIGZhLXctMTYiIGFyaWEtaGlkZGVuPSJ0cnVlIiBkYXRhLWljb249ImJ1ZyIgZGF0YS1wcmVmaXg9ImZhcyIgZm9jdXNhYmxlPSJmYWxzZSIgcm9sZT0iaW1nIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTUxMS45ODggMjg4LjljLS40NzggMTcuNDMtMTUuMjE3IDMxLjEtMzIuNjUzIDMxLjFINDI0djE2YzAgMjEuODY0LTQuODgyIDQyLjU4NC0xMy42IDYxLjE0NWw2MC4yMjggNjAuMjI4YzEyLjQ5NiAxMi40OTcgMTIuNDk2IDMyLjc1OCAwIDQ1LjI1NS0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDBsLTU0LjczNi01NC43MzZDMzQ1Ljg4NiA0NjcuOTY1IDMxNC4zNTEgNDgwIDI4MCA0ODBWMjM2YzAtNi42MjctNS4zNzMtMTItMTItMTJoLTI0Yy02LjYyNyAwLTEyIDUuMzczLTEyIDEydjI0NGMtMzQuMzUxIDAtNjUuODg2LTEyLjAzNS05MC42MzYtMzIuMTA4bC01NC43MzYgNTQuNzM2Yy0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDAtMTIuNDk2LTEyLjQ5Ny0xMi40OTYtMzIuNzU4IDAtNDUuMjU1bDYwLjIyOC02MC4yMjhDOTIuODgyIDM3OC41ODQgODggMzU3Ljg2NCA4OCAzMzZ2LTE2SDMyLjY2NkMxNS4yMyAzMjAgLjQ5MSAzMDYuMzMuMDEzIDI4OC45LS40ODQgMjcwLjgxNiAxNC4wMjggMjU2IDMyIDI1Nmg1NnYtNTguNzQ1bC00Ni42MjgtNDYuNjI4Yy0xMi40OTYtMTIuNDk3LTEyLjQ5Ni0zMi43NTggMC00NS4yNTUgMTIuNDk4LTEyLjQ5NyAzMi43NTgtMTIuNDk3IDQ1LjI1NiAwTDE0MS4yNTUgMTYwaDIyOS40ODlsNTQuNjI3LTU0LjYyN2MxMi40OTgtMTIuNDk3IDMyLjc1OC0xMi40OTcgNDUuMjU2IDAgMTIuNDk2IDEyLjQ5NyAxMi40OTYgMzIuNzU4IDAgNDUuMjU1TDQyNCAxOTcuMjU1VjI1Nmg1NmMxNy45NzIgMCAzMi40ODQgMTQuODE2IDMxLjk4OCAzMi45ek0yNTcgMGMtNjEuODU2IDAtMTEyIDUwLjE0NC0xMTIgMTEyaDIyNEMzNjkgNTAuMTQ0IDMxOC44NTYgMCAyNTcgMHoiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPgo=
)][Download] [![Discord](https://img.shields.io/discord/313125603924639766.svg?color=%237289da&label=Discord&logo=discord&logoColor=%237289da)][Discord] [![Support](https://img.shields.io/badge/Patreon-Support-orange.svg?logo=Patreon)][Patreon] )][Download] [![Discord](https://img.shields.io/discord/313125603924639766.svg?color=%237289da&label=Discord&logo=discord&logoColor=%237289da)][Discord] [![Support](https://img.shields.io/badge/Patreon-Support-orange.svg?logo=Patreon)][Patreon]
Forge is a free, open-source modding API all of your favourite mods use! Forge is a free, open-source modding API all of your favourite mods use!
+38 -44
View File
@@ -1,12 +1,13 @@
import net.minecraftforge.gradleutils.PomUtils
plugins { plugins {
id 'com.github.ben-manes.versions'
id 'org.javamodularity.moduleplugin' version '1.8.3' apply false
id 'org.cadixdev.licenser'
id 'java-library' id 'java-library'
id 'jacoco' id 'maven-publish'
id 'net.minecraftforge.licenser'
id 'net.minecraftforge.gradleutils'
} }
dependencyUpdates.rejectVersionIf { isNonStable(it.candidate.version) } apply from: rootProject.file('build_shared.gradle')
dependencies { dependencies {
compileOnly(libs.nulls) compileOnly(libs.nulls)
@@ -17,57 +18,50 @@ dependencies {
implementation(libs.commons.io) implementation(libs.commons.io)
} }
task sourcesJar(type: Jar) { java {
archiveClassifier = 'sources' toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
from sourceSets.main.allSource withSourcesJar()
} }
ext { tasks.named('jar', Jar).configure {
MANIFESTS = [ manifest {
'': [ attributes([
'FMLModType': 'LIBRARY', 'Automatic-Module-Name': 'net.minecraftforge.fmlcore',
'Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"), 'FMLModType': 'LIBRARY'
'Git-Commit': GIT_INFO.abbreviatedId, ] as LinkedHashMap)
'Git-Branch': GIT_INFO.branch, attributes([
'Build-Number': "${System.getenv('BUILD_NUMBER')?:0}" 'Specification-Title': 'FML',
] as LinkedHashMap,
'net/minecraftforge/fml/loading/': [
'Specification-Title': 'FMLLoader',
'Specification-Vendor': 'Forge Development LLC', 'Specification-Vendor': 'Forge Development LLC',
'Specification-Version': '1', 'Specification-Version': '1',
'Implementation-Title': 'FML Loader', 'Implementation-Title': 'FML',
'Implementation-Version': '1.0', 'Implementation-Version': '1.0',
'Implementation-Vendor': 'Forge' 'Implementation-Vendor': 'Forge Development LLC'
] as LinkedHashMap ] as LinkedHashMap, 'net/minecraftforge/fml/')
]
}
jar.doFirst {
manifest.attributes['Automatic-Module-Name'] = project.name
MANIFESTS.each { pkg, values ->
if (pkg == '')
manifest.attributes(values)
else
manifest.attributes(values, pkg)
} }
} }
tasks.withType(JavaCompile) { tasks.withType(JavaCompile).configureEach {
options.compilerArgs << '-Xlint:unchecked' options.compilerArgs << '-Xlint:-unchecked'
} }
license { license {
header = rootProject.file('LICENSE-header.txt') header = rootProject.file('LICENSE-header.txt')
include 'net/minecraftforge/'
} }
artifacts { publishing {
archives jar publications.register('mavenJava', MavenPublication).configure {
archives sourcesJar from components.java
artifactId = 'fmlcore'
pom {
name = project.name
description = 'Modifactions to Minecraft to enable mod developers.'
url = 'https://github.com/MinecraftForge/MinecraftForge'
PomUtils.setGitHubDetails(pom, 'MinecraftForge')
license PomUtils.Licenses.LGPLv2_1
}
}
repositories {
maven gradleutils.publishingForgeMaven
}
} }
publishing.publications.mavenJava(MavenPublication) {
from components.java
artifact sourcesJar
}
@@ -5,36 +5,39 @@
package net.minecraftforge.fml; package net.minecraftforge.fml;
import cpw.mods.modlauncher.util.ServiceLoaderUtils;
import net.minecraftforge.eventbus.api.IEventBus; import net.minecraftforge.eventbus.api.IEventBus;
import net.minecraftforge.fml.config.IConfigEvent; import net.minecraftforge.fml.config.IConfigEvent;
import net.minecraftforge.fml.loading.FMLLoader; import net.minecraftforge.fml.loading.FMLLoader;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader; import java.util.ServiceLoader;
import java.util.function.Supplier; import java.util.function.Supplier;
/**
* Used to allow access to certain things from the game layer
*/
public class Bindings { public class Bindings {
private static final Bindings INSTANCE = new Bindings(); private Bindings() {}
private final IBindingsProvider provider; /**
* The provider of the bindings
private Bindings() { * @implNote May also throw a {@link ServiceConfigurationError}
final var providers = ServiceLoaderUtils.streamServiceLoader(()->ServiceLoader.load(FMLLoader.getGameLayer(), IBindingsProvider.class), sce->{}).toList(); */
if (providers.size() != 1) { private static final IBindingsProvider PROVIDER = ServiceLoader.load(FMLLoader.getGameLayer(), IBindingsProvider.class)
throw new IllegalStateException("Could not find bindings provider"); .findFirst().orElseThrow(() -> new IllegalStateException("Could not find bindings provider"));
}
this.provider = providers.get(0);
}
/**
* @return A supplier of net.minecraftforge.common.MinecraftForge#EVENT_BUS
*/
public static Supplier<IEventBus> getForgeBus() { public static Supplier<IEventBus> getForgeBus() {
return INSTANCE.provider.getForgeBusSupplier(); return PROVIDER.getForgeBusSupplier();
} }
public static Supplier<I18NParser> getMessageParser() { public static Supplier<I18NParser> getMessageParser() {
return INSTANCE.provider.getMessageParser(); return PROVIDER.getMessageParser();
} }
public static Supplier<IConfigEvent.ConfigConfig> getConfigConfiguration() { public static Supplier<IConfigEvent.ConfigConfig> getConfigConfiguration() {
return INSTANCE.provider.getConfigConfiguration(); return PROVIDER.getConfigConfiguration();
} }
} }
@@ -96,5 +96,26 @@ public interface IExtensionPoint<T extends Record>
@SuppressWarnings("JavadocReference") // reference to NetworkConstants, ForgeHooksClient @SuppressWarnings("JavadocReference") // reference to NetworkConstants, ForgeHooksClient
record DisplayTest(Supplier<String> suppliedVersion, BiPredicate<String, Boolean> remoteVersionTest) implements IExtensionPoint<DisplayTest> { record DisplayTest(Supplier<String> suppliedVersion, BiPredicate<String, Boolean> remoteVersionTest) implements IExtensionPoint<DisplayTest> {
public static final String IGNORESERVERONLY = "SERVER_ONLY"; public static final String IGNORESERVERONLY = "SERVER_ONLY";
/**
* Ignores any version information coming from the server - use for server only mods
*/
public static final Supplier<DisplayTest> IGNORE_SERVER_VERSION = () -> new DisplayTest(IGNORESERVERONLY, (remoteVersion, isFromServer) -> true);
/**
* Ignores all information and provides no information
* <p>Note: If your mod is purely client-side and has no multiplayer functionality (be it dedicated servers or
* Open to LAN), consider setting {@code clientSideOnly=true} in the root of your mods.toml.</p>
*/
public static final Supplier<DisplayTest> IGNORE_ALL_VERSION = () -> new DisplayTest("", (remoteVersion, isFromServer) -> true);
/**
* An optional alternative to {@link #DisplayTest(Supplier, BiPredicate)} which accepts a constant version string
* instead of a {@link Supplier}.
* <p>Internally, the provided version string is wrapped in a Supplier for you.</p>
*/
public DisplayTest(String version, BiPredicate<String, Boolean> remoteVersionTest) {
this(() -> version, remoteVersionTest);
}
} }
} }
@@ -16,8 +16,7 @@ import net.minecraftforge.api.distmarker.Dist;
* *
* @see Dist * @see Dist
*/ */
public enum LogicalSide public enum LogicalSide {
{
/** /**
* The logical client of the Minecraft game, which interfaces with the player's inputs and renders the player's * The logical client of the Minecraft game, which interfaces with the player's inputs and renders the player's
* viewpoint. * viewpoint.
@@ -27,6 +26,7 @@ public enum LogicalSide
* @see Dist#CLIENT * @see Dist#CLIENT
*/ */
CLIENT, CLIENT,
/** /**
* The logical server of the Minecraft game, responsible for connecting to clients and running the simulation logic * The logical server of the Minecraft game, responsible for connecting to clients and running the simulation logic
* on the level. * on the level.
@@ -41,16 +41,14 @@ public enum LogicalSide
/** /**
* {@return if this logical side is the server} * {@return if this logical side is the server}
*/ */
public boolean isServer() public boolean isServer() {
{
return !isClient(); return !isClient();
} }
/** /**
* {@return if the logical side is the client} * {@return if the logical side is the client}
*/ */
public boolean isClient() public boolean isClient() {
{
return this == CLIENT; return this == CLIENT;
} }
} }
@@ -21,6 +21,7 @@ import java.util.Optional;
import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor; import java.util.concurrent.Executor;
import java.util.function.BiFunction; import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.function.Supplier; import java.util.function.Supplier;
@@ -58,15 +59,16 @@ public abstract class ModContainer
this.modInfo = info; this.modInfo = info;
this.modLoadingStage = ModLoadingStage.CONSTRUCT; this.modLoadingStage = ModLoadingStage.CONSTRUCT;
final String displayTestString = info.getConfig().<String>getConfigElement("displayTest").orElse("MATCH_VERSION"); // missing defaults to DEFAULT type final String displayTestString = info.getConfig().<String>getConfigElement("displayTest")
.orElseGet(() -> info.getOwningFile().isClientSideOnly() ? "IGNORE_ALL_VERSION" : "MATCH_VERSION");
Supplier<IExtensionPoint.DisplayTest> displayTestSupplier = switch (displayTestString) { Supplier<IExtensionPoint.DisplayTest> displayTestSupplier = switch (displayTestString) {
case "MATCH_VERSION" -> // default displaytest checks for version string match case "MATCH_VERSION" -> // default displaytest checks for version string match
() -> new IExtensionPoint.DisplayTest(() -> this.modInfo.getVersion().toString(), () -> new IExtensionPoint.DisplayTest(() -> this.modInfo.getVersion().toString(),
(incoming, isNetwork) -> Objects.equals(incoming, this.modInfo.getVersion().toString())); (incoming, isNetwork) -> Objects.equals(incoming, this.modInfo.getVersion().toString()));
case "IGNORE_SERVER_VERSION" -> // Ignores any version information coming from the server - use for server only mods case "IGNORE_SERVER_VERSION" -> // Ignores any version information coming from the server - use for server only mods
() -> new IExtensionPoint.DisplayTest(() -> IExtensionPoint.DisplayTest.IGNORESERVERONLY, (incoming, isNetwork) -> true); IExtensionPoint.DisplayTest.IGNORE_SERVER_VERSION;
case "IGNORE_ALL_VERSION" -> // Ignores all information and provides no information case "IGNORE_ALL_VERSION" -> // Ignores all information and provides no information
() -> new IExtensionPoint.DisplayTest(() -> "", (incoming, isNetwork) -> true); IExtensionPoint.DisplayTest.IGNORE_ALL_VERSION;
case "NONE" -> null; // NO display test at all - use this if you're going to do your own display test case "NONE" -> null; // NO display test at all - use this if you're going to do your own display test
default -> // any other value throws an exception default -> // any other value throws an exception
throw new IllegalArgumentException("Invalid displayTest value supplied in mods.toml"); throw new IllegalArgumentException("Invalid displayTest value supplied in mods.toml");
@@ -145,6 +147,22 @@ public abstract class ModContainer
extensionPoints.put(point, extension); extensionPoints.put(point, extension);
} }
public void registerDisplayTest(IExtensionPoint.DisplayTest displayTest) {
registerExtensionPoint(IExtensionPoint.DisplayTest.class, () -> displayTest);
}
public void registerDisplayTest(Supplier<IExtensionPoint.DisplayTest> displayTest) {
registerExtensionPoint(IExtensionPoint.DisplayTest.class, displayTest);
}
public void registerDisplayTest(String version, BiPredicate<String, Boolean> remoteVersionTest) {
registerDisplayTest(new IExtensionPoint.DisplayTest(version, remoteVersionTest));
}
public void registerDisplayTest(Supplier<String> suppliedVersion, BiPredicate<String, Boolean> remoteVersionTest) {
registerDisplayTest(new IExtensionPoint.DisplayTest(suppliedVersion, remoteVersionTest));
}
public void addConfig(final ModConfig modConfig) { public void addConfig(final ModConfig modConfig) {
configs.put(modConfig.getType(), modConfig); configs.put(modConfig.getType(), modConfig);
} }
@@ -47,7 +47,7 @@ import java.util.stream.Stream;
*/ */
public class ModList public class ModList
{ {
private static Logger LOGGER = LogManager.getLogger(); //private static final Logger LOGGER = LogManager.getLogger();
private static ModList INSTANCE; private static ModList INSTANCE;
private final List<IModFileInfo> modFiles; private final List<IModFileInfo> modFiles;
private final List<IModInfo> sortedList; private final List<IModInfo> sortedList;
@@ -120,14 +120,14 @@ public class ModList
return executor -> gather( return executor -> gather(
this.mods.stream() this.mods.stream()
.map(mod -> ModContainer.buildTransitionHandler(mod, eventGenerator, progressBar, stateChange, executor)) .map(mod -> ModContainer.buildTransitionHandler(mod, eventGenerator, progressBar, stateChange, executor))
.collect(Collectors.toList())) .toList()
.thenComposeAsync(ModList::completableFutureFromExceptionList, executor); ).thenComposeAsync(ModList::completableFutureFromExceptionList, executor);
} }
static CompletionStage<Void> completableFutureFromExceptionList(List<? extends Map.Entry<?, Throwable>> t) { static CompletionStage<Void> completableFutureFromExceptionList(List<? extends Map.Entry<?, Throwable>> t) {
if (t.stream().noneMatch(e->e.getValue()!=null)) { if (t.stream().noneMatch(e->e.getValue()!=null)) {
return CompletableFuture.completedFuture(null); return CompletableFuture.completedFuture(null);
} else { } else {
final List<Throwable> throwables = t.stream().filter(e -> e.getValue() != null).map(Map.Entry::getValue).collect(Collectors.toList()); final List<Throwable> throwables = t.stream().filter(e -> e.getValue() != null).map(Map.Entry::getValue).toList();
CompletableFuture<Void> cf = new CompletableFuture<>(); CompletableFuture<Void> cf = new CompletableFuture<>();
final RuntimeException accumulator = new RuntimeException(); final RuntimeException accumulator = new RuntimeException();
cf.completeExceptionally(accumulator); cf.completeExceptionally(accumulator);
@@ -6,6 +6,7 @@
package net.minecraftforge.fml; package net.minecraftforge.fml;
import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableList;
import com.google.common.collect.Streams;
import net.minecraftforge.eventbus.api.Event; import net.minecraftforge.eventbus.api.Event;
import net.minecraftforge.fml.event.IModBusEvent; import net.minecraftforge.fml.event.IModBusEvent;
import net.minecraftforge.fml.loading.FMLEnvironment; import net.minecraftforge.fml.loading.FMLEnvironment;
@@ -32,6 +33,7 @@ import java.util.function.BiConsumer;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.function.Function; import java.util.function.Function;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import java.util.stream.Stream;
import static net.minecraftforge.fml.Logging.CORE; import static net.minecraftforge.fml.Logging.CORE;
import static net.minecraftforge.fml.Logging.LOADING; import static net.minecraftforge.fml.Logging.LOADING;
@@ -91,13 +93,13 @@ public class ModLoader
{ {
INSTANCE = this; INSTANCE = this;
this.loadingModList = FMLLoader.getLoadingModList(); this.loadingModList = FMLLoader.getLoadingModList();
this.loadingExceptions = FMLLoader.getLoadingModList().getErrors().stream() this.loadingExceptions = this.loadingModList.getErrors().stream()
.flatMap(ModLoadingException::fromEarlyException) .flatMap(ModLoadingException::fromEarlyException)
.collect(Collectors.toList()); .collect(Collectors.toList());
this.loadingWarnings = FMLLoader.getLoadingModList().getBrokenFiles().stream() this.loadingWarnings = this.loadingModList.getBrokenFiles().stream()
.map(file -> new ModLoadingWarning(null, ModLoadingStage.VALIDATE, InvalidModIdentifier.identifyJarProblem(file.getFilePath()).orElse("fml.modloading.brokenfile"), file.getFileName())) .map(file -> new ModLoadingWarning(null, ModLoadingStage.VALIDATE, InvalidModIdentifier.identifyJarProblem(file.getFilePath()).orElse("fml.modloading.brokenfile"), file.getFileName()))
.collect(Collectors.toList()); .collect(Collectors.toList());
FMLLoader.getLoadingModList().getModFiles().stream() this.loadingModList.getModFiles().stream()
.filter(ModFileInfo::missingLicense) .filter(ModFileInfo::missingLicense)
.filter(modFileInfo -> modFileInfo.getMods().stream().noneMatch(thisModInfo -> this.loadingExceptions.stream().map(ModLoadingException::getModInfo).anyMatch(otherInfo -> otherInfo == thisModInfo))) //Ignore files where any other mod already encountered an error .filter(modFileInfo -> modFileInfo.getMods().stream().noneMatch(thisModInfo -> this.loadingExceptions.stream().map(ModLoadingException::getModInfo).anyMatch(otherInfo -> otherInfo == thisModInfo))) //Ignore files where any other mod already encountered an error
.map(modFileInfo -> new ModLoadingException(null, ModLoadingStage.VALIDATE, "fml.modloading.missinglicense", null, modFileInfo.getFile())) .map(modFileInfo -> new ModLoadingException(null, ModLoadingStage.VALIDATE, "fml.modloading.missinglicense", null, modFileInfo.getFile()))
@@ -228,10 +230,9 @@ public class ModLoader
} catch (CompletionException e) { } catch (CompletionException e) {
loadingStateValid = false; loadingStateValid = false;
Throwable t = e.getCause(); Throwable t = e.getCause();
final List<Throwable> notModLoading = Arrays.stream(t.getSuppressed()) boolean hasNotModLoadingEx = Arrays.stream(t.getSuppressed())
.filter(obj -> !(obj instanceof ModLoadingException)) .anyMatch(obj -> !(obj instanceof ModLoadingException));
.collect(Collectors.toList()); if (hasNotModLoadingEx) {
if (!notModLoading.isEmpty()) {
LOGGER.fatal("Encountered non-modloading exceptions!", e); LOGGER.fatal("Encountered non-modloading exceptions!", e);
statusConsumer.ifPresent(c->c.accept("ERROR DURING MOD LOADING")); statusConsumer.ifPresent(c->c.accept("ERROR DURING MOD LOADING"));
throw e; throw e;
@@ -257,10 +258,10 @@ public class ModLoader
.stream() .stream()
.map(e -> buildModContainerFromTOML(modFile, modInfoMap, e)) .map(e -> buildModContainerFromTOML(modFile, modInfoMap, e))
.filter(Objects::nonNull) .filter(Objects::nonNull)
.collect(Collectors.toList()); .toList();
if (containers.size() != modInfoMap.size()) { if (containers.size() != modInfoMap.size()) {
var modIds = modInfoMap.values().stream().map(IModInfo::getModId).sorted().collect(Collectors.toList()); var modIds = modInfoMap.values().stream().map(IModInfo::getModId).sorted().toList();
var containerIds = containers.stream().map(c -> c != null ? c.getModId() : "(null)").sorted().collect(Collectors.toList()); var containerIds = containers.stream().map(c -> c != null ? c.getModId() : "(null)").sorted().toList();
LOGGER.fatal(LOADING,"File {} constructed {} mods: {}, but had {} mods specified: {}", LOGGER.fatal(LOADING,"File {} constructed {} mods: {}, but had {} mods specified: {}",
modFile.getFilePath(), modFile.getFilePath(),
@@ -278,7 +279,7 @@ public class ModLoader
loadingExceptions.add(new ModLoadingException(null, ModLoadingStage.CONSTRUCT, "fml.modloading.missingclasses", null, modFile.getFilePath())); loadingExceptions.add(new ModLoadingException(null, ModLoadingStage.CONSTRUCT, "fml.modloading.missingclasses", null, modFile.getFilePath()));
} }
// remove errored mod containers // remove errored mod containers
return containers.stream().filter(mc -> mc.modLoadingStage != ModLoadingStage.ERROR).collect(Collectors.toList()); return containers.stream().filter(mc -> mc.modLoadingStage != ModLoadingStage.ERROR).toList();
} }
private ModContainer buildModContainerFromTOML(final IModFile modFile, final Map<String, IModInfo> modInfoMap, final Map.Entry<String, ? extends IModLanguageProvider.IModLanguageLoader> idToProviderEntry) { private ModContainer buildModContainerFromTOML(final IModFile modFile, final Map<String, IModInfo> modInfoMap, final Map.Entry<String, ? extends IModLanguageProvider.IModLanguageLoader> idToProviderEntry) {
@@ -12,6 +12,7 @@ import net.minecraftforge.fml.loading.FMLLoader;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import java.util.function.BiPredicate;
import java.util.function.Supplier; import java.util.function.Supplier;
public class ModLoadingContext public class ModLoadingContext
@@ -50,6 +51,44 @@ public class ModLoadingContext
getActiveContainer().registerExtensionPoint(point, extension); getActiveContainer().registerExtensionPoint(point, extension);
} }
/**
* Register a {@link IExtensionPoint.DisplayTest} with the mod container.
* <p>A shorthand for registering a DisplayTest with {@link #registerExtensionPoint(Class, Supplier)}.</p>
* @param displayTest The {@link IExtensionPoint.DisplayTest} to register
*/
public void registerDisplayTest(IExtensionPoint.DisplayTest displayTest) {
getActiveContainer().registerDisplayTest(() -> displayTest);
}
/**
* Register a {@link IExtensionPoint.DisplayTest} with the mod container.
* <p>A shorthand for registering a DisplayTest supplier with {@link #registerExtensionPoint(Class, Supplier)}.</p>
* @param displayTest The {@link Supplier<IExtensionPoint.DisplayTest>} to register
*/
public void registerDisplayTest(Supplier<IExtensionPoint.DisplayTest> displayTest) {
getActiveContainer().registerDisplayTest(displayTest);
}
/**
* Register a {@link IExtensionPoint.DisplayTest} with the mod container.
* <p>A shorthand for registering a DisplayTest with {@link #registerExtensionPoint(Class, Supplier)} that also
* creates the DisplayTest instance for you using the provided parameters.</p>
* @see IExtensionPoint.DisplayTest#DisplayTest(String, BiPredicate)
*/
public void registerDisplayTest(String version, BiPredicate<String, Boolean> remoteVersionTest) {
getActiveContainer().registerDisplayTest(new IExtensionPoint.DisplayTest(version, remoteVersionTest));
}
/**
* Register a {@link IExtensionPoint.DisplayTest} with the mod container.
* <p>A shorthand for registering a DisplayTest with {@link #registerExtensionPoint(Class, Supplier)} that also
* creates the DisplayTest instance for you using the provided parameters.</p>
* @see IExtensionPoint.DisplayTest#DisplayTest(Supplier, BiPredicate)
*/
public void registerDisplayTest(Supplier<String> suppliedVersion, BiPredicate<String, Boolean> remoteVersionTest) {
getActiveContainer().registerDisplayTest(new IExtensionPoint.DisplayTest(suppliedVersion, remoteVersionTest));
}
public void registerConfig(ModConfig.Type type, IConfigSpec<?> spec) { public void registerConfig(ModConfig.Type type, IConfigSpec<?> spec) {
if (spec.isEmpty()) if (spec.isEmpty())
{ {
@@ -12,8 +12,7 @@ import java.util.Arrays;
import java.util.List; import java.util.List;
import java.util.stream.Stream; import java.util.stream.Stream;
public class ModLoadingWarning public class ModLoadingWarning {
{
/** /**
* Mod Info for mod with warning * Mod Info for mod with warning
*/ */
@@ -7,7 +7,6 @@ package net.minecraftforge.fml;
import com.google.gson.Gson; import com.google.gson.Gson;
import net.minecraftforge.fml.loading.FMLConfig; import net.minecraftforge.fml.loading.FMLConfig;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.forgespi.language.IModInfo; import net.minecraftforge.forgespi.language.IModInfo;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
@@ -35,81 +34,72 @@ import java.util.zip.GZIPInputStream;
import static net.minecraftforge.fml.VersionChecker.Status.*; import static net.minecraftforge.fml.VersionChecker.Status.*;
public class VersionChecker public class VersionChecker {
{
private static final Logger LOGGER = LogManager.getLogger(); private static final Logger LOGGER = LogManager.getLogger();
private static final int MAX_HTTP_REDIRECTS = Integer.getInteger("http.maxRedirects", 20); private static final int MAX_HTTP_REDIRECTS = Integer.getInteger("http.maxRedirects", 20);
private static final int HTTP_TIMEOUT_SECS = Integer.getInteger("http.timeoutSecs", 15); private static final int HTTP_TIMEOUT_SECS = Integer.getInteger("http.timeoutSecs", 15);
public enum Status public enum Status {
{
PENDING(), PENDING(),
FAILED(), FAILED(),
UP_TO_DATE(), UP_TO_DATE(),
OUTDATED(3, true), OUTDATED(3, true, true),
AHEAD(), AHEAD(),
BETA(), BETA(),
BETA_OUTDATED(6, true); BETA_OUTDATED(6, true, true);
final int sheetOffset; private final int sheetOffset;
final boolean draw, animated; private final boolean draw, animated;
Status() Status() {
{
this(0, false, false); this(0, false, false);
} }
Status(int sheetOffset) Status(int sheetOffset, boolean draw, boolean animated) {
{
this(sheetOffset, true, false);
}
Status(int sheetOffset, boolean animated)
{
this(sheetOffset, true, animated);
}
Status(int sheetOffset, boolean draw, boolean animated)
{
this.sheetOffset = sheetOffset; this.sheetOffset = sheetOffset;
this.draw = draw; this.draw = draw;
this.animated = animated; this.animated = animated;
} }
public int getSheetOffset() public int getSheetOffset() {
{
return sheetOffset; return sheetOffset;
} }
public boolean shouldDraw() public boolean shouldDraw() {
{
return draw; return draw;
} }
public boolean isAnimated() public boolean isAnimated() {
{
return animated; return animated;
} }
public boolean isOutdated() {
return this == OUTDATED || this == BETA_OUTDATED;
}
} }
public record CheckResult(VersionChecker.Status status, ComparableVersion target, Map<ComparableVersion, String> changes, String url) {} public record CheckResult(VersionChecker.Status status, ComparableVersion target, Map<ComparableVersion, String> changes, String url) {}
public static void startVersionCheck() public static void startVersionCheck() {
{ new Thread("Forge Version Check") {
new Thread("Forge Version Check")
{
private HttpClient client; private HttpClient client;
private String mcVersion;
private String agent;
@Override @Override
public void run() public void run() {
{ if (!FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.VERSION_CHECK)) {
if (!FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.VERSION_CHECK))
{
LOGGER.info("Global Forge version check system disabled, no further processing."); LOGGER.info("Global Forge version check system disabled, no further processing.");
return; return;
} }
var mc = ModList.get().getModContainerById("minecraft");
var forge = ModList.get().getModContainerById("forge");
this.mcVersion = mc.get().getModInfo().getVersion().toString();
this.agent = "Java-http-client/" + System.getProperty("java.version")
+ " MinecraftForge/" + mcVersion + '-' + forge.get().getModInfo().getVersion();
client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(HTTP_TIMEOUT_SECS)).build(); client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(HTTP_TIMEOUT_SECS)).build();
gatherMods().forEach(this::process); gatherMods().forEach(this::process);
} }
@@ -119,15 +109,9 @@ public class VersionChecker
*/ */
private String openUrlString(URL url, IModInfo mod) throws IOException, URISyntaxException, InterruptedException { private String openUrlString(URL url, IModInfo mod) throws IOException, URISyntaxException, InterruptedException {
URL currentUrl = url; URL currentUrl = url;
var userAgent = this.agent + ' ' + mod.getModId() + '/' + mod.getVersion();
final StringBuilder sb = new StringBuilder(); for (int redirects = 0; redirects < MAX_HTTP_REDIRECTS; redirects++) {
sb.append("Java-http-client/").append(System.getProperty("java.version")).append(' ');
sb.append("MinecraftForge/").append(FMLLoader.versionInfo().mcAndForgeVersion()).append(' ');
sb.append(mod.getModId()).append('/').append(mod.getVersion());
final String userAgent = sb.toString();
for (int redirects = 0; redirects < MAX_HTTP_REDIRECTS; redirects++)
{
var request = HttpRequest.newBuilder() var request = HttpRequest.newBuilder()
.uri(currentUrl.toURI()) .uri(currentUrl.toURI())
.timeout(Duration.ofSeconds(HTTP_TIMEOUT_SECS)) .timeout(Duration.ofSeconds(HTTP_TIMEOUT_SECS))
@@ -139,8 +123,7 @@ public class VersionChecker
final HttpResponse<InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream()); final HttpResponse<InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
int responseCode = response.statusCode(); int responseCode = response.statusCode();
if (responseCode >= 300 && responseCode <= 399) if (responseCode >= 300 && responseCode <= 399) {
{
String newLocation = response.headers().firstValue("Location") String newLocation = response.headers().firstValue("Location")
.orElseThrow(() -> new IOException("Got a 3xx response code but Location header was null while trying to fetch " + url)); .orElseThrow(() -> new IOException("Got a 3xx response code but Location header was null while trying to fetch " + url));
currentUrl = new URL(currentUrl, newLocation); currentUrl = new URL(currentUrl, newLocation);
@@ -150,26 +133,22 @@ public class VersionChecker
final boolean isGzipEncoded = response.headers().firstValue("Content-Encoding").orElse("").equals("gzip"); final boolean isGzipEncoded = response.headers().firstValue("Content-Encoding").orElse("").equals("gzip");
final String bodyStr; final String bodyStr;
try (InputStream inStream = isGzipEncoded ? new GZIPInputStream(response.body()) : response.body()) try (var inStream = isGzipEncoded ? new GZIPInputStream(response.body()) : response.body();
{ var bufferedReader = new BufferedReader(new InputStreamReader(inStream))
try (var bufferedReader = new BufferedReader(new InputStreamReader(inStream))) ) {
{ bodyStr = bufferedReader.lines().collect(Collectors.joining("\n"));
bodyStr = bufferedReader.lines().collect(Collectors.joining("\n"));
}
} }
return bodyStr; return bodyStr;
} }
throw new IOException("Too many redirects while trying to fetch " + url); throw new IOException("Too many redirects while trying to fetch " + url);
} }
private void process(IModInfo mod) private void process(IModInfo mod) {
{
Status status = PENDING; Status status = PENDING;
ComparableVersion target = null; ComparableVersion target = null;
Map<ComparableVersion, String> changes = null; Map<ComparableVersion, String> changes = null;
String display_url = null; String display_url = null;
try try {
{
if (mod.getUpdateURL().isEmpty()) return; if (mod.getUpdateURL().isEmpty()) return;
URL url = mod.getUpdateURL().get(); URL url = mod.getUpdateURL().get();
LOGGER.info("[{}] Starting version check at {}", mod.getModId(), url.toString()); LOGGER.info("[{}] Starting version check at {}", mod.getModId(), url.toString());
@@ -178,54 +157,40 @@ public class VersionChecker
LOGGER.debug("[{}] Received version check data:\n{}", mod.getModId(), data); LOGGER.debug("[{}] Received version check data:\n{}", mod.getModId(), data);
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Map<String, Object> json = new Gson().fromJson(data, Map.class); Map<String, Object> json = new Gson().fromJson(data, Map.class);
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Map<String, String> promos = (Map<String, String>)json.get("promos"); Map<String, String> promos = (Map<String, String>)json.get("promos");
display_url = (String)json.get("homepage"); display_url = (String)json.get("homepage");
var mcVersion = FMLLoader.versionInfo().mcVersion();
String rec = promos.get(mcVersion + "-recommended"); String rec = promos.get(mcVersion + "-recommended");
String lat = promos.get(mcVersion + "-latest"); String lat = promos.get(mcVersion + "-latest");
ComparableVersion current = new ComparableVersion(mod.getVersion().toString()); ComparableVersion current = new ComparableVersion(mod.getVersion().toString());
if (rec != null) if (rec != null) {
{
ComparableVersion recommended = new ComparableVersion(rec); ComparableVersion recommended = new ComparableVersion(rec);
int diff = recommended.compareTo(current); int diff = recommended.compareTo(current);
if (diff == 0) if (diff == 0)
status = UP_TO_DATE; status = UP_TO_DATE;
else if (diff < 0) else if (diff < 0) {
{
status = AHEAD; status = AHEAD;
if (lat != null) if (lat != null) {
{
ComparableVersion latest = new ComparableVersion(lat); ComparableVersion latest = new ComparableVersion(lat);
if (current.compareTo(latest) < 0) if (current.compareTo(latest) < 0) {
{
status = OUTDATED; status = OUTDATED;
target = latest; target = latest;
} }
} }
} } else {
else
{
status = OUTDATED; status = OUTDATED;
target = recommended; target = recommended;
} }
} } else if (lat != null) {
else if (lat != null)
{
ComparableVersion latest = new ComparableVersion(lat); ComparableVersion latest = new ComparableVersion(lat);
if (current.compareTo(latest) < 0) status = current.compareTo(latest) < 0 ? BETA_OUTDATED : BETA;
status = BETA_OUTDATED;
else
status = BETA;
target = latest; target = latest;
} } else
else
status = BETA; status = BETA;
LOGGER.info("[{}] Found status: {} Current: {} Target: {}", mod.getModId(), status, current, target); LOGGER.info("[{}] Found status: {} Current: {} Target: {}", mod.getModId(), status, current, target);
@@ -233,38 +198,30 @@ public class VersionChecker
changes = new LinkedHashMap<>(); changes = new LinkedHashMap<>();
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Map<String, String> tmp = (Map<String, String>)json.get(mcVersion); Map<String, String> tmp = (Map<String, String>)json.get(mcVersion);
if (tmp != null) if (tmp != null) {
{
List<ComparableVersion> ordered = new ArrayList<>(); List<ComparableVersion> ordered = new ArrayList<>();
for (String key : tmp.keySet()) for (String key : tmp.keySet()) {
{
ComparableVersion ver = new ComparableVersion(key); ComparableVersion ver = new ComparableVersion(key);
if (ver.compareTo(current) > 0 && (target == null || ver.compareTo(target) < 1)) if (ver.compareTo(current) > 0 && (target == null || ver.compareTo(target) < 1))
{
ordered.add(ver); ordered.add(ver);
}
} }
Collections.sort(ordered); Collections.sort(ordered);
for (ComparableVersion ver : ordered) for (ComparableVersion ver : ordered) {
{
changes.put(ver, tmp.get(ver.toString())); changes.put(ver, tmp.get(ver.toString()));
} }
} }
} } catch (Exception e) {
catch (Exception e)
{
LOGGER.warn("Failed to process update information", e); LOGGER.warn("Failed to process update information", e);
status = FAILED; status = FAILED;
} }
results.put(mod, new CheckResult(status, target, changes, display_url)); RESULTS.put(mod, new CheckResult(status, target, changes, display_url));
} }
}.start(); }.start();
} }
// Gather a list of mods that have opted in to this update system by providing a URL. // Gather a list of mods that have opted in to this update system by providing a URL.
private static List<IModInfo> gatherMods() private static List<IModInfo> gatherMods() {
{
List<IModInfo> ret = new LinkedList<>(); List<IModInfo> ret = new LinkedList<>();
for (IModInfo info : ModList.get().getMods()) { for (IModInfo info : ModList.get().getMods()) {
if (info.getUpdateURL().isPresent()) if (info.getUpdateURL().isPresent())
@@ -273,12 +230,10 @@ public class VersionChecker
return ret; return ret;
} }
private static Map<IModInfo, CheckResult> results = new ConcurrentHashMap<>(); private static final Map<IModInfo, CheckResult> RESULTS = new ConcurrentHashMap<>();
private static final CheckResult PENDING_CHECK = new CheckResult(PENDING, null, null, null); private static final CheckResult PENDING_CHECK = new CheckResult(PENDING, null, null, null);
public static CheckResult getResult(IModInfo mod) public static CheckResult getResult(IModInfo mod) {
{ return RESULTS.getOrDefault(mod, PENDING_CHECK);
return results.getOrDefault(mod, PENDING_CHECK);
} }
} }
@@ -67,7 +67,9 @@ public class ConfigFileTypeHandler {
} }
private boolean setupConfigFile(final ModConfig modConfig, final Path file, final ConfigFormat<?> conf) throws IOException { private boolean setupConfigFile(final ModConfig modConfig, final Path file, final ConfigFormat<?> conf) throws IOException {
Files.createDirectories(file.getParent()); if (!Files.isDirectory(file.getParent())) {
Files.createDirectories(file.getParent());
}
Path p = defaultConfigPath.resolve(modConfig.getFileName()); Path p = defaultConfigPath.resolve(modConfig.getFileName());
if (Files.exists(p)) { if (Files.exists(p)) {
LOGGER.info(CONFIG, "Loading default config file from path {}", p); LOGGER.info(CONFIG, "Loading default config file from path {}", p);
+38 -14
View File
@@ -1,10 +1,14 @@
import net.minecraftforge.gradleutils.PomUtils
plugins { plugins {
id 'org.javamodularity.moduleplugin' version '1.8.7' apply false
id 'org.cadixdev.licenser'
id 'java-library' id 'java-library'
id 'jacoco' id 'maven-publish'
id 'net.minecraftforge.licenser'
id 'net.minecraftforge.gradleutils'
} }
apply from: rootProject.file('build_shared.gradle')
import org.gradle.internal.os.OperatingSystem import org.gradle.internal.os.OperatingSystem
switch (OperatingSystem.current()) { switch (OperatingSystem.current()) {
case OperatingSystem.LINUX: case OperatingSystem.LINUX:
@@ -18,7 +22,10 @@ switch (OperatingSystem.current()) {
break break
} }
java.withSourcesJar() java {
toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
withSourcesJar()
}
dependencies { dependencies {
compileOnly(libs.nulls) compileOnly(libs.nulls)
@@ -37,32 +44,49 @@ dependencies {
testRuntimeOnly("org.lwjgl:lwjgl-stb::$lwjglNatives") testRuntimeOnly("org.lwjgl:lwjgl-stb::$lwjglNatives")
} }
test { tasks.named('test', Test).configure {
useJUnitPlatform() useJUnitPlatform()
} }
jar { tasks.named('jar', Jar).configure {
manifest { manifest {
attributes([ attributes([
'Specification-Title': 'FMLEarlyDisplay', 'Automatic-Module-Name': 'net.minecraftforge.earlydisplay',
'Forge-Module-Layer': 'boot'
] as LinkedHashMap)
attributes([
'Specification-Title': 'FML Early Display',
'Specification-Vendor': 'Forge Development LLC', 'Specification-Vendor': 'Forge Development LLC',
'Specification-Version': '1', 'Specification-Version': '1',
'Implementation-Title': 'FML Early Display', 'Implementation-Title': 'FML Early Display',
'Implementation-Version': '1.0', 'Implementation-Vendor': 'Forge Development LLC',
'Implementation-Vendor': 'Forge' 'Implementation-Version': '1.0'
] as LinkedHashMap, 'net/minecraftforge/fml/earlydisplay/') ] as LinkedHashMap, 'net/minecraftforge/fml/earlydisplay/')
} }
} }
tasks.withType(JavaCompile) { tasks.withType(JavaCompile).configureEach {
options.compilerArgs << '-Xlint:unchecked' options.compilerArgs << '-Xlint:unchecked'
} }
license { license {
header = rootProject.file('LICENSE-header.txt') header = rootProject.file('LICENSE-header.txt')
include 'net/minecraftforge/'
} }
publishing.publications.mavenJava(MavenPublication) { publishing {
from components.java publications.register('mavenJava', MavenPublication).configure {
} from components.java
artifactId = 'fmlearlydisplay'
pom {
name = project.name
description = 'A pretty looking, but prone to erroring screen displayed during Forge loading.'
url = 'https://github.com/MinecraftForge/MinecraftForge'
PomUtils.setGitHubDetails(pom, 'MinecraftForge')
license PomUtils.Licenses.LGPLv2_1
}
}
repositories {
maven gradleutils.publishingForgeMaven
}
}
@@ -14,9 +14,7 @@ import net.minecraftforge.fml.loading.ImmediateWindowProvider;
import net.minecraftforge.fml.loading.progress.StartupNotificationManager; import net.minecraftforge.fml.loading.progress.StartupNotificationManager;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.lwjgl.PointerBuffer; import org.lwjgl.PointerBuffer;
import org.lwjgl.glfw.GLFWImage;
import org.lwjgl.glfw.GLFWVidMode; import org.lwjgl.glfw.GLFWVidMode;
import org.lwjgl.stb.STBImage;
import org.lwjgl.system.MemoryStack; import org.lwjgl.system.MemoryStack;
import org.lwjgl.system.MemoryUtil; import org.lwjgl.system.MemoryUtil;
import org.lwjgl.util.tinyfd.TinyFileDialogs; import org.lwjgl.util.tinyfd.TinyFileDialogs;
@@ -30,9 +28,8 @@ import java.io.InputStreamReader;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.lang.reflect.Modifier; import java.lang.reflect.Modifier;
import java.net.URI; import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Paths; import java.nio.file.Path;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Calendar; import java.util.Calendar;
@@ -50,7 +47,6 @@ import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntConsumer; import java.util.function.IntConsumer;
import java.util.function.IntSupplier; import java.util.function.IntSupplier;
import java.util.function.LongSupplier; import java.util.function.LongSupplier;
@@ -80,7 +76,7 @@ public class DisplayWindow implements ImmediateWindowProvider {
private static final Logger LOGGER = LoggerFactory.getLogger("EARLYDISPLAY"); private static final Logger LOGGER = LoggerFactory.getLogger("EARLYDISPLAY");
private final AtomicBoolean animationTimerTrigger = new AtomicBoolean(true); private final AtomicBoolean animationTimerTrigger = new AtomicBoolean(true);
private ColourScheme colourScheme; private ColourScheme colourScheme = ColourScheme.RED;
private ElementShader elementShader; private ElementShader elementShader;
private RenderElement.DisplayContext context; private RenderElement.DisplayContext context;
@@ -114,11 +110,13 @@ public class DisplayWindow implements ImmediateWindowProvider {
public String name() { public String name() {
return "fmlearlywindow"; return "fmlearlywindow";
} }
@Override @Override
public Runnable initialize(String[] arguments) { public Runnable initialize(String[] arguments) {
String mcVersion = FMLLoader.versionInfo().mcVersion();
String forgeVersion = FMLLoader.versionInfo().forgeVersion();
final OptionParser parser = new OptionParser(); final OptionParser parser = new OptionParser();
var mcversionopt = parser.accepts("fml.mcVersion").withRequiredArg().ofType(String.class);
var forgeversionopt = parser.accepts("fml.forgeVersion").withRequiredArg().ofType(String.class);
var widthopt = parser.accepts("width") var widthopt = parser.accepts("width")
.withRequiredArg().ofType(Integer.class) .withRequiredArg().ofType(Integer.class)
.defaultsTo(FMLConfig.getIntConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_WIDTH)); .defaultsTo(FMLConfig.getIntConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_WIDTH));
@@ -133,25 +131,28 @@ public class DisplayWindow implements ImmediateWindowProvider {
FMLConfig.updateConfig(FMLConfig.ConfigValue.EARLY_WINDOW_WIDTH, winWidth); FMLConfig.updateConfig(FMLConfig.ConfigValue.EARLY_WINDOW_WIDTH, winWidth);
FMLConfig.updateConfig(FMLConfig.ConfigValue.EARLY_WINDOW_HEIGHT, winHeight); FMLConfig.updateConfig(FMLConfig.ConfigValue.EARLY_WINDOW_HEIGHT, winHeight);
fbScale = FMLConfig.getIntConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_FBSCALE); fbScale = FMLConfig.getIntConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_FBSCALE);
if (System.getenv("FML_EARLY_WINDOW_DARK")!= null) { if (System.getenv("FML_EARLY_WINDOW_DARK") != null) {
this.colourScheme = ColourScheme.BLACK; this.colourScheme = ColourScheme.BLACK;
} else { } else {
try { try {
var optionLines = Files.readAllLines(FMLPaths.GAMEDIR.get().resolve(Paths.get("options.txt"))); // check the options file for the colour scheme
var options = optionLines.stream().map(l -> l.split(":")).filter(a -> a.length == 2).collect(Collectors.toMap(a -> a[0], a -> a[1])); var optionLines = Files.readAllLines(FMLPaths.GAMEDIR.get().resolve(Path.of("options.txt")));
var colourScheme = Boolean.parseBoolean(options.getOrDefault("darkMojangStudiosBackground", "false")); var keyName = "darkMojangStudiosBackground:";
this.colourScheme = colourScheme ? ColourScheme.BLACK : ColourScheme.RED; for (String line : optionLines) {
} catch (IOException ioe) { if (line.startsWith(keyName)) {
// No options this.colourScheme = line.startsWith("true", keyName.length()) ? ColourScheme.BLACK : ColourScheme.RED;
this.colourScheme = ColourScheme.RED; // default to red colourscheme break;
}
}
} catch (IOException e) {
this.colourScheme = ColourScheme.RED; // fallback to red colourScheme
} }
} }
this.maximized = parsed.has(maximizedopt) || FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_MAXIMIZED); this.maximized = parsed.has(maximizedopt) || FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_MAXIMIZED);
var forgeVersion = parsed.valueOf(forgeversionopt); StartupNotificationManager.modLoaderConsumer().ifPresent(c->c.accept("Forge loading " + forgeVersion));
StartupNotificationManager.modLoaderConsumer().ifPresent(c->c.accept("Forge loading "+ forgeVersion));
performanceInfo = new PerformanceInfo(); performanceInfo = new PerformanceInfo();
return start(parsed.valueOf(mcversionopt), forgeVersion); return start(mcVersion, forgeVersion);
} }
private static final long MINFRAMETIME = TimeUnit.MILLISECONDS.toNanos(10); // This is the FPS cap on the window - note animation is capped at 20FPS via the tickTimer private static final long MINFRAMETIME = TimeUnit.MILLISECONDS.toNanos(10); // This is the FPS cap on the window - note animation is capped at 20FPS via the tickTimer
@@ -228,12 +229,12 @@ public class DisplayWindow implements ImmediateWindowProvider {
LOGGER.error("Crash during font initialization", t); LOGGER.error("Crash during font initialization", t);
crashElegantly("An error occurred initializing a font for rendering. "+t.getMessage()); crashElegantly("An error occurred initializing a font for rendering. "+t.getMessage());
} }
this.elements = new ArrayList<>(Arrays.asList( this.elements = new ArrayList<>(List.of(
RenderElement.anvil(font), RenderElement.anvil(font),
RenderElement.logMessageOverlay(font), RenderElement.logMessageOverlay(font),
RenderElement.forgeVersionOverlay(font, mcVersion+"-"+forgeVersion.split("-")[0]), RenderElement.forgeVersionOverlay(font, mcVersion + "-" + forgeVersion),
RenderElement.performanceBar(font), RenderElement.performanceBar(font),
RenderElement.progressBars(font) RenderElement.progressBars(font)
)); ));
var date = Calendar.getInstance(); var date = Calendar.getInstance();
@@ -285,6 +286,7 @@ public class DisplayWindow implements ImmediateWindowProvider {
public Runnable start(@Nullable String mcVersion, final String forgeVersion) { public Runnable start(@Nullable String mcVersion, final String forgeVersion) {
renderScheduler = Executors.newSingleThreadScheduledExecutor(r -> { renderScheduler = Executors.newSingleThreadScheduledExecutor(r -> {
final var thread = Executors.defaultThreadFactory().newThread(r); final var thread = Executors.defaultThreadFactory().newThread(r);
thread.setName("EarlyDisplay");
thread.setDaemon(true); thread.setDaemon(true);
return thread; return thread;
}); });
@@ -362,14 +364,15 @@ public class DisplayWindow implements ImmediateWindowProvider {
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API); glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
if (mcVersion != null) {
// this emulates what we would get without early progress window String vanillaWindowTitle = "Minecraft* ";
// as vanilla never sets these, so GLFW uses the first window title if (mcVersion != null) vanillaWindowTitle += mcVersion;
// set them explicitly to avoid it using "FML early loading progress" as the class
String vanillaWindowTitle = "Minecraft* " + mcVersion; // this emulates what we would get without early progress window
glfwWindowHintString(GLFW_X11_CLASS_NAME, vanillaWindowTitle); // as vanilla never sets these, so GLFW uses the first window title
glfwWindowHintString(GLFW_X11_INSTANCE_NAME, vanillaWindowTitle); // set them explicitly to avoid it using "FML early loading progress" as the class
} glfwWindowHintString(GLFW_X11_CLASS_NAME, vanillaWindowTitle);
glfwWindowHintString(GLFW_X11_INSTANCE_NAME, vanillaWindowTitle);
long primaryMonitor = glfwGetPrimaryMonitor(); long primaryMonitor = glfwGetPrimaryMonitor();
if (primaryMonitor == 0) { if (primaryMonitor == 0) {
@@ -391,7 +394,8 @@ public class DisplayWindow implements ImmediateWindowProvider {
}, 10, TimeUnit.SECONDS); }, 10, TimeUnit.SECONDS);
int versidx = 0; int versidx = 0;
var skipVersions = FMLConfig.<String>getListConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_SKIP_GL_VERSIONS); var skipVersions = FMLConfig.<String>getListConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_SKIP_GL_VERSIONS);
final String[] lastGLError=new String[GL_VERSIONS.length]; boolean showHelpLog = FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_LOG_HELP_MSG);
final String[] lastGLError = new String[GL_VERSIONS.length];
do { do {
final var glVersionToTry = GL_VERSIONS[versidx][0] + "." + GL_VERSIONS[versidx][1]; final var glVersionToTry = GL_VERSIONS[versidx][0] + "." + GL_VERSIONS[versidx][1];
if (skipVersions.contains(glVersionToTry)) { if (skipVersions.contains(glVersionToTry)) {
@@ -400,11 +404,23 @@ public class DisplayWindow implements ImmediateWindowProvider {
continue; continue;
} }
LOGGER.info("Trying GL version " + glVersionToTry); LOGGER.info("Trying GL version " + glVersionToTry);
if (showHelpLog && versidx == 0) {
LOGGER.info("""
If this message is the only thing at the bottom of your log before a crash, you probably have a driver issue.
Possible solutions:
A) Make sure Minecraft is set to prefer high performance graphics in the OS and/or driver control panel
B) Check for driver updates on the graphics brand's website
C) Try reinstalling your graphics drivers
D) If still not working after trying all of the above, ask for further help on the Forge forums or Discord
You can safely ignore this message if the game starts up successfully.""");
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, GL_VERSIONS[versidx][0]); // we try our versions one at a time glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, GL_VERSIONS[versidx][0]); // we try our versions one at a time
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, GL_VERSIONS[versidx][1]); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, GL_VERSIONS[versidx][1]);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
window = glfwCreateWindow(winWidth, winHeight, "Minecraft: Forge Loading...", 0L, 0L); window = glfwCreateWindow(winWidth, winHeight, vanillaWindowTitle, 0L, 0L);
var erridx = versidx; var erridx = versidx;
handleLastGLFWError((error, description) -> lastGLError[erridx] = String.format("Trying %d.%d: GLFW error: [0x%X]%s", GL_VERSIONS[erridx][0], GL_VERSIONS[erridx][1], error, description)); handleLastGLFWError((error, description) -> lastGLError[erridx] = String.format("Trying %d.%d: GLFW error: [0x%X]%s", GL_VERSIONS[erridx][0], GL_VERSIONS[erridx][1], error, description));
if (lastGLError[versidx] != null) { if (lastGLError[versidx] != null) {
@@ -432,6 +448,9 @@ public class DisplayWindow implements ImmediateWindowProvider {
this.glVersion = gotVersion; this.glVersion = gotVersion;
this.window = window; this.window = window;
if (showHelpLog)
FMLConfig.updateConfig(FMLConfig.ConfigValue.EARLY_WINDOW_LOG_HELP_MSG, false);
int[] x = new int[1]; int[] x = new int[1];
int[] y = new int[1]; int[] y = new int[1];
glfwGetMonitorPos(primaryMonitor, x, y); glfwGetMonitorPos(primaryMonitor, x, y);
@@ -449,19 +468,19 @@ public class DisplayWindow implements ImmediateWindowProvider {
glfwSetWindowPos(window, (vidmode.width() - this.winWidth) / 2 + monitorX, (vidmode.height() - this.winHeight) / 2 + monitorY); glfwSetWindowPos(window, (vidmode.width() - this.winWidth) / 2 + monitorX, (vidmode.height() - this.winHeight) / 2 + monitorY);
// Attempt setting the icon // Attempt setting the icon
int[] channels = new int[1]; // int[] channels = new int[1];
try (var glfwImgBuffer = GLFWImage.create(MemoryUtil.getAllocator().malloc(GLFWImage.SIZEOF), 1)) { // try (var glfwImgBuffer = GLFWImage.create(MemoryUtil.getAllocator().malloc(GLFWImage.SIZEOF), 1)) {
final ByteBuffer imgBuffer; // final ByteBuffer imgBuffer;
try (GLFWImage glfwImages = GLFWImage.malloc()) { // try (GLFWImage glfwImages = GLFWImage.malloc()) {
imgBuffer = STBHelper.loadImageFromClasspath("forge_logo.png", 20000, x, y, channels); // imgBuffer = STBHelper.loadImageFromClasspath("forge_logo.png", 20000, x, y, channels);
glfwImgBuffer.put(glfwImages.set(x[0], y[0], imgBuffer)); // glfwImgBuffer.put(glfwImages.set(x[0], y[0], imgBuffer));
glfwSetWindowIcon(window, glfwImgBuffer); // glfwSetWindowIcon(window, glfwImgBuffer);
STBImage.stbi_image_free(imgBuffer); // STBImage.stbi_image_free(imgBuffer);
} // }
} catch (NullPointerException e) { // } catch (NullPointerException e) {
System.err.println("Failed to load forge logo"); // System.err.println("Failed to load forge logo");
} // }
handleLastGLFWError((error, description) -> LOGGER.debug(String.format("Suppressing GLFW icon error: [0x%X]%s", error, description))); // handleLastGLFWError((error, description) -> LOGGER.debug(String.format("Suppressing GLFW icon error: [0x%X]%s", error, description)));
glfwSetFramebufferSizeCallback(window, this::fbResize); glfwSetFramebufferSizeCallback(window, this::fbResize);
glfwSetWindowPosCallback(window, this::winMove); glfwSetWindowPosCallback(window, this::winMove);
@@ -596,8 +615,7 @@ public class DisplayWindow implements ImmediateWindowProvider {
var fm = layer.findModule("forge").orElseThrow(); var fm = layer.findModule("forge").orElseThrow();
getClass().getModule().addReads(fm); getClass().getModule().addReads(fm);
var clz = FMLLoader.getGameLayer().findModule("forge").map(l->Class.forName(l, "net.minecraftforge.client.loading.ForgeLoadingOverlay")).orElseThrow(); var clz = FMLLoader.getGameLayer().findModule("forge").map(l->Class.forName(l, "net.minecraftforge.client.loading.ForgeLoadingOverlay")).orElseThrow();
var methods = Arrays.stream(clz.getMethods()).filter(m-> Modifier.isStatic(m.getModifiers())).collect(Collectors.toMap(Method::getName, Function.identity())); loadingOverlay = Arrays.stream(clz.getDeclaredMethods()).filter(m-> Modifier.isStatic(m.getModifiers()) && m.getName().equals("newInstance")).findFirst().orElseThrow();
loadingOverlay = methods.get("newInstance");
} }
public int getFramebufferTextureId() { public int getFramebufferTextureId() {
@@ -6,6 +6,7 @@
package net.minecraftforge.fml.earlydisplay; package net.minecraftforge.fml.earlydisplay;
import com.sun.management.OperatingSystemMXBean; import com.sun.management.OperatingSystemMXBean;
import net.minecraftforge.fml.loading.FMLConfig;
import java.lang.management.ManagementFactory; import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean; import java.lang.management.MemoryMXBean;
@@ -13,28 +14,37 @@ import java.lang.management.MemoryUsage;
public class PerformanceInfo { public class PerformanceInfo {
private final boolean showCPUUsage;
private final OperatingSystemMXBean osBean; private final OperatingSystemMXBean osBean;
private final MemoryMXBean memoryBean; private final MemoryMXBean memoryBean;
float memory;
private float memory;
private String text; private String text;
PerformanceInfo() { PerformanceInfo() {
osBean = ManagementFactory.getPlatformMXBean(OperatingSystemMXBean.class); showCPUUsage = FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_SHOW_CPU);
osBean = showCPUUsage ? ManagementFactory.getPlatformMXBean(OperatingSystemMXBean.class) : null;
memoryBean = ManagementFactory.getMemoryMXBean(); memoryBean = ManagementFactory.getMemoryMXBean();
} }
void update() { void update() {
final MemoryUsage heapusage = memoryBean.getHeapMemoryUsage(); final MemoryUsage heapusage = memoryBean.getHeapMemoryUsage();
memory = (float) heapusage.getUsed() / heapusage.getMax(); memory = (float) heapusage.getUsed() / heapusage.getMax();
if (!showCPUUsage) {
text = "Heap: %d/%d MB (%.1f%%) OffHeap: %d MB".formatted(heapusage.getUsed() >> 20, heapusage.getMax() >> 20, memory * 100.0, memoryBean.getNonHeapMemoryUsage().getUsed() >> 20);
return;
}
var cpuLoad = osBean.getProcessCpuLoad(); var cpuLoad = osBean.getProcessCpuLoad();
String cpuText; String cpuText;
if (cpuLoad == -1) { if (cpuLoad == -1) {
cpuText = String.format("*CPU: %.1f%%", osBean.getCpuLoad() * 100f); cpuText = "*CPU: %.1f%%".formatted(osBean.getCpuLoad() * 100f);
} else { } else {
cpuText = String.format("CPU: %.1f%%", cpuLoad * 100f); cpuText = "CPU: %.1f%%".formatted(cpuLoad * 100f);
} }
text = String.format("Heap: %d/%d MB (%.1f%%) OffHeap: %d MB %s", heapusage.getUsed() >> 20, heapusage.getMax() >> 20, memory * 100.0, memoryBean.getNonHeapMemoryUsage().getUsed() >> 20, cpuText); text = "Heap: %d/%d MB (%.1f%%) OffHeap: %d MB %s".formatted(heapusage.getUsed() >> 20, heapusage.getMax() >> 20, memory * 100.0, memoryBean.getNonHeapMemoryUsage().getUsed() >> 20, cpuText);
} }
String text() { String text() {
@@ -34,11 +34,14 @@ public class RenderElement {
}; };
} }
} }
@FunctionalInterface
interface TextureRenderer { interface TextureRenderer {
void accept(SimpleBufferBuilder bb, DisplayContext context, int[] size, int frame); void accept(SimpleBufferBuilder bb, DisplayContext context, int[] size, int frame);
} }
@FunctionalInterface
interface Initializer extends Supplier<Renderer> {} interface Initializer extends Supplier<Renderer> {}
@FunctionalInterface
interface TextGenerator { interface TextGenerator {
void accept(SimpleBufferBuilder bb, SimpleFont fh, DisplayContext ctx); void accept(SimpleBufferBuilder bb, SimpleFont fh, DisplayContext ctx);
} }
@@ -201,14 +204,17 @@ public class RenderElement {
bar.then(label).accept(buffer, context, frameNumber); bar.then(label).accept(buffer, context, frameNumber);
} }
@FunctionalInterface
interface ColourFunction { interface ColourFunction {
int colour(int frame); int colour(int frame);
} }
@FunctionalInterface
interface ProgressDisplay { interface ProgressDisplay {
float[] progress(int frame); float[] progress(int frame);
} }
@FunctionalInterface
interface BarPosition { interface BarPosition {
int[] location(DisplayContext context); int[] location(DisplayContext context);
} }
@@ -280,7 +286,7 @@ public class RenderElement {
if (num < min) { if (num < min) {
return min; return min;
} else { } else {
return num > max ? max : num; return Math.min(num, max);
} }
} }
@@ -288,7 +294,7 @@ public class RenderElement {
if (num < min) { if (num < min) {
return min; return min;
} else { } else {
return num > max ? max : num; return Math.min(num, max);
} }
} }
+55 -36
View File
@@ -1,12 +1,14 @@
import net.minecraftforge.gradleutils.PomUtils
plugins { plugins {
id 'com.github.ben-manes.versions'
id 'org.javamodularity.moduleplugin' version '1.8.3' apply false
id 'org.cadixdev.licenser'
id 'java-library' id 'java-library'
id 'jacoco' id 'maven-publish'
id 'net.minecraftforge.licenser'
id 'net.minecraftforge.gradleutils'
} }
dependencyUpdates.rejectVersionIf { isNonStable(it.candidate.version) } apply from: rootProject.file('build_shared.gradle')
configurations.forEach{ it.transitive = false } configurations.forEach{ it.transitive = false }
dependencies { dependencies {
@@ -35,53 +37,70 @@ dependencies {
implementation(libs.jimfs) implementation(libs.jimfs)
implementation(libs.log4j.core) implementation(libs.log4j.core)
annotationProcessor(libs.log4j.core) annotationProcessor(libs.bundles.log4j)
testCompileOnly(libs.nulls) testCompileOnly(libs.nulls)
testRuntimeOnly(libs.bootstrap) testRuntimeOnly(libs.bootstrap)
} }
task sourcesJar(type: Jar) { java {
archiveClassifier = 'sources' toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
from sourceSets.main.allSource withSourcesJar()
} }
ext { tasks.named('jar', Jar).configure {
MANIFESTS = [ manifest {
'net/minecraftforge/fml/loading/': [ attributes([
'Specification-Title': 'FMLLoader', 'Automatic-Module-Name': 'net.minecraftforge.fmlloader',
'Specification-Vendor': 'Forge Development LLC', 'Forge-Module-Layer': 'boot'
'Specification-Version': '1', ] as LinkedHashMap)
'Implementation-Title': 'FML Loader', attributes([
'Implementation-Version': '1.0', 'Specification-Title': 'FMLLoader',
'Implementation-Vendor': 'Forge' 'Specification-Vendor': 'Forge Development LLC',
] as LinkedHashMap 'Specification-Version': '1',
] 'Implementation-Title': 'FMLLoader',
} 'Implementation-Vendor': 'Forge Development LLC',
'Implementation-Version': FORGE_VERSION
jar.doFirst { ] as LinkedHashMap, 'net/minecraftforge/fml/loading/')
manifest.attributes['Automatic-Module-Name'] = project.name
MANIFESTS.each { pkg, values ->
manifest.attributes(values, pkg)
} }
} }
tasks.withType(JavaCompile) { tasks.withType(JavaCompile).configureEach {
options.compilerArgs << '-Xlint:unchecked' options.compilerArgs << '-Xlint:unchecked'
} }
license { license {
header = rootProject.file('LICENSE-header.txt') header = rootProject.file('LICENSE-header.txt')
include 'net/minecraftforge/'
} }
artifacts { publishing {
archives jar publications.register('mavenJava', MavenPublication).configure {
archives sourcesJar from components.java
artifactId = 'fmlloader'
pom {
name = project.name
description = 'Modifactions to Minecraft to enable mod developers.'
url = 'https://github.com/MinecraftForge/MinecraftForge'
PomUtils.setGitHubDetails(pom, 'MinecraftForge')
license PomUtils.Licenses.LGPLv2_1
}
}
repositories {
maven gradleutils.publishingForgeMaven
}
} }
publishing.publications.mavenJava(MavenPublication) { tasks.register('writeForgeVersionJson') {
from components.java doLast {
artifact sourcesJar file('src/main/resources/forge_version.json').json = [
} forge: FORGE_VERSION,
mc: MC_VERSION,
mcp: MCP_VERSION
]
}
}
tasks.named('generateResources').configure {
dependsOn('writeForgeVersionJson')
}
@@ -11,7 +11,7 @@ import java.util.concurrent.Executors;
import java.util.concurrent.Future; import java.util.concurrent.Future;
public class BackgroundWaiter { public class BackgroundWaiter {
private static ExecutorService runner = Executors.newSingleThreadExecutor(); private static final ExecutorService runner = Executors.newSingleThreadExecutor();
public static void runAndTick(Runnable r, Runnable tick) { public static void runAndTick(Runnable r, Runnable tick) {
ImmediateWindowHandler.updateProgress("Loading bootstrap resources"); ImmediateWindowHandler.updateProgress("Loading bootstrap resources");
@@ -1,61 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading;
import cpw.mods.modlauncher.api.NamedPath;
import cpw.mods.modlauncher.serviceapi.ITransformerDiscoveryService;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
public class ClasspathTransformerDiscoverer implements ITransformerDiscoveryService {
private final List<Path> legacyClasspath = Arrays.stream(System.getProperty("legacyClassPath", "").split(File.pathSeparator)).map(Path::of).toList();
@Override
public List<NamedPath> candidates(Path gameDirectory) {
return Collections.emptyList();
}
@Override
public List<NamedPath> candidates(final Path gameDirectory, final String launchTarget) {
if (launchTarget != null && launchTarget.contains("dev")) {
this.scan(gameDirectory);
}
return List.copyOf(found);
}
private final static List<NamedPath> found = new ArrayList<>();
public static List<Path> allExcluded() {
return found.stream().map(np->np.paths()[0]).toList();
}
private void scan(final Path gameDirectory) {
try {
locateTransformers("META-INF/services/cpw.mods.modlauncher.api.ITransformationService");
locateTransformers("META-INF/services/net.minecraftforge.forgespi.locating.IModLocator");
} catch (IOException e) {
LogManager.getLogger().error("Error during discovery of transform services from the classpath", e);
}
}
private void locateTransformers(String resource) throws IOException {
final Enumeration<URL> resources = ClassLoader.getSystemClassLoader().getResources(resource);
while (resources.hasMoreElements()) {
URL url = resources.nextElement();
Path path = ClasspathLocatorUtils.findJarPathFor(resource, url.toString(), url);
if (legacyClasspath.stream().anyMatch(path::equals) || !Files.exists(path) || Files.isDirectory(path))
continue;
found.add(new NamedPath(path.toUri().toString(), path));
}
}
}
@@ -36,7 +36,9 @@ public class FMLConfig
EARLY_WINDOW_FBSCALE("earlyWindowFBScale", 1, "Early window framebuffer scale"), EARLY_WINDOW_FBSCALE("earlyWindowFBScale", 1, "Early window framebuffer scale"),
EARLY_WINDOW_MAXIMIZED("earlyWindowMaximized", Boolean.FALSE, "Early window starts maximized"), EARLY_WINDOW_MAXIMIZED("earlyWindowMaximized", Boolean.FALSE, "Early window starts maximized"),
EARLY_WINDOW_SKIP_GL_VERSIONS("earlyWindowSkipGLVersions", List.of(), "Skip specific GL versions, may help with buggy graphics card drivers"), EARLY_WINDOW_SKIP_GL_VERSIONS("earlyWindowSkipGLVersions", List.of(), "Skip specific GL versions, may help with buggy graphics card drivers"),
EARLY_WINDOW_SQUIR("earlyWindowSquir", Boolean.FALSE, "Squir?") EARLY_WINDOW_SQUIR("earlyWindowSquir", Boolean.FALSE, "Squir?"),
EARLY_WINDOW_SHOW_CPU("earlyWindowShowCPU", Boolean.FALSE, "Whether to show CPU usage stats in early window"),
EARLY_WINDOW_LOG_HELP_MSG("earlyWindowLogHelpMessage", Boolean.TRUE, "Whether to log a help message on first attempt, to aid troubleshooting. This setting should automatically disable itself after a successful launch"),
; ;
private final String entry; private final String entry;
@@ -8,8 +8,6 @@ package net.minecraftforge.fml.loading;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import cpw.mods.modlauncher.Launcher; import cpw.mods.modlauncher.Launcher;
import cpw.mods.modlauncher.api.*; import cpw.mods.modlauncher.api.*;
import cpw.mods.modlauncher.serviceapi.ILaunchPluginService;
import cpw.mods.modlauncher.util.ServiceLoaderUtils;
import net.minecraftforge.fml.loading.moddiscovery.BackgroundScanHandler; import net.minecraftforge.fml.loading.moddiscovery.BackgroundScanHandler;
import net.minecraftforge.fml.loading.moddiscovery.ModDiscoverer; import net.minecraftforge.fml.loading.moddiscovery.ModDiscoverer;
import net.minecraftforge.fml.loading.moddiscovery.ModFile; import net.minecraftforge.fml.loading.moddiscovery.ModFile;
@@ -24,27 +22,29 @@ import org.slf4j.Logger;
import java.nio.file.Path; import java.nio.file.Path;
import java.nio.file.Paths; import java.nio.file.Paths;
import java.util.*; import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;
import java.util.Set;
import java.util.function.BiFunction; import java.util.function.BiFunction;
import java.util.stream.Collectors;
import static net.minecraftforge.fml.loading.LogMarkers.CORE; import static net.minecraftforge.fml.loading.LogMarkers.CORE;
import static net.minecraftforge.fml.loading.LogMarkers.SCAN; import static net.minecraftforge.fml.loading.LogMarkers.SCAN;
public class FMLLoader public class FMLLoader {
{
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private static AccessTransformerService accessTransformer; private static AccessTransformerService accessTransformer;
private static ModDiscoverer modDiscoverer; private static ModDiscoverer modDiscoverer;
private static ICoreModProvider coreModProvider; private static ICoreModProvider coreModProvider;
private static ILaunchPluginService eventBus;
private static LanguageLoadingProvider languageLoadingProvider; private static LanguageLoadingProvider languageLoadingProvider;
private static Dist dist; private static Dist dist;
private static String naming; private static String naming;
private static LoadingModList loadingModList; private static LoadingModList loadingModList;
private static RuntimeDistCleaner runtimeDistCleaner; private static RuntimeDistCleaner runtimeDistCleaner;
private static Path gamePath; private static Path gamePath;
private static VersionInfo versionInfo; private static final VersionInfo versionInfo = VersionInfo.detect();
private static String launchHandlerName; private static String launchHandlerName;
private static CommonLaunchHandler commonLaunchHandler; private static CommonLaunchHandler commonLaunchHandler;
public static Runnable progressWindowTick; public static Runnable progressWindowTick;
@@ -53,80 +53,74 @@ public class FMLLoader
private static boolean production; private static boolean production;
private static IModuleLayerManager moduleLayerManager; private static IModuleLayerManager moduleLayerManager;
static void onInitialLoad(IEnvironment environment, Set<String> otherServices) throws IncompatibleEnvironmentException static void onInitialLoad(IEnvironment env, Set<String> otherServices) throws IncompatibleEnvironmentException {
{ LOGGER.debug(CORE, "Detected version data : {}", versionInfo);
final String version = LauncherVersion.getVersion(); LOGGER.debug(CORE, "FML {} loading", LauncherVersion.getVersion());
LOGGER.debug(CORE,"FML {} loading", version);
final Package modLauncherPackage = ITransformationService.class.getPackage();
LOGGER.debug(CORE,"FML found ModLauncher version : {}", modLauncherPackage.getImplementationVersion());
if (!modLauncherPackage.isCompatibleWith("4.0")) {
LOGGER.error(CORE, "Found incompatible ModLauncher specification : {}, version {} from {}", modLauncherPackage.getSpecificationVersion(), modLauncherPackage.getImplementationVersion(), modLauncherPackage.getImplementationVendor());
throw new IncompatibleEnvironmentException("Incompatible modlauncher found "+modLauncherPackage.getSpecificationVersion());
}
accessTransformer = (AccessTransformerService) environment.findLaunchPlugin("accesstransformer").orElseThrow(()-> { checkPackage(ITransformationService.class, "4.0", "ModLauncher");
LOGGER.error(CORE, "Access Transformer library is missing, we need this to run"); accessTransformer = getPlugin(env, "accesstransformer", "1.0", "AccessTransformer");
return new IncompatibleEnvironmentException("Missing AccessTransformer, cannot run"); /*eventBus =*/ getPlugin(env, "eventbus", "1.0", "EventBus");
}); runtimeDistCleaner = getPlugin(env, "runtimedistcleaner", "1.0", "RuntimeDistCleaner");
coreModProvider = getSingleService(ICoreModProvider.class, "CoreMod");
final Package atPackage = accessTransformer.getClass().getPackage(); LOGGER.debug(CORE,"FML found CoreMod version : {}", JarVersionLookupHandler.getInfo(coreModProvider.getClass()).impl().version().orElse("MISSING"));
LOGGER.debug(CORE,"FML found AccessTransformer version : {}", atPackage.getImplementationVersion()); checkPackage(Environment.class, "2.0", "ForgeSPI");
if (!atPackage.isCompatibleWith("1.0")) {
LOGGER.error(CORE, "Found incompatible AccessTransformer specification : {}, version {} from {}", atPackage.getSpecificationVersion(), atPackage.getImplementationVersion(), atPackage.getImplementationVendor());
throw new IncompatibleEnvironmentException("Incompatible accesstransformer found "+atPackage.getSpecificationVersion());
}
eventBus = environment.findLaunchPlugin("eventbus").orElseThrow(()-> {
LOGGER.error(CORE, "Event Bus library is missing, we need this to run");
return new IncompatibleEnvironmentException("Missing EventBus, cannot run");
});
final Package eventBusPackage = eventBus.getClass().getPackage();
LOGGER.debug(CORE,"FML found EventBus version : {}", eventBusPackage.getImplementationVersion());
if (!eventBusPackage.isCompatibleWith("1.0")) {
LOGGER.error(CORE, "Found incompatible EventBus specification : {}, version {} from {}", eventBusPackage.getSpecificationVersion(), eventBusPackage.getImplementationVersion(), eventBusPackage.getImplementationVendor());
throw new IncompatibleEnvironmentException("Incompatible eventbus found "+eventBusPackage.getSpecificationVersion());
}
runtimeDistCleaner = (RuntimeDistCleaner)environment.findLaunchPlugin("runtimedistcleaner").orElseThrow(()-> {
LOGGER.error(CORE, "Dist Cleaner is missing, we need this to run");
return new IncompatibleEnvironmentException("Missing DistCleaner, cannot run!");
});
LOGGER.debug(CORE, "Found Runtime Dist Cleaner");
var coreModProviders = ServiceLoaderUtils.streamWithErrorHandling(ServiceLoader.load(FMLLoader.class.getModule().getLayer(), ICoreModProvider.class), sce -> LOGGER.error(CORE, "Failed to load a coremod library, expect problems", sce)).toList();
if (coreModProviders.isEmpty()) {
LOGGER.error(CORE, "Found no coremod provider. Cannot run");
throw new IncompatibleEnvironmentException("No coremod library found");
} else if (coreModProviders.size() > 1) {
LOGGER.error(CORE, "Found multiple coremod providers : {}. Cannot run", coreModProviders.stream().map(p -> p.getClass().getName()).collect(Collectors.toList()));
throw new IncompatibleEnvironmentException("Multiple coremod libraries found");
}
coreModProvider = coreModProviders.get(0);
final Package coremodPackage = coreModProvider.getClass().getPackage();
LOGGER.debug(CORE,"FML found CoreMod version : {}", coremodPackage.getImplementationVersion());
LOGGER.debug(CORE, "Found ForgeSPI package implementation version {}", Environment.class.getPackage().getImplementationVersion());
LOGGER.debug(CORE, "Found ForgeSPI package specification {}", Environment.class.getPackage().getSpecificationVersion());
if (Integer.parseInt(Environment.class.getPackage().getSpecificationVersion()) < 2) {
LOGGER.error(CORE, "Found an out of date ForgeSPI implementation: {}, loading cannot continue", Environment.class.getPackage().getSpecificationVersion());
throw new IncompatibleEnvironmentException("ForgeSPI is out of date, we cannot continue");
}
try { try {
Class.forName("com.electronwill.nightconfig.core.Config", false, environment.getClass().getClassLoader()); Class.forName("com.electronwill.nightconfig.core.Config", false, env.getClass().getClassLoader());
Class.forName("com.electronwill.nightconfig.toml.TomlFormat", false, environment.getClass().getClassLoader()); Class.forName("com.electronwill.nightconfig.toml.TomlFormat", false, env.getClass().getClassLoader());
} catch (ClassNotFoundException e) { } catch (ClassNotFoundException e) {
LOGGER.error(CORE, "Failed to load NightConfig"); LOGGER.error(CORE, "Failed to load NightConfig");
throw new IncompatibleEnvironmentException("Missing NightConfig"); throw new IncompatibleEnvironmentException("Missing NightConfig");
} }
} }
static void setupLaunchHandler(final IEnvironment environment, final Map<String, Object> arguments) private static <T> T getPlugin(IEnvironment env, String id, String version, String name) throws IncompatibleEnvironmentException {
{ @SuppressWarnings("unchecked")
var plugin = (T)env.findLaunchPlugin(id).orElseThrow(() -> {
LOGGER.error(CORE, "{} library is missing, we need this to run", name);
return new IncompatibleEnvironmentException("Missing " + name + ", cannot run");
});
checkPackage(plugin.getClass(), version, name);
return plugin;
}
private static void checkPackage(Class<?> cls, String version, String name) throws IncompatibleEnvironmentException {
var pkg = cls.getPackage();
var info = JarVersionLookupHandler.getInfo(pkg);
LOGGER.debug(CORE, "Found {} version: {}", name, info.impl().version().orElse("MISSING"));
if (!pkg.isCompatibleWith(version)) {
LOGGER.error(CORE, "Found incompatible {} specification: {}, version {} from {}", name,
info.spec().version().orElse("MISSING"),
info.impl().version().orElse("MISSING"),
info.impl().vendor().orElse("MISSING")
);
throw new IncompatibleEnvironmentException("Incompatible " + name + " found " + info.spec().version().orElse("MISSING"));
}
}
private static <T> T getSingleService(Class<T> clazz, String name) throws IncompatibleEnvironmentException {
var providers = new ArrayList<T>();
for (var itr = ServiceLoader.load(FMLLoader.class.getModule().getLayer(), clazz).iterator(); itr.hasNext(); ) {
try {
providers.add(itr.next());
} catch (ServiceConfigurationError e) {
LOGGER.error(CORE, "Failed to load a " + name + " library, expect problems", e);
}
}
if (providers.isEmpty()) {
LOGGER.error(CORE, "Found no {} provider. Cannot run", name);
throw new IncompatibleEnvironmentException("No " + name + " library found");
} else if (providers.size() > 1) {
LOGGER.error(CORE, "Found multiple {} providers: {}. Cannot run", name, providers.stream().map(p -> p.getClass().getName()).toList());
throw new IncompatibleEnvironmentException("Multiple " + name + " libraries found");
}
return providers.get(0);
}
static void setupLaunchHandler(final IEnvironment environment, final Map<String, Object> arguments) {
final String launchTarget = environment.getProperty(IEnvironment.Keys.LAUNCHTARGET.get()).orElse("MISSING"); final String launchTarget = environment.getProperty(IEnvironment.Keys.LAUNCHTARGET.get()).orElse("MISSING");
arguments.put("launchTarget", launchTarget); arguments.put("launchTarget", launchTarget);
final Optional<ILaunchHandlerService> launchHandler = environment.findLaunchHandler(launchTarget); final Optional<ILaunchHandlerService> launchHandler = environment.findLaunchHandler(launchTarget);
@@ -136,7 +130,7 @@ public class FMLLoader
throw new RuntimeException("Missing launch handler: " + launchTarget); throw new RuntimeException("Missing launch handler: " + launchTarget);
} }
// TODO: What the fuck is the point of using a service if you require a specific concrete class // TODO: [FML][Loader] What the fuck is the point of using a service if you require a specific concrete class
if (!(launchHandler.get() instanceof CommonLaunchHandler)) { if (!(launchHandler.get() instanceof CommonLaunchHandler)) {
LOGGER.error(CORE, "Incompatible Launch handler found - type {}, cannot continue", launchHandler.get().getClass().getName()); LOGGER.error(CORE, "Incompatible Launch handler found - type {}, cannot continue", launchHandler.get().getClass().getName());
throw new RuntimeException("Incompatible launch handler found"); throw new RuntimeException("Incompatible launch handler found");
@@ -149,16 +143,12 @@ public class FMLLoader
dist = commonLaunchHandler.getDist(); dist = commonLaunchHandler.getDist();
production = commonLaunchHandler.isProduction(); production = commonLaunchHandler.isProduction();
versionInfo = new VersionInfo(arguments);
accessTransformer.getExtension().accept(Pair.of(naming, "srg")); accessTransformer.getExtension().accept(Pair.of(naming, "srg"));
LOGGER.debug(CORE,"Received command line version data : {}", versionInfo);
runtimeDistCleaner.getExtension().accept(dist); runtimeDistCleaner.getExtension().accept(dist);
} }
public static List<ITransformationService.Resource> beginModScan(final Map<String,?> arguments)
{ public static List<ITransformationService.Resource> beginModScan(final Map<String,?> arguments) {
LOGGER.debug(SCAN,"Scanning for Mod Locators"); LOGGER.debug(SCAN,"Scanning for Mod Locators");
modDiscoverer = new ModDiscoverer(arguments); modDiscoverer = new ModDiscoverer(arguments);
modValidator = modDiscoverer.discoverMods(); modValidator = modDiscoverer.discoverMods();
@@ -178,8 +168,7 @@ public class FMLLoader
return coreModProvider; return coreModProvider;
} }
public static LanguageLoadingProvider getLanguageLoadingProvider() public static LanguageLoadingProvider getLanguageLoadingProvider() {
{
return languageLoadingProvider; return languageLoadingProvider;
} }
@@ -191,31 +180,26 @@ public class FMLLoader
return commonLaunchHandler; return commonLaunchHandler;
} }
public static void addAccessTransformer(Path atPath, ModFile modName) public static void addAccessTransformer(Path atPath, ModFile modName) {
{
LOGGER.debug(SCAN, "Adding Access Transformer in {}", modName.getFilePath()); LOGGER.debug(SCAN, "Adding Access Transformer in {}", modName.getFilePath());
accessTransformer.offerResource(atPath, modName.getFileName()); accessTransformer.offerResource(atPath, modName.getFileName());
} }
public static Dist getDist() public static Dist getDist() {
{
return dist; return dist;
} }
public static void beforeStart(ModuleLayer gameLayer) public static void beforeStart(ModuleLayer gameLayer) {
{
ImmediateWindowHandler.acceptGameLayer(gameLayer); ImmediateWindowHandler.acceptGameLayer(gameLayer);
ImmediateWindowHandler.updateProgress("Launching minecraft"); ImmediateWindowHandler.updateProgress("Launching minecraft");
progressWindowTick.run(); progressWindowTick.run();
} }
public static LoadingModList getLoadingModList() public static LoadingModList getLoadingModList() {
{
return loadingModList; return loadingModList;
} }
public static Path getGamePath() public static Path getGamePath() {
{
return gamePath; return gamePath;
} }
@@ -232,7 +216,7 @@ public class FMLLoader
} }
public static List<Map<String, String>> modLauncherModList() { public static List<Map<String, String>> modLauncherModList() {
return Launcher.INSTANCE.environment().getProperty(IEnvironment.Keys.MODLIST.get()).orElseGet(Collections::emptyList); return Launcher.INSTANCE.environment().getProperty(IEnvironment.Keys.MODLIST.get()).orElse(List.of());
} }
public static String launcherHandlerName() { public static String launcherHandlerName() {
@@ -7,7 +7,6 @@ package net.minecraftforge.fml.loading;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import cpw.mods.modlauncher.api.*; import cpw.mods.modlauncher.api.*;
import joptsimple.ArgumentAcceptingOptionSpec;
import joptsimple.OptionSpecBuilder; import joptsimple.OptionSpecBuilder;
import net.minecraftforge.fml.loading.moddiscovery.ModFile; import net.minecraftforge.fml.loading.moddiscovery.ModFile;
import net.minecraftforge.forgespi.Environment; import net.minecraftforge.forgespi.Environment;
@@ -15,7 +14,6 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Locale; import java.util.Locale;
@@ -24,36 +22,18 @@ import java.util.Set;
import java.util.function.BiFunction; import java.util.function.BiFunction;
import static net.minecraftforge.fml.loading.LogMarkers.CORE; import static net.minecraftforge.fml.loading.LogMarkers.CORE;
public class FMLServiceProvider implements ITransformationService public class FMLServiceProvider implements ITransformationService {
{
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private ArgumentAcceptingOptionSpec<String> modsOption;
private ArgumentAcceptingOptionSpec<String> modListsOption;
private ArgumentAcceptingOptionSpec<String> mavenRootsOption;
private ArgumentAcceptingOptionSpec<String> forgeOption;
private ArgumentAcceptingOptionSpec<String> mcOption;
private ArgumentAcceptingOptionSpec<String> forgeGroupOption;
private ArgumentAcceptingOptionSpec<String> mcpOption;
private ArgumentAcceptingOptionSpec<String> mappingsOption;
private List<String> modsArgumentList;
private List<String> modListsArgumentList;
private List<String> mavenRootsArgumentList;
private String targetForgeVersion;
private String targetMcVersion;
private String targetMcpVersion;
private String targetMcpMappings;
private String targetForgeGroup;
private Map<String, Object> arguments; private Map<String, Object> arguments;
public FMLServiceProvider() public FMLServiceProvider() {
{ var markers = System.getProperty("forge.logging.markers", "").split(",");
final String markerselection = System.getProperty("forge.logging.markers", ""); for (var marker : markers)
Arrays.stream(markerselection.split(",")).forEach(marker -> System.setProperty("forge.logging.marker." + marker.toLowerCase(Locale.ROOT), "ACCEPT")); System.setProperty("forge.logging.marker." + marker.toLowerCase(Locale.ROOT), "ACCEPT");
} }
@Override @Override
public String name() public String name() {
{
return "fml"; return "fml";
} }
@@ -66,14 +46,6 @@ public class FMLServiceProvider implements ITransformationService
LOGGER.debug(CORE, "Preparing ModFile"); LOGGER.debug(CORE, "Preparing ModFile");
environment.computePropertyIfAbsent(Environment.Keys.MODFILEFACTORY.get(), k->ModFile::new); environment.computePropertyIfAbsent(Environment.Keys.MODFILEFACTORY.get(), k->ModFile::new);
arguments = new HashMap<>(); arguments = new HashMap<>();
arguments.put("modLists", modListsArgumentList);
arguments.put("mods", modsArgumentList);
arguments.put("mavenRoots", mavenRootsArgumentList);
arguments.put("forgeVersion", targetForgeVersion);
arguments.put("forgeGroup", targetForgeGroup);
arguments.put("mcVersion", targetMcVersion);
arguments.put("mcpVersion", targetMcpVersion);
arguments.put("mcpMappings", targetMcpMappings);
LOGGER.debug(CORE, "Preparing launch handler"); LOGGER.debug(CORE, "Preparing launch handler");
FMLLoader.setupLaunchHandler(environment, arguments); FMLLoader.setupLaunchHandler(environment, arguments);
FMLEnvironment.setupInteropEnvironment(environment); FMLEnvironment.setupInteropEnvironment(environment);
@@ -92,46 +64,22 @@ public class FMLServiceProvider implements ITransformationService
} }
@Override @Override
public void onLoad(IEnvironment environment, Set<String> otherServices) throws IncompatibleEnvironmentException public void onLoad(IEnvironment environment, Set<String> otherServices) throws IncompatibleEnvironmentException {
{
// LOGGER.debug("Injecting tracing printstreams for STDOUT/STDERR.");
// System.setOut(new TracingPrintStream(LogManager.getLogger("STDOUT"), System.out));
// System.setErr(new TracingPrintStream(LogManager.getLogger("STDERR"), System.err));
FMLLoader.onInitialLoad(environment, otherServices); FMLLoader.onInitialLoad(environment, otherServices);
} }
@Override @Override
public void arguments(BiFunction<String, String, OptionSpecBuilder> argumentBuilder) public void arguments(BiFunction<String, String, OptionSpecBuilder> argumentBuilder) {
{
forgeOption = argumentBuilder.apply("forgeVersion", "Forge Version number").withRequiredArg().ofType(String.class).required();
forgeGroupOption = argumentBuilder.apply("forgeGroup", "Forge Group (for testing)").withRequiredArg().ofType(String.class).defaultsTo("net.minecraftforge");
mcOption = argumentBuilder.apply("mcVersion", "Minecraft Version number").withRequiredArg().ofType(String.class).required();
mcpOption = argumentBuilder.apply("mcpVersion", "MCP Version number").withRequiredArg().ofType(String.class).required();
mappingsOption = argumentBuilder.apply("mcpMappings", "MCP Mappings Channel and Version").withRequiredArg().ofType(String.class);
modsOption = argumentBuilder.apply("mods", "List of mods to add").withRequiredArg().ofType(String.class).withValuesSeparatedBy(",");
modListsOption = argumentBuilder.apply("modLists", "JSON modlists").withRequiredArg().ofType(String.class).withValuesSeparatedBy(",");
mavenRootsOption = argumentBuilder.apply("mavenRoots", "Maven root directories").withRequiredArg().ofType(String.class).withValuesSeparatedBy(",");
} }
@Override @Override
public void argumentValues(OptionResult option) public void argumentValues(OptionResult option) {
{
modsArgumentList = option.values(modsOption);
modListsArgumentList = option.values(modListsOption);
mavenRootsArgumentList = option.values(mavenRootsOption);
targetForgeVersion = option.value(forgeOption);
targetForgeGroup = option.value(forgeGroupOption);
targetMcVersion = option.value(mcOption);
targetMcpVersion = option.value(mcpOption);
targetMcpMappings = option.value(mappingsOption);
} }
@SuppressWarnings("rawtypes") @SuppressWarnings("rawtypes")
@Override @Override
public @NotNull List<ITransformer> transformers() public @NotNull List<ITransformer> transformers() {
{
LOGGER.debug(CORE, "Loading coremod transformers"); LOGGER.debug(CORE, "Loading coremod transformers");
return new ArrayList<>(FMLLoader.getCoreModProvider().getCoreModTransformers()); return new ArrayList<>(FMLLoader.getCoreModProvider().getCoreModTransformers());
} }
} }
@@ -32,15 +32,16 @@ public class ImmediateWindowHandler {
} else { } else {
final var providername = FMLConfig.getConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_PROVIDER); final var providername = FMLConfig.getConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_PROVIDER);
LOGGER.info("Loading ImmediateWindowProvider {}", providername); LOGGER.info("Loading ImmediateWindowProvider {}", providername);
final var maybeProvider = ServiceLoader.load(ImmediateWindowProvider.class) for (var service : ServiceLoader.load(ImmediateWindowProvider.class)) {
.stream() if (providername.equals(service.name())) {
.map(ServiceLoader.Provider::get) provider = service;
.filter(p -> Objects.equals(p.name(), providername)) break;
.findFirst(); }
provider = maybeProvider.or(() -> { }
if (provider == null) {
LOGGER.info("Failed to find ImmediateWindowProvider {}, disabling", providername); LOGGER.info("Failed to find ImmediateWindowProvider {}, disabling", providername);
return Optional.of(new DummyProvider()); provider = new DummyProvider();
}).orElseThrow(); }
} }
// Only update config if the provider isn't the dummy provider // Only update config if the provider isn't the dummy provider
if (!Objects.equals(provider.name(), "dummyprovider")) if (!Objects.equals(provider.name(), "dummyprovider"))
@@ -11,32 +11,72 @@ import java.util.Optional;
* Finds Version data from a package, with possible default values * Finds Version data from a package, with possible default values
*/ */
public class JarVersionLookupHandler { public class JarVersionLookupHandler {
public record Version(Optional<String> title, Optional<String> vendor, Optional<String> version) {
@Override
public String toString() {
return "[" +
"title=" + title.orElse(null) +
", vendor=" + vendor.orElse(null) +
", version=" + version.orElse(null) +
"]";
}
}
public record Info(Version spec, Version impl) {}
@SuppressWarnings("deprecation")
public static Info getInfo(String pkgName) {
return getInfo(Package.getPackage(pkgName));
}
public static Info getInfo(Class<?> clazz) {
return getInfo(clazz.getPackage());
}
public static Info getInfo(Package pkg) {
return new Info(
new Version(
Optional.ofNullable(pkg.getSpecificationTitle()),
Optional.ofNullable(pkg.getSpecificationVendor()),
Optional.ofNullable(pkg.getSpecificationVersion())
),
new Version(
Optional.ofNullable(pkg.getImplementationTitle()),
Optional.ofNullable(pkg.getImplementationVendor()),
Optional.ofNullable(pkg.getImplementationVersion())
)
);
}
@Deprecated(forRemoval = true, since = "1.20.2")
public static Optional<String> getImplementationVersion(final String pkgName) { public static Optional<String> getImplementationVersion(final String pkgName) {
// Note that with Java 9, you'll probably want the module's version data, hence pulling this out // Note that with Java 9, you'll probably want the module's version data, hence pulling this out
final String pkgVersion = Package.getPackage(pkgName).getImplementationVersion(); final String pkgVersion = Package.getPackage(pkgName).getImplementationVersion();
return Optional.ofNullable(pkgVersion); return Optional.ofNullable(pkgVersion);
} }
@Deprecated(forRemoval = true, since = "1.20.2")
public static Optional<String> getSpecificationVersion(final String pkgName) { public static Optional<String> getSpecificationVersion(final String pkgName) {
// Note that with Java 9, you'll probably want the module's version data, hence pulling this out // Note that with Java 9, you'll probably want the module's version data, hence pulling this out
final String pkgVersion = Package.getPackage(pkgName).getSpecificationVersion(); final String pkgVersion = Package.getPackage(pkgName).getSpecificationVersion();
return Optional.ofNullable(pkgVersion); return Optional.ofNullable(pkgVersion);
} }
@Deprecated(forRemoval = true, since = "1.20.2")
public static Optional<String> getImplementationVersion(final Class<?> clazz) { public static Optional<String> getImplementationVersion(final Class<?> clazz) {
// With java 9 we'll use the module's version if it exists in preference. // With java 9 we'll use the module's version if it exists in preference.
final String pkgVersion = clazz.getPackage().getImplementationVersion(); final String pkgVersion = clazz.getPackage().getImplementationVersion();
return Optional.ofNullable(pkgVersion); return Optional.ofNullable(pkgVersion);
} }
@Deprecated(forRemoval = true, since = "1.20.2")
public static Optional<String> getImplementationTitle(final Class<?> clazz) { public static Optional<String> getImplementationTitle(final Class<?> clazz) {
// With java 9 we'll use the module's version if it exists in preference. // With java 9 we'll use the module's version if it exists in preference.
final String pkgVersion = clazz.getPackage().getImplementationTitle(); final String pkgVersion = clazz.getPackage().getImplementationTitle();
return Optional.ofNullable(pkgVersion); return Optional.ofNullable(pkgVersion);
} }
@Deprecated(forRemoval = true, since = "1.20.2")
public static Optional<String> getSpecificationVersion(final Class<?> clazz) { public static Optional<String> getSpecificationVersion(final Class<?> clazz) {
// With java 9 we'll use the module's version if it exists in preference. // With java 9 we'll use the module's version if it exists in preference.
final String pkgVersion = clazz.getPackage().getSpecificationVersion(); final String pkgVersion = clazz.getPackage().getSpecificationVersion();
@@ -7,26 +7,19 @@ package net.minecraftforge.fml.loading;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import cpw.mods.modlauncher.Launcher; import cpw.mods.modlauncher.Launcher;
import cpw.mods.modlauncher.api.IModuleLayerManager; import cpw.mods.modlauncher.api.IModuleLayerManager.Layer;
import cpw.mods.modlauncher.util.ServiceLoaderUtils;
import net.minecraftforge.forgespi.language.IModLanguageProvider; import net.minecraftforge.forgespi.language.IModLanguageProvider;
import net.minecraftforge.fml.loading.moddiscovery.ExplodedDirectoryLocator;
import net.minecraftforge.fml.loading.moddiscovery.ModFile; import net.minecraftforge.fml.loading.moddiscovery.ModFile;
import org.apache.maven.artifact.versioning.ArtifactVersion; import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion; import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.maven.artifact.versioning.VersionRange; import org.apache.maven.artifact.versioning.VersionRange;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.net.URISyntaxException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional; import java.util.ServiceConfigurationError;
import java.util.ServiceLoader; import java.util.ServiceLoader;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.function.Function; import java.util.function.Function;
@@ -35,115 +28,97 @@ import java.util.stream.Stream;
import static net.minecraftforge.fml.loading.LogMarkers.CORE; import static net.minecraftforge.fml.loading.LogMarkers.CORE;
import static net.minecraftforge.fml.loading.LogMarkers.LOADING; import static net.minecraftforge.fml.loading.LogMarkers.LOADING;
public class LanguageLoadingProvider public class LanguageLoadingProvider {
{ public void forEach(Consumer<IModLanguageProvider> consumer) {
providers.forEach(consumer);
}
public <T> Stream<T> applyForEach(Function<IModLanguageProvider, T> function) {
return providers.stream().map(function);
}
public void reload() {
loadLanguageProviders();
}
/** This doesn't actually do anything with the argument, so just call reload(). Not sure when cpw broke that. */
@Deprecated(forRemoval = true, since = "1.20.2")
public void addAdditionalLanguages(List<ModFile> modFiles) {
reload();
}
/*==========================================================================*
* INTERNAL SHIT *
*==========================================================================*/
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private final List<IModLanguageProvider> languageProviders = new ArrayList<>();
private final ServiceLoader<IModLanguageProvider> serviceLoader; private final ServiceLoader<IModLanguageProvider> serviceLoader;
private final Map<String, ModLanguageWrapper> languageProviderMap = new HashMap<>(); private final List<IModLanguageProvider> providers = new ArrayList<>();
private List<Path> languagePaths = new ArrayList<>(); private final Map<String, Wrapper> providersByName = new HashMap<>();
private static final DefaultArtifactVersion IN_DEV = new DefaultArtifactVersion("0.0-dev");
public void forEach(final Consumer<IModLanguageProvider> consumer) private record Wrapper(ArtifactVersion version, IModLanguageProvider service) {}
{
languageProviders.forEach(consumer);
}
public <T> Stream<T> applyForEach(final Function<IModLanguageProvider, T> function) {
return languageProviders.stream().map(function);
}
private static class ModLanguageWrapper {
private final IModLanguageProvider modLanguageProvider;
private final ArtifactVersion version;
public ModLanguageWrapper(IModLanguageProvider modLanguageProvider, ArtifactVersion version)
{
this.modLanguageProvider = modLanguageProvider;
this.version = version;
}
public ArtifactVersion getVersion()
{
return version;
}
public IModLanguageProvider getModLanguageProvider()
{
return modLanguageProvider;
}
}
LanguageLoadingProvider() { LanguageLoadingProvider() {
var sl = Launcher.INSTANCE.environment().findModuleLayerManager().flatMap(lm->lm.getLayer(IModuleLayerManager.Layer.PLUGIN)).orElseThrow(); var sl = Launcher.INSTANCE.environment().findModuleLayerManager().flatMap(lm -> lm.getLayer(Layer.PLUGIN)).orElseThrow();
serviceLoader = ServiceLoader.load(sl, IModLanguageProvider.class); serviceLoader = ServiceLoader.load(sl, IModLanguageProvider.class);
loadLanguageProviders(); loadLanguageProviders();
} }
private void loadLanguageProviders() { private void loadLanguageProviders() {
LOGGER.debug(CORE, "Found {} language providers", ServiceLoaderUtils.streamServiceLoader(()->serviceLoader, sce->LOGGER.error("Problem with language loaders")).count()); providers.clear();
serviceLoader.forEach(languageProviders::add); providersByName.clear();
ImmediateWindowHandler.updateProgress("Loading language providers");
languageProviders.forEach(lp -> {
final Path lpPath;
try {
lpPath = Paths.get(lp.getClass().getProtectionDomain().getCodeSource().getLocation().toURI());
} catch (URISyntaxException e) {
throw new RuntimeException("Huh?", e);
}
Optional<String> implementationVersion = JarVersionLookupHandler.getImplementationVersion(lp.getClass());
String impl = implementationVersion.orElse(Files.isDirectory(lpPath) ? FMLLoader.versionInfo().forgeVersion().split("\\.")[0] : null);
if (impl == null) {
LOGGER.error(CORE, "Found unversioned language provider {}", lp.name());
throw new RuntimeException("Failed to find implementation version for language provider "+ lp.name());
}
LOGGER.debug(CORE, "Found language provider {}, version {}", lp.name(), impl);
ImmediateWindowHandler.updateProgress("Loaded language provider "+lp.name()+ " " + impl);
languageProviderMap.put(lp.name(), new ModLanguageWrapper(lp, new DefaultArtifactVersion(impl)));
});
}
void addForgeLanguage(final Path forgePath) {
if (!languageProviderMap.containsKey("javafml")) {
LOGGER.debug(CORE,"Adding forge as a language from {}", forgePath.toString());
addLanguagePaths(Stream.of(forgePath));
serviceLoader.reload();
loadLanguageProviders();
} else {
LOGGER.debug(CORE, "Skipping adding forge jar - javafml is already present");
}
}
private void addLanguagePaths(final Stream<Path> langPaths) {
languageProviders.clear();
languageProviderMap.clear();
// langPaths.peek(languagePaths::add).map(Path::toFile).map(File::toURI).map(rethrowFunction(URI::toURL)).forEach(languageClassLoader::addURL);
}
public void addAdditionalLanguages(List<ModFile> modFiles)
{
if (modFiles==null) return;
Stream<Path> langPaths = modFiles.stream().map(ModFile::getFilePath);
addLanguagePaths(langPaths);
serviceLoader.reload(); serviceLoader.reload();
loadLanguageProviders(); for (var itr = serviceLoader.iterator(); itr.hasNext(); ) {
} try {
var srvc = itr.next();
Stream<Path> getLibraries() { providers.add(srvc);
return languagePaths.stream(); } catch (ServiceConfigurationError sce) {
} LOGGER.error(CORE, "Failed to load IModLauguageProvider Service: " + sce.getMessage());
}
public IModLanguageProvider findLanguage(ModFile mf, String modLoader, VersionRange modLoaderVersion) {
final String languageFileName = mf.getProvider() instanceof ExplodedDirectoryLocator ? "in-development" : mf.getFileName();
final ModLanguageWrapper mlw = languageProviderMap.get(modLoader);
if (mlw == null) {
LOGGER.error(LOADING,"Missing language {} version {} wanted by {}", modLoader, modLoaderVersion, languageFileName);
throw new EarlyLoadingException("Missing language "+modLoader, null, Collections.singletonList(new EarlyLoadingException.ExceptionData("fml.language.missingversion", modLoader, modLoaderVersion, languageFileName, "null")));
}
if (!VersionSupportMatrix.testVersionSupportMatrix(modLoaderVersion, modLoader, "languageloader", (llid, range) -> range.containsVersion(mlw.getVersion()))) {
LOGGER.error(LOADING,"Missing language {} version {} wanted by {}, found {}", modLoader, modLoaderVersion, languageFileName, mlw.getVersion());
throw new EarlyLoadingException("Missing language "+ modLoader + " matching range "+modLoaderVersion + " found "+mlw.getVersion(), null, Collections.singletonList(new EarlyLoadingException.ExceptionData("fml.language.missingversion", modLoader, modLoaderVersion, languageFileName, mlw.getVersion())));
} }
return mlw.getModLanguageProvider(); LOGGER.debug(CORE, "Found {} language providers", providers.size());
ImmediateWindowHandler.updateProgress("Loading language providers");
for (var provider : providers) {
var info = JarVersionLookupHandler.getInfo(provider.getClass());
if (info.impl().version().isEmpty() && FMLEnvironment.production) {
LOGGER.error(CORE, "Found unversioned language provider {}: {}", provider.name(), provider.getClass().getName());
throw new RuntimeException("Failed to find implementation version for language provider " + provider.name() + " of type " + provider.getClass().getName());
}
var version = info.impl().version().map(DefaultArtifactVersion::new).orElse(IN_DEV);
LOGGER.debug(CORE, "Found language provider {}, version {}", provider.name(), version);
ImmediateWindowHandler.updateProgress("Loaded language provider " + provider.name() + " " + version);
providersByName.put(provider.name(), new Wrapper(version, provider));
}
}
public IModLanguageProvider findLanguage(ModFile mod, String language, VersionRange versionRange) {
var consumer = mod.getFileName();
var wrapper = providersByName.get(language);
if (wrapper == null) {
LOGGER.error(LOADING, "Missing language {} version {} wanted by {}", language, versionRange, consumer);
var data = new EarlyLoadingException.ExceptionData("fml.language.missingversion", language, versionRange, consumer, "null");
throw new EarlyLoadingException("Missing language " + language, null, List.of(data));
}
var version = wrapper.version();
if (version == IN_DEV) {
LOGGER.debug(LOADING, "Language Provider {} version is unknown, but {} was requested by {}. Proceeding as this is development environement", language, versionRange, consumer);
return wrapper.service();
}
if (!versionRange.containsVersion(version)) {
LOGGER.error(LOADING, "Missing language {} version {} wanted by {}, found {}", language, versionRange, consumer, version);
var data = new EarlyLoadingException.ExceptionData("fml.language.missingversion", language, versionRange, consumer, version);
throw new EarlyLoadingException("Missing language " + language + " matching range " + versionRange + " found " + version, null, List.of(data));
}
return wrapper.service();
} }
} }
@@ -8,21 +8,19 @@ package net.minecraftforge.fml.loading;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import org.slf4j.Logger; import org.slf4j.Logger;
import static net.minecraftforge.fml.loading.LogMarkers.CORE;
public class LauncherVersion { public class LauncherVersion {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private static final String launcherVersion; private static final String launcherVersion;
static { static {
String vers = JarVersionLookupHandler.getImplementationVersion(LauncherVersion.class).orElse(System.getenv("LAUNCHER_VERSION")); var info = JarVersionLookupHandler.getInfo(LauncherVersion.class);
if (vers == null) throw new RuntimeException("Missing FMLLauncher version, cannot continue"); if (info.impl().version().isEmpty())
launcherVersion = vers; throw new IllegalStateException("Failed to find version for package " + LauncherVersion.class.getPackageName() + " This is an invalid environment");
LOGGER.debug(CORE, "Found FMLLauncher version {}", launcherVersion); launcherVersion = info.impl().version().get();
LOGGER.debug(LogMarkers.CORE, "Found FMLLauncher version {}", launcherVersion);
} }
public static String getVersion() public static String getVersion() {
{
return launcherVersion; return launcherVersion;
} }
} }
@@ -1,53 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading;
import com.mojang.logging.LogUtils;
import org.slf4j.Logger;
import java.nio.file.Files;
import java.nio.file.Path;
public class LibraryFinder {
private static final Logger LOGGER = LogUtils.getLogger();
private static Path libsPath;
static Path findLibsPath() {
if (libsPath == null) {
libsPath = Path.of(System.getProperty("libraryDirectory","crazysnowmannonsense/cheezwhizz"));
if (!Files.isDirectory(libsPath)) {
throw new IllegalStateException("Missing libraryDirectory system property, cannot continue");
}
}
return libsPath;
}
static Path getForgeLibraryPath(final String mcVersion, final String forgeVersion, final String forgeGroup) {
Path forgePath = findLibsPath().resolve(MavenCoordinateResolver.get(forgeGroup, "forge", "", "universal", mcVersion+"-"+forgeVersion));
LOGGER.debug(LogMarkers.CORE, "Found forge path {} is {}", forgePath, pathStatus(forgePath));
return forgePath;
}
static String pathStatus(final Path path) {
return Files.exists(path) ? "present" : "missing";
}
static Path[] getMCPaths(final String mcVersion, final String mcpVersion, final String forgeVersion, final String forgeGroup, final String type) {
Path srgMcPath = findLibsPath().resolve(MavenCoordinateResolver.get("net.minecraft", type, "", "srg", mcVersion+"-"+mcpVersion));
Path mcExtrasPath = findLibsPath().resolve(MavenCoordinateResolver.get("net.minecraft", type, "", "extra", mcVersion+"-"+mcpVersion));
Path patchedBinariesPath = findLibsPath().resolve(MavenCoordinateResolver.get(forgeGroup, "forge", "", type, mcVersion+"-"+forgeVersion));
LOGGER.debug(LogMarkers.CORE,"SRG MC at {} is {}", srgMcPath.toString(), pathStatus(srgMcPath));
LOGGER.debug(LogMarkers.CORE,"MC Extras at {} is {}", mcExtrasPath.toString(), pathStatus(mcExtrasPath));
LOGGER.debug(LogMarkers.CORE,"Forge patches at {} is {}", patchedBinariesPath.toString(), pathStatus(patchedBinariesPath));
return new Path[] { patchedBinariesPath, mcExtrasPath, srgMcPath };
}
public static Path findPathForMaven(final String group, final String artifact, final String extension, final String classifier, final String version) {
return findLibsPath().resolve(MavenCoordinateResolver.get(group, artifact, extension, classifier, version));
}
public static Path findPathForMaven(final String maven) {
return findLibsPath().resolve(MavenCoordinateResolver.get(maven));
}
}
@@ -77,7 +77,7 @@ public class MCPNamingService implements INameMappingService {
} }
private static void loadMappings(final String mappingFileName, BiConsumer<String, String> mapStore) { private static void loadMappings(final String mappingFileName, BiConsumer<String, String> mapStore) {
URL path = ClassLoader.getSystemResource(mappingFileName); //We EXPLICITLY go through the SystemClassLoader here because this is dev-time only. And will be on the root classpath. URL path = MCPNamingService.class.getClassLoader().getResource(mappingFileName);
if (path == null) if (path == null)
return; return;
@@ -10,6 +10,8 @@ import cpw.mods.jarhandling.SecureJar;
import cpw.mods.modlauncher.api.LamdbaExceptionUtils; import cpw.mods.modlauncher.api.LamdbaExceptionUtils;
import cpw.mods.modlauncher.api.NamedPath; import cpw.mods.modlauncher.api.NamedPath;
import cpw.mods.modlauncher.serviceapi.ITransformerDiscoveryService; import cpw.mods.modlauncher.serviceapi.ITransformerDiscoveryService;
import org.jetbrains.annotations.ApiStatus;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.io.IOException; import java.io.IOException;
@@ -20,6 +22,7 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
@ApiStatus.Internal
public class ModDirTransformerDiscoverer implements ITransformerDiscoveryService { public class ModDirTransformerDiscoverer implements ITransformerDiscoveryService {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private static final Set<String> SERVICES = Set.of( private static final Set<String> SERVICES = Set.of(
@@ -76,4 +79,15 @@ public class ModDirTransformerDiscoverer implements ITransformerDiscoveryService
.filter(SERVICES::contains) .filter(SERVICES::contains)
.forEach(s -> found.add(new NamedPath(s, path))); .forEach(s -> found.add(new NamedPath(s, path)));
} }
public static boolean isServiceProvider(Path path) {
var jar = SecureJar.from(path);
for (var providers : jar.moduleDataProvider().descriptor().provides()) {
if (SERVICES.contains(providers.service()))
return true;
}
return false;
}
} }
@@ -8,8 +8,6 @@ package net.minecraftforge.fml.loading;
import com.google.common.graph.GraphBuilder; import com.google.common.graph.GraphBuilder;
import com.google.common.graph.MutableGraph; import com.google.common.graph.MutableGraph;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import cpw.mods.jarhandling.SecureJar;
import net.minecraftforge.fml.loading.moddiscovery.MinecraftLocator;
import net.minecraftforge.forgespi.language.IModInfo; import net.minecraftforge.forgespi.language.IModInfo;
import net.minecraftforge.fml.loading.EarlyLoadingException.ExceptionData; import net.minecraftforge.fml.loading.EarlyLoadingException.ExceptionData;
import net.minecraftforge.fml.loading.moddiscovery.ModFile; import net.minecraftforge.fml.loading.moddiscovery.ModFile;
@@ -21,10 +19,14 @@ import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion; import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.util.*; import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function; import java.util.function.Function;
import java.util.jar.Manifest;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import java.util.stream.Stream; import java.util.stream.Stream;
@@ -52,6 +54,9 @@ public class ModSorter
ms.buildUniqueList(); ms.buildUniqueList();
} catch (EarlyLoadingException e) { } catch (EarlyLoadingException e) {
// We cannot build any list with duped mods. We have to abort immediately and report it // We cannot build any list with duped mods. We have to abort immediately and report it
// Note this will never actually throw an error because the duplicate checks are done in ModDiscovererer before we get to this phase
// So all this is really doing is wasting time.
// But i'm leaving it here until I rewrite all of cpw's mod loading code because its such a clusterfuck.
return LoadingModList.of(ms.systemMods, ms.systemMods.stream().map(mf->(ModInfo)mf.getModInfos().get(0)).collect(toList()), e); return LoadingModList.of(ms.systemMods, ms.systemMods.stream().map(mf->(ModInfo)mf.getModInfos().get(0)).collect(toList()), e);
} }
// try and validate dependencies // try and validate dependencies
@@ -150,27 +155,13 @@ public class ModSorter
)); ));
} }
private void detectSystemMods(final Map<String, List<ModFile>> modFilesByFirstId) private void detectSystemMods(final Map<String, List<ModFile>> modFilesByFirstId) {
{
// Capture system mods (ex. MC, Forge) here, so we can keep them for later // Capture system mods (ex. MC, Forge) here, so we can keep them for later
final Set<String> systemMods = new HashSet<>(); var systemMods = List.of("minecraft", "forge");
// The minecraft mod is always a system mod
systemMods.add("minecraft");
// Find mod file from MinecraftLocator to define the system mods
modFiles.stream()
.filter(modFile -> modFile.getProvider().getClass() == MinecraftLocator.class)
.map(ModFile::getSecureJar)
.map(SecureJar::moduleDataProvider)
.map(SecureJar.ModuleDataProvider::getManifest)
.map(Manifest::getMainAttributes)
.map(mf -> mf.getValue("FML-System-Mods"))
.filter(Objects::nonNull)
.findFirst()
.ifPresent(value -> systemMods.addAll(Arrays.asList(value.split(","))));
LOGGER.debug("Configured system mods: {}", systemMods); LOGGER.debug("Configured system mods: {}", systemMods);
this.systemMods = new ArrayList<>(); this.systemMods = new ArrayList<>();
for (String systemMod : systemMods) { for (var systemMod : systemMods) {
var container = modFilesByFirstId.get(systemMod); var container = modFilesByFirstId.get(systemMod);
if (container != null && !container.isEmpty()) { if (container != null && !container.isEmpty()) {
LOGGER.debug("Found system mod: {}", systemMod); LOGGER.debug("Found system mod: {}", systemMod);
@@ -57,11 +57,17 @@ public class RuntimeDistCleaner implements ILaunchPluginService
throw new RuntimeException("Attempted to load class "+ classNode.name + " for invalid dist "+ DIST); throw new RuntimeException("Attempted to load class "+ classNode.name + " for invalid dist "+ DIST);
} }
if (!FMLEnvironment.production && hasOnlyInWithModAnnotation(classNode.visibleAnnotations))
{
LOGGER.error(DISTXFORM, "Attempted to load class {} with @Mod and @OnlyIn/@OnlyIns annotations", classNode.name);
throw new RuntimeException("Found @OnlyIn on @Mod class "+ classNode.name + " - this is not allowed as it causes crashes. Remove the OnlyIn and consider setting clientSideOnly=true in the root of your mods.toml instead");
}
if (classNode.interfaces != null ) if (classNode.interfaces != null )
{ {
unpack(classNode.visibleAnnotations).stream() unpack(classNode.visibleAnnotations).stream()
.filter(ann->Objects.equals(ann.desc, ONLYIN)) .filter(ann->Objects.equals(ann.desc, ONLYIN))
.filter(ann->ann.values.indexOf("_interface") != -1) .filter(ann-> ann.values.contains("_interface"))
.filter(ann->!Objects.equals(((String[])ann.values.get(ann.values.indexOf("value") + 1))[1], DIST)) .filter(ann->!Objects.equals(((String[])ann.values.get(ann.values.indexOf("value") + 1))[1], DIST))
.map(ann -> ((Type)ann.values.get(ann.values.indexOf("_interface") + 1)).getInternalName()) .map(ann -> ((Type)ann.values.get(ann.values.indexOf("_interface") + 1)).getInternalName())
.forEach(intf -> { .forEach(intf -> {
@@ -137,22 +143,78 @@ public class RuntimeDistCleaner implements ILaunchPluginService
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
private static List<AnnotationNode> unpack(final List<AnnotationNode> anns) { private static List<AnnotationNode> unpack(final List<AnnotationNode> anns)
if (anns == null) return Collections.emptyList(); {
List<AnnotationNode> ret = anns.stream().filter(ann->Objects.equals(ann.desc, ONLYIN)).collect(Collectors.toList()); if (anns == null)
anns.stream().filter(ann->Objects.equals(ann.desc, ONLYINS) && ann.values != null) {
.map( ann -> (List<AnnotationNode>)ann.values.get(ann.values.indexOf("value") + 1)) return Collections.emptyList();
.filter(v -> v != null) }
.forEach(v -> v.forEach(ret::add));
return ret; List<AnnotationNode> unpacked = new ArrayList<>();
for (var annotationNode : anns)
{
if (Objects.equals(annotationNode.desc, ONLYINS))
{
unpacked.add(annotationNode);
if (annotationNode.values != null)
{
List<AnnotationNode> subNodes = (List<AnnotationNode>) annotationNode.values.get(annotationNode.values.indexOf("value") + 1);
if (subNodes != null)
{
unpacked.addAll(subNodes);
}
}
}
}
return unpacked;
} }
private boolean remove(final List<AnnotationNode> anns, final String side) private boolean remove(final List<AnnotationNode> anns, final String side)
{ {
return unpack(anns).stream(). var onlyIns = unpack(anns);
filter(ann->Objects.equals(ann.desc, ONLYIN)).
filter(ann->ann.values.indexOf("_interface") == -1). for (var onlyIn : onlyIns)
anyMatch(ann -> !Objects.equals(((String[])ann.values.get(ann.values.indexOf("value")+1))[1], side)); {
if (!Objects.equals(onlyIn.desc, ONLYINS) || onlyIn.values.contains("_interface"))
{
continue;
}
if (!Objects.equals(((String[])onlyIn.values.get(onlyIn.values.indexOf("value") + 1))[1], side))
{
return true;
}
}
return false;
}
private boolean hasOnlyInWithModAnnotation(final List<AnnotationNode> anns)
{
if (anns == null)
{
return false;
}
var foundModAnnotation = false;
var foundOnlyIn = false;
for (var ann : anns)
{
if (ann.desc.equals("Lnet/minecraftforge/fml/common/Mod;"))
{
foundModAnnotation = true;
} else if (Objects.equals(ann.desc, ONLYIN) || Objects.equals(ann.desc, ONLYINS))
{
foundOnlyIn = true;
}
}
return foundModAnnotation && foundOnlyIn;
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@@ -5,42 +5,37 @@
package net.minecraftforge.fml.loading; package net.minecraftforge.fml.loading;
import com.google.common.collect.ImmutableMap;
import net.minecraftforge.fml.loading.moddiscovery.ModFile; import net.minecraftforge.fml.loading.moddiscovery.ModFile;
import org.apache.commons.lang3.text.StrLookup;
import org.apache.commons.lang3.text.StrSubstitutor;
import java.util.Map; import java.util.Map;
@SuppressWarnings("deprecation") import org.apache.commons.lang3.text.StrLookup;
public class StringSubstitutor import org.apache.commons.lang3.text.StrSubstitutor;
{
private static final Map<String,String> globals = ImmutableMap.of(
"mcVersion", FMLLoader.versionInfo().mcVersion(),
"forgeVersion", FMLLoader.versionInfo().forgeVersion()
);
@SuppressWarnings("deprecation")
public class StringSubstitutor {
public static String replace(final String in, final ModFile file) { public static String replace(final String in, final ModFile file) {
return new StrSubstitutor(getStringLookup(file)).replace(in); return new StrSubstitutor(getStringLookup(file)).replace(in);
} }
private static StrLookup<String> getStringLookup(final ModFile file) { private static StrLookup<String> getStringLookup(final ModFile file) {
return new StrLookup<String>() var globals = Map.of(
{ "mcVersion", FMLLoader.versionInfo().mcVersion(),
"forgeVersion", FMLLoader.versionInfo().forgeVersion()
);
return new StrLookup<String>() {
@Override @Override
public String lookup(String key) public String lookup(String key) {
{ var parts = key.split("\\.");
final String[] parts = key.split("\\."); if (parts.length == 1)
if (parts.length == 1) return key; return key;
final String pfx = parts[0]; var pfx = parts[0];
if ("global".equals(pfx)) if ("global".equals(pfx))
{
return globals.get(parts[1]); return globals.get(parts[1]);
}
else if ("file".equals(pfx) && file != null) else if ("file".equals(pfx) && file != null)
{
return String.valueOf(file.getSubstitutionMap().get().get(parts[1])); return String.valueOf(file.getSubstitutionMap().get().get(parts[1]));
}
return key; return key;
} }
}; };
@@ -5,18 +5,45 @@
package net.minecraftforge.fml.loading; package net.minecraftforge.fml.loading;
import java.util.Map; import java.io.IOException;
import java.io.InputStreamReader;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonSyntaxException;
/** TODO: [FML][Loader] Remove VersionInfo - we shouldn't need to base any decisions on forge or mc version info at the loader level. So once I get a proper replacement i'm gunna kill this. */
public record VersionInfo(String forgeVersion, String mcVersion, String mcpVersion, String forgeGroup) { public record VersionInfo(String forgeVersion, String mcVersion, String mcpVersion, String forgeGroup) {
VersionInfo(Map<String, ?> arguments) {
this((String) arguments.get("forgeVersion"), (String) arguments.get("mcVersion"), (String) arguments.get("mcpVersion"), (String) arguments.get("forgeGroup"));
}
public String mcAndForgeVersion() { public String mcAndForgeVersion() {
return mcVersion+"-"+forgeVersion; return mcVersion + "-" + forgeVersion;
} }
public String mcAndMCPVersion() { public String mcAndMCPVersion() {
return mcVersion + "-" + mcpVersion; return mcVersion + "-" + mcpVersion;
} }
/*==========================================================================*
* INTERNAL SHIT *
*==========================================================================*/
private static final Gson GSON = new GsonBuilder().create();
private static <T> T readJson(String path, Class<T> type) {
try (var is = VersionInfo.class.getResourceAsStream(path)) {
if (is == null)
return null;
try (var reader = new InputStreamReader(is)) {
return GSON.fromJson(reader, type);
}
} catch (IOException | JsonSyntaxException e) {
throw new IllegalStateException("Failed to parse version info from " + path , e);
}
}
static VersionInfo detect() {
var forge = readJson("/forge_version.json", JSON.class);
if (forge == null)
throw new IllegalStateException("Failed to find /forge_version.json This is a critical issue");
return new VersionInfo(forge.forge(), forge.mc(), forge.mcp(), "net.minecraftforge");
}
private record JSON(String forge, String mcp, String mc) {}
} }
@@ -18,7 +18,7 @@ import java.util.function.BiPredicate;
public class VersionSupportMatrix { public class VersionSupportMatrix {
private static final HashMap<String, List<ArtifactVersion>> overrideVersions = new HashMap<>(); private static final HashMap<String, List<ArtifactVersion>> overrideVersions = new HashMap<>();
static { static {
final ArtifactVersion version = new DefaultArtifactVersion(FMLLoader.versionInfo().mcVersion()); final ArtifactVersion version = new DefaultArtifactVersion(FMLLoader.versionInfo().mcVersion());
if (MavenVersionAdapter.createFromVersionSpec("[1.19.2]").containsVersion(version)) { if (MavenVersionAdapter.createFromVersionSpec("[1.19.2]").containsVersion(version)) {
// 1.19.2 is Compatible with 1.19.1 // 1.19.2 is Compatible with 1.19.1
add("languageloader.javafml", "42"); add("languageloader.javafml", "42");
@@ -31,7 +31,7 @@ public class VersionSupportMatrix {
} }
public static <T> boolean testVersionSupportMatrix(VersionRange declaredRange, String lookupId, String type, BiPredicate<String, VersionRange> standardLookup) { public static <T> boolean testVersionSupportMatrix(VersionRange declaredRange, String lookupId, String type, BiPredicate<String, VersionRange> standardLookup) {
if (standardLookup.test(lookupId, declaredRange)) return true; if (standardLookup.test(lookupId, declaredRange)) return true;
List<ArtifactVersion> custom = overrideVersions.get(type +"." +lookupId); List<ArtifactVersion> custom = overrideVersions.get(type + "." + lookupId);
return custom == null ? false : custom.stream().anyMatch(declaredRange::containsVersion); return custom == null ? false : custom.stream().anyMatch(declaredRange::containsVersion);
} }
} }
@@ -1,52 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import com.mojang.logging.LogUtils;
import net.minecraftforge.forgespi.locating.IDependencyLocator;
import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.ModFileLoadingException;
import org.slf4j.Logger;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Optional;
public abstract class AbstractJarFileDependencyLocator extends AbstractJarFileModProvider implements IDependencyLocator
{
private static final Logger LOGGER = LogUtils.getLogger();
protected Optional<InputStream> loadResourceFromModFile(final IModFile modFile, final Path path) {
try {
return Optional.of(Files.newInputStream(modFile.findResource(path.toString())));
}
catch (final FileNotFoundException e) {
LOGGER.debug("Failed to load resource {} from {}, it does not contain dependency information.", path, modFile.getFileName());
return Optional.empty();
}
catch (final Exception e) {
LOGGER.error("Failed to load resource {} from mod {}, cause {}", path, modFile.getFileName(), e);
return Optional.empty();
}
}
protected Optional<IModFile> loadModFileFrom(final IModFile file, final Path path) {
try {
final Path pathInModFile = file.findResource(path.toString());
return Optional.of(createMod(pathInModFile).file());
}
catch (Exception e) {
LOGGER.error("Failed to load mod file {} from {}", path, file.getFileName());
throw new ModFileLoadingException("Failed to load mod file "+file.getFileName());
}
}
protected String identifyMod(final IModFile modFile) {
return modFile.getFileName();
}
}
@@ -1,23 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import net.minecraftforge.forgespi.locating.IModLocator;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;
public abstract class AbstractJarFileModLocator extends AbstractJarFileModProvider implements IModLocator
{
@Override
public List<IModLocator.ModFileOrException> scanMods()
{
return scanCandidates().map(this::createMod).toList();
}
public abstract Stream<Path> scanCandidates();
}
@@ -1,36 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import com.mojang.logging.LogUtils;
import cpw.mods.jarhandling.SecureJar;
import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.forgespi.locating.IModFile;
import org.slf4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Stream;
public abstract class AbstractJarFileModProvider extends AbstractModProvider
{
private static final Logger LOGGER = LogUtils.getLogger();
@Override
public void scanFile(final IModFile file, final Consumer<Path> pathConsumer) {
LOGGER.debug(LogMarkers.SCAN,"Scan started: {}", file);
final Function<Path, SecureJar.Status> status = p->file.getSecureJar().verifyPath(p);
try (Stream<Path> files = Files.find(file.getSecureJar().getRootPath(), Integer.MAX_VALUE, (p, a) -> p.getNameCount() > 0 && p.getFileName().toString().endsWith(".class"))) {
file.setSecurityStatus(files.peek(pathConsumer).map(status).reduce((s1, s2)-> SecureJar.Status.values()[Math.min(s1.ordinal(), s2.ordinal())]).orElse(SecureJar.Status.INVALID));
} catch (IOException e) {
e.printStackTrace();
}
LOGGER.debug(LogMarkers.SCAN,"Scan finished: {}", file);
}
}
@@ -16,26 +16,34 @@ import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.IModLocator; import net.minecraftforge.forgespi.locating.IModLocator;
import net.minecraftforge.forgespi.locating.IModProvider; import net.minecraftforge.forgespi.locating.IModProvider;
import net.minecraftforge.forgespi.locating.ModFileLoadingException; import net.minecraftforge.forgespi.locating.ModFileLoadingException;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional; import java.util.Optional;
import java.util.function.Function; import java.util.function.Consumer;
import java.util.jar.Manifest; import java.util.jar.JarFile;
@ApiStatus.Internal
public abstract class AbstractModProvider implements IModProvider { public abstract class AbstractModProvider implements IModProvider {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
protected static final String MODS_TOML = "META-INF/mods.toml"; protected static final String MODS_TOML = "META-INF/mods.toml";
protected static final String MANIFEST = "META-INF/MANIFEST.MF";
protected IModLocator.ModFileOrException createMod(Path... path) { protected IModLocator.ModFileOrException createMod(Path path) {
return createMod(path, false);
}
@Nullable
protected IModLocator.ModFileOrException createMod(Path path, boolean ignoreUnknown) {
var mjm = new ModJarMetadata(); var mjm = new ModJarMetadata();
var sj = SecureJar.from( var sj = SecureJar.from(
Manifest::new,
jar -> jar.moduleDataProvider().findFile(MODS_TOML).isPresent() ? mjm : JarMetadata.from(jar, path), jar -> jar.moduleDataProvider().findFile(MODS_TOML).isPresent() ? mjm : JarMetadata.from(jar, path),
path path
); );
@@ -48,19 +56,25 @@ public abstract class AbstractModProvider implements IModProvider {
if (sj.moduleDataProvider().findFile(MODS_TOML).isPresent()) { if (sj.moduleDataProvider().findFile(MODS_TOML).isPresent()) {
LOGGER.debug(LogMarkers.SCAN, "Found {} mod of type {}: {}", MODS_TOML, type, path); LOGGER.debug(LogMarkers.SCAN, "Found {} mod of type {}: {}", MODS_TOML, type, path);
mod = new ModFile(sj, this, ModFileParser::modsTomlParser); mod = new ModFile(sj, this, ModFileParser::modsTomlParser);
if (mod.getModFileInfo().getFileProperties().containsKey(ModFileInfo.NOT_A_FORGE_MOD_PROP)) {
LOGGER.error(LogMarkers.SCAN, "Unable to load file \"{}\" because its mods.toml is requesting an invalid javafml loaderVersion (use \"*\" if you want to allow all versions) and is missing a forge modId dependency declaration (see the sample mods.toml in the MDK).", path);
return new IModLocator.ModFileOrException(null, new ModFileLoadingException("File \"%s\" is not a Forge mod and cannot be loaded. Look for a Forge version of this mod or consider alternative mods.".formatted(mod.getFileName())));
}
} else if (type != null) { } else if (type != null) {
LOGGER.debug(LogMarkers.SCAN, "Found {} mod of type {}: {}", MANIFEST, type, path); LOGGER.debug(LogMarkers.SCAN, "Found {} mod of type {}: {}", JarFile.MANIFEST_NAME, type, path);
mod = new ModFile(sj, this, this::manifestParser, type); mod = new ModFile(sj, this, this::manifestParser, type);
} else if (ignoreUnknown) {
return null;
} else } else
return new IModLocator.ModFileOrException(null, new ModFileLoadingException("Invalid mod file found " + Arrays.toString(path))); return new IModLocator.ModFileOrException(null, new ModFileLoadingException("Invalid mod file found " + path));
mjm.setModFile(mod); mjm.setModFile(mod);
return new IModLocator.ModFileOrException(mod, null); return new IModLocator.ModFileOrException(mod, null);
} }
protected IModFileInfo manifestParser(final IModFile mod) { protected IModFileInfo manifestParser(final IModFile mod) {
Function<String, Optional<String>> cfg = name -> Optional.ofNullable(mod.getSecureJar().moduleDataProvider().getManifest().getMainAttributes().getValue(name)); var mf = mod.getSecureJar().moduleDataProvider().getManifest().getMainAttributes();
var license = cfg.apply("LICENSE").orElse(""); var license = mf.getValue("LICENSE");
var dummy = new IConfigurable() { var dummy = new IConfigurable() {
@Override @Override
public <T> Optional<T> getConfigElement(String... key) { public <T> Optional<T> getConfigElement(String... key) {
@@ -72,7 +86,7 @@ public abstract class AbstractModProvider implements IModProvider {
} }
}; };
return new DefaultModFileInfo(mod, license, dummy); return new DefaultModFileInfo(mod, license == null ? "" : license, dummy);
} }
@Override @Override
@@ -80,16 +94,57 @@ public abstract class AbstractModProvider implements IModProvider {
return true; return true;
} }
@Override
public void initArguments(final Map<String, ?> arguments) {
}
protected String getDefaultJarModType() { protected String getDefaultJarModType() {
return null; return null;
} }
@Override
public void scanFile(IModFile file, Consumer<Path> pathConsumer) {
LOGGER.debug(LogMarkers.SCAN, "Scan started: {}", file);
var jar = file.getSecureJar();
var root = jar.getRootPath();
Consumer<Path> consumer = pathConsumer;
//TODO: [SecureJar] Actually redesign this to have a proper validation.
var holder = new Holder<SecureJar.Status>();
holder.value = SecureJar.Status.NONE;
if (jar.hasSecurityData()) {
consumer = path -> {
pathConsumer.accept(path);
var status = jar.verifyPath(path);
if (status.ordinal() < holder.value.ordinal())
holder.value = status;
};
}
try (var files = Files.walk(root)) {
files
.filter(p -> p.toString().endsWith(".class"))
.forEach(consumer);
file.setSecurityStatus(holder.value);
} catch (IOException e) {
e.printStackTrace();
}
LOGGER.debug(LogMarkers.SCAN, "Scan finished: {}", file);
}
private static final class Holder<T> {
T value;
}
private record DefaultModFileInfo(IModFile mod, String license, IConfigurable configurable) implements IModFileInfo, IConfigurable { private record DefaultModFileInfo(IModFile mod, String license, IConfigurable configurable) implements IModFileInfo, IConfigurable {
@Override public <T> Optional<T> getConfigElement(final String... strings) { return Optional.empty(); } @Override public <T> Optional<T> getConfigElement(final String... strings) { return Optional.empty(); }
@Override public List<? extends IConfigurable> getConfigList(final String... strings) { return null; } @Override public List<? extends IConfigurable> getConfigList(final String... strings) { return null; }
@Override public List<IModInfo> getMods() { return Collections.emptyList(); } @Override public List<IModInfo> getMods() { return Collections.emptyList(); }
@Override public List<LanguageSpec> requiredLanguageLoaders() { return Collections.emptyList(); } @Override public List<LanguageSpec> requiredLanguageLoaders() { return Collections.emptyList(); }
@Override public boolean showAsResourcePack() { return false; } @Override public boolean showAsResourcePack() { return false; }
@Override public boolean showAsDataPack() { return false; }
@Override public Map<String, Object> getFileProperties() { return Collections.emptyMap(); } @Override public Map<String, Object> getFileProperties() { return Collections.emptyMap(); }
@Override public String getLicense() { return license; } @Override public String getLicense() { return license; }
@Override public IModFile getFile() { return mod; } @Override public IModFile getFile() { return mod; }
@@ -5,68 +5,113 @@
package net.minecraftforge.fml.loading.moddiscovery; package net.minecraftforge.fml.loading.moddiscovery;
import net.minecraftforge.fml.loading.ClasspathLocatorUtils;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import net.minecraftforge.fml.loading.LogMarkers; import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.fml.loading.ModDirTransformerDiscoverer;
import net.minecraftforge.forgespi.locating.IModLocator;
import org.jetbrains.annotations.ApiStatus;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.net.URI;
import java.net.URL; import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Collections;
import java.util.Enumeration; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.jar.Attributes;
import java.util.stream.Stream; import java.util.jar.JarFile;
import java.util.jar.Manifest;
public class ClasspathLocator extends AbstractJarFileModLocator { @ApiStatus.Internal
public class ClasspathLocator extends AbstractModProvider implements IModLocator {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private final List<Path> legacyClasspath = Arrays.stream(System.getProperty("legacyClassPath", "").split(File.pathSeparator)).map(Path::of).toList(); private static final Attributes.Name MOD_TYPE = new Attributes.Name("FMLModType");
private boolean enabled = false;
@Override @Override
public String name() { public String name() {
return "userdev classpath"; return "classpath";
} }
@Override @Override
public Stream<Path> scanCandidates() { public List<ModFileOrException> scanMods() {
if (!enabled) //var cl = ClassLoader.getSystemClassLoader();
return Stream.of(); var cl = getClass().getClassLoader();
try { // Find 'minecraft' during dev time this is also Forge. So skip it.
var claimed = new ArrayList<>(legacyClasspath); // Can return null for dedicated server as Minecraft isn't on the classpath
var paths = Stream.<Path>builder(); // On the client it doesn't matter as it's the vanilla jar so wouldnt have mods.toml in it.
var minecraft = getPathFromResource(cl, "net/minecraft/obfuscate/DontObfuscate.class");
findPaths(claimed, MODS_TOML).forEach(paths::add); var claimed = new HashSet<Path>();
findPaths(claimed, MANIFEST).forEach(paths::add); var tomls = getUrls(cl, MODS_TOML);
for (var url : tomls) {
return paths.build(); var path = getPath(url, MODS_TOML);
} catch (IOException e) { if (!path.equals(minecraft))
LOGGER.error(LogMarkers.SCAN, "Error trying to find resources", e); claimed.add(path);
throw new RuntimeException(e);
} }
}
private List<Path> findPaths(List<Path> claimed, String resource) throws IOException { var manifests = getUrls(cl, JarFile.MANIFEST_NAME);
var ret = new ArrayList<Path>(); for (var url : manifests) {
final Enumeration<URL> resources = ClassLoader.getSystemClassLoader().getResources(resource); var path = getPath(url, JarFile.MANIFEST_NAME);
while (resources.hasMoreElements()) { if (claimed.contains(path))
URL url = resources.nextElement();
Path path = ClasspathLocatorUtils.findJarPathFor(resource, resource, url);
if (claimed.stream().anyMatch(path::equals) || !Files.exists(path) || Files.isDirectory(path))
continue; continue;
ret.add(path);
try (var is = url.openStream()) {
var mf = new Manifest(is);
var type = mf.getMainAttributes().getValue(MOD_TYPE);
if (type != null)
claimed.add(path);
} catch (IOException e) {
LOGGER.warn(LogMarkers.SCAN, "Error reading manifest from: " + url, e);
}
}
var ret = new ArrayList<ModFileOrException>();
for (var path : claimed) {
// Filter out anything found by the ServiceLoader
if (!ModDirTransformerDiscoverer.isServiceProvider(path))
ret.add(createMod(path));
} }
return ret; return ret;
} }
@Override private List<URL> getUrls(ClassLoader cl, String resource) {
public void initArguments(Map<String, ?> arguments) { try {
var launchTarget = (String) arguments.get("launchTarget"); var lst = Collections.list(cl.getResources(resource));
enabled = launchTarget != null && launchTarget.contains("dev"); if (LOGGER.isDebugEnabled(LogMarkers.SCAN)) {
Collections.sort(lst, (a, b) -> a.toString().compareTo(b.toString()));
LOGGER.debug(LogMarkers.SCAN, "Scanning Classloader: {} for {}", cl, resource);
for (var url : lst)
LOGGER.debug(LogMarkers.SCAN, "\t{}", url);
}
return lst;
} catch (IOException e) {
LOGGER.warn(LogMarkers.SCAN, "Error finding resources for: " + resource, e);
return List.of();
}
}
private static Path getPath(URL url, String resource) {
var str = url.toString();
int len = resource.length();
if ("jar".equalsIgnoreCase(url.getProtocol())) {
str = url.getFile();
len += 2;
}
str = str.substring(0, str.length() - len);
var path = Paths.get(URI.create(str));
return path;
}
private static Path getPathFromResource(ClassLoader cl, String resource) {
var url = cl.getResource(resource);
if (url == null)
return null;
return getPath(url, resource);
} }
} }
@@ -12,6 +12,9 @@ import java.io.Reader;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.Internal
public class CoreModFile implements ICoreModFile { public class CoreModFile implements ICoreModFile {
private final Path internalPath; private final Path internalPath;
private final ModFile file; private final ModFile file;
@@ -1,78 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import com.mojang.logging.LogUtils;
import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.IModLocator;
import org.slf4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class ExplodedDirectoryLocator implements IModLocator {
private static final Logger LOGGER = LogUtils.getLogger();
public record ExplodedMod(String modid, List<Path> paths) {}
private final List<ExplodedMod> explodedMods = new ArrayList<>();
private final Map<ExplodedMod, IModFile> mods = new HashMap<>();
@Override
public List<IModLocator.ModFileOrException> scanMods() {
explodedMods.forEach(explodedMod ->
ModJarMetadata.buildFile(this,
jar->jar.moduleDataProvider().findFile("/META-INF/mods.toml").isPresent(),
null,
explodedMod.paths().toArray(Path[]::new))
.ifPresentOrElse(f->mods.put(explodedMod, f), () -> LOGGER.warn(LogMarkers.LOADING, "Failed to find exploded resource mods.toml in directory {}", explodedMod.paths().get(0).toString())));
return mods.values().stream().map(mf->new IModLocator.ModFileOrException(mf, null)).toList();
}
@Override
public String name() {
return "exploded directory";
}
@Override
public void scanFile(final IModFile file, final Consumer<Path> pathConsumer) {
LOGGER.debug(LogMarkers.SCAN,"Scanning exploded directory {}", file.getFilePath().toString());
try (Stream<Path> files = Files.find(file.getSecureJar().getRootPath(), Integer.MAX_VALUE, (p, a) -> p.getNameCount() > 0 && p.getFileName().toString().endsWith(".class"))) {
files.forEach(pathConsumer);
} catch (IOException e) {
e.printStackTrace();
}
LOGGER.debug(LogMarkers.SCAN,"Exploded directory scan complete {}", file.getFilePath().toString());
}
@Override
public String toString()
{
return "{ExplodedDir locator}";
}
@SuppressWarnings("unchecked")
@Override
public void initArguments(final Map<String, ?> arguments) {
final var explodedTargets = ((Map<String, List<ExplodedMod>>) arguments).get("explodedTargets");
if (explodedTargets != null && !explodedTargets.isEmpty()) {
explodedMods.addAll(explodedTargets);
}
}
@Override
public boolean isValid(final IModFile modFile) {
return true;
}
}
@@ -12,10 +12,12 @@ import java.nio.file.Path;
import java.util.Arrays; import java.util.Arrays;
import java.util.Optional; import java.util.Optional;
import java.util.function.BiPredicate; import java.util.function.BiPredicate;
import java.util.stream.Stream;
import java.util.zip.ZipFile; import java.util.zip.ZipFile;
import static cpw.mods.modlauncher.api.LamdbaExceptionUtils.*; import static cpw.mods.modlauncher.api.LamdbaExceptionUtils.*;
// TODO: [FML][Loader] By the time this is reached, most stuff this checks for is already filtered out - needs fixing.
public enum InvalidModIdentifier { public enum InvalidModIdentifier {
OLDFORGE(filePresent("mcmod.info")), OLDFORGE(filePresent("mcmod.info")),
@@ -23,9 +25,9 @@ public enum InvalidModIdentifier {
LITELOADER(filePresent("litemod.json")), LITELOADER(filePresent("litemod.json")),
OPTIFINE(filePresent("optifine/Installer.class")), OPTIFINE(filePresent("optifine/Installer.class")),
BUKKIT(filePresent("plugin.yml")), BUKKIT(filePresent("plugin.yml")),
INVALIDZIP((f,zf) -> !zf.isPresent()); INVALIDZIP((f,zf) -> zf.isEmpty()); // note: only this one INVALIDZIP check is ran until the todo on this class is fixed
private BiPredicate<Path, Optional<ZipFile>> ident; private final BiPredicate<Path, Optional<ZipFile>> ident;
InvalidModIdentifier(BiPredicate<Path, Optional<ZipFile>> identifier) InvalidModIdentifier(BiPredicate<Path, Optional<ZipFile>> identifier)
{ {
@@ -40,7 +42,7 @@ public enum InvalidModIdentifier {
public static Optional<String> identifyJarProblem(Path path) public static Optional<String> identifyJarProblem(Path path)
{ {
Optional<ZipFile> zfo = optionalFromException(() -> new ZipFile(path.toFile())); Optional<ZipFile> zfo = optionalFromException(() -> new ZipFile(path.toFile()));
Optional<String> result = Arrays.stream(values()). Optional<String> result = Stream.of(INVALIDZIP).
filter(i -> i.ident.test(path, zfo)). filter(i -> i.ident.test(path, zfo)).
map(InvalidModIdentifier::getReason). map(InvalidModIdentifier::getReason).
findAny(); findAny();
@@ -10,17 +10,21 @@ import com.google.common.collect.Lists;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import net.minecraftforge.fml.loading.EarlyLoadingException; import net.minecraftforge.fml.loading.EarlyLoadingException;
import net.minecraftforge.forgespi.language.IModInfo; import net.minecraftforge.forgespi.language.IModInfo;
import net.minecraftforge.forgespi.locating.IDependencyLocator;
import net.minecraftforge.forgespi.locating.IModFile; import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.ModFileLoadingException; import net.minecraftforge.forgespi.locating.ModFileLoadingException;
import net.minecraftforge.jarjar.selection.JarSelector; import net.minecraftforge.jarjar.selection.JarSelector;
import org.apache.maven.artifact.versioning.ArtifactVersion; import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.VersionRange; import org.apache.maven.artifact.versioning.VersionRange;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.io.InputStream;
import java.net.URI; import java.net.URI;
import java.nio.file.FileSystem; import java.nio.file.FileSystem;
import java.nio.file.FileSystems; import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.Collection; import java.util.Collection;
import java.util.Collections; import java.util.Collections;
@@ -30,26 +34,35 @@ import java.util.Optional;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import java.util.stream.Stream; import java.util.stream.Stream;
public class JarInJarDependencyLocator extends AbstractJarFileDependencyLocator @ApiStatus.Internal
{ public class JarInJarDependencyLocator extends AbstractModProvider implements IDependencyLocator {
private static final String COLOR_CODE = "\u00a7";
private static final String RESET = COLOR_CODE + "r";
private static final String YELLOW = COLOR_CODE + "e";
private static final String RED = COLOR_CODE + "4";
private static final String GREEN = COLOR_CODE + "2";
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
@Override @Override
public String name() public String name() {
{
return "JarInJar"; return "JarInJar";
} }
@Override @Override
public List<IModFile> scanMods(final Iterable<IModFile> loadedMods) public List<IModFile> scanMods(Iterable<IModFile> loadedMods) {
{
final List<IModFile> sources = Lists.newArrayList(); final List<IModFile> sources = Lists.newArrayList();
loadedMods.forEach(sources::add); loadedMods.forEach(sources::add);
final List<IModFile> dependenciesToLoad = JarSelector.detectAndSelect(sources, this::loadResourceFromModFile, this::loadModFileFrom, this::identifyMod, this::exception); var dependenciesToLoad = JarSelector.detectAndSelect(
sources,
this::loadResourceFromModFile,
this::loadModFileFrom,
this::identifyMod,
this::exception
);
if (dependenciesToLoad.isEmpty()) if (dependenciesToLoad.isEmpty()) {
{
LOGGER.info("No dependencies to load found. Skipping!"); LOGGER.info("No dependencies to load found. Skipping!");
return Collections.emptyList(); return Collections.emptyList();
} }
@@ -59,43 +72,27 @@ public class JarInJarDependencyLocator extends AbstractJarFileDependencyLocator
} }
@Override @Override
public void initArguments(final Map<String, ?> arguments) protected String getDefaultJarModType() {
{
// NO-OP, for now
}
@Override
protected String getDefaultJarModType()
{
return IModFile.Type.GAMELIBRARY.name(); return IModFile.Type.GAMELIBRARY.name();
} }
@SuppressWarnings("resource") protected Optional<IModFile> loadModFileFrom(IModFile file, Path path) {
@Override try {
protected Optional<IModFile> loadModFileFrom(final IModFile file, final Path path)
{
try
{
final Path pathInModFile = file.findResource(path.toString()); final Path pathInModFile = file.findResource(path.toString());
final URI filePathUri = new URI("jij:" + (pathInModFile.toAbsolutePath().toUri().getRawSchemeSpecificPart())).normalize(); final URI filePathUri = new URI("jij:" + (pathInModFile.toAbsolutePath().toUri().getRawSchemeSpecificPart())).normalize();
final Map<String, ?> outerFsArgs = ImmutableMap.of("packagePath", pathInModFile); final Map<String, ?> outerFsArgs = ImmutableMap.of("packagePath", pathInModFile);
final FileSystem zipFS = FileSystems.newFileSystem(filePathUri, outerFsArgs); final FileSystem zipFS = FileSystems.newFileSystem(filePathUri, outerFsArgs);
final Path pathInFS = zipFS.getPath("/"); final Path pathInFS = zipFS.getPath("/");
return Optional.of(createMod(pathInFS).file()); return Optional.of(createMod(pathInFS).file());
} } catch (Exception e) {
catch (Exception e)
{
LOGGER.error("Failed to load mod file {} from {}", path, file.getFileName()); LOGGER.error("Failed to load mod file {} from {}", path, file.getFileName());
final RuntimeException exception = new ModFileLoadingException("Failed to load mod file " + file.getFileName()); final RuntimeException exception = new ModFileLoadingException("Failed to load mod file " + file.getFileName());
exception.initCause(e); exception.initCause(e);
throw exception; throw exception;
} }
} }
protected EarlyLoadingException exception(Collection<JarSelector.ResolutionFailureInformation<IModFile>> failedDependencies) protected EarlyLoadingException exception(Collection<JarSelector.ResolutionFailureInformation<IModFile>> failedDependencies) {
{
final List<EarlyLoadingException.ExceptionData> errors = failedDependencies.stream() final List<EarlyLoadingException.ExceptionData> errors = failedDependencies.stream()
.filter(entry -> !entry.sources().isEmpty()) //Should never be the case, but just to be sure .filter(entry -> !entry.sources().isEmpty()) //Should never be the case, but just to be sure
.map(this::buildExceptionData) .map(this::buildExceptionData)
@@ -105,8 +102,7 @@ public class JarInJarDependencyLocator extends AbstractJarFileDependencyLocator
} }
@NotNull @NotNull
private EarlyLoadingException.ExceptionData buildExceptionData(final JarSelector.ResolutionFailureInformation<IModFile> entry) private EarlyLoadingException.ExceptionData buildExceptionData(JarSelector.ResolutionFailureInformation<IModFile> entry) {
{
return new EarlyLoadingException.ExceptionData( return new EarlyLoadingException.ExceptionData(
getErrorTranslationKey(entry), getErrorTranslationKey(entry),
entry.identifier().group() + ":" + entry.identifier().artifact(), entry.identifier().group() + ":" + entry.identifier().artifact(),
@@ -119,16 +115,14 @@ public class JarInJarDependencyLocator extends AbstractJarFileDependencyLocator
} }
@NotNull @NotNull
private String getErrorTranslationKey(final JarSelector.ResolutionFailureInformation<IModFile> entry) private String getErrorTranslationKey(JarSelector.ResolutionFailureInformation<IModFile> entry) {
{
return entry.failureReason() == JarSelector.FailureReason.VERSION_RESOLUTION_FAILED ? return entry.failureReason() == JarSelector.FailureReason.VERSION_RESOLUTION_FAILED ?
"fml.dependencyloading.conflictingdependencies" : "fml.dependencyloading.conflictingdependencies" :
"fml.dependencyloading.mismatchedcontaineddependencies"; "fml.dependencyloading.mismatchedcontaineddependencies";
} }
@NotNull @NotNull
private Stream<ModWithVersionRange> getModWithVersionRangeStream(final JarSelector.SourceWithRequestedVersionRange<IModFile> file) private Stream<ModWithVersionRange> getModWithVersionRangeStream(JarSelector.SourceWithRequestedVersionRange<IModFile> file) {
{
return file.sources() return file.sources()
.stream() .stream()
.map(IModFile::getModFileInfo) .map(IModFile::getModFileInfo)
@@ -136,23 +130,37 @@ public class JarInJarDependencyLocator extends AbstractJarFileDependencyLocator
.map(modInfo -> new ModWithVersionRange(modInfo, file.requestedVersionRange(), file.includedVersion())); .map(modInfo -> new ModWithVersionRange(modInfo, file.requestedVersionRange(), file.includedVersion()));
} }
@NotNull protected Optional<InputStream> loadResourceFromModFile(IModFile modFile, Path path) {
private String formatError(final ModWithVersionRange modWithVersionRange) try {
{ var pathInModFile = modFile.findResource(path.toString());
return "\u00a7e" + modWithVersionRange.modInfo().getModId() + "\u00a7r - \u00a74" + modWithVersionRange.versionRange().toString() + "\u00a74 - \u00a72" + modWithVersionRange.artifactVersion().toString() + "\u00a72"; if (!Files.exists(pathInModFile)) {
} LOGGER.debug("Failed to load resource {} from {}, it does not contain dependency information.", path, modFile.getFileName());
return Optional.empty();
@Override }
protected String identifyMod(final IModFile modFile) return Optional.of(Files.newInputStream(pathInModFile));
{ } catch (Exception e) {
if (modFile.getModFileInfo() == null || modFile.getModInfos().isEmpty()) LOGGER.error("Failed to load resource {} from mod {}, cause {}", path, modFile.getFileName(), e);
{ return Optional.empty();
return modFile.getFileName();
} }
return modFile.getModInfos().stream().map(IModInfo::getModId).collect(Collectors.joining());
} }
private record ModWithVersionRange(IModInfo modInfo, VersionRange versionRange, ArtifactVersion artifactVersion) @NotNull
{} private String formatError(ModWithVersionRange modWithVersionRange){
return YELLOW + modWithVersionRange.modInfo().getModId() + RESET + " - " +
RED + modWithVersionRange.versionRange().toString() + RESET + " - " +
GREEN + modWithVersionRange.artifactVersion().toString() + RESET;
}
protected String identifyMod(IModFile modFile) {
if (modFile.getModFileInfo() != null && !modFile.getModInfos().isEmpty())
return modFile.getModInfos().stream().map(IModInfo::getModId).collect(Collectors.joining());
var module = modFile.getSecureJar().moduleDataProvider().name();
if (module != null && !module.isEmpty())
return module;
return modFile.getFileName();
}
private record ModWithVersionRange(IModInfo modInfo, VersionRange versionRange, ArtifactVersion artifactVersion) {}
} }
@@ -1,49 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import net.minecraftforge.fml.loading.FMLPaths;
import net.minecraftforge.fml.loading.MavenCoordinateResolver;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class MavenDirectoryLocator extends AbstractJarFileModLocator
{
private List<Path> modCoords;
@Override
public Stream<Path> scanCandidates() {
return modCoords.stream();
}
@Override
public String name() {
return "maven libs";
}
public String toString() {
return "{Maven Directory locator for mods "+this.modCoords+"}";
}
@SuppressWarnings("unchecked")
@Override
public void initArguments(final Map<String, ?> arguments) {
final List<String> mavenRoots = (List<String>) arguments.get("mavenRoots");
final List<Path> mavenRootPaths = mavenRoots.stream().map(n -> FMLPaths.GAMEDIR.get().resolve(n)).collect(Collectors.toList());
final List<String> mods = (List<String>) arguments.get("mods");
final List<String> listedMods = ModListHandler.processModLists((List<String>) arguments.get("modLists"), mavenRootPaths);
List<Path> localModCoords = Stream.concat(mods.stream(),listedMods.stream()).map(MavenCoordinateResolver::get).collect(Collectors.toList());
// find the modCoords path in each supplied maven path, and turn it into a mod file. (skips not found files)
this.modCoords = localModCoords.stream().map(mc -> mavenRootPaths.stream().map(root -> root.resolve(mc)).filter(path -> Files.exists(path)).findFirst().orElseThrow(() -> new IllegalArgumentException("Failed to locate requested mod coordinate " + mc))).collect(Collectors.toList());
}
}
@@ -6,62 +6,36 @@
package net.minecraftforge.fml.loading.moddiscovery; package net.minecraftforge.fml.loading.moddiscovery;
import com.electronwill.nightconfig.core.Config; import com.electronwill.nightconfig.core.Config;
import com.mojang.logging.LogUtils;
import cpw.mods.jarhandling.SecureJar; import cpw.mods.jarhandling.SecureJar;
import net.minecraftforge.fml.loading.FMLLoader; import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.forgespi.language.IModFileInfo; import net.minecraftforge.forgespi.language.IModFileInfo;
import net.minecraftforge.forgespi.locating.IModFile; import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.IModLocator; import net.minecraftforge.forgespi.locating.IModLocator;
import net.minecraftforge.forgespi.locating.ModFileFactory; import net.minecraftforge.forgespi.locating.ModFileFactory;
import org.slf4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class MinecraftLocator extends AbstractModProvider implements IModLocator import org.jetbrains.annotations.ApiStatus;
{
private static final Logger LOGGER = LogUtils.getLogger();
@ApiStatus.Internal
public class MinecraftLocator extends AbstractModProvider implements IModLocator {
@Override @Override
public List<IModLocator.ModFileOrException> scanMods() { public List<IModLocator.ModFileOrException> scanMods() {
final var launchHandler = FMLLoader.getLaunchHandler(); var minecraft = FMLLoader.getLaunchHandler().getMinecraftPaths();
var baseMC = launchHandler.getMinecraftPaths();
var mcjar = ModJarMetadata.buildFile(j->ModFileFactory.FACTORY.build(j, this, this::buildMinecraftTOML), j->true, baseMC.minecraftFilter(), baseMC.minecraftPaths().toArray(Path[]::new)).orElseThrow();
var artifacts = baseMC.otherArtifacts().stream()
.map(SecureJar::from)
.map(sj -> new ModFile(sj, this, ModFileParser::modsTomlParser))
.collect(Collectors.<IModFile>toList());
var othermods = baseMC.otherModPaths().stream()
.map(p -> createMod(p.toArray(Path[]::new)))
.filter(Objects::nonNull);
artifacts.add(mcjar);
return Stream.concat(artifacts.stream().map(f -> new ModFileOrException(f, null)), othermods).toList(); // Minecraft itself.
var meta = new ModJarMetadata();
var mcjar = SecureJar.from(
jar -> meta,
minecraft.toArray(Path[]::new)
);
var mc = ModFileFactory.FACTORY.build(mcjar, this, this::buildMinecraftTOML);
meta.setModFile(mc);
return List.of(new ModFileOrException(mc, null));
} }
private IModFileInfo buildMinecraftTOML(final IModFile iModFile) { private IModFileInfo buildMinecraftTOML(final IModFile iModFile) {
final ModFile modFile = (ModFile) iModFile;
/*
final Path mcmodtoml = modFile.findResource("META-INF", "minecraftmod.toml");
if (Files.notExists(mcmodtoml)) {
LOGGER.fatal(LOADING, "Mod file {} is missing minecraftmod.toml file", modFile.getFilePath());
return null;
}
final FileConfig mcmodstomlfile = FileConfig.builder(mcmodtoml).build();
mcmodstomlfile.load();
mcmodstomlfile.close();
*/
// We haven't changed this in years, and I can't be asked right now to special case this one file in the path. // We haven't changed this in years, and I can't be asked right now to special case this one file in the path.
final var conf = Config.inMemory(); final var conf = Config.inMemory();
conf.set("modLoader", "minecraft"); conf.set("modLoader", "minecraft");
@@ -76,47 +50,13 @@ public class MinecraftLocator extends AbstractModProvider implements IModLocator
mods.set("authors", "MCP: Searge,ProfMobius,IngisKahn,Fesh0r,ZeuX,R4wk,LexManos,Bspkrs"); mods.set("authors", "MCP: Searge,ProfMobius,IngisKahn,Fesh0r,ZeuX,R4wk,LexManos,Bspkrs");
mods.set("description", "Minecraft, decompiled and deobfuscated with MCP technology"); mods.set("description", "Minecraft, decompiled and deobfuscated with MCP technology");
conf.set("mods", List.of(mods)); conf.set("mods", List.of(mods));
/*
conf.putAll(mcmodstomlfile);
final var extralangs = Stream.<IModFileInfo.LanguageSpec>builder(); var configWrapper = new NightConfigWrapper(conf);
final Path forgemodtoml = modFile.findResource("META-INF", "mods.toml"); return new ModFileInfo((ModFile)iModFile, configWrapper, configWrapper::setFile, List.of());
if (Files.notExists(forgemodtoml)) {
LOGGER.info("No forge mods.toml file found, not loading forge mod");
} else {
final FileConfig forgemodstomlfile = FileConfig.builder(forgemodtoml).build();
forgemodstomlfile.load();
forgemodstomlfile.close();
conf.putAll(forgemodstomlfile);
conf.<List<Object>>get("mods").add(0, mcmodstomlfile.<List<Object>>get("mods").get(0)); // Add MC as a sub-mod
extralangs.add(new IModFileInfo.LanguageSpec(mcmodstomlfile.get("modLoader"), MavenVersionAdapter.createFromVersionSpec(mcmodstomlfile.get("loaderVersion"))));
}
*/
final NightConfigWrapper configWrapper = new NightConfigWrapper(conf);
//final ModFileInfo modFileInfo = new ModFileInfo(modFile, configWrapper, extralangs.build().toList());
return new ModFileInfo(modFile, configWrapper, configWrapper::setFile, List.of());
} }
@Override @Override
public String name() { public String name() {
return "minecraft"; return "minecraft";
} }
@Override
public void scanFile(final IModFile modFile, final Consumer<Path> pathConsumer) {
LOGGER.debug(LogMarkers.SCAN, "Scan started: {}", modFile);
try (Stream<Path> files = Files.find(modFile.getSecureJar().getRootPath(), Integer.MAX_VALUE, (p, a) -> p.getNameCount() > 0 && p.getFileName().toString().endsWith(".class"))) {
files.forEach(pathConsumer);
} catch (IOException e) {
e.printStackTrace();
}
LOGGER.debug(LogMarkers.SCAN, "Scan finished: {}", modFile);
}
@Override
public void initArguments(final Map<String, ?> arguments) {
// no op
}
} }
@@ -7,65 +7,42 @@ package net.minecraftforge.fml.loading.moddiscovery;
import java.lang.annotation.ElementType; import java.lang.annotation.ElementType;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map; import java.util.Map;
import net.minecraftforge.forgespi.language.ModFileScanData; import net.minecraftforge.forgespi.language.ModFileScanData;
import net.minecraftforge.forgespi.language.ModFileScanData.EnumData;
import org.jetbrains.annotations.ApiStatus;
import org.objectweb.asm.Type; import org.objectweb.asm.Type;
import com.google.common.base.MoreObjects; import com.google.common.base.MoreObjects;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
public class ModAnnotation @ApiStatus.Internal
{ class ModAnnotation {
public static ModFileScanData.AnnotationData fromModAnnotation(final Type clazz, final ModAnnotation annotation) { public static ModFileScanData.AnnotationData fromModAnnotation(Type clazz, ModAnnotation annotation) {
return new ModFileScanData.AnnotationData(annotation.asmType, annotation.type, clazz, annotation.member, annotation.values); return new ModFileScanData.AnnotationData(annotation.asmType, annotation.type, clazz, annotation.member, annotation.values);
} }
public static class EnumHolder
{
private final String desc;
private final String value;
public EnumHolder(String desc, String value)
{
this.desc = desc;
this.value = value;
}
public String getDesc()
{
return desc;
}
public String getValue()
{
return value;
}
}
private final ElementType type; private final ElementType type;
private final Type asmType; private final Type asmType;
private final String member; private final String member;
private final Map<String,Object> values = Maps.newHashMap(); private final Map<String,Object> values = new HashMap<>();
private ArrayList<Object> arrayList; private ArrayList<Object> arrayList;
private String arrayName; private String arrayName;
public ModAnnotation(ElementType type, Type asmType, String member) public ModAnnotation(ElementType type, Type asmType, String member) {
{
this.type = type; this.type = type;
this.asmType = asmType; this.asmType = asmType;
this.member = member; this.member = member;
} }
public ModAnnotation(Type asmType, ModAnnotation parent) public ModAnnotation(Type asmType, ModAnnotation parent) {
{ this(parent.type, asmType, parent.member);
this.type = parent.type;
this.asmType = asmType;
this.member = parent.member;
} }
@Override @Override
public String toString() public String toString() {
{
return MoreObjects.toStringHelper("Annotation") return MoreObjects.toStringHelper("Annotation")
.add("type",type) .add("type",type)
.add("name",asmType.getClassName()) .add("name",asmType.getClassName())
@@ -74,52 +51,45 @@ public class ModAnnotation
.toString(); .toString();
} }
public ElementType getType() public ElementType getType() {
{
return type; return type;
} }
public Type getASMType()
{ public Type getASMType() {
return asmType; return asmType;
} }
public String getMember()
{ public String getMember() {
return member; return member;
} }
public Map<String, Object> getValues()
{ public Map<String, Object> getValues() {
return values; return values;
} }
public void addArray(String name)
{ public void addArray(String name) {
this.arrayList = Lists.newArrayList(); this.arrayList = new ArrayList<>();
this.arrayName = name; this.arrayName = name;
} }
public void addProperty(String key, Object value)
{ public void addProperty(String key, Object value) {
if (this.arrayList != null) if (this.arrayList != null)
{
arrayList.add(value); arrayList.add(value);
}
else else
{
values.put(key, value); values.put(key, value);
}
} }
public void addEnumProperty(String key, String enumName, String value) public void addEnumProperty(String key, String enumName, String value) {
{ addProperty(key, new EnumData(Type.getType(enumName), value));
addProperty(key, new EnumHolder(enumName, value));
} }
public void endArray() public void endArray() {
{
values.put(arrayName, arrayList); values.put(arrayName, arrayList);
arrayList = null; arrayList = null;
} }
public ModAnnotation addChildAnnotation(String name, String desc)
{ public ModAnnotation addChildAnnotation(String name, String desc) {
ModAnnotation child = new ModAnnotation(Type.getType(desc), this); var child = new ModAnnotation(Type.getType(desc), this);
addProperty(name, child.getValues()); addProperty(name, child.getValues());
return child; return child;
} }
@@ -1,67 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.Opcodes;
import java.util.LinkedList;
public class ModAnnotationVisitor extends AnnotationVisitor {
private final ModAnnotation annotation;
private LinkedList<ModAnnotation> annotations;
private boolean array;
private boolean isSubAnnotation;
public ModAnnotationVisitor(LinkedList<ModAnnotation> annotations, ModAnnotation annotation) {
super(Opcodes.ASM9);
this.annotations = annotations;
this.annotation = annotation;
}
public ModAnnotationVisitor(LinkedList<ModAnnotation> annotations, ModAnnotation annotation, String name) {
this(annotations, annotation);
this.array = true;
annotation.addArray(name);
}
public ModAnnotationVisitor(LinkedList<ModAnnotation> annotations, ModAnnotation annotation, boolean isSubAnnotation) {
this(annotations, annotation);
this.isSubAnnotation = true;
}
@Override
public void visit(String key, Object value) {
annotation.addProperty(key, value);
}
@Override
public void visitEnum(String name, String desc, String value) {
annotation.addEnumProperty(name, desc, value);
}
@Override
public AnnotationVisitor visitArray(String name) {
return new ModAnnotationVisitor(annotations, annotation, name);
}
@Override
public AnnotationVisitor visitAnnotation(String name, String desc) {
var ma = annotations.getFirst();
var childAnnotation = ma.addChildAnnotation(name, desc);
annotations.addFirst(childAnnotation);
return new ModAnnotationVisitor(annotations, childAnnotation, true);
}
@Override
public void visitEnd() {
if (array)
annotation.endArray();
if (isSubAnnotation)
annotations.addLast(annotations.removeFirst());
}
}
@@ -6,6 +6,8 @@
package net.minecraftforge.fml.loading.moddiscovery; package net.minecraftforge.fml.loading.moddiscovery;
import net.minecraftforge.forgespi.language.ModFileScanData; import net.minecraftforge.forgespi.language.ModFileScanData;
import org.jetbrains.annotations.ApiStatus;
import org.objectweb.asm.AnnotationVisitor; import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.FieldVisitor; import org.objectweb.asm.FieldVisitor;
@@ -19,13 +21,14 @@ import java.util.Set;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import java.util.stream.Stream; import java.util.stream.Stream;
public class ModClassVisitor extends ClassVisitor { @ApiStatus.Internal
class ModClassVisitor extends ClassVisitor {
private Type asmType; private Type asmType;
private Type asmSuperType; private Type asmSuperType;
private Set<Type> interfaces; private Set<Type> interfaces;
private final LinkedList<ModAnnotation> annotations = new LinkedList<>(); private final LinkedList<ModAnnotation> annotations = new LinkedList<>();
public ModClassVisitor() { ModClassVisitor() {
super(Opcodes.ASM9); super(Opcodes.ASM9);
} }
@@ -38,19 +41,33 @@ public class ModClassVisitor extends ClassVisitor {
@Override @Override
public AnnotationVisitor visitAnnotation(final String annotationName, final boolean runtimeVisible) { public AnnotationVisitor visitAnnotation(final String annotationName, final boolean runtimeVisible) {
ModAnnotation ann = new ModAnnotation(ElementType.TYPE, Type.getType(annotationName), this.asmType.getClassName()); var ann = new ModAnnotation(ElementType.TYPE, Type.getType(annotationName), this.asmType.getClassName());
annotations.addFirst(ann); annotations.addFirst(ann);
return new ModAnnotationVisitor(annotations, ann); return new ModAnnotationVisitor(ann);
} }
@Override @Override
public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
return new ModFieldVisitor(name, annotations); return new FieldVisitor(Opcodes.ASM9) {
@Override
public AnnotationVisitor visitAnnotation(String annotationName, boolean runtimeVisible) {
var ann = new ModAnnotation(ElementType.FIELD, Type.getType(annotationName), name);
annotations.addFirst(ann);
return new ModAnnotationVisitor(ann);
}
};
} }
@Override @Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
return new ModMethodVisitor(name, desc, annotations); return new MethodVisitor(Opcodes.ASM9) {
@Override
public AnnotationVisitor visitAnnotation(String annotationName, boolean runtimeVisible) {
ModAnnotation ann = new ModAnnotation(ElementType.METHOD, Type.getType(annotationName), name + desc);
annotations.addFirst(ann);
return new ModAnnotationVisitor(ann);
}
};
} }
public void buildData(final Set<ModFileScanData.ClassData> classes, final Set<ModFileScanData.AnnotationData> baked) { public void buildData(final Set<ModFileScanData.ClassData> classes, final Set<ModFileScanData.AnnotationData> baked) {
@@ -60,4 +77,58 @@ public class ModClassVisitor extends ClassVisitor {
baked.add(ModAnnotation.fromModAnnotation(this.asmType, a)); baked.add(ModAnnotation.fromModAnnotation(this.asmType, a));
} }
} }
private class ModAnnotationVisitor extends AnnotationVisitor {
private final ModAnnotation annotation;
private boolean array;
private boolean isSubAnnotation;
public ModAnnotationVisitor(ModAnnotation annotation) {
super(Opcodes.ASM9);
this.annotation = annotation;
}
public ModAnnotationVisitor(ModAnnotation annotation, String name) {
this(annotation);
this.array = true;
annotation.addArray(name);
}
public ModAnnotationVisitor(ModAnnotation annotation, boolean isSubAnnotation) {
this(annotation);
this.isSubAnnotation = true;
}
@Override
public void visit(String key, Object value) {
annotation.addProperty(key, value);
}
@Override
public void visitEnum(String name, String desc, String value) {
annotation.addEnumProperty(name, desc, value);
}
@Override
public AnnotationVisitor visitArray(String name) {
return new ModAnnotationVisitor(annotation, name);
}
@Override
public AnnotationVisitor visitAnnotation(String name, String desc) {
var ma = annotations.getFirst();
var childAnnotation = ma.addChildAnnotation(name, desc);
annotations.addFirst(childAnnotation);
return new ModAnnotationVisitor(childAnnotation, true);
}
@Override
public void visitEnd() {
if (array)
annotation.endArray();
if (isSubAnnotation)
annotations.addLast(annotations.removeFirst());
}
}
} }
@@ -12,6 +12,7 @@ import cpw.mods.modlauncher.Launcher;
import cpw.mods.modlauncher.api.IModuleLayerManager; import cpw.mods.modlauncher.api.IModuleLayerManager;
import cpw.mods.modlauncher.util.ServiceLoaderUtils; import cpw.mods.modlauncher.util.ServiceLoaderUtils;
import net.minecraftforge.fml.loading.EarlyLoadingException; import net.minecraftforge.fml.loading.EarlyLoadingException;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.ImmediateWindowHandler; import net.minecraftforge.fml.loading.ImmediateWindowHandler;
import net.minecraftforge.fml.loading.LogMarkers; import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.fml.loading.UniqueModListBuilder; import net.minecraftforge.fml.loading.UniqueModListBuilder;
@@ -21,6 +22,9 @@ import net.minecraftforge.forgespi.language.IModFileInfo;
import net.minecraftforge.forgespi.locating.IDependencyLocator; import net.minecraftforge.forgespi.locating.IDependencyLocator;
import net.minecraftforge.forgespi.locating.IModFile; import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.IModLocator; import net.minecraftforge.forgespi.locating.IModLocator;
import net.minecraftforge.forgespi.locating.ModFileLoadingException;
import org.jetbrains.annotations.ApiStatus;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.util.ArrayList; import java.util.ArrayList;
@@ -30,6 +34,7 @@ import java.util.Objects;
import java.util.ServiceLoader; import java.util.ServiceLoader;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@ApiStatus.Internal
public class ModDiscoverer { public class ModDiscoverer {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private final ServiceLoader<IModLocator> modLocators; private final ServiceLoader<IModLocator> modLocators;
@@ -67,6 +72,8 @@ public class ModDiscoverer {
List<EarlyLoadingException.ExceptionData> discoveryErrorData = new ArrayList<>(); List<EarlyLoadingException.ExceptionData> discoveryErrorData = new ArrayList<>();
boolean successfullyLoadedMods = true; boolean successfullyLoadedMods = true;
List<IModFileInfo> brokenFiles = new ArrayList<>(); List<IModFileInfo> brokenFiles = new ArrayList<>();
List<ModFileLoadingException> modFileLoadingExceptions = new ArrayList<>();
boolean distIsDedicatedServer = FMLLoader.getDist().isDedicatedServer();
ImmediateWindowHandler.updateProgress("Discovering mod files"); ImmediateWindowHandler.updateProgress("Discovering mod files");
//Loop all mod locators to get the prime mods to load from. //Loop all mod locators to get the prime mods to load from.
for (IModLocator locator : modLocatorList) { for (IModLocator locator : modLocatorList) {
@@ -77,7 +84,17 @@ public class ModDiscoverer {
var exceptions = candidates.stream().map(IModLocator.ModFileOrException::ex).filter(Objects::nonNull).toList(); var exceptions = candidates.stream().map(IModLocator.ModFileOrException::ex).filter(Objects::nonNull).toList();
if (!exceptions.isEmpty()) { if (!exceptions.isEmpty()) {
LOGGER.debug(LogMarkers.SCAN, "Locator {} found {} invalid mod files", locator, exceptions.size()); LOGGER.debug(LogMarkers.SCAN, "Locator {} found {} invalid mod files", locator, exceptions.size());
brokenFiles.addAll(exceptions.stream().map(e->e instanceof InvalidModFileException ime ? ime.getBrokenFile() : null).filter(Objects::nonNull).toList()); for (ModFileLoadingException ex : exceptions) {
// pipe exception messages through the discoveryErrorData to avoid swallowing some exceptions and improve error messages
// (no longer a generic "Invalid mod file" for all InvalidModExceptions - it actually shows the exception message now)
if (ex instanceof InvalidModFileException invalidModFileEx) {
var modInfo = invalidModFileEx.getBrokenFile();
brokenFiles.add(modInfo);
discoveryErrorData.add(new EarlyLoadingException.ExceptionData(ex.getMessage(), modInfo));
} else {
discoveryErrorData.add(new EarlyLoadingException.ExceptionData(ex.getMessage()));
}
}
} }
var locatedFiles = candidates.stream().map(IModLocator.ModFileOrException::file).filter(Objects::nonNull).collect(Collectors.toList()); var locatedFiles = candidates.stream().map(IModLocator.ModFileOrException::file).filter(Objects::nonNull).collect(Collectors.toList());
@@ -85,8 +102,17 @@ public class ModDiscoverer {
if (!badModFiles.isEmpty()) { if (!badModFiles.isEmpty()) {
LOGGER.error(LogMarkers.SCAN, "Locator {} returned {} files which is are not ModFile instances! They will be skipped!", locator, badModFiles.size()); LOGGER.error(LogMarkers.SCAN, "Locator {} returned {} files which is are not ModFile instances! They will be skipped!", locator, badModFiles.size());
brokenFiles.addAll(badModFiles.stream().map(IModFile::getModFileInfo).toList()); brokenFiles.addAll(badModFiles.stream().map(IModFile::getModFileInfo).toList());
locatedFiles.removeAll(badModFiles);
} }
locatedFiles.removeAll(badModFiles);
if (distIsDedicatedServer) {
var clientOnlyModFiles = locatedFiles.stream().filter(file -> file.getModFileInfo().isClientSideOnly()).toList();
if (!clientOnlyModFiles.isEmpty()) {
LOGGER.warn(LogMarkers.SCAN, "Locator {} returned {} files which are client-side-only mods, but we're on a dedicated server. They will be skipped!", locator, clientOnlyModFiles.size());
locatedFiles.removeAll(clientOnlyModFiles);
}
}
LOGGER.debug(LogMarkers.SCAN, "Locator {} found {} valid mod files", locator, locatedFiles.size()); LOGGER.debug(LogMarkers.SCAN, "Locator {} found {} valid mod files", locator, locatedFiles.size());
handleLocatedFiles(loadedFiles, locatedFiles); handleLocatedFiles(loadedFiles, locatedFiles);
} catch (InvalidModFileException imfe) { } catch (InvalidModFileException imfe) {
@@ -159,7 +185,7 @@ public class ModDiscoverer {
//Validate the loading. With a deduplicated list, we can now successfully process the artifacts and load //Validate the loading. With a deduplicated list, we can now successfully process the artifacts and load
//transformer plugins. //transformer plugins.
var validator = new ModValidator(modFilesMap, brokenFiles, discoveryErrorData); var validator = new ModValidator(modFilesMap, brokenFiles, discoveryErrorData, modFileLoadingExceptions);
validator.stage1Validation(); validator.stage1Validation();
return validator; return validator;
} }
@@ -1,35 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import java.lang.annotation.ElementType;
import java.util.LinkedList;
public class ModFieldVisitor extends FieldVisitor
{
private final LinkedList<ModAnnotation> annotations;
private final String fieldName;
public ModFieldVisitor(String name, final LinkedList<ModAnnotation> annotations)
{
super(Opcodes.ASM9);
this.fieldName = name;
this.annotations = annotations;
}
@Override
public AnnotationVisitor visitAnnotation(String annotationName, boolean runtimeVisible)
{
ModAnnotation ann = new ModAnnotation(ElementType.FIELD, Type.getType(annotationName), fieldName);
annotations.addFirst(ann);
return new ModAnnotationVisitor(annotations, ann);
}
}
@@ -23,6 +23,8 @@ import org.slf4j.Logger;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
@@ -35,16 +37,7 @@ import java.util.jar.Attributes;
import java.util.jar.Manifest; import java.util.jar.Manifest;
public class ModFile implements IModFile { public class ModFile implements IModFile {
// Mods either must have a mods.toml or a manifest. We can no longer just put any jar on the classpath.
@Deprecated(forRemoval = true, since = "1.18")
public static final Manifest DEFAULTMANIFEST;
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
static {
DEFAULTMANIFEST = new Manifest();
DEFAULTMANIFEST.getMainAttributes().putValue("FMLModType", "MOD");
}
private final String jarVersion; private final String jarVersion;
private final ModFileFactory.ModFileInfoParser parser; private final ModFileFactory.ModFileInfoParser parser;
private Map<String, Object> fileProperties; private Map<String, Object> fileProperties;
@@ -176,9 +169,13 @@ public class ModFile implements IModFile {
} }
public void identifyLanguage() { public void identifyLanguage() {
this.loaders = this.modFileInfo.requiredLanguageLoaders().stream() var lst = new ArrayList<IModLanguageProvider>(this.modFileInfo.requiredLanguageLoaders().size());
.map(spec-> FMLLoader.getLanguageLoadingProvider().findLanguage(this, spec.languageName(), spec.acceptedVersions())) var services = FMLLoader.getLanguageLoadingProvider();
.toList(); for (var spec : this.modFileInfo.requiredLanguageLoaders()) {
var service = services.findLanguage(this, spec.languageName(), spec.acceptedVersions());
lst.add(service);
}
this.loaders = Collections.unmodifiableList(lst);
} }
@Override @Override
@@ -14,6 +14,7 @@ import net.minecraftforge.forgespi.language.IConfigurable;
import net.minecraftforge.forgespi.language.IModFileInfo; import net.minecraftforge.forgespi.language.IModFileInfo;
import net.minecraftforge.forgespi.language.IModInfo; import net.minecraftforge.forgespi.language.IModInfo;
import net.minecraftforge.forgespi.language.MavenVersionAdapter; import net.minecraftforge.forgespi.language.MavenVersionAdapter;
import org.jetbrains.annotations.ApiStatus;
import org.slf4j.Logger; import org.slf4j.Logger;
import javax.security.auth.x500.X500Principal; import javax.security.auth.x500.X500Principal;
import java.net.URL; import java.net.URL;
@@ -29,6 +30,7 @@ import java.security.cert.X509Certificate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
@@ -40,11 +42,19 @@ import java.util.stream.Stream;
public class ModFileInfo implements IModFileInfo, IConfigurable public class ModFileInfo implements IModFileInfo, IConfigurable
{ {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private static final String MAYBE_NOT_JAVAFML_VER = "[2,)";
private static final String JAVAFML = "javafml";
@ApiStatus.Internal
public static final String NOT_A_FORGE_MOD_PROP = "__FORGE__not_a_forge_mod";
private final IConfigurable config; private final IConfigurable config;
private final ModFile modFile; private final ModFile modFile;
private final URL issueURL; private final URL issueURL;
private final List<LanguageSpec> languageSpecs; private final List<LanguageSpec> languageSpecs;
private final boolean showAsResourcePack; private final boolean showAsResourcePack;
private final boolean clientSideOnly;
private final boolean showAsDataPack;
private final List<IModInfo> mods; private final List<IModInfo> mods;
private final Map<String,Object> properties; private final Map<String,Object> properties;
private final String license; private final String license;
@@ -59,23 +69,46 @@ public class ModFileInfo implements IModFileInfo, IConfigurable
var modLoader = config.<String>getConfigElement("modLoader") var modLoader = config.<String>getConfigElement("modLoader")
.orElseThrow(()->new InvalidModFileException("Missing ModLoader in file", this)); .orElseThrow(()->new InvalidModFileException("Missing ModLoader in file", this));
// as is modloader version // as is modloader version
var modLoaderVersion = config.<String>getConfigElement("loaderVersion") var modLoaderVerStr = config.<String>getConfigElement("loaderVersion")
.map(MavenVersionAdapter::createFromVersionSpec)
.orElseThrow(()->new InvalidModFileException("Missing ModLoader version in file", this)); .orElseThrow(()->new InvalidModFileException("Missing ModLoader version in file", this));
var modLoaderVersion = MavenVersionAdapter.createFromVersionSpec(modLoaderVerStr);
this.languageSpecs = new ArrayList<>(List.of(new LanguageSpec(modLoader, modLoaderVersion))); this.languageSpecs = new ArrayList<>(List.of(new LanguageSpec(modLoader, modLoaderVersion)));
// if true, this might not be a Forge mod
boolean maybeNotAForgeMod = modLoader.equals(JAVAFML)
&& modLoaderVersion.hasRestrictions() // if loaderVersion is not "*"
&& modLoaderVerStr.equals(MAYBE_NOT_JAVAFML_VER); // if loaderVersion is exactly "[2,)"
// the remaining properties are optional with sensible defaults // the remaining properties are optional with sensible defaults
this.license = config.<String>getConfigElement("license") this.license = config.<String>getConfigElement("license")
.orElse(""); .orElse("");
this.showAsResourcePack = config.<Boolean>getConfigElement("showAsResourcePack") this.showAsResourcePack = config.<Boolean>getConfigElement("showAsResourcePack")
.orElse(false); .orElse(false);
this.clientSideOnly = config.<Boolean>getConfigElement("clientSideOnly")
.orElse(false);
if (this.clientSideOnly) {
// if clientSideOnly, then this is definitely a Forge mod
maybeNotAForgeMod = false;
}
this.showAsDataPack = config.<Boolean>getConfigElement("showAsDataPack")
.orElse(false);
this.usesServices = config.<List<String>>getConfigElement("services") this.usesServices = config.<List<String>>getConfigElement("services")
.orElse(List.of()); .orElse(List.of());
this.properties = config.<Map<String, Object>>getConfigElement("properties")
.orElse(Collections.emptyMap());
this.modFile.setFileProperties(this.properties);
this.issueURL = config.<String>getConfigElement("issueTrackerURL") this.issueURL = config.<String>getConfigElement("issueTrackerURL")
.map(StringUtils::toURL) .map(StringUtils::toURL)
.orElse(null); .orElse(null);
if (maybeNotAForgeMod) {
// mark this file as not a Forge mod. Note: this marker may be removed later based on the mod dependencies
this.properties = config.<Map<String, Object>>getConfigElement("properties")
.orElse(new LinkedHashMap<>());
this.properties.put(NOT_A_FORGE_MOD_PROP, true);
} else {
this.properties = config.<Map<String, Object>>getConfigElement("properties")
.orElse(Collections.emptyMap());
}
this.modFile.setFileProperties(this.properties);
final List<? extends IConfigurable> modConfigs = config.getConfigList("mods"); final List<? extends IConfigurable> modConfigs = config.getConfigList("mods");
if (modConfigs.isEmpty()) if (modConfigs.isEmpty())
{ {
@@ -126,6 +159,18 @@ public class ModFileInfo implements IModFileInfo, IConfigurable
return this.showAsResourcePack; return this.showAsResourcePack;
} }
@Override
public boolean isClientSideOnly()
{
return this.clientSideOnly;
}
@Override
public boolean showAsDataPack()
{
return this.showAsDataPack;
}
@Override @Override
public <T> Optional<T> getConfigElement(final String... key) public <T> Optional<T> getConfigElement(final String... key)
{ {
@@ -13,6 +13,7 @@ import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.forgespi.language.IModFileInfo; import net.minecraftforge.forgespi.language.IModFileInfo;
import net.minecraftforge.forgespi.locating.IModFile; import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.ModFileFactory; import net.minecraftforge.forgespi.locating.ModFileFactory;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.io.IOException; import java.io.IOException;
@@ -30,7 +31,7 @@ public class ModFileParser {
return parser.build(modFile); return parser.build(modFile);
} }
public static IModFileInfo modsTomlParser(final IModFile imodFile) { public static @Nullable IModFileInfo modsTomlParser(final IModFile imodFile) {
ModFile modFile = (ModFile) imodFile; ModFile modFile = (ModFile) imodFile;
LOGGER.debug(LogMarkers.LOADING,"Considering mod file candidate {}", modFile.getFilePath()); LOGGER.debug(LogMarkers.LOADING,"Considering mod file candidate {}", modFile.getFilePath());
final Path modsjson = modFile.findResource("META-INF", "mods.toml"); final Path modsjson = modFile.findResource("META-INF", "mods.toml");
@@ -15,6 +15,7 @@ import net.minecraftforge.forgespi.locating.ForgeFeature;
import org.apache.maven.artifact.versioning.ArtifactVersion; import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion; import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.maven.artifact.versioning.VersionRange; import org.apache.maven.artifact.versioning.VersionRange;
import org.jetbrains.annotations.ApiStatus;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.net.URL; import java.net.URL;
@@ -22,10 +23,11 @@ import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional; import java.util.Optional;
import java.util.function.Supplier;
import java.util.regex.Pattern; import java.util.regex.Pattern;
public class ModInfo implements IModInfo, IConfigurable @ApiStatus.Internal
{ public class ModInfo implements IModInfo, IConfigurable {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private static final DefaultArtifactVersion DEFAULT_VERSION = new DefaultArtifactVersion("1"); private static final DefaultArtifactVersion DEFAULT_VERSION = new DefaultArtifactVersion("1");
private static final Pattern VALID_MODID = Pattern.compile("^[a-z][a-z0-9_]{1,63}$"); private static final Pattern VALID_MODID = Pattern.compile("^[a-z][a-z0-9_]{1,63}$");
@@ -212,8 +214,23 @@ public class ModInfo implements IModInfo, IConfigurable
this.owner = owner; this.owner = owner;
this.modId = config.<String>getConfigElement("modId") this.modId = config.<String>getConfigElement("modId")
.orElseThrow(()->new InvalidModFileException("Missing required field modid in dependency", getOwningFile())); .orElseThrow(()->new InvalidModFileException("Missing required field modid in dependency", getOwningFile()));
this.mandatory = config.<Boolean>getConfigElement("mandatory") if (this.modId.equals("forge")) {
.orElseThrow(()->new InvalidModFileException("Missing required field mandatory in dependency", getOwningFile())); var fileProps = owner.getOwningFile().getFileProperties();
// Checking containsKey to avoid a possible exception if the property is not present (due to Collections.emptyMap())
if (!fileProps.isEmpty() && fileProps.containsKey(ModFileInfo.NOT_A_FORGE_MOD_PROP)) {
// if the mod has a dependency on Forge, but we thought it wasn't a Forge mod earlier, we were wrong
// so remove the flag.
fileProps.remove(ModFileInfo.NOT_A_FORGE_MOD_PROP);
}
}
var mandatory = config.<Boolean>getConfigElement("mandatory");
if (mandatory.isPresent()) {
this.mandatory = mandatory.get();
} else if (owner.getOwningFile().getFileProperties().containsKey(ModFileInfo.NOT_A_FORGE_MOD_PROP)) {
this.mandatory = true;
} else {
throw new InvalidModFileException("Missing required field mandatory in dependency", getOwningFile());
}
this.versionRange = config.<String>getConfigElement("versionRange") this.versionRange = config.<String>getConfigElement("versionRange")
.map(MavenVersionAdapter::createFromVersionSpec) .map(MavenVersionAdapter::createFromVersionSpec)
.orElse(UNBOUNDED); .orElse(UNBOUNDED);
@@ -6,48 +6,17 @@
package net.minecraftforge.fml.loading.moddiscovery; package net.minecraftforge.fml.loading.moddiscovery;
import cpw.mods.jarhandling.JarMetadata; import cpw.mods.jarhandling.JarMetadata;
import cpw.mods.jarhandling.SecureJar;
import net.minecraftforge.forgespi.locating.IModFile; import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.IModLocator;
import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleDescriptor;
import java.nio.file.Path;
import java.util.Objects; import java.util.Objects;
import java.util.Optional;
import java.util.function.BiPredicate;
import java.util.function.Function;
import java.util.function.Predicate;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.Internal
public final class ModJarMetadata implements JarMetadata { public final class ModJarMetadata implements JarMetadata {
private IModFile modFile; private IModFile modFile;
private ModuleDescriptor descriptor; private ModuleDescriptor descriptor;
// TODO: Remove helper functions to cleanup api
@Deprecated(forRemoval = true, since="1.18")
static Optional<IModFile> buildFile(IModLocator locator, Predicate<SecureJar> jarTest, BiPredicate<String, String> filter, Path... files) {
return buildFile(j->new ModFile(j, locator, ModFileParser::modsTomlParser), jarTest, filter, files);
}
// TODO: Remove helper functions to cleanup api
@Deprecated(forRemoval = true, since="1.18")
static IModFile buildFile(IModLocator locator, Path... files) {
return buildFile(locator, j->true, null, files).orElseThrow(()->new IllegalArgumentException("Failed to find valid JAR file"));
}
// TODO: Remove helper functions to cleanup api
@Deprecated(forRemoval = true, since="1.18")
static Optional<IModFile> buildFile(Function<SecureJar, IModFile> mfConstructor, Predicate<SecureJar> jarTest, BiPredicate<String, String> filter, Path... files) {
var mjm = new ModJarMetadata();
var sj = SecureJar.from(()->ModFile.DEFAULTMANIFEST, j->mjm, filter, files);
if (jarTest.test(sj)) {
var mf = mfConstructor.apply(sj);
mjm.setModFile(mf);
return Optional.of(mf);
} else {
return Optional.empty();
}
}
ModJarMetadata() { ModJarMetadata() {
} }
@@ -1,93 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import com.mojang.logging.LogUtils;
import net.minecraftforge.fml.loading.FMLPaths;
import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.fml.loading.MavenCoordinateResolver;
import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
public class ModListHandler {
private static final Logger LOGGER = LogUtils.getLogger();
/**
* Reads the modList paths specified, and searches each maven root for mods matching. Returns a list of mods
* found.
*
* @param modListPaths Paths to search for mod file lists
* @param mavenRootPaths Roots to look for mods listed
* @return list of found mod coordinates
*/
public static List<String> processModLists(final List<String> modListPaths, final List<Path> mavenRootPaths) {
final List<String> modCoordinates = modListPaths.stream().map(ModListHandler::transformPathToList).
flatMap(Collection::stream).
collect(Collectors.toList());
List<Pair<Path,String>> localModCoords = modCoordinates.stream().map(mc->Pair.of(MavenCoordinateResolver.get(mc), mc)).collect(Collectors.toList());
final List<Pair<Path, String>> foundCoordinates = localModCoords.stream().
map(mc -> mavenRootPaths.stream().
map(root -> Pair.of(root.resolve(mc.getLeft()), mc.getRight())).
filter(path -> Files.exists(path.getLeft())).
findFirst().
orElseGet(()->{
LOGGER.warn(LogMarkers.CORE, "Failed to find coordinate {}", mc);
return null;
})).
filter(Objects::nonNull).
collect(Collectors.toList());
final List<String> found = foundCoordinates.stream().map(Pair::getRight).collect(Collectors.toList());
LOGGER.debug(LogMarkers.CORE, "Found mod coordinates from lists: {}", found);
return found;
}
private static List<String> transformPathToList(final String path) {
LOGGER.debug(LogMarkers.CORE, "Reading mod list {}", path);
Path filePath = FMLPaths.GAMEDIR.get().resolve(path);
if (!Files.exists(filePath)) {
LOGGER.warn(LogMarkers.CORE, "Failed to find modlist file at {}", filePath);
return Collections.emptyList();
}
String extension = fileExtension(filePath);
if (Objects.equals("list",extension)) {
return readListFile(filePath).stream().filter(s -> !s.isEmpty()).collect(Collectors.toList());
} else {
LOGGER.warn(LogMarkers.CORE, "Failed to read unknown file list type {} for file {}", extension, filePath);
}
return Collections.emptyList();
}
private static String fileExtension(final Path path) {
String fileName = path.getFileName().toString();
int idx = fileName.lastIndexOf('.');
return idx > -1 ? fileName.substring(idx+1) : "";
}
/**
* Simple list file, ending in ".list" with one mod coordinate per line
* @param filePath path
* @return list
*/
private static List<String> readListFile(final Path filePath) {
try {
return Files.readAllLines(filePath);
} catch (IOException e) {
LOGGER.warn(LogMarkers.CORE, "Failed to read file list {}", filePath, e);
return Collections.emptyList();
}
}
}
@@ -1,38 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.moddiscovery;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import java.lang.annotation.ElementType;
import java.util.LinkedList;
public class ModMethodVisitor extends MethodVisitor {
private final LinkedList<ModAnnotation> annotations;
private String methodName;
private String methodDescriptor;
public ModMethodVisitor(String name, String desc, final LinkedList<ModAnnotation> annotations)
{
super(Opcodes.ASM9);
this.methodName = name;
this.methodDescriptor = desc;
this.annotations = annotations;
}
@Override
public AnnotationVisitor visitAnnotation(String annotationName, boolean runtimeVisible)
{
ModAnnotation ann = new ModAnnotation(ElementType.METHOD, Type.getType(annotationName), methodName+methodDescriptor);
annotations.addFirst(ann);
return new ModAnnotationVisitor(annotations, ann);
}
}
@@ -6,11 +6,18 @@
package net.minecraftforge.fml.loading.moddiscovery; package net.minecraftforge.fml.loading.moddiscovery;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import cpw.mods.jarhandling.SecureJar;
import cpw.mods.modlauncher.api.IModuleLayerManager; import cpw.mods.modlauncher.api.IModuleLayerManager;
import cpw.mods.modlauncher.api.ITransformationService; import cpw.mods.modlauncher.api.ITransformationService;
import net.minecraftforge.fml.loading.*; import net.minecraftforge.fml.loading.EarlyLoadingException;
import net.minecraftforge.fml.loading.ImmediateWindowHandler;
import net.minecraftforge.fml.loading.LoadingModList;
import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.fml.loading.ModSorter;
import net.minecraftforge.forgespi.language.IModFileInfo; import net.minecraftforge.forgespi.language.IModFileInfo;
import net.minecraftforge.forgespi.locating.IModFile; import net.minecraftforge.forgespi.locating.IModFile;
import net.minecraftforge.forgespi.locating.ModFileLoadingException;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
@@ -18,25 +25,30 @@ import java.util.ArrayList;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.stream.Collectors;
public class ModValidator { public class ModValidator {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
//private final Map<IModFile.Type, List<ModFile>> modFiles;
private final List<ModFile> candidatePlugins; private final List<ModFile> candidatePlugins;
private final List<ModFile> candidateMods; private final List<ModFile> candidateMods;
private final List<ModFile> gameLibraries;
private LoadingModList loadingModList; private LoadingModList loadingModList;
private List<IModFile> brokenFiles; private final List<IModFile> brokenFiles = new ArrayList<>();
private final List<EarlyLoadingException.ExceptionData> discoveryErrorData; private final List<EarlyLoadingException.ExceptionData> discoveryErrorData;
private final List<ModFileLoadingException> modFileLoadingExceptions;
public ModValidator(final Map<IModFile.Type, List<ModFile>> modFiles, final List<IModFileInfo> brokenFiles, final List<EarlyLoadingException.ExceptionData> discoveryErrorData) { public ModValidator(Map<IModFile.Type, List<ModFile>> modFiles, List<IModFileInfo> brokenFiles, List<EarlyLoadingException.ExceptionData> discoveryErrorData, List<ModFileLoadingException> modFileLoadingExceptions) {
//this.modFiles = modFiles;
this.candidateMods = lst(modFiles.get(IModFile.Type.MOD)); this.candidateMods = lst(modFiles.get(IModFile.Type.MOD));
this.candidateMods.addAll(lst(modFiles.get(IModFile.Type.GAMELIBRARY))); this.gameLibraries = lst(modFiles.get(IModFile.Type.GAMELIBRARY));
this.candidateMods.addAll(this.gameLibraries);
this.candidatePlugins = lst(modFiles.get(IModFile.Type.LANGPROVIDER)); this.candidatePlugins = lst(modFiles.get(IModFile.Type.LANGPROVIDER));
this.candidatePlugins.addAll(lst(modFiles.get(IModFile.Type.LIBRARY))); this.candidatePlugins.addAll(lst(modFiles.get(IModFile.Type.LIBRARY)));
this.discoveryErrorData = discoveryErrorData; this.discoveryErrorData = discoveryErrorData;
this.brokenFiles = brokenFiles.stream().map(IModFileInfo::getFile).collect(Collectors.toList()); // mutable list this.brokenFiles.addAll(brokenFiles.stream().map(IModFileInfo::getFile).toList());
this.modFileLoadingExceptions = modFileLoadingExceptions;
}
public ModValidator(Map<IModFile.Type, List<ModFile>> modFiles, List<IModFileInfo> brokenFiles, List<EarlyLoadingException.ExceptionData> discoveryErrorData) {
this(modFiles, brokenFiles, discoveryErrorData, List.of());
} }
private static List<ModFile> lst(List<ModFile> files) { private static List<ModFile> lst(List<ModFile> files) {
@@ -54,8 +66,7 @@ public class ModValidator {
@NotNull @NotNull
private List<ModFile> validateFiles(final List<ModFile> mods) { private List<ModFile> validateFiles(final List<ModFile> mods) {
final List<ModFile> brokenFiles = new ArrayList<>(); final List<ModFile> brokenFiles = new ArrayList<>();
for (Iterator<ModFile> iterator = mods.iterator(); iterator.hasNext(); ) for (Iterator<ModFile> iterator = mods.iterator(); iterator.hasNext();) {
{
ModFile modFile = iterator.next(); ModFile modFile = iterator.next();
if (!modFile.getProvider().isValid(modFile) || !modFile.identifyMods()) { if (!modFile.getProvider().isValid(modFile) || !modFile.identifyMods()) {
LOGGER.warn(LogMarkers.SCAN, "File {} has been ignored - it is invalid", modFile.getFilePath()); LOGGER.warn(LogMarkers.SCAN, "File {} has been ignored - it is invalid", modFile.getFilePath());
@@ -71,7 +82,26 @@ public class ModValidator {
} }
public ITransformationService.Resource getModResources() { public ITransformationService.Resource getModResources() {
return new ITransformationService.Resource(IModuleLayerManager.Layer.GAME, this.candidateMods.stream().map(IModFile::getSecureJar).toList()); var mods = new ArrayList<SecureJar>();
// Add only the valid mods that we will be attempting to load.
// If any detectable error happens during the sorting process {missing deps, duplicates,
// This helps prevent coremods/mixins from screwing up us displaying the error screens that the sorting/validation is trying to display.
// This won't fix them all as they are still loaded and will still apply but it might help
for (var info : this.loadingModList.getModFiles())
mods.add(info.getFile().getSecureJar());
// Add any game libraries, this *may* be duplicates, depending on the state of the sorting. But until I get around to re-writing
// that clusterfuck of a system, have this simple de-duplication. Order of resource is important, but i'm unsure if duplication is
// so might as well waste a few cycles on checking. Still faster then converting from a set to a list.
// Ideally we would explicitly list out which mods to load {forge and MC being the only ones} but some coremods could require extra things.
// So try game libraries as well
for (var lib : this.gameLibraries) {
var jar = lib.getSecureJar();
if (!mods.contains(jar))
mods.add(jar);
}
return new ITransformationService.Resource(IModuleLayerManager.Layer.GAME, mods);
} }
private List<EarlyLoadingException.ExceptionData> validateLanguages() { private List<EarlyLoadingException.ExceptionData> validateLanguages() {
@@ -9,33 +9,29 @@ import com.mojang.logging.LogUtils;
import net.minecraftforge.fml.loading.FMLPaths; import net.minecraftforge.fml.loading.FMLPaths;
import net.minecraftforge.fml.loading.LogMarkers; import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.fml.loading.ModDirTransformerDiscoverer; import net.minecraftforge.fml.loading.ModDirTransformerDiscoverer;
import net.minecraftforge.fml.loading.StringUtils; import net.minecraftforge.forgespi.locating.IModLocator;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.io.IOException;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Comparator; import java.util.Comparator;
import java.util.Map; import java.util.List;
import java.util.stream.Stream; import java.util.Locale;
import static cpw.mods.modlauncher.api.LamdbaExceptionUtils.uncheck;
/** /**
* Support loading mods located in JAR files in the mods folder * Support loading mods located in JAR files in the mods folder
*/ */
public class ModsFolderLocator extends AbstractJarFileModLocator public class ModsFolderLocator extends AbstractModProvider implements IModLocator {
{
private static final String SUFFIX = ".jar"; private static final String SUFFIX = ".jar";
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private final Path modFolder; private final Path modFolder;
private final String customName; private final String customName;
public ModsFolderLocator() { public ModsFolderLocator() {
this(FMLPaths.MODSDIR.get()); this(FMLPaths.MODSDIR.get(), "mods folder");
}
ModsFolderLocator(Path modFolder) {
this(modFolder, "mods folder");
} }
ModsFolderLocator(Path modFolder, String name) { ModsFolderLocator(Path modFolder, String name) {
@@ -44,13 +40,32 @@ public class ModsFolderLocator extends AbstractJarFileModLocator
} }
@Override @Override
public Stream<Path> scanCandidates() { public List<IModLocator.ModFileOrException> scanMods() {
LOGGER.debug(LogMarkers.SCAN,"Scanning mods dir {} for mods", this.modFolder); LOGGER.debug(LogMarkers.SCAN, "Scanning mods dir {} for mods", this.modFolder);
var excluded = ModDirTransformerDiscoverer.allExcluded(); var excluded = ModDirTransformerDiscoverer.allExcluded();
try {
var ret = new ArrayList<IModLocator.ModFileOrException>();
var files = Files.list(this.modFolder).toList();
for (var file : files) {
var name = file.getFileName().toString().toLowerCase(Locale.ROOT);
if (excluded.contains(file) || !name.endsWith(SUFFIX))
continue;
var mod = this.createMod(file, true);
if (mod == null) {
LOGGER.debug(LogMarkers.SCAN, "Found unknown jar file {} ignoring", file);
} else {
ret.add(mod);
}
}
return ret;
} catch (IOException e) {
return sneak(e);
}
}
return uncheck(()-> Files.list(this.modFolder)) @SuppressWarnings("unchecked")
.filter(p-> !excluded.contains(p) && StringUtils.toLowerCase(p.getFileName().toString()).endsWith(SUFFIX)) private static <E extends Throwable, R> R sneak(Throwable e) throws E {
.sorted(Comparator.comparing(path-> StringUtils.toLowerCase(path.getFileName().toString()))); throw (E)e;
} }
@Override @Override
@@ -62,8 +77,4 @@ public class ModsFolderLocator extends AbstractJarFileModLocator
public String toString() { public String toString() {
return "{"+customName+" locator at "+this.modFolder+"}"; return "{"+customName+" locator at "+this.modFolder+"}";
} }
@Override
public void initArguments(final Map<String, ?> arguments) {
}
} }
@@ -15,9 +15,12 @@ import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import org.jetbrains.annotations.ApiStatus;
import static java.util.Arrays.asList; import static java.util.Arrays.asList;
public class NightConfigWrapper implements IConfigurable { @ApiStatus.Internal
class NightConfigWrapper implements IConfigurable {
private final UnmodifiableConfig config; private final UnmodifiableConfig config;
private IModFileInfo file; private IModFileInfo file;
@@ -9,6 +9,8 @@ import com.mojang.logging.LogUtils;
import net.minecraftforge.fml.loading.LogMarkers; import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.forgespi.language.IModLanguageProvider; import net.minecraftforge.forgespi.language.IModLanguageProvider;
import net.minecraftforge.forgespi.language.ModFileScanData; import net.minecraftforge.forgespi.language.ModFileScanData;
import org.jetbrains.annotations.ApiStatus;
import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassReader;
import org.slf4j.Logger; import org.slf4j.Logger;
@@ -18,7 +20,8 @@ import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.List; import java.util.List;
public class Scanner { @ApiStatus.Internal
class Scanner {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private final ModFile fileToScan; private final ModFile fileToScan;
@@ -10,7 +10,7 @@ import java.util.concurrent.atomic.AtomicInteger;
public final class ProgressMeter { public final class ProgressMeter {
private final String name; private final String name;
private final int steps; private final int steps;
private AtomicInteger current; private final AtomicInteger current;
private Message label; private Message label;
public ProgressMeter(String name, int steps, int current, Message label) { public ProgressMeter(String name, int steps, int current, Message label) {
@@ -7,15 +7,9 @@ package net.minecraftforge.fml.loading.targets;
import cpw.mods.jarhandling.SecureJar; import cpw.mods.jarhandling.SecureJar;
import cpw.mods.modlauncher.api.ServiceRunner; import cpw.mods.modlauncher.api.ServiceRunner;
import net.minecraftforge.fml.loading.LogMarkers;
import java.io.File; import java.io.File;
import java.nio.file.Path; import java.nio.file.Path;
import java.nio.file.Paths; import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiPredicate; import java.util.function.BiPredicate;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
@@ -63,55 +57,6 @@ abstract class CommonDevLaunchHandler extends CommonLaunchHandler {
return args.getArguments(); return args.getArguments();
} }
protected List<Path> getLibraries(String[] classpath) {
// TODO: These should all be FMLModType: LIBRARY, find them that way?
// Or at the very least include version info
var fmlcore = findJarOnClasspath(classpath, "fmlcore");
var javafmllang = findJarOnClasspath(classpath, "javafmllanguage");
var lowcodelang = findJarOnClasspath(classpath, "lowcodelanguage");
var mclang = findJarOnClasspath(classpath, "mclanguage");
return List.of(fmlcore, javafmllang, lowcodelang, mclang);
}
protected BiPredicate<String, String> getMcFilter(Path extra, List<Path> minecraft) {
var packages = getPackages(); // Pulled out so it is passed to the lambda as value
var extraPath = extra.toString().replace('\\', '/');
// We serve everything, except for things in the forge packages.
BiPredicate<String, String> mcFilter = (path, base) -> {
if (base.equals(extraPath) ||
path.endsWith("/")) return true;
for (var pkg : packages)
if (path.startsWith(pkg)) return false;
return true;
};
return mcFilter;
}
protected Path getForgeMod(List<Path> minecraft) {
var packages = getPackages(); // Pulled out so it is passed to the lambda as value
// We need to separate out our resources/code so that we can show up as a different data pack.
var modJar = SecureJar.from((path, base) -> {
if (!path.endsWith(".class")) return true;
for (var pkg : packages)
if (path.startsWith(pkg)) return true;
return false;
}, minecraft.stream().distinct().toArray(Path[]::new));
//modJar.getPackages().stream().sorted().forEach(System.out::println);
return modJar.getRootPath();
}
private static String[] getPackages() {
return new String[] {
"net/minecraftforge/",
"META-INF/services/",
"META-INF/coremods.json",
"META-INF/mods.toml"
};
}
private static String getRandomNumbers(int length) { private static String getRandomNumbers(int length) {
// Generate a time-based random number, to mimic how n.m.client.Main works // Generate a time-based random number, to mimic how n.m.client.Main works
return Long.toString(System.nanoTime() % (int) Math.pow(10, length)); return Long.toString(System.nanoTime() % (int) Math.pow(10, length));
@@ -122,48 +67,11 @@ abstract class CommonDevLaunchHandler extends CommonLaunchHandler {
return super.makeService(preLaunch(arguments, gameLayer), gameLayer); return super.makeService(preLaunch(arguments, gameLayer), gameLayer);
} }
// TODO: Get rid of this string based classpath crap when I re-write mod loader protected static String[] findClassPath() {
protected static Map<String, List<Path>> getModClasses() { var classpath = System.getProperty("legacyClassPath");
var modClasses = Optional.ofNullable(System.getenv("MOD_CLASSES")).orElse(""); if (classpath == null)
LOGGER.debug(LogMarkers.CORE, "Got mod coordinates {} from env", modClasses); classpath = System.getProperty("java.class.path");
return classpath.split(File.pathSeparator);
/*
* So MOD_CLASSES at the end of the day is a Map<ModId, List<Path>> but because we want to shove that into a single string.
* And pass it in as an environment variable.. instead od using json, or a file path, or anything sane, cpw did hacky string stuff
* Basically what we want to do is split the string by File.pathSeperator to get each key-value pair.
* Then we find the magic string "%%" and split on that. Using the first half as the mod id and the second as the path.
* BUT the modID is optional, and if not specified {why wouldn't it be?} it uses "defaultmodid"
* Anyways, it was stream hell, but now it's simpler to debug/understand.
*/
Map<String, List<Path>> ret = new HashMap<>();
var entries = modClasses.split(File.pathSeparator);
for (var entry : entries) {
var modid = "defaultmodid";
var path = entry;
int idx = entry.indexOf("%%");
if (idx != -1) {
modid = entry.substring(0, idx);
path = entry.substring(idx + 2);
}
var p = Paths.get(path);
var lst = ret.computeIfAbsent(modid, k -> new ArrayList<>());
if (!lst.contains(p))
lst.add(p);
}
LOGGER.debug(LogMarkers.CORE, "Found supplied mod coordinates:");
ret.forEach((k, v) -> {
if (v.size() == 1)
LOGGER.debug(LogMarkers.CORE, "\t{}: {}", k, v.get(0));
else {
LOGGER.debug(LogMarkers.CORE, "\t{}:", k);
v.forEach(e -> LOGGER.debug("\t\t{}", e));
}
});
return ret;
} }
protected static Path findJarOnClasspath(String[] classpath, String match) { protected static Path findJarOnClasspath(String[] classpath, String match) {
@@ -181,8 +89,49 @@ abstract class CommonDevLaunchHandler extends CommonLaunchHandler {
} }
if (ret == null) if (ret == null)
new IllegalStateException("Could not find " + match + " in classpath"); throw new IllegalStateException("Could not find " + match + " in classpath");
return Paths.get(ret); return Paths.get(ret);
} }
// TODO: [Forge][UFS][DEV] Make Forge and MC seperate sources at dev time so we don't have to filter
protected static Path getMinecraftOnly(Path extra, Path forge) {
var packages = getPackages(); // Pulled out so it is passed to the lambda as value
var extraPath = extra.toString().replace('\\', '/');
// We serve everything, except for things in the forge packages.
BiPredicate<String, String> mcFilter = (path, base) -> {
if (base.equals(extraPath) ||
path.endsWith("/")) return true;
for (var pkg : packages)
if (path.startsWith(pkg)) return false;
return true;
};
var fs = UnionHelper.newFileSystem(mcFilter, new Path[] { forge, extra });
return fs.getRootDirectories().iterator().next();
}
// TODO: [Forge][UFS][DEV] Make Forge and MC seperate sources at dev time so we don't have to filter
protected static Path getForgeOnly(Path forge) {
var packages = getPackages(); // Pulled out so it is passed to the lambda as value
// We need to separate out our resources/code so that we can show up as a different data pack.
var modJar = SecureJar.from((path, base) -> {
if (!path.endsWith(".class")) return true;
for (var pkg : packages)
if (path.startsWith(pkg)) return true;
return false;
}, new Path[] { forge });
//modJar.getPackages().stream().sorted().forEach(System.out::println);
return modJar.getRootPath();
}
private static String[] getPackages() {
return new String[] {
"net/minecraftforge/",
"META-INF/services/",
"META-INF/coremods.json",
"META-INF/mods.toml"
};
}
} }
@@ -19,8 +19,8 @@ import org.slf4j.Logger;
import java.io.IOException; import java.io.IOException;
import java.net.URI; import java.net.URI;
import java.nio.file.Path; import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List; import java.util.List;
import java.util.function.BiPredicate;
/** /**
* This is required by FMLLoader because ILaunchHandlerService doesn't have the context we need. * This is required by FMLLoader because ILaunchHandlerService doesn't have the context we need.
@@ -29,16 +29,9 @@ import java.util.function.BiPredicate;
* So until that happens, guess this is public api. * So until that happens, guess this is public api.
*/ */
public abstract class CommonLaunchHandler implements ILaunchHandlerService { public abstract class CommonLaunchHandler implements ILaunchHandlerService {
public record LocatedPaths(
List<Path> minecraftPaths,
BiPredicate<String, String> minecraftFilter,
List<List<Path>> otherModPaths,
List<Path> otherArtifacts
) {}
protected static final Logger LOGGER = LogUtils.getLogger(); protected static final Logger LOGGER = LogUtils.getLogger();
private final LaunchType type; protected final LaunchType type;
private final String prefix; private final String prefix;
protected CommonLaunchHandler(LaunchType type, String prefix) { protected CommonLaunchHandler(LaunchType type, String prefix) {
@@ -52,7 +45,7 @@ public abstract class CommonLaunchHandler implements ILaunchHandlerService {
public boolean isProduction() { return false; } public boolean isProduction() { return false; }
public abstract String getNaming(); public abstract String getNaming();
public abstract LocatedPaths getMinecraftPaths(); public abstract List<Path> getMinecraftPaths();
@Override @Override
public void configureTransformationClassLoader(final ITransformingClassLoaderBuilder builder) { public void configureTransformationClassLoader(final ITransformingClassLoaderBuilder builder) {
@@ -60,7 +53,7 @@ public abstract class CommonLaunchHandler implements ILaunchHandlerService {
protected String[] preLaunch(String[] arguments, ModuleLayer layer) { protected String[] preLaunch(String[] arguments, ModuleLayer layer) {
URI uri; URI uri;
try (var reader = layer.configuration().findModule("fmlloader").orElseThrow().reference().open()) { try (var reader = layer.configuration().findModule("net.minecraftforge.fmlloader").orElseThrow().reference().open()) {
uri = reader.find("log4j2.xml").orElseThrow(); uri = reader.find("log4j2.xml").orElseThrow();
} catch (IOException e) { } catch (IOException e) {
throw new RuntimeException(e); throw new RuntimeException(e);
@@ -89,7 +82,7 @@ public abstract class CommonLaunchHandler implements ILaunchHandlerService {
protected static final LaunchType SERVER_GAMETEST = new LaunchType("server_gametest", "forge", "net.minecraftforge.gametest.GameTestMain", Dist.DEDICATED_SERVER, false); protected static final LaunchType SERVER_GAMETEST = new LaunchType("server_gametest", "forge", "net.minecraftforge.gametest.GameTestMain", Dist.DEDICATED_SERVER, false);
protected void runTarget(String module, String target, final String[] arguments, final ModuleLayer layer) throws Throwable { protected void runTarget(String module, String target, final String[] arguments, final ModuleLayer layer) throws Throwable {
var mod = layer.findModule(module).orElseThrow(); var mod = layer.findModule(module).orElse(null);
if (mod == null) throw new IllegalStateException("Could not find module " + module); if (mod == null) throw new IllegalStateException("Could not find module " + module);
var cls = Class.forName(mod, target); var cls = Class.forName(mod, target);
if (cls == null) throw new IllegalStateException("Could not find class " + target + " in module " + module); if (cls == null) throw new IllegalStateException("Could not find class " + target + " in module " + module);
@@ -97,4 +90,24 @@ public abstract class CommonLaunchHandler implements ILaunchHandlerService {
if (mtd == null) throw new IllegalStateException("Class " + target + " in module " + module + " does not have a main(String[]) method"); if (mtd == null) throw new IllegalStateException("Class " + target + " in module " + module + " does not have a main(String[]) method");
mtd.invoke(null, (Object)arguments); mtd.invoke(null, (Object)arguments);
} }
protected static Path getPathFromResource(String resource) {
return getPathFromResource(resource, ForgeDevLaunchHandler.class.getClassLoader());
}
protected static Path getPathFromResource(String resource, ClassLoader cl) {
var url = cl.getResource(resource);
if (url == null)
throw new IllegalStateException("Could not find " + resource + " in classloader " + cl);
var str = url.toString();
int len = resource.length();
if ("jar".equalsIgnoreCase(url.getProtocol())) {
str = url.getFile();
len += 2;
}
str = str.substring(0, str.length() - len);
var path = Paths.get(URI.create(str));
return path;
}
} }
@@ -4,269 +4,33 @@
*/ */
package net.minecraftforge.fml.loading.targets; package net.minecraftforge.fml.loading.targets;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.file.spi.FileSystemProvider;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Stream;
import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.ApiStatus;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Opcodes;
import com.electronwill.nightconfig.core.Config;
import com.electronwill.nightconfig.core.file.FileNotFoundAction;
import com.electronwill.nightconfig.core.io.WritingMode;
import com.electronwill.nightconfig.toml.TomlParser;
import com.electronwill.nightconfig.toml.TomlWriter;
import com.google.common.jimfs.Jimfs;
import cpw.mods.niofs.union.UnionFileSystemProvider;
@ApiStatus.Internal @ApiStatus.Internal
abstract class ForgeDevLaunchHandler extends CommonDevLaunchHandler { abstract class ForgeDevLaunchHandler extends CommonDevLaunchHandler {
private static final String MODS_TOML = "META-INF/mods.toml";
private static final String PACK_META = "pack.mcmeta";
private static final UnionFileSystemProvider UFSP = (UnionFileSystemProvider)FileSystemProvider.installedProviders().stream().filter(fsp->fsp.getScheme().equals("union")).findFirst().orElseThrow(()->new IllegalStateException("Couldn't find UnionFileSystemProvider"));
private ForgeDevLaunchHandler(LaunchType type) { private ForgeDevLaunchHandler(LaunchType type) {
super(type, "forge_dev_"); super(type, "forge_dev_");
} }
@Override @Override
public LocatedPaths getMinecraftPaths() { public List<Path> getMinecraftPaths() {
// Our exploded directories in development include all mods and minecraft itself.
var mods = getModClasses();
// The extra jar is on the classpath, so try and pull it out of the legacy classpath // The extra jar is on the classpath, so try and pull it out of the legacy classpath
var legacyCP = Objects.requireNonNull(System.getProperty("legacyClassPath"), "Missing legacyClassPath, cannot find client-extra").split(File.pathSeparator); var legacyCP = findClassPath();
var extra = findJarOnClasspath(legacyCP, "client-extra"); var extra = findJarOnClasspath(legacyCP, "client-extra");
// Minecraft is an exploded directory, so find it.
var minecraft = getPathFromResource("net/minecraft/client/Minecraft.class");
var forge = getPathFromResource("net/minecraftforge/common/MinecraftForge.class");
// If both Forge and MC are in the same folder, then we are in intellij or gradle
// So we have to create a filtered jar
if (!forge.equals(minecraft))
return List.of(minecraft, extra);
// Minecraft is extra jar {resources} + our exploded directories in dev var filtered = CommonDevLaunchHandler.getMinecraftOnly(extra, minecraft);
var minecraft = mods.remove("minecraft"); return List.of(filtered);
if (minecraft == null)
throw new IllegalStateException("Could not find 'minecraft' mod paths.");
var mcFilter = getMcFilter(extra, minecraft);
// The MC code/Patcher edits are in exploded directories
var modstream = Stream.<List<Path>>builder();
var forge = this.getForgeMod(minecraft);
modstream.add(List.of(forge));
// Explode our test mods into a framework that treats them all as separate jars.
var tests = mods.remove("tests");
if (tests != null)
explodeTestMods(tests).forEach(modstream::add);
mods.values().forEach(modstream::add);
return new LocatedPaths(
Stream.concat(minecraft.stream(), List.of(extra).stream()).toList(),
mcFilter,
modstream.build().toList(),
getLibraries(legacyCP)
);
}
private List<List<Path>> explodeTestMods(List<Path> paths) {
var mod = new ArrayList<List<Path>>();
var memory = Jimfs.newFileSystem();
// First lets find all class files, that have the @Mod annotation and map packages to modids.
var packages = findTestModPackages(paths);
for (var entry : packages.entrySet()) {
var pkg = entry.getKey();
var modids = entry.getValue();
var resourcePaths = new LinkedHashSet<Path>();
// Jump down into the package for resources
paths.stream()
.<Path>mapMulti((p, c) -> modids.forEach(id -> c.accept(p.resolve(id))))
.filter(Files::exists).forEach(resourcePaths::add);
var root = memory.getPath(modids.iterator().next()); // use the first modid as our root
buildModsToml(resourcePaths, modids, root);
buildPackMeta(resourcePaths, root);
if (Files.exists(root))
resourcePaths.add(root);
// We want just the class files from the root of the input paths. So make a new union with a filter.
var classes = UFSP.newFileSystem(
(path, base) -> {
if (path.endsWith("/")) {
if (path.startsWith("/"))
path = path.substring(1);
return pkg.startsWith(path) || path.startsWith(pkg);
}
return path.endsWith(".class") && path.startsWith(pkg);
}, paths.toArray(Path[]::new));
// And we want the resources, and none of the classes, just in case things get kinda fucky and somehow a package overlaps a sub package {shading?}
var resources = UFSP.newFileSystem((path, base) -> !path.endsWith(".class"), resourcePaths.toArray(Path[]::new));
mod.add(List.of(classes.getRoot(), resources.getRoot()));
}
return mod;
}
// Find all the @Mods so we can generate tomls, and so we can pick packages. Right now it doesn't allow mods in parent directories,
// I could make it merge all the way up, but I think this would be fine.
private Map<String, Set<String>> findTestModPackages(List<Path> paths) {
var mods = new HashMap<String, Set<String>>();
for (var path : paths) {
try (var files = Files.walk(path)) {
var classes = files
.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".class"))
.toList();
for (var cls : classes) {
try (var is = Files.newInputStream(cls)) {
var reader = new ClassReader(is);
reader.accept(new ClassVisitor(Opcodes.ASM9) {
private String clsName;
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
this.clsName = name;
super.visit(version, access, name, signature, superName, interfaces);
}
@Override
public AnnotationVisitor visitAnnotation(String name, boolean runtime) {
if (!"Lnet/minecraftforge/fml/common/Mod;".equals(name))
return super.visitAnnotation(name, runtime);
return new AnnotationVisitor(Opcodes.ASM9) {
@Override
public void visit(String key, Object value) {
if ("value".equals(key)) {
int idx = clsName.lastIndexOf('/');
var pkg = clsName.substring(0, idx);
mods.computeIfAbsent(pkg, k -> new HashSet<>()).add((String)value);
idx = pkg.lastIndexOf('/');
while (idx != -1) {
pkg = pkg.substring(0, idx);
idx = pkg.lastIndexOf('/');
if (mods.containsKey(pkg))
throw new IllegalStateException("Invalid ForgeDev test mod layout, conflicting packages: " + pkg + " for " + clsName);
}
}
}
};
}
}, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
}
}
} catch (IOException e) {
sneak(e);
}
}
return mods;
}
// Builds or update the mods.toml file for all @Mods in this package
private void buildModsToml(Set<Path> resources, Set<String> modids, Path root) {
var toml = resources.stream()
.map(p -> p.resolve(MODS_TOML))
.filter(Files::exists)
.findFirst()
.orElse(null);
Config cfg = null;
if (toml != null)
cfg = new TomlParser().parse(toml, FileNotFoundAction.READ_NOTHING);
else
cfg = Config.inMemory();
boolean modified = false;
var defaults = Map.of(
"modLoader", "javafml",
"loaderVersion", "[0,)",
"license", "Doesnt fucking matter"
);
for (var key : defaults.keySet()) {
if (!cfg.contains(key)) {
cfg.set(key, defaults.get(key));
modified = true;
}
}
var modlist = new ArrayList<Config>();
if (cfg.contains("mods")) {
@SuppressWarnings("unchecked")
var existing = ((List<Config>)cfg.get("mods"));
modlist.addAll(existing);
}
for (var modid : modids) {
if (!modlist.stream().anyMatch(c -> modid.equals(c.get("modId")))) {
modified = true;
var tmp = Config.inMemory();
tmp.set("modId", modid);
modlist.add(tmp);
}
}
cfg.set("mods", modlist);
if (modified) {
var target = root.resolve(MODS_TOML);
try {
Files.createDirectories(target.getParent());
new TomlWriter().write(cfg, target, WritingMode.REPLACE);
} catch (IOException e) {
throw new IllegalStateException("Failed to create in memory toml: " + target, e);
}
}
}
// This is optional, it just hides a warning screen when starting up. I should probably remove this once I restructure how data gen for test mods work and make it generate there.
private void buildPackMeta(Set<Path> paths, Path root) {
var existing = paths.stream()
.map(p -> p.resolve(PACK_META))
.filter(Files::exists)
.findFirst()
.orElse(null);
if (existing != null)
return;
var target = root.resolve(PACK_META);
try {
Files.createDirectories(target.getParent());
Files.writeString(target,
"""
{
"pack": {
"description": "doesn't matter",
"pack_format": 18
}
}
""", StandardCharsets.UTF_8, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE);
} catch (IOException e) {
throw new IllegalStateException("Failed to make in memory pack.mcmeta: " + target, e);
}
}
@SuppressWarnings("unchecked")
private static <E extends Throwable, R> R sneak(Throwable e) throws E {
throw (E)e;
} }
public static class Client extends ForgeDevLaunchHandler { public static class Client extends ForgeDevLaunchHandler {
@@ -0,0 +1,281 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jetbrains.annotations.ApiStatus;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Opcodes;
import com.electronwill.nightconfig.core.Config;
import com.electronwill.nightconfig.core.file.FileNotFoundAction;
import com.electronwill.nightconfig.core.io.WritingMode;
import com.electronwill.nightconfig.toml.TomlParser;
import com.electronwill.nightconfig.toml.TomlWriter;
import com.google.common.jimfs.Jimfs;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.moddiscovery.AbstractModProvider;
import net.minecraftforge.forgespi.locating.IModLocator;
@ApiStatus.Internal
public class ForgeDevLocator extends AbstractModProvider implements IModLocator {
private static final String PACK_META = "pack.mcmeta";
@Override
public String name() {
return "forge_dev_locator";
}
@Override
public List<ModFileOrException> scanMods() {
var handler = FMLLoader.getLaunchHandler();
if (!(handler instanceof ForgeDevLaunchHandler))
return List.of();
var mods = getMods();
var ret = new ArrayList<ModFileOrException>();
for (var path : mods) {
var mod = createMod(path);
if (mod != null)
ret.add(mod);
}
return ret;
}
private List<Path> getMods() {
// Forge is an exploded directory as well
var minecraft = ForgeDevLaunchHandler.getPathFromResource("net/minecraft/client/Minecraft.class");
var forge = ForgeDevLaunchHandler.getPathFromResource("net/minecraftforge/common/MinecraftForge.class");
if (minecraft.equals(forge)) {
// If both Forge and MC are in the same folder, then we are in intellij or gradle
// So we have to create a filtered jar
forge = CommonDevLaunchHandler.getForgeOnly(forge);
}
var ret = new ArrayList<Path>();
ret.add(forge);
var isTest = Boolean.getBoolean("forgedev.enableTestMods");
if (!isTest)
return ret;
var test = ForgeDevLaunchHandler.getPathFromResource("net/minecraftforge/test/BaseTestMod.class", ClassLoader.getSystemClassLoader());
// Explode our test mods into a framework that treats them all as separate jars.
var tests = explodeTestMods(test);
ret.addAll(tests);
return ret;
}
private List<Path> explodeTestMods(Path path) {
var mod = new ArrayList<Path>();
var memory = Jimfs.newFileSystem();
// First lets find all class files, that have the @Mod annotation and map packages to modids.
var packages = findTestModPackages(path);
for (var entry : packages.entrySet()) {
var pkg = entry.getKey();
var modids = entry.getValue();
// Find resource directories for every mod in this group
var resourcePaths = new LinkedHashSet<Path>();
for (var modid : modids) {
var rsc = path.resolve(modid);
if (Files.exists(rsc))
resourcePaths.add(rsc);
}
var root = memory.getPath(modids.iterator().next()); // use the first modid as our root
buildModsToml(resourcePaths, modids, root);
buildPackMeta(resourcePaths, root);
if (Files.exists(root))
resourcePaths.add(root);
// We want just the class files from the root of the input paths. So make a new union with a filter.
var classes = UnionHelper.newFileSystem(
(name, base) -> {
if (name.endsWith("/")) {
if (name.startsWith("/"))
name = name.substring(1);
return pkg.startsWith(name) || name.startsWith(pkg);
}
return name.endsWith(".class") && name.startsWith(pkg);
}, new Path[] { path }
);
// And we want the resources, and none of the classes, just in case things get kinda fucky and somehow a package overlaps a sub package {shading?}
var resources = UnionHelper.newFileSystem((name, base) -> !name.endsWith(".class"), resourcePaths.toArray(Path[]::new));
// Union of unions, Yay!
var union = UnionHelper.newFileSystem(null, new Path[] {
classes.getRootDirectories().iterator().next(),
resources.getRootDirectories().iterator().next()
});
mod.add(union.getRootDirectories().iterator().next());
}
return mod;
}
// Find all the @Mods so we can generate tomls, and so we can pick packages. Right now it doesn't allow mods in parent directories,
// I could make it merge all the way up, but I think this would be fine.
private Map<String, Set<String>> findTestModPackages(Path path) {
var mods = new HashMap<String, Set<String>>();
try (var files = Files.walk(path)) {
var classes = files
.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".class"))
.toList();
for (var cls : classes) {
try (var is = Files.newInputStream(cls)) {
var reader = new ClassReader(is);
reader.accept(new ClassVisitor(Opcodes.ASM9) {
private String clsName;
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
this.clsName = name;
super.visit(version, access, name, signature, superName, interfaces);
}
@Override
public AnnotationVisitor visitAnnotation(String name, boolean runtime) {
if (!"Lnet/minecraftforge/fml/common/Mod;".equals(name))
return super.visitAnnotation(name, runtime);
return new AnnotationVisitor(Opcodes.ASM9) {
@Override
public void visit(String key, Object value) {
if ("value".equals(key)) {
int idx = clsName.lastIndexOf('/');
var pkg = clsName.substring(0, idx);
mods.computeIfAbsent(pkg, k -> new HashSet<>()).add((String)value);
idx = pkg.lastIndexOf('/');
while (idx != -1) {
pkg = pkg.substring(0, idx);
idx = pkg.lastIndexOf('/');
if (mods.containsKey(pkg))
throw new IllegalStateException("Invalid ForgeDev test mod layout, conflicting packages: " + pkg + " for " + clsName);
}
}
}
};
}
}, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
}
}
} catch (IOException e) {
sneak(e);
}
return mods;
}
// Builds or update the mods.toml file for all @Mods in this package
private void buildModsToml(Set<Path> resources, Set<String> modids, Path root) {
var toml = resources.stream()
.map(p -> p.resolve(MODS_TOML))
.filter(Files::exists)
.findFirst()
.orElse(null);
Config cfg = null;
if (toml != null)
cfg = new TomlParser().parse(toml, FileNotFoundAction.READ_NOTHING);
else
cfg = Config.inMemory();
boolean modified = false;
var defaults = Map.of(
"modLoader", "javafml",
"loaderVersion", "[0,)",
"license", "Doesnt fucking matter"
);
for (var key : defaults.keySet()) {
if (!cfg.contains(key)) {
cfg.set(key, defaults.get(key));
modified = true;
}
}
var modlist = new ArrayList<Config>();
if (cfg.contains("mods")) {
@SuppressWarnings("unchecked")
var existing = ((List<Config>)cfg.get("mods"));
modlist.addAll(existing);
}
for (var modid : modids) {
if (!modlist.stream().anyMatch(c -> modid.equals(c.get("modId")))) {
modified = true;
var tmp = Config.inMemory();
tmp.set("modId", modid);
modlist.add(tmp);
}
}
cfg.set("mods", modlist);
if (modified) {
var target = root.resolve(MODS_TOML);
try {
Files.createDirectories(target.getParent());
new TomlWriter().write(cfg, target, WritingMode.REPLACE);
} catch (IOException e) {
throw new IllegalStateException("Failed to create in memory toml: " + target, e);
}
}
}
// This is optional, it just hides a warning screen when starting up. I should probably remove this once I restructure how data gen for test mods work and make it generate there.
private void buildPackMeta(Set<Path> paths, Path root) {
var existing = paths.stream()
.map(p -> p.resolve(PACK_META))
.filter(Files::exists)
.findFirst()
.orElse(null);
if (existing != null)
return;
var target = root.resolve(PACK_META);
try {
Files.createDirectories(target.getParent());
Files.writeString(target,
"""
{
"pack": {
"description": "doesn't matter",
"pack_format": 18
}
}
""", StandardCharsets.UTF_8, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE);
} catch (IOException e) {
throw new IllegalStateException("Failed to make in memory pack.mcmeta: " + target, e);
}
}
@SuppressWarnings("unchecked")
private static <E extends Throwable, R> R sneak(Throwable e) throws E {
throw (E)e;
}
}
@@ -7,93 +7,36 @@ package net.minecraftforge.fml.loading.targets;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.List; import java.util.List;
import java.util.function.BiPredicate;
import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.ApiStatus;
import cpw.mods.jarhandling.SecureJar;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.LibraryFinder;
import net.minecraftforge.fml.loading.VersionInfo;
@ApiStatus.Internal @ApiStatus.Internal
abstract class ForgeProdLaunchHandler extends CommonLaunchHandler { abstract class ForgeProdLaunchHandler extends CommonLaunchHandler {
protected ForgeProdLaunchHandler(LaunchType type) { protected ForgeProdLaunchHandler(LaunchType type) {
super(type, "forge_"); super(type, "forge_");
} }
@Override public String getNaming() { return "srg"; } @Override public String getNaming() { return "mcp"; }
@Override public boolean isProduction() { return true; } @Override public boolean isProduction() { return true; }
protected Path mvn(VersionInfo info, String artifact) {
return mvn(info, artifact, "");
}
protected Path mvn(VersionInfo info, String artifact, String classifier) {
return mvn(info.forgeGroup(), artifact, classifier, info.mcAndForgeVersion());
}
protected Path mvn(String group, String artifact, String classifier, String version) {
return LibraryFinder.findPathForMaven(group, artifact, "", classifier, version);
}
@Override
public LocatedPaths getMinecraftPaths() {
var vers = FMLLoader.versionInfo();
// Minecraft
var mc = getMCPaths(vers);
// mods (Forge)
var forgejar = mvn(vers, "forge", "universal");
// Libraries
var fmlcore = mvn(vers, "fmlcore");
var javafmllang = mvn(vers, "javafmllanguage");
var lowcodelang = mvn(vers, "lowcodelanguage");
var mclang = mvn(vers, "mclanguage");
return new LocatedPaths(
mc,
null,
List.of(List.of(forgejar)),
List.of(fmlcore, javafmllang, lowcodelang, mclang)
);
}
protected abstract List<Path> getMCPaths(VersionInfo vers);
public static class Client extends ForgeProdLaunchHandler { public static class Client extends ForgeProdLaunchHandler {
public Client() { public Client() {
super(CLIENT); super(CLIENT);
} }
@Override @Override
protected List<Path> getMCPaths(VersionInfo vers) { public List<Path> getMinecraftPaths() {
var mc = mvn("net.minecraft", "client", "srg", vers.mcAndMCPVersion()); return List.of(getPathFromResource("net/minecraft/client/Minecraft.class"));
var mcextra = mvn("net.minecraft", "client", "extra", vers.mcAndMCPVersion());
var patches = mvn(vers, "forge", "client");
return List.of(mc, mcextra, patches);
} }
} }
public static class Server extends ForgeProdLaunchHandler { public static class Server extends ForgeProdLaunchHandler {
public Server() { public Server() {
super(SERVER); super(SERVER);
} }
@Override @Override
protected List<Path> getMCPaths(VersionInfo vers) { public List<Path> getMinecraftPaths() {
var mc = mvn("net.minecraft", "server", "srg", vers.mcAndMCPVersion()); return List.of(getPathFromResource("net/minecraft/server/MinecraftServer.class"));
var mcextra = mvn("net.minecraft", "server", "extra", vers.mcAndMCPVersion());
var patches = mvn(vers, "forge", "server");
// TODO: Get rid of this by filtering the file at install time.
// We only want it for it's resources. So filter everything else out.
BiPredicate<String, String> filter = (path, base) -> {
return path.equals("META-INF/versions/") || // This is required because it bypasses our filter for the manifest, and it's a multi-release jar.
(!path.endsWith(".class") && !path.startsWith("META-INF/"));
};
mcextra = SecureJar.from(filter, mcextra).getRootPath();
return List.of(mc, mcextra, patches);
} }
} }
} }
@@ -6,14 +6,13 @@
package net.minecraftforge.fml.loading.targets; package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.fml.loading.FMLLoader; import net.minecraftforge.fml.loading.FMLLoader;
import java.io.File;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.List; import java.util.List;
import java.util.Objects; import java.util.function.BiPredicate;
import java.util.stream.Stream;
import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.ApiStatus;
import cpw.mods.jarhandling.SecureJar;
@ApiStatus.Internal @ApiStatus.Internal
abstract class ForgeUserdevLaunchHandler extends CommonDevLaunchHandler { abstract class ForgeUserdevLaunchHandler extends CommonDevLaunchHandler {
private ForgeUserdevLaunchHandler(LaunchType type) { private ForgeUserdevLaunchHandler(LaunchType type) {
@@ -21,8 +20,8 @@ abstract class ForgeUserdevLaunchHandler extends CommonDevLaunchHandler {
} }
@Override @Override
public LocatedPaths getMinecraftPaths() { public List<Path> getMinecraftPaths() {
var legacyCP = Objects.requireNonNull(System.getProperty("legacyClassPath"), "Missing legacyClassPath, cannot find userdev jars").split(File.pathSeparator); var legacyCP = findClassPath();
var vers = FMLLoader.versionInfo(); var vers = FMLLoader.versionInfo();
// Minecraft is extra jar {resources} + forge jar {patches} // Minecraft is extra jar {resources} + forge jar {patches}
@@ -30,22 +29,8 @@ abstract class ForgeUserdevLaunchHandler extends CommonDevLaunchHandler {
var extra = findJarOnClasspath(legacyCP, "client-extra"); var extra = findJarOnClasspath(legacyCP, "client-extra");
var forge = findJarOnClasspath(legacyCP, "forge-" + vers.mcAndForgeVersion()); var forge = findJarOnClasspath(legacyCP, "forge-" + vers.mcAndForgeVersion());
// We need to filter the forge jar to just MC code // We need to filter the forge jar to just MC code
var filter = getMcFilter(extra, List.of(forge)); var minecraft = CommonDevLaunchHandler.getMinecraftOnly(extra, forge);
return List.of(minecraft);
// Mods is forge classes + anything from MOD_CLASSES
var modstream = Stream.<List<Path>>builder();
// We want the forge as a seperate mod jar.
var forgemod = this.getForgeMod(List.of(forge));
modstream.add(List.of(forgemod));
// Mod code is in exploded directories
getModClasses().forEach((modid, paths) -> modstream.add(paths));
return new LocatedPaths(
List.of(forge, extra),
filter,
modstream.build().toList(),
getLibraries(legacyCP)
);
} }
public static class Client extends ForgeUserdevLaunchHandler { public static class Client extends ForgeUserdevLaunchHandler {
@@ -0,0 +1,32 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import java.util.List;
import org.jetbrains.annotations.ApiStatus;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.moddiscovery.AbstractModProvider;
import net.minecraftforge.forgespi.locating.IModLocator;
@ApiStatus.Internal
public class ForgeUserdevLocator extends AbstractModProvider implements IModLocator {
@Override
public String name() {
return "forge_userdev_locator";
}
@Override
public List<ModFileOrException> scanMods() {
var handler = FMLLoader.getLaunchHandler();
if (!(handler instanceof ForgeUserdevLaunchHandler))
return List.of();
var forge = ForgeDevLaunchHandler.getPathFromResource("net/minecraftforge/common/MinecraftForge.class");
var filtered = ForgeUserdevLaunchHandler.getForgeOnly(forge);
var mod = createMod(filtered);
return List.of(mod);
}
}
@@ -0,0 +1,56 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import java.io.IOException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.spi.FileSystemProvider;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.function.BiPredicate;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.Internal
final class UnionHelper {
private static final FileSystemProvider UFSP = getUnionFileSystemProvider();
private static FileSystemProvider getUnionFileSystemProvider() {
for (var provider : FileSystemProvider.installedProviders()) {
if ("union".equals(provider.getScheme()))
return provider;
}
throw new IllegalStateException("Missing UnionFileSystemProvider");
};
static FileSystem newFileSystem(BiPredicate<String, String> filter, Path[] paths) {
try {
if (paths == null || paths.length == 0)
throw new IllegalArgumentException("Must contain atleast one path");
if (filter == null && paths.length == 1)
return FileSystems.newFileSystem(paths[0]);
var map = new HashMap<String, Object>();
if (filter != null)
map.put("filter", filter);
var lst = new ArrayList<>(Arrays.asList(paths));
var base = lst.remove(0);
map.put("additional", lst);
return UFSP.newFileSystem(base, map);
} catch (IOException e) {
return sneak(e);
}
}
@SuppressWarnings("unchecked")
private static <E extends Throwable, R> R sneak(Throwable e) throws E {
throw (E)e;
}
}
Loaded 100 of 1807 files, more files were not shown because too many files have changed in this diff. Show more