Compare commits

...
65 Commits
Author SHA1 Message Date
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
LexManos 16defac82e 1.20.2 RB 1 - https://forums.minecraftforge.net/topic/139824-forge-481-minecraft-1202/ 2023-12-06 10:21:59 -08:00
J-RAP 16483d4ea1 Implemented ClientPauseEvent/Hook (#9782) 2023-11-30 17:55:34 -08:00
J.T. McQuigg 28909812bb Datagen addOptionalTag/s methods that allow passing the TagKey itself instead of passing the location (#9807) 2023-11-29 19:27:54 -08:00
LexManos e5580b84b7 Deprecate EntityRenderersEvent.AddLayers functions that hard case to LivingEntityRenderers as the backing maps do not guarantee that type. Closes #9683 2023-11-28 20:55:20 -08:00
LexManos 607ca5beea Fix TagLoader error not printing tag name correctly. Closes #9693 2023-11-28 19:31:20 -08:00
LexManos 744906e33a Fix LoadingErrorScreen inner headers are not centered. Closes #9687 2023-11-28 19:26:56 -08:00
LexManos c1557ec3c2 Rework KeyModifiers system to properly allow keybinds to be triggered when multiple modifiers are pressed.
Fix setting keybinds whel using keyboard inputs to select the menu. Closes #9793
2023-11-28 19:10:07 -08:00
LexManos 4ac1a3dedf Fix KeyModifiers not being properly taken into account. Closes #9806 2023-11-28 16:16:00 -08:00
Paint_Ninjaandembeddedt a26f952212 Don't turn off VSync when rendering from Minecraft context (#9800)
Co-authored-by: embeddedt <[email protected]>
2023-11-26 16:57:01 -08:00
Paint_Ninjaandembeddedt 83ee68c0b0 [1.20.x] Fix rare crash with early display window, fixes #9673 (#9798)
Co-Authored-By: embeddedt <[email protected]>
2023-11-26 16:23:46 -08:00
DBotThePony a5ff932125 Move Chunk Watch/Unwatch events to fire after sync packets have been sent to the client (#9790)
This makes sure that modders who send extra chunk data will have clients who know about the chunk.
2023-11-17 08:45:55 -08:00
LexManos 0d820eddd4 Add more sanitization to the ChannelListManager because other projects like to impose arbitrary critical restrictions. Closes #9789 #9772 2023-11-15 09:09:18 -08:00
LexManos 83c651ce39 Fix tag loading being unordered. Closes #9774 2023-11-13 08:50:16 -08:00
Lupicus 7cd88944d4 Fix texture UV values for obj models. Closes #9737 (#9767) 2023-11-10 15:56:38 -08:00
Paint_Ninja dff52ecd71 Gradle 8.4 (#9778) 2023-11-10 11:51:08 -08:00
DBotThePony da34d97d9d Make Ingredient check for invalidation on getItems(), invalidate ingredients on tags update (#9688) 2023-11-07 21:53:27 -08:00
Paint_Ninja a27405b8d1 Improve mod description formatting in mods screen (#9768) 2023-11-02 10:53:17 -07:00
LexManos 7a443276a5 Fix lowcode implementation version, now that it's actually labeling the correct package. 2023-10-24 23:13:26 -07:00
LexManos e34090c809 Buildscript cleanup and organization.
Updated to use newer libraries that reduce the command line arguments needed to run the game.
Fix issues in the SecureModule's classloader that caused resources to not be seen when they are on parent module layers.
2023-10-24 16:24:13 -07:00
LexManos 72e8ae252c Fix @GameTestGenerator not functioning correctly. Closes #9748 2023-10-23 11:37:51 -07:00
Paint_Ninja 347c480bdc Optimise registries by using fastutils collections to minimize boxing. (#9749) 2023-10-14 10:14:03 -07:00
Paint_Ninja e0b9474621 Minor MDK changes (#9750) 2023-10-14 09:38:49 -07:00
Paint_Ninja 8ad1e899a3 Improve mod loading error message for errors inside mod constructors (#9751) 2023-10-14 09:38:29 -07:00
The_Dead_2 3b6bb5edbc Add a CrashReportAnalyser that tries to identify the mod that crashed the game (#9732) 2023-10-14 09:38:14 -07:00
LexManos c4e7d694c1 Fix potential threading issue when registering CriteriaTriggers. Closes #9745 2023-10-12 22:31:35 -07:00
LexManos e00de1a326 Move to a cache based crowdin solution instead of hitting the api every build. 2023-10-12 22:30:48 -07:00
LexManos e9ee999558 Fix Melon/Pumpkin stems having wrong plat type causing them to remain after trampling farmland. Fixes #9495 2023-10-11 22:54:55 -07:00
LexManos a1aacf25fe Fix loot tables not having their ids set. 2023-10-10 23:41:21 -07:00
LexManos 0c2f3e5523 Make horses and llama's fire LivingFallEvent. Fixes #9743 2023-10-09 11:33:39 -07:00
LexManos a6978cffbf Fix advancement screen being too dark. Fixes #9727 2023-10-09 11:14:52 -07:00
LexManos 2332ecf984 Fix ConditionalCodec having an inverted test. Closes #9742
Remove clean project on CI.
Bump FG version to fix transitive issue on module path.
2023-10-08 13:13:17 -07:00
LexManos 9cd73c84a6 More buildscript work
Fixed ignoreList for client and server.
Lazy configured a few more tasks
Fixed early loading screen hardcoded names.. why?
2023-10-07 12:41:16 -07:00
LexManos ab544a78d3 Bump guava to module path for jimfs. Fixes dedicated server. 2023-10-07 01:01:12 -07:00
LexManos 5b0abf97c8 Revive custom ingredient types. 2023-10-06 21:14:04 -07:00
LexManos 587b684035 Revive ConditionalRecipe and ConditionalAdvancement.
Also directly add conditional support to all vanilla recipe data generators.
2023-10-06 21:01:03 -07:00
LexManos 90dafb0df0 Rewrite our GameTest hooks to be sane.
Add game test to GlobalLootModifierTest which validates the smelting modifiers.
Removed FakePlayer system, it's broken and needs a major rewrite.
2023-10-06 21:01:02 -07:00
LexManos aff05a4cf3 Cleanup FMLLoader and Launch Handlers.
Cleanup some of the build.gradle
Start work on restructuring test mods. They are now treated as their own jars, as well as having their mods.toml auto-generated. No more mods.toml conflicts!
Add pattern matching support to Data run modlist.
2023-10-06 21:01:01 -07:00
DavidQF555 1ddac54256 Fix Slot Index for Inventory Ticking Items (#9736) 2023-09-29 00:14:56 -07:00
LexManos fcf9088aa5 Make default Entity.getAddPacket automatically use Forge's enhanced spawn packet if nessasary.
This spawn packet needs to be re-designed, it is effectively only there to hook into creating the new entity instance. This will be re-evaluated during the cleanup in 1.21+
2023-09-28 16:31:18 -07:00
Paint_Ninjaandembeddedt 374dbc7a4b Optimise path filter in mod loading (#9710)
Co-authored-by: embeddedt <[email protected]>
2023-09-28 14:26:43 -07:00
Jonathan Colmenares d25ba7adc8 Fix ignitedByLava making blocks permanently flammable (#9735) Fixes #9730 2023-09-27 23:11:48 -07:00
LexManos 05c88ae33a Some BackgroundScanHandler code cleanup. Closes #9713 2023-09-27 23:08:50 -07:00
LexManos e2d564d32a Fix missed patch causing new onInventoryTick method to not be called. 2023-09-27 16:38:29 -07:00
Lubyanoy Ivan 225092130e Fixed PlayerDestroyItemEvent not triggering for Fishing Rods (#9729) 2023-09-26 10:45:34 -07:00
RealMangoRage eefca22aa3 Fix migration error causing nether and end portals to not function properly. 2023-09-24 09:57:15 -07:00
Paint_Ninja 19bbb88e52 Optimise ForgeRegistry#validateContent by removing optimization that ModLauncher broke. (#9715) 2023-09-24 09:56:35 -07:00
Martijn van den Brand 18886e5128 Fix double message encoding in Channel#toVanillaPacket #9721 (#9722)
Fix OpenContainer message not resetting reader index of additional data.
2023-09-23 12:12:46 -07:00
LexManos 47dfa83cff Make CriteriaTriggers#register public again. Closes #9723 2023-09-23 12:04:50 -07:00
LexManos 0940c532f2 Fix Hunger bar rendering incorrectly. Fixes #9725 2023-09-23 12:04:49 -07:00
LexManos d80f106140 Send known channels to the server when they send us theirs. 2023-09-21 16:25:51 -07:00
LexManos 516b35ce57 1.20.2 Release 2023-09-21 11:28:37 -07:00
LexManos be60ddbfca Enable ForgeLootTableProvider. 2023-09-20 17:46:22 -07:00
LexManos af6e848227 Global Loot Modifiers 2023-09-20 15:24:46 -07:00
LexManos dd139115ed Move old tests. 2023-09-20 15:24:15 -07:00
LexManos 145df60bec 1.20.2-rc2 2023-09-18 10:53:24 -07:00
LexManos f7cca8fb88 1.20.2-rc1 2023-09-15 12:51:23 -07:00
LexManos 1f59b3f9fe 1.20.2-pre4 2023-09-13 15:15:42 -07:00
LexManos 084effdadf 1.20.2-pre3 2023-09-12 12:34:59 -07:00
LexManos 40a7998281 Use official mappings for in-repo patches, will be converted to SRG during build. 2023-09-11 14:47:34 -07:00
LexManos 4786fa6f89 1.20.2-pre2 2023-09-11 12:47:19 -07:00
LexManos 9291b865c7 Fix debug overlay text not rendering. 2023-09-11 11:36:45 -07:00
LexManos 52eca96fdc Make SimpleChannel use a varInt for the discriminator allowing essentially unlimited packets. 2023-09-10 20:56:04 -07:00
LexManos 4649f7af36 Rewrite networking. 2023-09-10 20:27:15 -07:00
LexManos 3edefbe33e 1.20.2-pre1 2023-09-08 10:56:10 -07:00
2283 changed files with 25955 additions and 34380 deletions

No files matched your search

+3
View File
@@ -21,3 +21,6 @@ src/generated/**/*.json text eol=lf
src/generated_test/**/.cache/cache text eol=lf src/generated_test/**/.cache/cache text eol=lf
src/generated_test/**/*.json text eol=lf src/generated_test/**/*.json text eol=lf
# We force eclipse to use unix line endings
ide/eclipse/template/.settings/*.prefs text eol=lf
+9 -4
View File
@@ -13,6 +13,9 @@
/classes /classes
*.iml *.iml
# We however WANT the ide folder as it has tempaltes/configs for developing Forge.
!ide/**
#gradle #gradle
/build /build
/.gradle /.gradle
@@ -23,7 +26,6 @@
/projects/mcp/ /projects/mcp/
/projects/clean/ /projects/clean/
/projects/forge/ /projects/forge/
/projects/fmlonly/
#/patches/* #/patches/*
#occupational hazards #occupational hazards
@@ -32,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-/
@@ -47,3 +50,5 @@ changelog.txt
*.7z *.7z
/logs/ /logs/
/ForgeRoot.ipr
/ForgeRoot.iws
-15
View File
@@ -47,8 +47,6 @@ project {
""".trimIndent(), label = "The branch specification of the repository", description = "By default all main branches are build by the configuration. Modify this value to adapt the branches build.", display = ParameterDisplay.HIDDEN, allowEmpty = true) """.trimIndent(), label = "The branch specification of the repository", description = "By default all main branches are build by the configuration. Modify this value to adapt the branches build.", display = ParameterDisplay.HIDDEN, allowEmpty = true)
text("github_repository_name", "MinecraftForge", label = "The github repository name. Used to connect to it in VCS Roots.", description = "This is the repository slug on github. So for example `MinecraftForge` or `MinecraftForge`. It is interpolated into the global VCS Roots.", display = ParameterDisplay.HIDDEN, allowEmpty = false) text("github_repository_name", "MinecraftForge", label = "The github repository name. Used to connect to it in VCS Roots.", description = "This is the repository slug on github. So for example `MinecraftForge` or `MinecraftForge`. It is interpolated into the global VCS Roots.", display = ParameterDisplay.HIDDEN, allowEmpty = false)
text("env.PUBLISHED_JAVA_ARTIFACT_ID", "forge", label = "Published artifact id", description = "The maven coordinate artifact id that has been published by this build. Can not be empty.", allowEmpty = false) text("env.PUBLISHED_JAVA_ARTIFACT_ID", "forge", label = "Published artifact id", description = "The maven coordinate artifact id that has been published by this build. Can not be empty.", allowEmpty = false)
text("env.PUBLISHED_JAVA_FML_ARTIFACT_ID", "fmlonly", label = "Published fmlonly artifact id", description = "The maven coordinate artifact id for fml only that has been published by this build. Can not be empty.", allowEmpty = false)
text("env.PUBLISHED_JAVA_FML_ARTIFACT_VERSION", "0.0.0-SNAPSHOT", label = "Published fmlonly artifact version", description = "The version for fml only that has been published by this build. Can not be empty.", allowEmpty = false)
text("env.PUBLISHED_JAVA_GROUP", "net.minecraftforge", label = "Published group", description = "The maven coordinate group that has been published by this build. Can not be empty.", allowEmpty = false) text("env.PUBLISHED_JAVA_GROUP", "net.minecraftforge", label = "Published group", description = "The maven coordinate group that has been published by this build. Can not be empty.", allowEmpty = false)
//These are references and not actually keys //These are references and not actually keys
password("env.CROWDIN_KEY", "credentialsJSON:a3102dbe-805d-4177-9f54-3d2c2eb08fd5", display = ParameterDisplay.HIDDEN) password("env.CROWDIN_KEY", "credentialsJSON:a3102dbe-805d-4177-9f54-3d2c2eb08fd5", display = ParameterDisplay.HIDDEN)
@@ -76,19 +74,6 @@ object Build : BuildType({
id("MinecraftForge_MinecraftForge__Build") id("MinecraftForge_MinecraftForge__Build")
name = "Build" name = "Build"
description = "Builds and Publishes the main branches of the project." description = "Builds and Publishes the main branches of the project."
features {
feature {
id = "trigger_fml_only_files_generator"
type = "triggerBuildFeature"
param("triggers", "MinecraftForge_FilesGenerator_GeneratePages")
param("parameters", """
env.PUBLISHED_JAVA_FML_ARTIFACT_ID~env.PUBLISHED_JAVA_ARTIFACT_ID
env.PUBLISHED_JAVA_FML_ARTIFACT_VERSION~env.PUBLISHED_JAVA_ARTIFACT_VERSION
env.PUBLISHED_JAVA_GROUP
""".trimIndent())
}
}
}) })
object BuildSecondaryBranches : BuildType({ object BuildSecondaryBranches : BuildType({
Vendored
-125
View File
@@ -1,125 +0,0 @@
@Library('forge-shared-library')_
pipeline {
options {
disableConcurrentBuilds()
}
agent {
docker {
image 'gradle:7-jdk16'
//args '-v forgegc:/home/gradle/.gradle_cache/'
}
}
environment {
GRADLE_ARGS = '--no-daemon --console=plain' // No daemon for now as FG3 kinda derps. //'-Dorg.gradle.daemon.idletimeout=5000'
DISCORD_WEBHOOK = credentials('forge-discord-jenkins-webhook')
DISCORD_PREFIX = "Job: Forge Branch: ${BRANCH_NAME} Build: #${BUILD_NUMBER}"
JENKINS_HEAD = 'https://wiki.jenkins-ci.org/download/attachments/2916393/headshot.png'
}
stages {
stage('notify_start') {
when {
not {
changeRequest()
}
}
steps {
discordSend(
title: "${DISCORD_PREFIX} Started",
successful: true,
result: 'ABORTED', //White border
thumbnail: JENKINS_HEAD,
webhookURL: DISCORD_WEBHOOK
)
}
}
/*
stage('pull_cache') {
steps {
sh 'cp -r /home/gradle/.gradle_cache/jdks/ /home/gradle/.gradle/jdks/'
sh 'cp -r /home/gradle/.gradle_cache/wrapper/ /home/gradle/.gradle/wrapper/'
sh 'cp -r /home/gradle/.gradle_cache/caches/ /home/gradle/.gradle/caches/'
}
}
*/
stage('setup') {
steps {
withGradle {
sh './gradlew ${GRADLE_ARGS} --refresh-dependencies --continue setup'
}
script {
env.MYVERSION = sh(returnStdout: true, script: './gradlew :forge:properties -q | grep "^version:" | cut -d" " -f2').trim()
env.FMLONLY_VERSION = sh(returnStdout: true, script: './gradlew :fmlonly:properties -q | grep "^version:" | cut -d" " -f2').trim()
}
}
}
stage('changelog') {
when {
not {
changeRequest()
}
}
steps {
writeChangelog(currentBuild, 'build/changelog.txt')
}
}
stage('publish') {
when {
not {
changeRequest()
}
}
environment {
CROWDIN = credentials('forge-crowdin')
KEYSTORE = credentials('forge-jenkins-keystore-old')
KEYSTORE_KEYPASS = credentials('forge-jenkins-keystore-old-keypass')
KEYSTORE_STOREPASS = credentials('forge-jenkins-keystore-old-keypass')
}
steps {
withCredentials([usernamePassword(credentialsId: 'maven-forge-user', usernameVariable: 'MAVEN_USER', passwordVariable: 'MAVEN_PASSWORD')]) {
withGradle {
sh './gradlew ${GRADLE_ARGS} publish -PkeystoreKeyPass=${KEYSTORE_KEYPASS} -PkeystoreStorePass=${KEYSTORE_STOREPASS} -Pkeystore=${KEYSTORE} -PcrowdinKey=${CROWDIN}'
}
}
}
post {
success {
build job: 'filegenerator', parameters: [string(name: 'COMMAND', value: "promote net.minecraftforge:forge ${env.MYVERSION} latest")], propagate: false, wait: false
build job: 'filegenerator', parameters: [string(name: 'COMMAND', value: "promote net.minecraftforge:fmlonly ${env.FMLONLY_VERSION} latest")], propagate: false, wait: false
}
}
}
stage('test_publish_pr') { //Publish to local repo to test full process, but don't include credentials so it can't sign/publish to maven
when {
changeRequest()
}
environment {
CROWDIN = credentials('forge-crowdin')
}
steps {
withGradle {
sh './gradlew ${GRADLE_ARGS} publish -PcrowdinKey=${CROWDIN}'
}
}
}
}
post {
always {
script {
archiveArtifacts artifacts: 'projects/forge/build/libs/**/*.*', fingerprint: true, onlyIfSuccessful: true, allowEmptyArchive: true
if (env.CHANGE_ID == null) { // This is unset for non-PRs
discordSend(
title: "${DISCORD_PREFIX} Finished ${currentBuild.currentResult}",
description: '```\n' + getChanges(currentBuild) + '\n```',
successful: currentBuild.resultIsBetterOrEqualTo("SUCCESS"),
result: currentBuild.currentResult,
thumbnail: JENKINS_HEAD,
webhookURL: DISCORD_WEBHOOK
)
}
}
}
}
}
+18 -1774
View File
File diff suppressed because it is too large. Load diff
+1 -1
View File
@@ -1,6 +1,6 @@
repositories { repositories {
maven { url = 'https://maven.minecraftforge.net/' } maven { url = 'https://maven.minecraftforge.net/' }
mavenCentral() mavenCentral()
} }
dependencies { dependencies {
@@ -0,0 +1,55 @@
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
abstract class BundleList extends DefaultTask {
@InputFiles abstract ConfigurableFileCollection getConfig()
@InputFile abstract RegularFileProperty getServerBundle()
@OutputFile abstract RegularFileProperty getOutput()
BundleList() {
config.setFrom(project.configurations.installer)
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 (var 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")
}
[
project.tasks.universalJar
].forEach{ packed ->
def 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")
}
try (def zip = new java.util.zip.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')
}
}
@@ -0,0 +1,92 @@
package net.minecraftforge.forge.tasks;
import java.util.Properties;
import java.util.Enumeration;
import java.util.Map;
import java.util.TreeSet;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.Reader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.Set;
/**
* Eclipse config files are literally just java properties, with the header cleaned up.
* https://github.com/eclipse/buildship/blob/5b2c7fca7fa86cd74d71b3c099c7b1559eba038e/org.eclipse.buildship.core/src/main/java/org/eclipse/buildship/core/internal/configuration/PreferenceStore.java#L238
*
* This does the same thing, as well as sorting alphabetically.
* It also ignores all comments. We can add them latter if someone cares.
*/
public class CleanProperties extends Properties {
private static final long serialVersionUID = 1L;
private static final String LINE_SEP = System.getProperty("line.separator");
private static final String UNIX_LINE_SEP = "\n";
private static final Charset ENCODING = StandardCharsets.UTF_8;
public CleanProperties load(File input) throws IOException {
if (input.exists()) {
try (Reader is = new InputStreamReader(new FileInputStream(input), ENCODING)) {
super.load(is);
}
}
return this;
}
public void store(File out) throws IOException {
if (!out.getParentFile().exists())
out.getParentFile().mkdirs();
try (OutputStream os = new FileOutputStream(out)) {
store(os, null);
}
}
@Override
public synchronized Enumeration<Object> keys() {
Set<Object> ret = new TreeSet<>();
for (Enumeration<?> e = super.keys(); e.hasMoreElements();)
ret.add(e.nextElement());
return Collections.enumeration(ret);
}
@Override
public Set<Map.Entry<Object, Object>> entrySet() {
Set<Map.Entry<Object, Object>> ret = new TreeSet<>((l, r) -> ((String)l.getKey()).compareTo((String)r.getKey()));
ret.addAll(super.entrySet());
return ret;
}
@Override
public void store(OutputStream out, String comments) throws IOException {
out.write(clean().getBytes(ENCODING));
out.flush();
}
@Override
public void store(Writer out, String comments) throws IOException {
out.write(clean());
out.flush();
}
private String clean() throws IOException {
ByteArrayOutputStream tmp = new ByteArrayOutputStream();
try {
super.store(tmp, null);
} finally {
tmp.close();
}
String ret = tmp.toString(ENCODING).replace(LINE_SEP, UNIX_LINE_SEP);
ret = ret.substring(ret.indexOf(UNIX_LINE_SEP) + 1);
return ret;
}
}
@@ -1,73 +0,0 @@
package net.minecraftforge.forge.tasks
import org.gradle.api.DefaultTask
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.Property
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.Optional
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.TaskAction
import java.util.zip.ZipEntry
import java.util.zip.ZipInputStream
import java.util.zip.ZipOutputStream
abstract class Crowdin extends DefaultTask {
@Input abstract Property<String> getId()
@Input @Optional abstract Property<String> getKey()
@Input boolean json = true
@OutputFile abstract RegularFileProperty getOutput()
@OutputFile abstract RegularFileProperty getExport()
Crowdin() {
outputs.upToDateWhen{ false }
id.convention('minecraft-forge')
output.convention(project.layout.buildDirectory.dir(name).map {it.file("output.zip") })
export.convention(project.layout.buildDirectory.dir(name).map {it.file("export.json") })
}
@TaskAction
def run() {
File outputFile = output.get().asFile
File exportFile = export.get().asFile
if (outputFile.exists())
outputFile.delete()
if (!key.isPresent())
return
String key = this.key.get()
String id = this.id.get()
// Force an export
new URL("https://api.crowdin.com/api/project/${id}/export?key=${key}").withInputStream { i ->
exportFile.withOutputStream { it << i }
}
if (!exportFile.text.contains('success')) {
throw new RuntimeException("Crowdin export failed, see ${exportFile} for more info")
}
new URL("https://api.crowdin.com/api/project/${id}/download/all.zip?key=${key}").withInputStream { i ->
new ZipInputStream(i).withCloseable { zin ->
outputFile.withOutputStream { out ->
new ZipOutputStream(out).withCloseable { zout ->
ZipEntry zein
while ((zein = zin.nextEntry) != null) {
if (zein.isDirectory()) {
zout.putNextEntry(new ZipEntry(zein.name))
} else {
// 1.13+ uses json
if (zein.name.endsWith('.json') == json) {
ZipEntry zeout = new ZipEntry(json ? zein.name.toLowerCase() : zein.name)
zeout.time = 1
zout.putNextEntry(zeout)
zout << zin
}
}
}
}
}
}
}
}
}
@@ -0,0 +1,24 @@
package net.minecraftforge.forge.tasks
import org.gradle.api.DefaultTask
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.Property
import org.gradle.api.tasks.*
abstract class ExtractFile extends DefaultTask {
@InputFile abstract RegularFileProperty getInput()
@Input abstract Property<String> getTarget()
@OutputFile abstract RegularFileProperty getOutput()
@TaskAction
protected void exec() {
def zip = new java.util.zip.ZipFile(input.get().asFile);
def entry = zip.getEntry(target.get())
if (entry == null)
throw new IllegalStateException(input.get().asFile.absolutePath + " does not contain " + target.get())
def stream = zip.getInputStream(entry)
output.get().asFile.withOutputStream { out ->
stream.transferTo(out)
}
}
}
@@ -1,40 +0,0 @@
package net.minecraftforge.forge.tasks
import org.gradle.api.DefaultTask
import org.gradle.api.file.DirectoryProperty
import org.gradle.api.tasks.InputDirectory
import org.gradle.api.tasks.TaskAction
import java.nio.file.Files
abstract class FixPatchImports extends DefaultTask {
@InputDirectory abstract DirectoryProperty getClean()
@InputDirectory abstract DirectoryProperty getPatched()
@TaskAction
void run() {
final patchedPath = getPatched().get().asFile.toPath()
final cleanPath = getClean().get().asFile.toPath()
try (final var stream = Files.find(patchedPath, Integer.MAX_VALUE, (path, attr) -> path.toString().endsWith('.java'))) {
final itr = stream.iterator()
while (itr.hasNext()) {
final next = itr.next()
final clean = cleanPath.resolve(patchedPath.relativize(next).toString())
final patchedLines = Files.readAllLines(next)
final cleanLines = Files.readAllLines(clean)
final patchedImport = patchedLines.findLastIndexOf(2) { it.startsWith('import ') }
final cleanImport = cleanLines.findLastIndexOf(2) { it.startsWith('import ') }
if (cleanImport !== patchedImport) {
patchedLines.removeIf { it.startsWith('import ') }
patchedLines.addAll(2, cleanLines.subList(2, cleanImport + 1))
Files.write(next, patchedLines)
}
}
}
}
}
@@ -2,21 +2,26 @@ package net.minecraftforge.forge.tasks
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'))
@@ -24,21 +29,128 @@ abstract class InstallerJar extends Zip {
from(project.zipTree(downloadInstaller.output)) { from(project.zipTree(downloadInstaller.output)) {
duplicatesStrategy = 'exclude' 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 { 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 ->
deps.put(lib.name, lib.downloads.artifact)
//println(lib.name)
}
}
// First find things we build in this project.
[
project.tasks.universalJar, // Forge runtime code
project.tasks.serverShimJar // Shim jar for dedicated server
].forEach { 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 (var 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) {
def pack = parent.offline.get() || info.url.isEmpty()
// If it's a offline jar just always pack
if (!pack) {
try {
def remote = new URL("${info.url}.sha1").getText('UTF-8')
pack = !info.sha1.equals(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" }
}
}
}
}
} }
@@ -13,7 +13,6 @@ 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 +22,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 +42,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 { 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()
] ]
] ]
]) ])
@@ -16,59 +16,63 @@ 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) configure {
def mc = project.rootProject.ext.MC_VERSION
project.afterEvaluate { def forge = project.rootProject.ext.FORGE_VERSION
packedDependencies.get().forEach { def timestamp = iso8601Now()
def jarTask = project.rootProject.tasks.findByPath(it) json.putAll([
dependsOn(jarTask) _comment: [
input.from jarTask.archiveFile "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
} }
} }
} }
@TaskAction @TaskAction
protected void exec() { protected void exec() {
if (!json.libraries) [
json.libraries = [] project.tasks.universalJar
def libs = [:] ].forEach { packed ->
getArtifacts(project, project.configurations.installer, false).each { key, lib -> libs[key] = lib } def info = Util.getMavenInfoFromTask(packed)
getArtifacts(project, project.configurations.moduleonly, false).each { key, lib -> libs[key] = lib } json.libraries.add([
name: info.name,
packedDependencies.get().collect{ project.rootProject.tasks.findByPath(it) }.forEach {
def path = Util.getMavenPath(it)
def key = Util.getMavenDep(it)
libs[key] = [
name: key,
downloads: [ downloads: [
artifact: [ artifact: [
path: path, path: info.path,
url: "https://maven.minecraftforge.net/${path}", url: "https://maven.minecraftforge.net/$info.path",
sha1: it.archiveFile.get().asFile.sha1(), sha1: packed.archiveFile.get().asFile.sha1(),
size: it.archiveFile.get().asFile.length() size: packed.archiveFile.get().asFile.length()
] ]
] ]
] ])
}
getArtifacts(project, project.configurations.installer).each { key, lib ->
json.libraries.add(lib)
} }
libs.each { key, lib -> json.libraries.add(lib) }
Files.writeString(output.get().asFile.toPath(), new JsonBuilder(json).toPrettyString()) Files.writeString(output.get().asFile.toPath(), new JsonBuilder(json).toPrettyString())
} }
} }
@@ -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 {
@@ -16,25 +16,33 @@ import java.util.zip.ZipInputStream
public class Util { public class Util {
static final ASM_LEVEL = Opcodes.ASM9 static final ASM_LEVEL = Opcodes.ASM9
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, {bytes, size ->
md.update(bytes, 0, size) md.update(bytes, 0, size)
} }
return md.digest().collect {String.format "%02x", it}.join() return md.digest().collect {String.format "%02x", it}.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, {bytes, size ->
md.update(bytes, 0, size)
}
return md.digest().collect {String.format "%02x", it}.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") def format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
def result = format.format(delegate) def 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() def lst = new ArrayList()
@@ -47,100 +55,117 @@ public class Util {
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) { public static String[] getClasspath(project, libs, 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() } public static def getArtifacts(project, config) {
def ret = [:]
config.resolvedConfiguration.resolvedArtifacts.each { dep ->
def info = getMavenInfoFromDep(dep)
def url = "https://libraries.minecraft.net/$info.path"
if (!checkExists(url))
url = "https://maven.minecraftforge.net/$info.path"
ret[info.key] = [
name: info.name,
downloads: [
artifact: [
path: info.path,
url: url,
sha1: dep.file.sha1(),
size: dep.file.length()
]
]
]
}
return ret
}
public static Map getMavenInfoFromDep(dep) {
return getMavenInfoFromMap([
group: dep.moduleVersion.id.group,
name: dep.moduleVersion.id.name,
version: dep.moduleVersion.id.version,
classifier: dep.classifier,
extension: dep.extension
])
}
public static Map getMavenInfoFromTask(task) {
return getMavenInfoFromMap([
group: task.project.group,
name: task.project.name,
version: task.project.version,
classifier: task.archiveClassifier.get(),
extension: task.archiveExtension.get()
])
}
private static Map getMavenInfoFromMap(art) {
def key = "$art.group:$art.name"
def name = "$art.group:$art.name:$art.version"
def path = "${art.group.replace('.', '/')}/$art.name/$art.version/$art.name-$art.version"
if (art.classifier != null) {
name += ":$art.classifier"
path += "-$art.classifier"
}
if (!'jar'.equals(art.extension)) {
name += "@$art.extension"
path += ".$art.extension"
} else {
path += ".jar"
}
return [
key: key,
name: name,
path: path,
art: art
]
}
public static def sha1(file) { public static def iso8601Now() { new Date().iso8601() }
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) { public static def sha1(file) {
if (!project.ext.has('tree_resolver')) MessageDigest md = MessageDigest.getInstance('SHA-1')
project.ext.tree_resolver = 1 file.eachByte 4096, {bytes, size ->
def cfg = project.configurations.create('tree_resolver_' + project.ext.tree_resolver++) md.update(bytes, 0, size)
def dep = project.dependencies.create(artifact) }
cfg.dependencies.add(dep) return md.digest().collect {String.format "%02x", it}.join()
def files = cfg.resolve() }
return getArtifacts(project, cfg, true)
}
private static boolean checkExists(url) { private static def artifactTree(project, artifact, transitive = true) {
try { if (!project.ext.has('tree_resolver'))
def code = new URL(url).openConnection().with { project.ext.tree_resolver = 1
requestMethod = 'HEAD' def cfg = project.configurations.create('tree_resolver_' + project.ext.tree_resolver++)
connect() cfg.transitive = transitive
responseCode def dep = project.dependencies.create(artifact)
} cfg.dependencies.add(dep)
return code == 200 def files = cfg.resolve()
} catch (Exception e) { return getArtifacts(project, cfg)
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 boolean checkExists(url) {
} try {
} def code = new URL(url).openConnection().with {
requestMethod = 'HEAD'
connect()
responseCode
}
return code == 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(mcVersion) { static String getLatestForgeVersion(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'))
+65
View File
@@ -0,0 +1,65 @@
plugins {
id 'java-library'
id 'org.cadixdev.licenser'
id 'net.minecraftforge.gradle.patcher'
}
evaluationDependsOn(':mcp')
repositories {
mavenCentral()
maven gradleutils.forgeMaven
maven gradleutils.minecraftLibsMaven
}
java.toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
dependencies {
implementation(libs.forgespi)
}
patcher {
parent = project(':mcp')
mcVersion = MC_VERSION
patchedSrc = file('src/main/java')
mappings channel: MAPPING_CHANNEL, version: MAPPING_VERSION
runs {
clean_client {
client true
taskName 'clean_client'
ideaModule "${rootProject.name}.${project.name}.main"
main 'net.minecraft.client.main.Main'
workingDirectory project.file('run/client')
args '--gameDir', '.'
args '--version', MC_VERSION
args '--assetsDir', downloadAssets.output
args '--assetIndex', '{asset_index}'
args '--accessToken', '0'
}
clean_server {
client false
taskName 'clean_server'
ideaModule "${rootProject.name}.${project.name}.main"
main 'net.minecraft.server.Main'
workingDirectory project.file('run/server')
}
}
}
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 {
// 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' }
if (src == null) throw new IllegalStateException("You must run `setup` task before importing")
src.entryAttributes['ignore_optional_problems'] = 'true'
}
+1034
View File
File diff suppressed because it is too large. Load diff
+44
View File
@@ -0,0 +1,44 @@
apply plugin: 'eclipse'
eclipse {
classpath.file.whenMerged {
def minecraft = entries.find { it.path == 'src/main/java' }
if (minecraft == null) throw new IllegalStateException("You must run `setup` task before importing")
// Disable optional warnings on the minecraft decompiled source code. It just muddies the warning window and hides warnings in our own codebase
minecraft.entryAttributes['ignore_optional_problems'] = 'true'
def mods = [
'src/main/java': 'minecraft',
'src/main/resources': 'minecraft',
'src/test/java': 'minecraft-test',
'src/test/resources': 'minecraft-test',
'main-java': 'forge',
'main-resources': 'forge',
'generated': 'forge',
'test-java': 'forge-test',
'test-resources': 'forge-test',
'test-generated': 'forge-test',
]
entries.forEach { e ->
if ('src'.equals(e.kind) && e.hasProperty('output')) {
if (mods.containsKey(e.path))
e.output = 'bin/' + mods[e.path]
//else
// throw new IllegalStateException('Unknown path: ' + e.toString())
}
}
}
// Filter out the run directory
project.resourceFilter {
appliesTo = 'FOLDERS'
type = 'EXCLUDE_ALL'
matcher {
id = 'org.eclipse.ui.ide.multiFilter'
arguments = '1.0-name-matches-false-true-run'
}
}
}
+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')
temp.forEach(exst::put)
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
}
+3 -3
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.1&query=$.promos["1.20.1-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.2&query=$.promos["1.20.2-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.1-&query=$.promos["1.20.1-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.2-&query=$.promos["1.20.2-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!
@@ -73,4 +73,4 @@ Please ensure you have a valid email address associated with your GitHub account
[ForgeDev]: https://docs.minecraftforge.net/en/latest/forgedev/ [ForgeDev]: https://docs.minecraftforge.net/en/latest/forgedev/
[Pull-Requests]: https://docs.minecraftforge.net/en/latest/forgedev/#making-changes-and-pull-requests [Pull-Requests]: https://docs.minecraftforge.net/en/latest/forgedev/#making-changes-and-pull-requests
[Patreon]: https://www.patreon.com/MinecraftForge [Patreon]: https://www.patreon.com/LexManos
+43 -50
View File
@@ -1,74 +1,67 @@
plugins { import net.minecraftforge.gradleutils.PomUtils
id 'com.github.ben-manes.versions'
id 'org.javamodularity.moduleplugin' version '1.8.3' apply false
id 'org.cadixdev.licenser'
}
apply plugin: 'java-library'
apply plugin: 'jacoco'
apply plugin: 'org.javamodularity.moduleplugin'
dependencyUpdates.rejectVersionIf { isNonStable(it.candidate.version) } plugins {
id 'java-library'
id 'maven-publish'
id 'org.cadixdev.licenser'
id 'net.minecraftforge.gradleutils'
}
apply from: rootProject.file('build_shared.gradle')
dependencies { dependencies {
compileOnly("org.jetbrains:annotations:${JETBRAINS_ANNOTATIONS_VERSION}") compileOnly(libs.nulls)
api("net.minecraftforge:eventbus:${EVENTBUS_VERSION}") api(libs.eventbus)
implementation(project(':fmlloader')) implementation(project(':fmlloader'))
implementation("commons-io:commons-io:${COMMONS_IO_VERSION}") 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) {
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 {
publishing.publications.mavenJava(MavenPublication) { name = project.name
from components.java description = 'Modifactions to Minecraft to enable mod developers.'
artifact sourcesJar url = 'https://github.com/MinecraftForge/MinecraftForge'
PomUtils.setGitHubDetails(pom, 'MinecraftForge')
license PomUtils.Licenses.LGPLv2_1
}
}
repositories {
maven gradleutils.publishingForgeMaven
}
} }
@@ -5,11 +5,12 @@
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.ArrayList;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader; import java.util.ServiceLoader;
import java.util.function.Supplier; import java.util.function.Supplier;
@@ -19,10 +20,18 @@ public class Bindings {
private final IBindingsProvider provider; private final IBindingsProvider provider;
private Bindings() { private Bindings() {
final var providers = ServiceLoaderUtils.streamServiceLoader(()->ServiceLoader.load(FMLLoader.getGameLayer(), IBindingsProvider.class), sce->{}).toList(); var providers = new ArrayList<IBindingsProvider>(1);
if (providers.size() != 1) { for (var itr = ServiceLoader.load(FMLLoader.getGameLayer(), IBindingsProvider.class).iterator(); itr.hasNext(); ) {
throw new IllegalStateException("Could not find bindings provider"); try {
providers.add(itr.next());
} catch (ServiceConfigurationError sce) {
sce.printStackTrace();
}
} }
if (providers.size() != 1)
throw new IllegalStateException("Could not find bindings provider: " + providers);
this.provider = providers.get(0); this.provider = providers.get(0);
} }
@@ -25,6 +25,7 @@ import java.util.function.Supplier;
* @param <T> the type of the record which is held by the extension point * @param <T> the type of the record which is held by the extension point
*/ */
@SuppressWarnings("unused") // Type parameter T @SuppressWarnings("unused") // Type parameter T
// TODO: Complete re-write, this hasnt actually be used in a generic way by mods and we could make it a lot simpler.
public interface IExtensionPoint<T extends Record> public interface IExtensionPoint<T extends Record>
{ {
/** /**
@@ -40,7 +41,7 @@ public interface IExtensionPoint<T extends Record>
* where {@code true} means it is from the server and {@code false} means it is from the world save. The return * where {@code true} means it is from the server and {@code false} means it is from the world save. The return
* value of the predicate determines whether the remote version is "compatible" for the purposes of the display test.</p> * value of the predicate determines whether the remote version is "compatible" for the purposes of the display test.</p>
* *
* <p>The local compatibility version may be of the value {@link net.minecraftforge.network.NetworkConstants#IGNORESERVERONLY}, * <p>The local compatibility version may be of the value {@link DisplayTest#IGNORESERVERONLY},
* in which case clients will ignore the mod's presence if it is present on the server but not on the client. * in which case clients will ignore the mod's presence if it is present on the server but not on the client.
* However, the remote version test predicate must still accept this value as a remote version in order to display * However, the remote version test predicate must still accept this value as a remote version in order to display
* as compatible if the mod is present on the client.</p> * as compatible if the mod is present on the client.</p>
@@ -94,6 +95,6 @@ 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 = "OHNOES\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31\uD83D\uDE31"; public static final String IGNORESERVERONLY = "SERVER_ONLY";
} }
} }
@@ -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,68 @@ 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; final int sheetOffset;
final boolean draw, animated; 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 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 +105,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 +119,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 +129,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 +153,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,27 +194,20 @@ 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;
} }
@@ -263,8 +217,7 @@ public class VersionChecker
} }
// 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())
@@ -276,9 +229,7 @@ public class VersionChecker
private static Map<IModInfo, CheckResult> results = new ConcurrentHashMap<>(); private static 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);
} }
} }
+41 -42
View File
@@ -1,14 +1,15 @@
import net.minecraftforge.gradleutils.PomUtils
plugins { plugins {
id 'com.github.ben-manes.versions' id 'java-library'
id 'org.javamodularity.moduleplugin' version '1.8.7' apply false id 'maven-publish'
id 'org.cadixdev.licenser' id 'org.cadixdev.licenser'
id 'net.minecraftforge.gradleutils'
} }
apply plugin: 'java-library'
apply plugin: 'jacoco' apply from: rootProject.file('build_shared.gradle')
apply plugin: 'org.javamodularity.moduleplugin'
import org.gradle.internal.os.OperatingSystem import org.gradle.internal.os.OperatingSystem
switch (OperatingSystem.current()) { switch (OperatingSystem.current()) {
case OperatingSystem.LINUX: case OperatingSystem.LINUX:
project.ext.lwjglNatives = "natives-linux" project.ext.lwjglNatives = "natives-linux"
@@ -21,22 +22,18 @@ switch (OperatingSystem.current()) {
break break
} }
java {
dependencyUpdates.rejectVersionIf { isNonStable(it.candidate.version) } toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
withSourcesJar()
java.withSourcesJar() }
dependencies { dependencies {
compileOnly('org.jetbrains:annotations:23.0.0') compileOnly(libs.nulls)
implementation(project(':fmlloader')) implementation(project(':fmlloader'))
implementation(project(':fmlcore')) implementation(project(':fmlcore'))
implementation('org.lwjgl:lwjgl:3.3.1') implementation(libs.bundles.lwjgl)
implementation('org.lwjgl:lwjgl-glfw:3.3.1')
implementation('org.lwjgl:lwjgl-opengl:3.3.1')
implementation('org.lwjgl:lwjgl-stb:3.3.1')
implementation('org.lwjgl:lwjgl-tinyfd:3.3.1')
implementation('org.slf4j:slf4j-api:1.8.0-beta4') implementation('org.slf4j:slf4j-api:1.8.0-beta4')
implementation("net.sf.jopt-simple:jopt-simple:${JOPT_SIMPLE_VERSION}") implementation(libs.jopt.simple)
testImplementation('org.junit.jupiter:junit-jupiter-api:5.8.2') testImplementation('org.junit.jupiter:junit-jupiter-api:5.8.2')
testImplementation('org.powermock:powermock-core:2.0.9') testImplementation('org.powermock:powermock-core:2.0.9')
testRuntimeOnly('org.junit.jupiter:junit-jupiter-engine:5.8.2') testRuntimeOnly('org.junit.jupiter:junit-jupiter-engine:5.8.2')
@@ -51,31 +48,20 @@ test {
useJUnitPlatform() useJUnitPlatform()
} }
ext { jar {
MANIFESTS = [ manifest {
'': [ attributes([
'Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"), 'Automatic-Module-Name': 'net.minecraftforge.earlydisplay',
'Git-Commit': GIT_INFO.abbreviatedId, 'Forge-Module-Layer': 'boot'
'Git-Branch': GIT_INFO.branch, ] as LinkedHashMap)
'Build-Number': "${System.getenv('BUILD_NUMBER')?:0}", attributes([
] as LinkedHashMap, 'Specification-Title': 'FML Early Display',
'net/minecraftforge/fml/earlydisplay/': [
'Specification-Title': 'FMLEarlyDisplay',
'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 ] as LinkedHashMap, 'net/minecraftforge/fml/earlydisplay/')
]
}
jar.doFirst {
MANIFESTS.each { pkg, values ->
if (pkg == '')
manifest.attributes(values)
else
manifest.attributes(values, pkg)
} }
} }
@@ -85,9 +71,22 @@ tasks.withType(JavaCompile) {
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
}
} }
@@ -40,11 +40,13 @@ import java.util.List;
import java.util.Objects; import java.util.Objects;
import java.util.Optional; import java.util.Optional;
import java.util.StringJoiner; import java.util.StringJoiner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture; import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.Semaphore; import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
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;
@@ -86,6 +88,7 @@ public class DisplayWindow implements ImmediateWindowProvider {
private int framecount; private int framecount;
private EarlyFramebuffer framebuffer; private EarlyFramebuffer framebuffer;
private ScheduledFuture<?> windowTick; private ScheduledFuture<?> windowTick;
private ScheduledFuture<?> initializationFuture;
private PerformanceInfo performanceInfo; private PerformanceInfo performanceInfo;
private ScheduledFuture<?> performanceTick; private ScheduledFuture<?> performanceTick;
@@ -111,11 +114,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));
@@ -130,7 +135,7 @@ 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 {
@@ -145,10 +150,9 @@ public class DisplayWindow implements ImmediateWindowProvider {
} }
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
@@ -226,11 +230,11 @@ public class DisplayWindow implements ImmediateWindowProvider {
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<>(Arrays.asList(
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();
@@ -264,7 +268,6 @@ public class DisplayWindow implements ImmediateWindowProvider {
public void render(int alpha) { public void render(int alpha) {
var currentVAO = glGetInteger(GL_VERTEX_ARRAY_BINDING); var currentVAO = glGetInteger(GL_VERTEX_ARRAY_BINDING);
var currentFB = glGetInteger(GL_READ_FRAMEBUFFER_BINDING); var currentFB = glGetInteger(GL_READ_FRAMEBUFFER_BINDING);
glfwSwapInterval(0);
glViewport(0, 0, this.context.scaledWidth(), this.context.scaledHeight()); glViewport(0, 0, this.context.scaledWidth(), this.context.scaledHeight());
RenderElement.globalAlpha = alpha; RenderElement.globalAlpha = alpha;
framebuffer.activate(); framebuffer.activate();
@@ -283,11 +286,12 @@ 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;
}); });
initWindow(mcVersion); initWindow(mcVersion);
renderScheduler.schedule(() -> initRender(mcVersion, forgeVersion), 1, TimeUnit.MILLISECONDS); this.initializationFuture = renderScheduler.schedule(() -> initRender(mcVersion, forgeVersion), 1, TimeUnit.MILLISECONDS);
return this::periodicTick; return this::periodicTick;
} }
@@ -518,6 +522,16 @@ public class DisplayWindow implements ImmediateWindowProvider {
* @return the Window we own. * @return the Window we own.
*/ */
public long setupMinecraftWindow(final IntSupplier width, final IntSupplier height, final Supplier<String> title, final LongSupplier monitorSupplier) { public long setupMinecraftWindow(final IntSupplier width, final IntSupplier height, final Supplier<String> title, final LongSupplier monitorSupplier) {
// wait for the window to actually be initialized
try {
this.initializationFuture.get(30, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
} catch (TimeoutException e) {
Thread.dumpStack();
crashElegantly("We seem to be having trouble initializing the window, waited for 30 seconds");
}
// we have to spin wait for the window ticker // we have to spin wait for the window ticker
ImmediateWindowHandler.updateProgress("Initializing Game Graphics"); ImmediateWindowHandler.updateProgress("Initializing Game Graphics");
while (!this.windowTick.isDone()) { while (!this.windowTick.isDone()) {
+81 -72
View File
@@ -1,78 +1,67 @@
plugins { import net.minecraftforge.gradleutils.PomUtils
id 'com.github.ben-manes.versions'
id 'org.javamodularity.moduleplugin' version '1.8.3' apply false plugins {
id 'org.cadixdev.licenser' id 'java-library'
} id 'maven-publish'
apply plugin: 'java-library' id 'org.cadixdev.licenser'
apply plugin: 'jacoco' id 'net.minecraftforge.gradleutils'
apply plugin: 'org.javamodularity.moduleplugin' }
apply from: rootProject.file('build_shared.gradle')
dependencyUpdates.rejectVersionIf { isNonStable(it.candidate.version) }
configurations.forEach{ it.transitive = false } configurations.forEach{ it.transitive = false }
dependencies { dependencies {
compileOnly("org.jetbrains:annotations:${JETBRAINS_ANNOTATIONS_VERSION}") compileOnly(libs.nulls)
api("org.ow2.asm:asm:${ASM_VERSION}") api(libs.bundles.asm) // Needed by all the black magic
api("org.ow2.asm:asm-tree:${ASM_VERSION}") api(libs.forgespi)
api("org.ow2.asm:asm-commons:${ASM_VERSION}") api(libs.mergetool.api)
api("net.minecraftforge:forgespi:${SPI_VERSION}") api(libs.log4j.api)
api("net.minecraftforge:mergetool:${MERGETOOL_VERSION}:api") api(libs.slf4j.api)
api("org.apache.logging.log4j:log4j-api:${LOG4J_VERSION}") api(libs.guava)
api("org.slf4j:slf4j-api:${SLF4J_API_VERSION}") api(libs.gson)
api("com.google.guava:guava:${GUAVA_VERSION}") api(libs.maven.artifact)
api("com.google.code.gson:gson:${GSON_VERSION}") api(libs.apache.commons)
api("org.apache.maven:maven-artifact:${APACHE_MAVEN_ARTIFACT_VERSION}") api(libs.bundles.night.config)
api("org.apache.commons:commons-lang3:${APACHE_COMMONS_LANG3_VERSION}") api(libs.modlauncher)
api("com.electronwill.night-config:core:${NIGHTCONFIG_VERSION}") api(libs.coremods)
api("com.electronwill.night-config:toml:${NIGHTCONFIG_VERSION}") api(libs.mojang.logging)
api("cpw.mods:modlauncher:${MODLAUNCHER_VERSION}") api(libs.jarjar.selector)
api("net.minecraftforge:coremods:${COREMODS_VERSION}") api(libs.jarjar.meta)
api("com.mojang:logging:${MOJANG_LOGGING_VERSION}")
api "net.minecraftforge:JarJarSelector:${JARJAR_VERSION}"
api "net.minecraftforge:JarJarMetadata:${JARJAR_VERSION}"
implementation("net.sf.jopt-simple:jopt-simple:${JOPT_SIMPLE_VERSION}") implementation(libs.jopt.simple)
implementation("cpw.mods:securejarhandler:${SECUREJARHANDLER_VERSION}") implementation(libs.securemodules)
implementation("net.minecraftforge:accesstransformers:${ACCESSTRANSFORMERS_VERSION}") implementation(libs.accesstransformers)
implementation("net.minecrell:terminalconsoleappender:${TERMINALCONSOLEAPPENDER_VERSION}") implementation(libs.terminalconsoleappender)
// implementation("org.jline:jline:${JLINE_VERSION}") implementation(libs.jimfs)
implementation("org.apache.logging.log4j:log4j-core:${LOG4J_VERSION}") implementation(libs.log4j.core)
annotationProcessor("org.apache.logging.log4j:log4j-core:${LOG4J_VERSION}") annotationProcessor(libs.log4j.core)
testCompileOnly("org.jetbrains:annotations:${JETBRAINS_ANNOTATIONS_VERSION}") testCompileOnly(libs.nulls)
testRuntimeOnly("cpw.mods:bootstraplauncher:${BOOTSTRAPLAUNCHER_VERSION}") 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 {
'/': [ attributes([
'Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"), 'Automatic-Module-Name': 'net.minecraftforge.fmlloader',
'Git-Commit': GIT_INFO.abbreviatedId, 'Forge-Module-Layer': 'boot'
'Git-Branch': GIT_INFO.branch, ] as LinkedHashMap)
'Build-Number': "${System.getenv('BUILD_NUMBER')?:0}", attributes([
] as LinkedHashMap, 'Specification-Title': 'FMLLoader',
'net/minecraftforge/fml/loading/': [ 'Specification-Vendor': 'Forge Development LLC',
'Specification-Title': 'FMLLoader', 'Specification-Version': '1',
'Specification-Vendor': 'Forge Development LLC', 'Implementation-Title': 'FMLLoader',
'Specification-Version': '1', 'Implementation-Vendor': 'Forge Development LLC',
'Implementation-Title': 'FML Loader', 'Implementation-Version': FORGE_VERSION
'Implementation-Version': '1.0', ] as LinkedHashMap, 'net/minecraftforge/fml/loading/')
'Implementation-Vendor': 'Forge'
] as LinkedHashMap
]
}
jar.doFirst {
manifest.attributes['Automatic-Module-Name'] = project.name
MANIFESTS.each { pkg, values ->
manifest.attributes(values, pkg)
} }
} }
@@ -82,16 +71,36 @@ tasks.withType(JavaCompile) {
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
] as LinkedHashMap
}
}
tasks.named('generateResources').configure {
dependsOn('writeForgeVersionJson')
}
@@ -56,6 +56,7 @@ public class ObjectHolderDefinalize implements ILaunchPluginService {
return lst != null && lst.stream().anyMatch(n -> n.desc.equals(OBJECT_HOLDER)); return lst != null && lst.stream().anyMatch(n -> n.desc.equals(OBJECT_HOLDER));
} }
@SuppressWarnings("unused")
private String getValue(List<AnnotationNode> lst) private String getValue(List<AnnotationNode> lst)
{ {
AnnotationNode ann = lst.stream().filter(n -> n.desc.equals(OBJECT_HOLDER)).findFirst().get(); AnnotationNode ann = lst.stream().filter(n -> n.desc.equals(OBJECT_HOLDER)).findFirst().get();
@@ -20,8 +20,6 @@ import org.objectweb.asm.tree.MethodNode;
import cpw.mods.modlauncher.serviceapi.ILaunchPluginService; import cpw.mods.modlauncher.serviceapi.ILaunchPluginService;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;
/** /**
* Modifies specified enums to allow runtime extension by making the $VALUES field non-final and * Modifies specified enums to allow runtime extension by making the $VALUES field non-final and
@@ -5,8 +5,6 @@
package net.minecraftforge.fml.loading; package net.minecraftforge.fml.loading;
import net.minecraftforge.fml.loading.progress.StartupNotificationManager;
import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
@@ -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));
}
}
}
@@ -14,6 +14,8 @@ import java.util.List;
* or server. * or server.
*/ */
public class EarlyLoadingException extends RuntimeException { public class EarlyLoadingException extends RuntimeException {
private static final long serialVersionUID = 2302192216172508006L;
public static class ExceptionData { public static class ExceptionData {
private final IModInfo modInfo; private final IModInfo modInfo;
private final String i18message; private final String i18message;
@@ -42,7 +42,6 @@ public class FMLConfig
private final String entry; private final String entry;
private final Object defaultValue; private final Object defaultValue;
private final String comment; private final String comment;
private final Class<?> valueType;
private final Function<Object, Object> entryFunction; private final Function<Object, Object> entryFunction;
ConfigValue(final String entry, final Object defaultValue, final String comment) { ConfigValue(final String entry, final Object defaultValue, final String comment) {
@@ -52,7 +51,6 @@ public class FMLConfig
this.entry = entry; this.entry = entry;
this.defaultValue = defaultValue; this.defaultValue = defaultValue;
this.comment = comment; this.comment = comment;
this.valueType = defaultValue.getClass();
this.entryFunction = entryFunction; this.entryFunction = entryFunction;
} }
@@ -8,15 +8,12 @@ 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;
import net.minecraftforge.fml.loading.moddiscovery.ModValidator; import net.minecraftforge.fml.loading.moddiscovery.ModValidator;
import net.minecraftforge.accesstransformer.service.AccessTransformerService; import net.minecraftforge.accesstransformer.service.AccessTransformerService;
import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.fml.loading.progress.StartupNotificationManager;
import net.minecraftforge.fml.loading.targets.CommonLaunchHandler; import net.minecraftforge.fml.loading.targets.CommonLaunchHandler;
import net.minecraftforge.forgespi.Environment; import net.minecraftforge.forgespi.Environment;
import net.minecraftforge.forgespi.coremod.ICoreModProvider; import net.minecraftforge.forgespi.coremod.ICoreModProvider;
@@ -25,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 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;
@@ -54,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);
@@ -137,6 +130,7 @@ public class FMLLoader
throw new RuntimeException("Missing launch handler: " + launchTarget); throw new RuntimeException("Missing launch handler: " + launchTarget);
} }
// 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,45 +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")
@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());
} }
} }
@@ -1,35 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading;
import java.io.File;
import java.nio.file.Path;
public class FileUtils
{
public static String fileExtension(final Path path) {
String fileName = path.getFileName().toString();
int idx = fileName.lastIndexOf('.');
if (idx > -1) {
return fileName.substring(idx+1);
} else {
return "";
}
}
public static boolean matchFileName(String path, String... matches) {
// Extract file name from path
String name = path.substring(Math.min(path.lastIndexOf(File.separatorChar) + 1, path.length()));
// Check if it contains any of the desired keywords
for (String match : matches) {
if (name.contains(match)) {
return true;
}
}
return false;
}
}
@@ -23,7 +23,7 @@ public class ImmediateWindowHandler {
private static ProgressMeter earlyProgress; private static ProgressMeter earlyProgress;
public static void load(final String launchTarget, final String[] arguments) { public static void load(final String launchTarget, final String[] arguments) {
if (!List.of("forgeclient", "forgeclientuserdev", "forgeclientdev").contains(launchTarget)) { if (!launchTarget.contains("client")) {
provider = new DummyProvider(); provider = new DummyProvider();
LOGGER.info("ImmediateWindowProvider not loading because launch target is {}", launchTarget); LOGGER.info("ImmediateWindowProvider not loading because launch target is {}", launchTarget);
} else if (!FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_CONTROL)) { } else if (!FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_CONTROL)) {
@@ -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,31 +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,27 +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.fml.loading.progress.StartupNotificationManager;
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;
@@ -36,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;
} }
} }
@@ -5,45 +5,20 @@
package net.minecraftforge.fml.loading; package net.minecraftforge.fml.loading;
import com.mojang.logging.LogUtils;
import org.slf4j.Logger;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
public class LibraryFinder { public class LibraryFinder {
private static final Logger LOGGER = LogUtils.getLogger();
private static Path libsPath; private static Path libsPath;
static Path findLibsPath() { static Path findLibsPath() {
if (libsPath == null) { if (libsPath == null) {
libsPath = Path.of(System.getProperty("libraryDirectory","crazysnowmannonsense/cheezwhizz")); libsPath = Path.of(System.getProperty("libraryDirectory", "libraries"));
if (!Files.isDirectory(libsPath)) { if (!Files.isDirectory(libsPath))
throw new IllegalStateException("Missing libraryDirectory system property, cannot continue"); throw new IllegalStateException("Library directory: `" + libsPath + "` does not exist. Set it via the `libraryDirectory` system property.");
}
} }
return libsPath; 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) { 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)); return findLibsPath().resolve(MavenCoordinateResolver.get(group, artifact, extension, classifier, version));
} }
@@ -7,7 +7,6 @@ package net.minecraftforge.fml.loading;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import cpw.mods.jarhandling.SecureJar; import cpw.mods.jarhandling.SecureJar;
import cpw.mods.modlauncher.Launcher;
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;
@@ -19,8 +18,6 @@ import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.ServiceLoader;
import java.util.zip.ZipFile;
import java.util.Set; import java.util.Set;
public class ModDirTransformerDiscoverer implements ITransformerDiscoveryService { public class ModDirTransformerDiscoverer implements ITransformerDiscoveryService {
@@ -1,96 +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 cpw.mods.modlauncher.api.LamdbaExceptionUtils;
import org.slf4j.Logger;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Objects;
import java.util.Optional;
import java.util.jar.Manifest;
import static net.minecraftforge.fml.loading.LogMarkers.CORE;
public class ModJarURLHandler extends URLStreamHandler
{
private static final Logger LOGGER = LogUtils.getLogger();
// modjar://modid/path/to/file
@Override
protected URLConnection openConnection(URL url) {
return new ModJarURLConnection(url);
}
@Override
protected int hashCode(final URL u) {
return Objects.hash(u.getHost(), u.getFile());
}
@Override
protected boolean equals(final URL u1, final URL u2) {
return Objects.equals(u1.getProtocol(), u2.getProtocol())
&& Objects.equals(u1.getHost(), u2.getHost())
&& Objects.equals(u1.getFile(), u2.getFile());
}
static class ModJarURLConnection extends URLConnection {
private Path resource;
private String modpath;
private String modid;
private Optional<Manifest> manifest;
public ModJarURLConnection(final URL url) {
super(url);
}
@Override
public void connect()
{
// if (resource == null) {
// modid = url.getHost();
// // trim first char
// modpath = url.getPath().substring(1);
// resource = FMLLoader.getLoadingModList().getModFileById(modid).getFile().findResource(modpath);
// manifest = FMLLoader.getLoadingModList().getModFileById(modid).getManifest();
// }
}
@Override
public InputStream getInputStream() throws IOException
{
connect();
LOGGER.trace(CORE, "Loading modjar URL {} got resource {} {}", url, resource, resource != null ? Files.exists(resource) : "missing");
return Files.newInputStream(resource);
}
@Override
public long getContentLengthLong() {
try {
connect();
return Files.size(resource);
} catch (IOException e) {
return -1L;
}
}
// Used to cache protectiondomains by "top level object" aka the modid
@Override
public URL getURL() {
return LamdbaExceptionUtils.uncheck(()->new URL("modjar://"+modid));
}
public Optional<Manifest> getManifest() {
return manifest;
}
}
}
@@ -8,9 +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.IModFileInfo;
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;
@@ -22,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;
@@ -72,7 +73,6 @@ public class ModSorter
} }
} }
@SuppressWarnings("UnstableApiUsage")
private void sort() private void sort()
{ {
// lambdas are identity based, so sorting them is impossible unless you hold reference to them // lambdas are identity based, so sorting them is impossible unless you hold reference to them
@@ -121,7 +121,6 @@ public class ModSorter
.collect(toList()); .collect(toList());
} }
@SuppressWarnings("UnstableApiUsage")
private void addDependency(MutableGraph<ModFileInfo> topoGraph, IModInfo.ModVersion dep) private void addDependency(MutableGraph<ModFileInfo> topoGraph, IModInfo.ModVersion dep)
{ {
final ModFileInfo self = (ModFileInfo)dep.getOwner().getOwningFile(); final ModFileInfo self = (ModFileInfo)dep.getOwner().getOwningFile();
@@ -133,6 +132,7 @@ public class ModSorter
switch (dep.getOrdering()) { switch (dep.getOrdering()) {
case BEFORE -> topoGraph.putEdge(self, target); case BEFORE -> topoGraph.putEdge(self, target);
case AFTER -> topoGraph.putEdge(target, self); case AFTER -> topoGraph.putEdge(target, self);
default -> {}
} }
} }
@@ -152,27 +152,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);
@@ -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 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,54 +16,53 @@ 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.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;
public abstract class AbstractModProvider implements IModProvider @ApiStatus.Internal
{ 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) {
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
(root, p) -> true,
path
); );
IModFile mod; IModFile mod;
var type = sj.moduleDataProvider().getManifest().getMainAttributes().getValue(ModFile.TYPE); var type = sj.moduleDataProvider().getManifest().getMainAttributes().getValue(ModFile.TYPE);
if (type == null) { if (type == null)
type = getDefaultJarModType(); type = getDefaultJarModType();
}
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);
} 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 { } 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) {
@@ -75,7 +74,7 @@ public abstract class AbstractModProvider implements IModProvider
} }
}; };
return new DefaultModFileInfo(mod, license, dummy); return new DefaultModFileInfo(mod, license == null ? "" : license, dummy);
} }
@Override @Override
@@ -83,41 +82,64 @@ 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 {
Files.walk(root)
.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 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 @Override public <T> Optional<T> getConfigElement(final String... strings) { return Optional.empty(); }
public <T> Optional<T> getConfigElement(final String... strings) @Override public List<? extends IConfigurable> getConfigList(final String... strings) { return null; }
{
return Optional.empty();
}
@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 Map<String, Object> getFileProperties() { return Collections.emptyMap(); } @Override public Map<String, Object> getFileProperties() { return Collections.emptyMap(); }
@Override @Override public String getLicense() { return license; }
public String getLicense() { return license; }
@Override public IModFile getFile() { return mod; } @Override public IModFile getFile() { return mod; }
@Override public IConfigurable getConfig() { return configurable; } @Override public IConfigurable getConfig() { return configurable; }
// These Should never be called as it's only called from ModJarMetadata.version and we bypass that // These Should never be called as it's only called from ModJarMetadata.version and we bypass that
@Override public String moduleName() { return mod.getSecureJar().name(); } @Override public String moduleName() { return mod.getSecureJar().name(); }
@Override public String versionString() { return null; } @Override public String versionString() { return null; }
@Override public List<String> usesServices() { return null; } @Override public List<String> usesServices() { return null; }
@Override public String toString() { return "IModFileInfo(" + mod.getFilePath() + ")"; }
@Override
public String toString() {
return "IModFileInfo(" + mod.getFilePath() + ")";
}
} }
} }
@@ -9,13 +9,11 @@ import com.mojang.logging.LogUtils;
import net.minecraftforge.fml.loading.ImmediateWindowHandler; import net.minecraftforge.fml.loading.ImmediateWindowHandler;
import net.minecraftforge.fml.loading.LoadingModList; import net.minecraftforge.fml.loading.LoadingModList;
import net.minecraftforge.fml.loading.LogMarkers; import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.fml.loading.progress.StartupNotificationManager;
import net.minecraftforge.forgespi.language.ModFileScanData; import net.minecraftforge.forgespi.language.ModFileScanData;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.time.Duration; import java.time.Duration;
import java.time.Instant; import java.time.Instant;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.concurrent.*; import java.util.concurrent.*;
@@ -32,9 +30,6 @@ public class BackgroundScanHandler
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private final ExecutorService modContentScanner; private final ExecutorService modContentScanner;
private final List<ModFile> pendingFiles;
private final List<ModFile> scannedFiles;
private final List<ModFile> allFiles;
private final List<ModFile> modFiles; private final List<ModFile> modFiles;
private ScanStatus status; private ScanStatus status;
private LoadingModList loadingModList; private LoadingModList loadingModList;
@@ -46,9 +41,6 @@ public class BackgroundScanHandler
thread.setDaemon(true); thread.setDaemon(true);
return thread; return thread;
}); });
scannedFiles = new ArrayList<>();
pendingFiles = new ArrayList<>();
allFiles = new ArrayList<>();
status = ScanStatus.NOT_STARTED; status = ScanStatus.NOT_STARTED;
} }
@@ -63,8 +55,6 @@ public class BackgroundScanHandler
} }
status = ScanStatus.RUNNING; status = ScanStatus.RUNNING;
ImmediateWindowHandler.updateProgress("Scanning mod candidates"); ImmediateWindowHandler.updateProgress("Scanning mod candidates");
allFiles.add(file);
pendingFiles.add(file);
final CompletableFuture<ModFileScanData> future = CompletableFuture.supplyAsync(file::compileContent, modContentScanner) final CompletableFuture<ModFileScanData> future = CompletableFuture.supplyAsync(file::compileContent, modContentScanner)
.whenComplete(file::setScanResult) .whenComplete(file::setScanResult)
.whenComplete((r,t)-> this.addCompletedFile(file,r,t)); .whenComplete((r,t)-> this.addCompletedFile(file,r,t));
@@ -76,8 +66,6 @@ public class BackgroundScanHandler
status = ScanStatus.ERRORED; status = ScanStatus.ERRORED;
LOGGER.error(LogMarkers.SCAN,"An error occurred scanning file {}", file, throwable); LOGGER.error(LogMarkers.SCAN,"An error occurred scanning file {}", file, throwable);
} }
pendingFiles.remove(file);
scannedFiles.add(file);
} }
public void setLoadingModList(LoadingModList loadingModList) public void setLoadingModList(LoadingModList loadingModList)
@@ -5,90 +5,109 @@
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.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.URI;
import java.net.URISyntaxException;
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.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)
ret.add(createMod(path));
return ret; return ret;
} }
@Override private List<URL> getUrls(ClassLoader cl, String resource) {
public void initArguments(Map<String, ?> arguments) {
var launchTarget = (String) arguments.get("launchTarget");
enabled = launchTarget != null && launchTarget.contains("dev");
}
private Path findJarPathFor(final String resourceName, final String jarName, final URL resource) {
try { try {
Path path; var lst = Collections.list(cl.getResources(resource));
final URI uri = resource.toURI(); if (LOGGER.isDebugEnabled(LogMarkers.SCAN)) {
if (uri.getScheme().equals("jar") && uri.getRawSchemeSpecificPart().contains("!/")) { Collections.sort(lst, (a, b) -> a.toString().compareTo(b.toString()));
int lastExcl = uri.getRawSchemeSpecificPart().lastIndexOf("!/"); LOGGER.debug(LogMarkers.SCAN, "Scanning Classloader: {} for {}", cl, resource);
path = Paths.get(new URI(uri.getRawSchemeSpecificPart().substring(0, lastExcl))); for (var url : lst)
} else { LOGGER.debug(LogMarkers.SCAN, "\t{}", url);
path = Paths.get(new URI("file://"+uri.getRawSchemeSpecificPart().substring(0, uri.getRawSchemeSpecificPart().length()-resourceName.length())));
} }
//LOGGER.debug(CORE, "Found JAR {} at path {}", jarName, path.toString()); return lst;
return path; } catch (IOException e) {
} catch (NullPointerException | URISyntaxException e) { LOGGER.warn(LogMarkers.SCAN, "Error finding resources for: " + resource, e);
LOGGER.error(LogMarkers.SCAN, "Failed to find JAR for class {} - {}", resourceName, jarName); return List.of();
throw new RuntimeException("Unable to locate "+resourceName+" - "+jarName, e);
} }
} }
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(),
(a,b) -> true,
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;
}
}
@@ -11,12 +11,11 @@ import net.minecraftforge.forgespi.locating.ModFileLoadingException;
import java.util.Locale; import java.util.Locale;
import java.util.Optional; import java.util.Optional;
public class InvalidModFileException extends ModFileLoadingException public class InvalidModFileException extends ModFileLoadingException {
{ private static final long serialVersionUID = 1230464325917450374L;
private final IModFileInfo modFileInfo; private final IModFileInfo modFileInfo;
public InvalidModFileException(String message, IModFileInfo modFileInfo) public InvalidModFileException(String message, IModFileInfo modFileInfo) {
{
super(String.format(Locale.ROOT, "%s (%s)", message, Optional.ofNullable(modFileInfo).map(mf->mf.getFile().getFileName()).orElse("MISSING FILE NAME"))); super(String.format(Locale.ROOT, "%s (%s)", message, Optional.ofNullable(modFileInfo).map(mf->mf.getFile().getFileName()).orElse("MISSING FILE NAME")));
this.modFileInfo = modFileInfo; this.modFileInfo = modFileInfo;
} }
@@ -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,81 +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 String name;
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;
this.name = name;
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)
{
ModAnnotation ma = annotations.getFirst();
final ModAnnotation childAnnotation = ma.addChildAnnotation(name, desc);
annotations.addFirst(childAnnotation);
return new ModAnnotationVisitor(annotations, childAnnotation,true);
}
@Override
public void visitEnd()
{
if (array)
{
annotation.endArray();
}
if (isSubAnnotation)
{
ModAnnotation child = annotations.removeFirst();
annotations.addLast(child);
}
}
}
@@ -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;
@@ -15,58 +17,118 @@ import org.objectweb.asm.Type;
import java.lang.annotation.ElementType; import java.lang.annotation.ElementType;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List;
import java.util.Set; 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);
} }
@Override @Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
{
this.asmType = Type.getObjectType(name); this.asmType = Type.getObjectType(name);
this.asmSuperType = superName != null && superName.length() > 0 ? Type.getObjectType(superName) : null; this.asmSuperType = superName != null && !superName.isEmpty() ? Type.getObjectType(superName) : null;
this.interfaces = Stream.of(interfaces).map(Type::getObjectType).collect(Collectors.toSet()); this.interfaces = Stream.of(interfaces).map(Type::getObjectType).collect(Collectors.toSet());
} }
@Override @Override
public AnnotationVisitor visitAnnotation(final String annotationName, final boolean runtimeVisible) public AnnotationVisitor visitAnnotation(final String annotationName, final boolean runtimeVisible) {
{ var ann = new ModAnnotation(ElementType.TYPE, Type.getType(annotationName), this.asmType.getClassName());
ModAnnotation 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
public FieldVisitor visitField(int access, String name, String desc, String signature, Object value)
{
return new ModFieldVisitor(name, annotations);
} }
@Override @Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
{ return new FieldVisitor(Opcodes.ASM9) {
return new ModMethodVisitor(name, desc, annotations); @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);
}
};
} }
public void buildData(final Set<ModFileScanData.ClassData> classes, final Set<ModFileScanData.AnnotationData> annotations) { @Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
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) {
classes.add(new ModFileScanData.ClassData(this.asmType, this.asmSuperType, this.interfaces)); classes.add(new ModFileScanData.ClassData(this.asmType, this.asmSuperType, this.interfaces));
final List<ModFileScanData.AnnotationData> collect = this.annotations.stream(). for (var a : this.annotations) {
filter(ma->ModFileScanData.interestingAnnotations().test(ma.getASMType())). //if (ModFileScanData.interestingAnnotations().test(a.getASMType())) // Always true, so who cares. Left as a note to remove this in SPI later.
map(a -> ModAnnotation.fromModAnnotation(this.asmType, a)).collect(Collectors.toList()); baked.add(ModAnnotation.fromModAnnotation(this.asmType, a));
annotations.addAll(collect); }
} }
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());
}
}
} }
@@ -21,6 +21,8 @@ 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 org.jetbrains.annotations.ApiStatus;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.util.ArrayList; import java.util.ArrayList;
@@ -30,6 +32,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;
@@ -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);
}
}
@@ -10,7 +10,6 @@ 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.fml.loading.LogMarkers;
import net.minecraftforge.fml.loading.progress.StartupNotificationManager;
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.IModLanguageProvider; import net.minecraftforge.forgespi.language.IModLanguageProvider;
@@ -24,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;
@@ -36,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;
@@ -177,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
@@ -207,8 +203,11 @@ public class ModFile implements IModFile {
this.securityStatus = status; this.securityStatus = status;
} }
public ArtifactVersion getJarVersion() public SecureJar.Status getSecurityStatus() {
{ return this.securityStatus;
}
public ArtifactVersion getJarVersion() {
return new DefaultArtifactVersion(this.jarVersion); return new DefaultArtifactVersion(this.jarVersion);
} }
@@ -22,7 +22,6 @@ import java.nio.file.Path;
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.stream.Collectors;
public class ModFileParser { public class ModFileParser {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
@@ -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;
@@ -24,8 +25,8 @@ import java.util.Map;
import java.util.Optional; import java.util.Optional;
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}$");
@@ -80,7 +81,8 @@ public class ModInfo implements IModInfo, IConfigurable
this.displayName = config.<String>getConfigElement("displayName") this.displayName = config.<String>getConfigElement("displayName")
.orElse(this.modId); .orElse(this.modId);
this.description = config.<String>getConfigElement("description") this.description = config.<String>getConfigElement("description")
.orElse("MISSING DESCRIPTION"); .orElse("MISSING DESCRIPTION")
.replace("\r\n", "\n").stripIndent();
this.logoFile = Optional.ofNullable(config.<String>getConfigElement("logoFile") this.logoFile = Optional.ofNullable(config.<String>getConfigElement("logoFile")
.orElseGet(() -> ownFile.flatMap(mf -> mf.<String>getConfigElement("logoFile")) .orElseGet(() -> ownFile.flatMap(mf -> mf.<String>getConfigElement("logoFile"))
.orElse(null))); .orElse(null)));
@@ -205,7 +207,7 @@ public class ModInfo implements IModInfo, IConfigurable
private final boolean mandatory; private final boolean mandatory;
private final Ordering ordering; private final Ordering ordering;
private final DependencySide side; private final DependencySide side;
private Optional<URL> referralUrl; private final Optional<URL> referralUrl;
public ModVersion(final IModInfo owner, final IConfigurable config) { public ModVersion(final IModInfo owner, final IConfigurable config) {
this.owner = owner; this.owner = owner;
@@ -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, (a,b) -> true, 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,88 +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.FileUtils;
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 = FileUtils.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();
}
/**
* 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);
}
}
@@ -9,7 +9,6 @@ import com.mojang.logging.LogUtils;
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.*;
import net.minecraftforge.fml.loading.progress.StartupNotificationManager;
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 org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
@@ -23,7 +22,7 @@ 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 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 LoadingModList loadingModList; private LoadingModList loadingModList;
@@ -31,7 +30,7 @@ public class ModValidator {
private final List<EarlyLoadingException.ExceptionData> discoveryErrorData; private final List<EarlyLoadingException.ExceptionData> discoveryErrorData;
public ModValidator(final Map<IModFile.Type, List<ModFile>> modFiles, final List<IModFileInfo> brokenFiles, final List<EarlyLoadingException.ExceptionData> discoveryErrorData) { public ModValidator(final Map<IModFile.Type, List<ModFile>> modFiles, final List<IModFileInfo> brokenFiles, final List<EarlyLoadingException.ExceptionData> discoveryErrorData) {
this.modFiles = modFiles; //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.candidateMods.addAll(lst(modFiles.get(IModFile.Type.GAMELIBRARY)));
this.candidatePlugins = lst(modFiles.get(IModFile.Type.LANGPROVIDER)); this.candidatePlugins = lst(modFiles.get(IModFile.Type.LANGPROVIDER));
@@ -9,33 +9,28 @@ 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.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 +39,22 @@ 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 stream = Files.list(this.modFolder)) {
return stream.filter(path -> !excluded.contains(path) && path.getFileName().toString().toLowerCase(Locale.ROOT).endsWith(SUFFIX))
.sorted(Comparator.comparing(path -> path.getFileName().toString().toLowerCase(Locale.ROOT)))
.map(this::createMod)
.toList();
} 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 +66,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,8 +10,6 @@ import com.google.common.base.CharMatcher;
import java.util.*; import java.util.*;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class StartupNotificationManager { public class StartupNotificationManager {
private static volatile EnumMap<Message.MessageType, List<Message>> messages = new EnumMap<>(Message.MessageType.class); private static volatile EnumMap<Message.MessageType, List<Message>> messages = new EnumMap<>(Message.MessageType.class);
@@ -6,6 +6,8 @@
package net.minecraftforge.fml.loading.targets; package net.minecraftforge.fml.loading.targets;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import org.jetbrains.annotations.ApiStatus;
import org.slf4j.Logger; import org.slf4j.Logger;
import java.util.ArrayList; import java.util.ArrayList;
@@ -19,6 +21,7 @@ import java.util.function.Supplier;
* A class that attempts to parse command line arguments into key value pairs to allow addition and editing. * A class that attempts to parse command line arguments into key value pairs to allow addition and editing.
* Can not use JOptSimple as that doesn't parse out the values for keys unless the spec says it has a value. * Can not use JOptSimple as that doesn't parse out the values for keys unless the spec says it has a value.
*/ */
@ApiStatus.Internal
class ArgumentList { class ArgumentList {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private List<Supplier<String[]>> entries = new ArrayList<>(); private List<Supplier<String[]>> entries = new ArrayList<>();
@@ -1,47 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import cpw.mods.modlauncher.api.ServiceRunner;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.LibraryFinder;
import net.minecraftforge.fml.loading.VersionInfo;
import net.minecraftforge.api.distmarker.Dist;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;
public abstract class CommonClientLaunchHandler extends CommonLaunchHandler {
@Override public Dist getDist() { return Dist.CLIENT; }
@Override public String getNaming() { return "srg"; }
@Override public boolean isProduction() { return true; }
@Override
protected ServiceRunner makeService(final String[] arguments, final ModuleLayer gameLayer) {
return ()->clientService(arguments, gameLayer);
}
@Override
public LocatedPaths getMinecraftPaths() {
final var vers = FMLLoader.versionInfo();
var mc = LibraryFinder.findPathForMaven("net.minecraft", "client", "", "srg", vers.mcAndMCPVersion());
var mcextra = LibraryFinder.findPathForMaven("net.minecraft", "client", "", "extra", vers.mcAndMCPVersion());
var mcstream = Stream.<Path>builder().add(mc).add(mcextra);
var modstream = Stream.<List<Path>>builder();
processMCStream(vers, mcstream, modstream);
var fmlcore = LibraryFinder.findPathForMaven(vers.forgeGroup(), "fmlcore", "", "", vers.mcAndForgeVersion());
var javafmllang = LibraryFinder.findPathForMaven(vers.forgeGroup(), "javafmllanguage", "", "", vers.mcAndForgeVersion());
var lowcodelang = LibraryFinder.findPathForMaven(vers.forgeGroup(), "lowcodelanguage", "", "", vers.mcAndForgeVersion());
var mclang = LibraryFinder.findPathForMaven(vers.forgeGroup(), "mclanguage", "", "", vers.mcAndForgeVersion());
return new LocatedPaths(mcstream.build().toList(), (a,b) -> true, modstream.build().toList(), List.of(fmlcore, javafmllang, lowcodelang, mclang));
}
protected abstract void processMCStream(VersionInfo versionInfo, Stream.Builder<Path> mc, Stream.Builder<List<Path>> mods);
}
@@ -7,46 +7,24 @@ 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.FileUtils;
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.Arrays;
import java.util.List;
import java.util.Objects;
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;
import java.util.stream.Stream;
public abstract class CommonDevLaunchHandler extends CommonLaunchHandler { import org.jetbrains.annotations.ApiStatus;
@ApiStatus.Internal
abstract class CommonDevLaunchHandler extends CommonLaunchHandler {
protected CommonDevLaunchHandler(LaunchType type, String prefix) {
super(type, prefix);
}
@Override public String getNaming() { return "mcp"; } @Override public String getNaming() { return "mcp"; }
@Override public boolean isProduction() { return false; } @Override public boolean isProduction() { return false; }
@Override
public LocatedPaths getMinecraftPaths() {
// Minecraft is extra jar {resources} + our exploded directories in dev
final var mcstream = Stream.<Path>builder();
// 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 extra = findJarOnClasspath(legacyCP, "client-extra");
// The MC code/Patcher edits are in exploded directories
final var modstream = Stream.<List<Path>>builder();
final var mods = getModClasses();
final var minecraft = mods.remove("minecraft");
if (minecraft == null)
throw new IllegalStateException("Could not find 'minecraft' mod paths.");
minecraft.stream().distinct().forEach(mcstream::add);
mods.values().forEach(modstream::add);
mcstream.add(extra);
var mcFilter = getMcFilter(extra, minecraft, modstream);
return new LocatedPaths(mcstream.build().toList(), mcFilter, modstream.build().toList(), getFmlStuff(legacyCP));
}
@Override @Override
protected String[] preLaunch(String[] arguments, ModuleLayer layer) { protected String[] preLaunch(String[] arguments, ModuleLayer layer) {
super.preLaunch(arguments, layer); super.preLaunch(arguments, layer);
@@ -79,24 +57,47 @@ public abstract class CommonDevLaunchHandler extends CommonLaunchHandler {
return args.getArguments(); return args.getArguments();
} }
protected List<Path> getFmlStuff(String[] classpath) { private static String getRandomNumbers(int length) {
// We also want the FML things, fmlcore, javafmllanguage, mclanguage, I don't like hard coding these, but hey whatever works for now. // Generate a time-based random number, to mimic how n.m.client.Main works
return Arrays.stream(classpath) return Long.toString(System.nanoTime() % (int) Math.pow(10, length));
.filter(e -> FileUtils.matchFileName(e, "fmlcore", "javafmllanguage", "lowcodelanguage", "mclanguage")) }
.map(Paths::get)
.toList(); @Override
protected ServiceRunner makeService(final String[] arguments, final ModuleLayer gameLayer) {
return super.makeService(preLaunch(arguments, gameLayer), gameLayer);
}
protected static String[] findClassPath() {
var classpath = System.getProperty("legacyClassPath");
if (classpath == null)
classpath = System.getProperty("java.class.path");
return classpath.split(File.pathSeparator);
} }
protected static Path findJarOnClasspath(String[] classpath, String match) { protected static Path findJarOnClasspath(String[] classpath, String match) {
return Paths.get(Arrays.stream(classpath) String ret = null;
.filter(e -> FileUtils.matchFileName(e, match))
.findFirst() for (var entry : classpath) {
.orElseThrow(() -> new IllegalStateException("Could not find " + match + " in classpath"))); int idx = entry.lastIndexOf(File.separatorChar);
if (idx == -1) continue;
var name = entry.substring(idx + 1);
if (name.startsWith(match)) {
ret = entry;
break;
}
}
if (ret == null)
throw new IllegalStateException("Could not find " + match + " in classpath");
return Paths.get(ret);
} }
protected BiPredicate<String, String> getMcFilter(Path extra, List<Path> minecraft, Stream.Builder<List<Path>> mods) { // TODO: [Forge][UFS][DEV] Make Forge and MC seperate sources at dev time so we don't have to filter
final var packages = getPackages(); protected static Path getMinecraftOnly(Path extra, Path forge) {
final var extraPath = extra.toString().replace('\\', '/'); 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. // We serve everything, except for things in the forge packages.
BiPredicate<String, String> mcFilter = (path, base) -> { BiPredicate<String, String> mcFilter = (path, base) -> {
@@ -106,34 +107,31 @@ public abstract class CommonDevLaunchHandler extends CommonLaunchHandler {
if (path.startsWith(pkg)) return false; if (path.startsWith(pkg)) return false;
return true; 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. // 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) -> { var modJar = SecureJar.from((path, base) -> {
if (!path.endsWith(".class")) return true; if (!path.endsWith(".class")) return true;
for (var pkg : packages) for (var pkg : packages)
if (path.startsWith(pkg)) return true; if (path.startsWith(pkg)) return true;
return false; return false;
}, minecraft.stream().distinct().toArray(Path[]::new)); }, new Path[] { forge });
//modJar.getPackages().stream().sorted().forEach(System.out::println); //modJar.getPackages().stream().sorted().forEach(System.out::println);
mods.add(List.of(modJar.getRootPath())); return modJar.getRootPath();
return mcFilter;
} }
protected String[] getPackages() { private static String[] getPackages() {
return new String[]{ "net/minecraftforge/", "META-INF/services/", "META-INF/coremods.json", "META-INF/mods.toml" }; return new String[] {
"net/minecraftforge/",
"META-INF/services/",
"META-INF/coremods.json",
"META-INF/mods.toml"
};
} }
private static String getRandomNumbers(int length) {
// Generate a time-based random number, to mimic how n.m.client.Main works
return Long.toString(System.nanoTime() % (int) Math.pow(10, length));
}
@Override
protected ServiceRunner makeService(final String[] arguments, final ModuleLayer gameLayer) {
var args = preLaunch(arguments, gameLayer);
return ()->devService(args, gameLayer);
}
abstract void devService(final String[] arguments, final ModuleLayer gameLayer) throws Throwable;
} }
@@ -10,54 +10,49 @@ import cpw.mods.modlauncher.api.ILaunchHandlerService;
import cpw.mods.modlauncher.api.ITransformingClassLoaderBuilder; import cpw.mods.modlauncher.api.ITransformingClassLoaderBuilder;
import cpw.mods.modlauncher.api.ServiceRunner; import cpw.mods.modlauncher.api.ServiceRunner;
import net.minecraftforge.fml.loading.FMLLoader; import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.LogMarkers;
import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.Dist;
import org.apache.logging.log4j.core.LoggerContext; import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.ConfigurationFactory; import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.core.config.ConfigurationSource; import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.apache.logging.log4j.core.config.Configurator; import org.apache.logging.log4j.core.config.Configurator;
import org.slf4j.Logger; import org.slf4j.Logger;
import sun.misc.Unsafe;
import java.io.File;
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.Arrays;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;
/**
* This is required by FMLLoader because ILaunchHandlerService doesn't have the context we need.
* I need to clean this up to make proper api. But that involves editing ModLauncher itself which i'm not gunna do right now.
*
* 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();
public abstract Dist getDist(); protected final LaunchType type;
private final String prefix;
protected CommonLaunchHandler(LaunchType type, String prefix) {
this.type = type;
this.prefix = prefix;
}
@Override public String name() { return this.prefix + this.type.name(); }
public Dist getDist() { return this.type.dist(); }
public boolean isData() { return this.type.data(); }
public boolean isProduction() { return false; }
public abstract String getNaming(); public abstract String getNaming();
public boolean isProduction() { public abstract List<Path> getMinecraftPaths();
return false;
}
public boolean isData() {
return false;
}
public abstract LocatedPaths getMinecraftPaths();
@Override @Override
public void configureTransformationClassLoader(final ITransformingClassLoaderBuilder builder) { public void configureTransformationClassLoader(final ITransformingClassLoaderBuilder builder) {
} }
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);
@@ -69,45 +64,29 @@ public abstract class CommonLaunchHandler implements ILaunchHandlerService {
return arguments; return arguments;
} }
protected final Map<String, List<Path>> getModClasses() {
final String modClasses = Optional.ofNullable(System.getenv("MOD_CLASSES")).orElse("");
LOGGER.debug(LogMarkers.CORE, "Got mod coordinates {} from env", modClasses);
record ExplodedModPath(String modid, Path path) {}
// "a/b/;c/d/;" -> "modid%%c:\fish\pepper;modid%%c:\fish2\pepper2\;modid2%%c:\fishy\bums;modid2%%c:\hmm"
final var modClassPaths = Arrays.stream(modClasses.split(File.pathSeparator))
.map(inp -> inp.split("%%", 2))
.map(splitString -> new ExplodedModPath(splitString.length == 1 ? "defaultmodid" : splitString[0], Paths.get(splitString[splitString.length - 1])))
.collect(Collectors.groupingBy(ExplodedModPath::modid, Collectors.mapping(ExplodedModPath::path, Collectors.toList())));
LOGGER.debug(LogMarkers.CORE, "Found supplied mod coordinates [{}]", modClassPaths);
//final var explodedTargets = ((Map<String, List<ExplodedDirectoryLocator.ExplodedMod>>)arguments).computeIfAbsent("explodedTargets", a -> new ArrayList<>());
//modClassPaths.forEach((modlabel,paths) -> explodedTargets.add(new ExplodedDirectoryLocator.ExplodedMod(modlabel, paths)));
return modClassPaths;
}
@Override @Override
public ServiceRunner launchService(final String[] arguments, final ModuleLayer gameLayer) { public ServiceRunner launchService(final String[] arguments, final ModuleLayer gameLayer) {
FMLLoader.beforeStart(gameLayer); FMLLoader.beforeStart(gameLayer);
return makeService(arguments, gameLayer); return makeService(arguments, gameLayer);
} }
protected abstract ServiceRunner makeService(final String[] arguments, final ModuleLayer gameLayer); protected ServiceRunner makeService(final String[] arguments, final ModuleLayer gameLayer) {
return () -> runTarget(this.type.module(), this.type.main(), arguments, gameLayer);
protected void clientService(final String[] arguments, final ModuleLayer layer) throws Throwable {
runTarget("net.minecraft.client.main.Main", arguments, layer);
} }
protected void serverService(final String[] arguments, final ModuleLayer layer) throws Throwable { protected record LaunchType(String name, String module, String main, Dist dist, boolean data) {};
runTarget("net.minecraft.server.Main", arguments, layer); protected static final LaunchType CLIENT = new LaunchType("client", "minecraft", "net.minecraft.client.main.Main", Dist.CLIENT, false);
} protected static final LaunchType DATA = new LaunchType("data", "minecraft", "net.minecraft.data.Main", Dist.CLIENT, true);
protected static final LaunchType SERVER = new LaunchType("server", "minecraft", "net.minecraft.server.Main", 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 dataService(final String[] arguments, final ModuleLayer layer) throws Throwable { protected void runTarget(String module, String target, final String[] arguments, final ModuleLayer layer) throws Throwable {
runTarget("net.minecraft.data.Main", arguments, layer); var mod = layer.findModule(module).orElse(null);
} if (mod == null) throw new IllegalStateException("Could not find module " + module);
var cls = Class.forName(mod, target);
protected void runTarget(final String target, final String[] arguments, final ModuleLayer layer) throws Throwable { if (cls == null) throw new IllegalStateException("Could not find class " + target + " in module " + module);
Class.forName(layer.findModule("minecraft").orElseThrow(),target).getMethod("main", String[].class).invoke(null, (Object)arguments); var mtd = cls.getMethod("main", String[].class);
if (mtd == null) throw new IllegalStateException("Class " + target + " in module " + module + " does not have a main(String[]) method");
mtd.invoke(null, (Object)arguments);
} }
} }
@@ -1,58 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import cpw.mods.jarhandling.SecureJar;
import cpw.mods.modlauncher.api.ServiceRunner;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.LibraryFinder;
import net.minecraftforge.fml.loading.VersionInfo;
import net.minecraftforge.api.distmarker.Dist;
import java.nio.file.Path;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.stream.Stream;
public abstract class CommonServerLaunchHandler extends CommonLaunchHandler {
@Override public Dist getDist() { return Dist.DEDICATED_SERVER; }
@Override public String getNaming() { return "srg"; }
@Override public boolean isProduction() { return true; }
@Override
protected ServiceRunner makeService(String[] arguments, ModuleLayer layer) {
return () -> serverService(arguments, layer);
}
@Override
public LocatedPaths getMinecraftPaths() {
final var vers = FMLLoader.versionInfo();
var mc = LibraryFinder.findPathForMaven("net.minecraft", "server", "", "srg", vers.mcAndMCPVersion());
var mcextra = LibraryFinder.findPathForMaven("net.minecraft", "server", "", "extra", vers.mcAndMCPVersion());
var mcextra_filtered = SecureJar.from( // We only want it for it's resources. So filter everything else out.
(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
);
BiPredicate<String, String> filter = (path, base) -> true;
var mcstream = Stream.<Path>builder().add(mc).add(mcextra_filtered.getRootPath());
var modstream = Stream.<List<Path>>builder();
filter = processMCStream(vers, mcstream, filter, modstream);
var fmlcore = LibraryFinder.findPathForMaven(vers.forgeGroup(), "fmlcore", "", "", vers.mcAndForgeVersion());
var javafmllang = LibraryFinder.findPathForMaven(vers.forgeGroup(), "javafmllanguage", "", "", vers.mcAndForgeVersion());
var lowcodelang = LibraryFinder.findPathForMaven(vers.forgeGroup(), "lowcodelanguage", "", "", vers.mcAndForgeVersion());
var mclang = LibraryFinder.findPathForMaven(vers.forgeGroup(), "mclanguage", "", "", vers.mcAndForgeVersion());
return new LocatedPaths(mcstream.build().toList(), filter, modstream.build().toList(), List.of(fmlcore, javafmllang, lowcodelang, mclang));
}
protected abstract BiPredicate<String, String> processMCStream(VersionInfo versionInfo, Stream.Builder<Path> mc, BiPredicate<String, String> filter, Stream.Builder<List<Path>> mods);
}
@@ -1,42 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.VersionInfo;
import java.io.File;
import java.nio.file.Path;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public abstract class CommonUserdevLaunchHandler extends CommonDevLaunchHandler {
@Override
public LocatedPaths getMinecraftPaths() {
final var vers = FMLLoader.versionInfo();
// Minecraft is extra jar {resources} + forge jar {patches}
final var mcstream = Stream.<Path>builder();
// Mod code is in exploded directories
final var modstream = Stream.<List<Path>>builder();
// The MC extra and forge jars are on the classpath, so try and pull them out
var legacyCP = Objects.requireNonNull(System.getProperty("legacyClassPath"), "Missing legacyClassPath, cannot find userdev jars").split(File.pathSeparator);
var extra = findJarOnClasspath(legacyCP, "client-extra");
processStreams(legacyCP, vers, mcstream, modstream);
getModClasses().forEach((modid, paths) -> modstream.add(paths));
var minecraft = mcstream.build().collect(Collectors.toList());
var mcFilter = getMcFilter(extra, minecraft, modstream);
minecraft.add(extra); // Add extra late so the filter is made correctly
return new LocatedPaths(minecraft, mcFilter, modstream.build().toList(), getFmlStuff(legacyCP));
}
protected abstract void processStreams(String[] classpath, VersionInfo versionInfo, Stream.Builder<Path> mc, Stream.Builder<List<Path>> mods);
}
@@ -1,18 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class FMLClientDevLaunchHandler extends CommonDevLaunchHandler {
@Override public String name() { return "fmlclientdev"; }
@Override public Dist getDist() { return Dist.CLIENT; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
clientService(arguments, layer);
}
}
@@ -1,23 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;
import net.minecraftforge.fml.loading.LibraryFinder;
import net.minecraftforge.fml.loading.VersionInfo;
public class FMLClientLaunchHandler extends CommonClientLaunchHandler {
@Override public String name() { return "fmlclient"; }
@Override
protected void processMCStream(VersionInfo versionInfo, Stream.Builder<Path> mc, Stream.Builder<List<Path>> mods) {
var fmlonly = LibraryFinder.findPathForMaven(versionInfo.forgeGroup(), "fmlonly", "", "universal", versionInfo.mcAndForgeVersion());
mods.add(List.of(fmlonly));
}
}
@@ -1,21 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class FMLClientUserdevLaunchHandler extends FMLUserdevLaunchHandler {
@Override
public String name() { return "fmlclientuserdev"; }
@Override
public Dist getDist() { return Dist.CLIENT; }
@Override
protected void devService(String[] arguments, ModuleLayer layer) throws Throwable {
clientService(arguments, layer);
}
}
@@ -1,24 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class FMLDataUserdevLaunchHandler extends FMLUserdevLaunchHandler {
@Override
public String name() { return "fmldatauserdev"; }
@Override
public Dist getDist() { return Dist.CLIENT; }
@Override
public boolean isData() { return true; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
dataService(arguments, layer);
}
}
@@ -1,18 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class FMLServerDevLaunchHandler extends CommonDevLaunchHandler {
@Override public String name() { return "fmlserverdev"; }
@Override public Dist getDist() { return Dist.DEDICATED_SERVER; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
serverService(arguments, layer);
}
}
@@ -1,26 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import cpw.mods.modlauncher.api.ILaunchHandlerService;
import net.minecraftforge.fml.loading.LibraryFinder;
import net.minecraftforge.fml.loading.VersionInfo;
import java.nio.file.Path;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.stream.Stream;
public class FMLServerLaunchHandler extends CommonServerLaunchHandler implements ILaunchHandlerService {
@Override public String name() { return "fmlserver"; }
@Override
protected BiPredicate<String, String> processMCStream(VersionInfo versionInfo, Stream.Builder<Path> mc, BiPredicate<String, String> filter, Stream.Builder<List<Path>> mods) {
var fmlonly = LibraryFinder.findPathForMaven(versionInfo.forgeGroup(), "fmlonly", "", "universal", versionInfo.mcAndForgeVersion());
mods.add(List.of(fmlonly));
return filter;
}
}
@@ -1,18 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class FMLServerUserdevLaunchHandler extends FMLUserdevLaunchHandler {
@Override public String name() { return "fmlserveruserdev"; }
@Override public Dist getDist() { return Dist.DEDICATED_SERVER; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
serverService(arguments, layer);
}
}
@@ -1,20 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.fml.loading.VersionInfo;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;
public abstract class FMLUserdevLaunchHandler extends CommonUserdevLaunchHandler {
@Override
protected void processStreams(String[] classpath, VersionInfo versionInfo, Stream.Builder<Path> mc, Stream.Builder<List<Path>> mods) {
var fmlonly = findJarOnClasspath(classpath, "fmlonly-" + versionInfo.mcAndForgeVersion());
mc.add(fmlonly);
}
}
@@ -1,18 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class ForgeClientDevLaunchHandler extends CommonDevLaunchHandler {
@Override public String name() { return "forgeclientdev"; }
@Override public Dist getDist() { return Dist.CLIENT; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
clientService(arguments, layer);
}
}
@@ -1,25 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;
import net.minecraftforge.fml.loading.LibraryFinder;
import net.minecraftforge.fml.loading.VersionInfo;
public class ForgeClientLaunchHandler extends CommonClientLaunchHandler {
@Override public String name() { return "forgeclient"; }
@Override
protected void processMCStream(VersionInfo versionInfo, Stream.Builder<Path> mc, Stream.Builder<List<Path>> mods) {
var forgepatches = LibraryFinder.findPathForMaven(versionInfo.forgeGroup(), "forge", "", "client", versionInfo.mcAndForgeVersion());
var forgejar = LibraryFinder.findPathForMaven(versionInfo.forgeGroup(), "forge", "", "universal", versionInfo.mcAndForgeVersion());
mc.add(forgepatches);
mods.add(List.of(forgejar));
}
}
@@ -1,21 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class ForgeClientUserdevLaunchHandler extends ForgeUserdevLaunchHandler {
@Override
public String name() { return "forgeclientuserdev"; }
@Override
public Dist getDist() { return Dist.CLIENT; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
clientService(arguments, layer);
}
}
@@ -1,19 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class ForgeDataDevLaunchHandler extends CommonDevLaunchHandler {
@Override public String name() { return "forgedatadev"; }
@Override public Dist getDist() { return Dist.CLIENT; }
@Override public boolean isData() { return true; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
Class.forName(layer.findModule("minecraft").orElseThrow(), "net.minecraft.data.Main").getMethod("main", String[].class).invoke(null, (Object) arguments);
}
}
@@ -1,24 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class ForgeDataUserdevLaunchHandler extends ForgeUserdevLaunchHandler {
@Override
public String name() { return "forgedatauserdev"; }
@Override
public Dist getDist() { return Dist.CLIENT; }
@Override
public boolean isData() { return true; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
dataService(arguments, layer);
}
}
@@ -0,0 +1,78 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import java.net.URI;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.Internal
abstract class ForgeDevLaunchHandler extends CommonDevLaunchHandler {
private ForgeDevLaunchHandler(LaunchType type) {
super(type, "forge_dev_");
}
@Override
public List<Path> getMinecraftPaths() {
// The extra jar is on the classpath, so try and pull it out of the legacy classpath
var legacyCP = findClassPath();
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);
var filtered = CommonDevLaunchHandler.getMinecraftOnly(extra, minecraft);
return List.of(filtered);
}
static Path getPathFromResource(String resource) {
var cl = ForgeDevLaunchHandler.class.getClassLoader();
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;
}
public static class Client extends ForgeDevLaunchHandler {
public Client() {
super(CLIENT);
}
}
public static class Data extends ForgeDevLaunchHandler {
public Data() {
super(DATA);
}
}
public static class Server extends ForgeDevLaunchHandler {
public Server() {
super(SERVER);
}
}
public static class ServerGameTest extends ForgeDevLaunchHandler {
public ServerGameTest() {
super(SERVER_GAMETEST);
}
}
}
@@ -0,0 +1,276 @@
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");
// 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;
}
}
@@ -1,18 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class ForgeGametestDevLaunchHandler extends CommonDevLaunchHandler {
@Override public String name() { return "forgegametestserverdev"; }
@Override public Dist getDist() { return Dist.DEDICATED_SERVER; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
Class.forName(layer.findModule("forge").orElseThrow(), "net.minecraftforge.gametest.GameTestMain").getMethod("main", String[].class).invoke(null, (Object)arguments);
}
}
@@ -1,18 +0,0 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import net.minecraftforge.api.distmarker.Dist;
public class ForgeGametestUserdevLaunchHandler extends ForgeUserdevLaunchHandler {
@Override public String name() { return "forgegametestserveruserdev"; }
@Override public Dist getDist() { return Dist.DEDICATED_SERVER; }
@Override
public void devService(String[] arguments, ModuleLayer layer) throws Throwable {
Class.forName(layer.findModule("forge").orElseThrow(), "net.minecraftforge.gametest.GameTestMain").getMethod("main", String[].class).invoke(null, (Object)arguments);
}
}
@@ -0,0 +1,42 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.fml.loading.targets;
import java.nio.file.Path;
import java.util.List;
import org.jetbrains.annotations.ApiStatus;
import net.minecraftforge.fml.loading.FMLLoader;
import net.minecraftforge.fml.loading.LibraryFinder;
@ApiStatus.Internal
abstract class ForgeProdLaunchHandler extends CommonLaunchHandler {
protected ForgeProdLaunchHandler(LaunchType type) {
super(type, "forge_");
}
@Override public String getNaming() { return "srg"; }
@Override public boolean isProduction() { return true; }
@Override
public List<Path> getMinecraftPaths() {
var vers = FMLLoader.versionInfo();
var mc = LibraryFinder.findPathForMaven(vers.forgeGroup(), "forge", "", this.type.name(), vers.mcAndForgeVersion());
return List.of(mc);
}
public static class Client extends ForgeProdLaunchHandler {
public Client() {
super(CLIENT);
}
}
public static class Server extends ForgeProdLaunchHandler {
public Server() {
super(SERVER);
}
}
}
Loaded 100 of 2283 files, more files were not shown because too many files have changed in this diff. Show more