import de.undercouch.gradle.tasks.download.Download import groovy.json.JsonBuilder import net.minecraftforge.forge.tasks.checks.CheckATs import net.minecraftforge.forge.tasks.checks.CheckExcs import net.minecraftforge.forge.tasks.checks.CheckPatches import net.minecraftforge.forge.tasks.checks.CheckSAS import net.minecraftforge.forge.tasks.checks.CheckTask import java.nio.file.Files import java.util.Date import java.util.LinkedHashMap import net.minecraftforge.forge.tasks.* import static net.minecraftforge.forge.tasks.Util.* import net.minecraftforge.gradle.common.tasks.ApplyBinPatches import net.minecraftforge.gradle.common.tasks.CheckJarCompatibility import net.minecraftforge.gradle.common.tasks.DownloadMavenArtifact import net.minecraftforge.gradle.common.tasks.ExtractInheritance import net.minecraftforge.gradle.common.tasks.SignJar import net.minecraftforge.gradle.patcher.tasks.GeneratePatches import net.minecraftforge.gradle.userdev.tasks.RenameJar import net.minecraftforge.gradleutils.PomUtils import org.apache.tools.ant.filters.ReplaceTokens import org.gradle.plugins.ide.eclipse.model.SourceFolder import org.objectweb.asm.Opcodes plugins { id 'org.cadixdev.licenser' version '0.6.1' id 'com.github.ben-manes.versions' version '0.46.0' id 'net.minecraftforge.gradleutils' version '[2.2,2.3)' id 'eclipse' id 'de.undercouch.download' version '5.4.0' id 'net.minecraftforge.gradle.patcher' version '[6.0.16,6.2)' apply false id 'net.minecraftforge.gradle.mcp' version '[6.0.16,6.2)' apply false } Util.init() //Init all our extension methods! ext { JAR_SIGNER = null if (project.hasProperty('keystore')) { JAR_SIGNER = [ storepass: project.properties.keystoreStorePass, keypass: project.properties.keystoreKeyPass, keystore: project.properties.keystore ] } MAPPING_CHANNEL = 'official' MC_VERSION = '1.20.2' MAPPING_VERSION = MC_VERSION MC_NEXT_VERSION = '1.21' MCP_VERSION = '20230921.100330' SNAPSHOT = false INSTALLER_VERSION = '2.1.+' GIT_INFO = gradleutils.gitInfo VERSION = gradleutils.getFilteredMCTagOffsetBranchVersion(true, '[0-9]', MC_VERSION) // FML_VERSION = gradleutils.getFilteredMCTagOffsetBranchVersion(true, 'FML', MC_VERSION) FORGE_VERSION = VERSION.substring(MC_VERSION.length() + 1) BINPATCH_TOOL = 'net.minecraftforge:binarypatcher:1.1.1:fatjar' INSTALLER_TOOLS = 'net.minecraftforge:installertools:1.3.0' JAR_SPLITTER = 'net.minecraftforge:jarsplitter:1.1.4' FART = 'net.minecraftforge:ForgeAutoRenamingTool:1.0.5:all' MIN_TAG_FOR_CHANGELOG = '47.999' } println('Version: ' + VERSION + ' Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ')' + ' Arch: ' + System.getProperty('os.arch')) changelog { fromTag MIN_TAG_FOR_CHANGELOG } def extraTxts = [ rootProject.file('CREDITS.txt'), rootProject.file('LICENSE.txt'), rootProject.tasks.createChangelog.outputFile ] tasks.register('downloadVersionManifest', Download) { src 'https://piston-meta.mojang.com/mc/game/version_manifest_v2.json' dest file('build/versions/version_manifest.json') useETag 'all' onlyIfModified true quiet true } tasks.register('downloadJson', Download) { dependsOn downloadVersionManifest inputs.file downloadVersionManifest.dest src { downloadVersionManifest.dest.json.versions.find{ it.id == MC_VERSION }.url } dest file("build/versions/${MC_VERSION}/version.json") useETag 'all' onlyIfModified true quiet true } tasks.register('downloadClientRaw', Download) { dependsOn downloadJson inputs.file downloadJson.dest src { downloadJson.dest.json.downloads.client.url } dest file("build/versions/${MC_VERSION}/client.jar") useETag 'all' onlyIfModified true quiet true } tasks.register('downloadServerRaw', Download) { dependsOn downloadJson inputs.file downloadJson.dest src { downloadJson.dest.json.downloads.server.url } dest file("build/versions/${MC_VERSION}/server.jar") useETag 'all' onlyIfModified true quiet true } subprojects { apply plugin: 'maven-publish' apply plugin: 'eclipse' apply plugin: 'java' group = 'net.minecraftforge' version = VERSION //println(name + ' Version: ' + version) repositories { mavenCentral() maven gradleutils.forgeMaven maven gradleutils.minecraftLibsMaven } java.toolchain.languageVersion = JavaLanguageVersion.of(17) tasks.withType(Javadoc).configureEach { options.tags = [ 'apiNote:a:API Note:', 'implSpec:a:Implementation Requirements:', 'implNote:a:Implementation Note:' ] options.addStringOption('Xdoclint:all,-missing', '-public') } publishing { publications { mavenJava(MavenPublication) { // Normal Maven/old gradle doesn't support '2.+' version wildcards // For now we just suppress. We *should* force the resolution to pinned versions. suppressPomMetadataWarningsFor('apiElements') suppressPomMetadataWarningsFor('runtimeElements') 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 } } tasks.withType(JavaCompile).configureEach { options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation options.warnings = false // Shutup deprecated for removal warnings } } project(':mcp') { apply plugin: 'net.minecraftforge.gradle.mcp' tasks.withType(AbstractPublishToMaven.class).forEach{tsk -> tsk.enabled = false } // We don't want to publish anything mcp { config MC_VERSION + '-' + MCP_VERSION pipeline = 'joined' } } def sharedFmlonlyForge = { Project prj -> prj.afterEvaluate { [prj.tasks.universalJar, prj.tasks.installerJar].each { t -> def signTask = prj.task([type: SignJar, dependsOn: t], "sign${t.name.capitalize()}") { onlyIf { JAR_SIGNER != null && t.state.failure == null } def jarsigner = JAR_SIGNER == null ? [:] : JAR_SIGNER alias = 'forge' storePass = jarsigner.storepass keyPass = jarsigner.keypass keyStore = jarsigner.keystore inputFile = t.archiveFile.get().asFile outputFile = t.archiveFile.get().asFile } t.finalizedBy(signTask) } } prj.tasks.userdevConfig { getArtifacts(prj, prj.configurations.installer, true).each { key, lib -> libraries.add(lib.name) } getArtifacts(prj, prj.configurations.moduleonly, true).each { key, lib -> libraries.add(lib.name) modules.add(lib.name) } for (child in prj.ext.PACKED_DEPS) { libraries.add(Util.getMavenDep(rootProject.tasks.findByPath(child))) } //libraries.add("${project.group}:${project.name}:${project.version}:launcher") inject = '' // We don't have a userdev sourceset anymore. Empty as a gradle workaround... runs { client { environment 'MCP_MAPPINGS', '{mcp_mappings}' property 'forge.enableGameTest', 'true' args '--launchTarget', "forge_userdev_client" args '--version', 'MOD_DEV' args '--assetIndex', '{asset_index}' args '--assetsDir', '{assets_root}' } server { environment 'MCP_MAPPINGS', '{mcp_mappings}' property 'forge.enableGameTest', 'true' args '--launchTarget', "forge_userdev_server" } gameTestServer { environment 'MCP_MAPPINGS', '{mcp_mappings}' args '--launchTarget', "forge_userdev_server_gametest" } data { environment 'MCP_MAPPINGS', '{mcp_mappings}' args '--launchTarget', "forge_userdev_data" args '--assetIndex', '{asset_index}' args '--assetsDir', '{assets_root}' } } } def userdevRuns = prj.tasks.userdevConfig.runs def ignoreList = ( //bsl uses filename.startsWith, so we have to use the project name, i add '-' for saftey's sake and not wanting to ignore things that modders add. But the whole system is really dumb/fragile. prj.configurations.moduleonly.allDependencies.collect{ it.name } + ['client-extra', 'fmlcore', 'javafmllanguage', 'lowcodelanguage', 'mclanguage', prj.name] ).collect{ it + '-' }.sort().join(',') for (def run : prj.patcher.runs + userdevRuns) { if (run.parents) continue // We already added this to the parent run config //run.property 'bsl.debug', 'true' run.main 'net.minecraftforge.bootstrap.BootstrapLauncher' run.args '--gameDir', '.' run.args '--fml.forgeVersion', FORGE_VERSION run.args '--fml.mcVersion', MC_VERSION run.args '--fml.forgeGroup', prj.group run.args '--fml.mcpVersion', MCP_VERSION run.jvmArgs '-Djava.net.preferIPv6Addresses=system' run.client run.name.contains('client') // SecureJarHandler bootstrap values. run.property 'ignoreList', ignoreList // FIXME: Without this jna doesn't work at runtime. Someone figure out why please? run.property 'mergeModules', 'jna-5.10.0.jar,jna-platform-5.10.0.jar' if (userdevRuns.contains(run)) { run.property 'legacyClassPath.file', '{minecraft_classpath_file}' run.jvmArgs '-p', '{modules}' } else { run.property 'legacyClassPath.file', '{runtime_classpath_file}' run.jvmArgs '-p', prj.configurations.moduleonly.files.collect { it.path }.join(File.pathSeparator) } run.jvmArgs '--add-modules', 'ALL-MODULE-PATH' // Additions to these JVM module args should be mirrored to server_files/args.txt and other similar blocks in the buildscript run.jvmArgs '--add-exports', 'jdk.naming.dns/com.sun.jndi.dns=java.naming' } for (def run : prj.patcher.runs) { def isTest = run.name.endsWith('_test') run.taskName = run.name run.environment 'FORGE_SPEC', prj.SPEC_VERSION run.workingDirectory prj.file('run/' + run.name) run.ideaModule rootProject.name + '.' + prj.name + '.' + (isTest ? 'test' : 'main') run.mods { minecraft { source prj.sourceSets.main } } if (isTest) { run.property 'forge.enableGameTest', 'true' run.mods { tests { sources prj.sourceSets.test } } } } def MODULE_PATH = Util.getArtifacts(prj, prj.configurations.moduleonly, false).values().collect{"libraries/${it.downloads.artifact.path}"}.sort() def tokens = [ TASK: 'forge_server', MAVEN_PATH: prj.ext.MAVEN_PATH.toString(), FORGE_VERSION: FORGE_VERSION, MC_VERSION: MC_VERSION, MCP_VERSION: MCP_VERSION, FORGE_GROUP: prj.group, IGNORE_LIST: Util.getArtifacts(prj, prj.configurations.moduleonly, false).values().collect{it.downloads.artifact.path.rsplit('/', 1)[1]}.sort().join(','), MODULES: 'ALL-MODULE-PATH' ] prj.task([dependsOn: rootProject.downloadServerRaw], 'makeClasspathFiles') { doLast { def CLASS_PATH = Util.getArtifacts(prj, prj.configurations.installer, false).values().collect{"libraries/${it.downloads.artifact.path}"} + [ 'libraries/' + Util.getMavenPath(rootProject.tasks.findByPath(':fmlloader:jar')), "libraries/net/minecraft/server/${MC_VERSION}-${MCP_VERSION}/server-${MC_VERSION}-${MCP_VERSION}-extra.jar" ] def claimed = CLASS_PATH.collect{ it.rsplit('/', 2)[0] }.toSet() // Allow us to override versions try (def zip = new java.util.zip.ZipFile(rootProject.downloadServerRaw.dest)) { CLASS_PATH += zip.getInputStream(zip.getEntry('META-INF/classpath-joined')).text.split(';') .findAll{ it.startsWith('libraries/') && !claimed.contains(it.rsplit('/', 2)[0]) } } configure(prj.installerJar) { from(rootProject.file('server_files/args.txt')) { filter(ReplaceTokens, tokens: tokens + [MODULE_PATH: MODULE_PATH.join(';'), CLASS_PATH: CLASS_PATH.join(';')]) rename { 'data/win_args.txt' } } from(rootProject.file('server_files/args.txt')) { filter(ReplaceTokens, tokens: tokens + [MODULE_PATH: MODULE_PATH.join(':'), CLASS_PATH: CLASS_PATH.join(':')]) rename { 'data/unix_args.txt' } } } } } prj.afterEvaluate { prj.installerJar { dependsOn('makeClasspathFiles') from(rootProject.file('server_files/')) { exclude 'args.txt' filter(ReplaceTokens, tokens: tokens) into('data/') } } } } project(':forge') { evaluationDependsOn(':mcp') apply plugin: 'java-library' apply plugin: 'net.minecraftforge.gradle.patcher' apply plugin: 'org.cadixdev.licenser' applyPatches { level 'WARNING' } sourceSets { main { java { srcDirs = [ "$rootDir/src/main/java", "$rootDir/src/fmlcommon/java" ] } resources { srcDirs = [ "$rootDir/src/main/resources", "$rootDir/src/generated/resources", "$rootDir/src/fmlcommon/resources" ] } } test { java { srcDirs = [ "$rootDir/src/test/java" ] } resources { srcDirs = [ "$rootDir/src/test/resources", "$rootDir/src/generated_test/resources" ] } } } 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' } src.entryAttributes['ignore_optional_problems'] = 'true' } project.resourceFilter { appliesTo = 'FOLDERS' type = 'EXCLUDE_ALL' matcher { id = 'org.eclipse.ui.ide.multiFilter' arguments = '1.0-name-matches-false-false-run' } } } ext { SPEC_VERSION = gradleutils.gitInfo.tag // The new versioning sceme is -.. // ForgeMC is a unique identifier for every MC version we have supported. // Essentially, the same as the old, except dropping the first number, and the builds are no longer unique. MCP_ARTIFACT = project(':mcp').mcp.config.get() VERSION_JSON = project(':mcp').file('build/mcp/downloadJson/version.json') PACKED_DEPS = [':fmlcore:jar', ':fmlloader:jar', ':fmlearlydisplay:jar', ':javafmllanguage:jar', ':lowcodelanguage:jar', ':mclanguage:jar'] MAVEN_PATH = "${group.replace('.', '/')}/${project.name}/${VERSION}" } configurations { // Don't pull all libraries, if we're missing something, add it to the installer list so the installer knows to download it. installer { transitive = false } moduleonly { transitive = false } api.extendsFrom(installer) } dependencies { moduleonly(libs.bootstrap) moduleonly(libs.securemodules) // Needed by bootstrap moduleonly(libs.unsafe) // Needed by securemodules moduleonly(libs.bundles.asm) // Needed by all the black magic moduleonly(libs.jarjar.fs) // Filesystems need to be on the bootstrap? I think thats why this is here. moduleonly(libs.bundles.jimfs) // In memory file system used for ForgeDev launches installer(libs.unsafe) installer(libs.securemodules) installer(libs.bundles.asm) // Needed by all the black magic installer(libs.accesstransformers) installer(libs.antlr.runtime) // Dep of AccessTransformer installer(libs.eventbus) installer(libs.typetools) // Dep of EventBus installer(libs.forgespi) installer(libs.coremods) installer(libs.nashorn) // Dep of Coremods installer(libs.modlauncher) installer(libs.mergetool.api) installer(libs.bundles.night.config) installer(libs.maven.artifact) installer(libs.bundles.terminalconsoleappender) installer(libs.mixin) installer(libs.bundles.jarjar) implementation project(':fmlcore') implementation project(':fmlloader') implementation project(':fmlearlydisplay') implementation project(':javafmllanguage') implementation project(':lowcodelanguage') implementation project(':mclanguage') runtimeOnly(libs.bootstrap) } patcher { excs.from file("$rootDir/src/main/resources/forge.exc") parent = project(':mcp') mcVersion = MC_VERSION mappings channel: MAPPING_CHANNEL, version: MAPPING_VERSION patches = file("$rootDir/patches/minecraft") patchedSrc = file('src/main/java') srgPatches = false accessTransformers.from file("$rootDir/src/main/resources/META-INF/accesstransformer.cfg") sideAnnotationStrippers.from file("$rootDir/src/main/resources/forge.sas") runs { forge_client { property 'eventbus.checkTypesOnDispatch', 'true' property 'org.lwjgl.system.SharedLibraryExtractDirectory', 'lwjgl_dll' args '--launchTarget', 'forge_dev_client', '--username', 'Dev', '--version', project.name, '--accessToken', '0', '--userType', 'mojang', '--versionType', 'release', '--assetsDir', downloadAssets.output, '--assetIndex', "{asset_index}" } forge_client_test { parent runs.forge_client } forge_server { args '--launchTarget', 'forge_dev_server' } forge_server_test { parent runs.forge_server } forge_server_gametest { args '--launchTarget', 'forge_dev_server_gametest' } forge_server_gametest_test { parent runs.forge_server_gametest } forge_data { args '--launchTarget', 'forge_dev_data', '--mod', 'forge', '--all', '--validate', '--output', rootProject.file('src/generated/resources/'), '--validate', '--existing', sourceSets.main.resources.srcDirs[0], '--assetsDir', downloadAssets.output, '--assetIndex', "{asset_index}" } forge_data_test { args '--launchTarget', 'forge_dev_data', '--mod', '.+', '--all', '--validate', '--output', rootProject.file('src/generated_test/resources/'), '--existing', sourceSets.main.resources.srcDirs[0], '--existing', sourceSets.test.resources.srcDirs[0], '--assetsDir', downloadAssets.output, '--assetIndex', "{asset_index}" } } } afterEvaluate { if (!patcher.srgPatches) { srg2mcpClean { dependsOn = [] input = project(':mcp').setupMCP.output } userdevJar { onlyIf = { t -> true } } def patches = project.file('build/genPatchesForUserdev/output/') patches.mkdirs() def genPatchesForUserdev = tasks.register('genPatchesForUserdev', GeneratePatches){ base = project(':mcp').setupMCP.output modified = applyRangeMapBase.output originalPrefix = genPatches.originalPrefix modifiedPrefix = genPatches.modifiedPrefix output = patches autoHeader true lineEnding = '\n' } bakePatches { dependsOn = [] input = genPatchesForUserdev.get().output } } } ext { MANIFESTS = [ '/': [ 'GitCommit': gradleutils.gitInfo.abbreviatedId, 'Git-Branch': gradleutils.gitInfo.branch, 'FML-System-Mods': 'forge' ] as LinkedHashMap, 'net/minecraftforge/versions/forge/': [ 'Specification-Title': 'Forge', 'Specification-Vendor': 'Forge Development LLC', 'Specification-Version': SPEC_VERSION, 'Implementation-Title': project.group, 'Implementation-Version': project.version.substring(MC_VERSION.length() + 1), 'Implementation-Vendor': 'Forge Development LLC' ] as LinkedHashMap, 'net/minecraftforge/versions/mcp/': [ 'Specification-Title': 'Minecraft', 'Specification-Vendor': 'Mojang', 'Specification-Version': MC_VERSION, 'Implementation-Title': 'MCP', 'Implementation-Version': MCP_VERSION, 'Implementation-Vendor': 'Forge' ] as LinkedHashMap, 'net/minecraftforge/fml/javafmlmod/': [ 'Specification-Title': 'Mod Language Provider', 'Specification-Vendor': 'Forge Development LLC', 'Specification-Version': '1', 'Implementation-Title': 'FML Java Mod', 'Implementation-Version': SPEC_VERSION, 'Implementation-Vendor': 'Forge' ] as LinkedHashMap, 'net/minecraftforge/fml/mclanguageprovider/': [ 'Specification-Title': 'Mod Language Provider', 'Specification-Vendor': 'Forge Development LLC', 'Specification-Version': '1', 'Implementation-Title': 'Minecraft Language Mod Provider', 'Implementation-Version': '1', 'Implementation-Vendor': 'Forge' ] as LinkedHashMap, 'net/minecraftforge/fml/loading/': [ 'Specification-Title': 'Launcher', 'Specification-Vendor': 'Forge Development LLC', 'Specification-Version': '1', 'Implementation-Title': 'FML Launcher', 'Implementation-Version': SPEC_VERSION, 'Implementation-Vendor': 'Forge' ] as LinkedHashMap ] } tasks.register('downloadCrowdin', Download) { src 'https://files.minecraftforge.net/crowdin.zip' dest file('build/crowdin.zip') useETag 'all' onlyIfModified true quiet true } sharedFmlonlyForge.call(project) task downloadLibraries(type: DownloadLibraries, dependsOn: ':mcp:setupMCP') { input = VERSION_JSON output = rootProject.file('build/libraries/') } task extractInheritance(type: ExtractInheritance, dependsOn: [downloadLibraries]) { tool = INSTALLER_TOOLS + ':fatjar' args.add '--annotations' input = genJoinedBinPatches.cleanJar libraries.addAll downloadLibraries.librariesOutput.map { rf -> Files.readAllLines(rf.asFile.toPath()).stream().map(File::new).collect(java.util.stream.Collectors.toList()) } } tasks.register("findFieldInstanceChecks", FieldCompareFinder) { jar = createJoinedSRG.output output = rootProject.file('src/main/resources/coremods/field_to_instanceof.json') fields { /* 1.17 changed most things to use Tags. So this isn't nessasary anymore so just make an empty list bows { cls = 'net/minecraft/world/item/Items' name = 'f_42411_' replacement = 'net/minecraft/world/item/BowItem' } crossbows { cls = 'net/minecraft/world/item/Items' name = 'f_42717_' replacement = 'net/minecraft/world/item/CrossbowItem' } */ } } tasks.register("findFinalizeSpawnTargets", BytecodePredicateFinder) { jar = createJoinedSRG.output output = rootProject.file('src/main/resources/coremods/finalize_spawn_targets.json') predicate = { parent, node, insn -> 'net/minecraft/world/level/BaseSpawner' != parent.name // Ignore this class as we special case it. && insn.getOpcode() == Opcodes.INVOKEVIRTUAL && insn.name.equals('m_6518_') && insn.desc.equals('(Lnet/minecraft/world/level/ServerLevelAccessor;Lnet/minecraft/world/DifficultyInstance;Lnet/minecraft/world/entity/MobSpawnType;Lnet/minecraft/world/entity/SpawnGroupData;Lnet/minecraft/nbt/CompoundTag;)Lnet/minecraft/world/entity/SpawnGroupData;') } } tasks.register('validateDeprecations', ValidateDeprecations) { input = tasks.jar.archiveFile mcVersion = MC_VERSION } tasks.jar.finalizedBy 'validateDeprecations' tasks.register("downloadInstaller", DownloadMavenArtifact) { artifact = "net.minecraftforge:installer:${INSTALLER_VERSION}:shrunk" changing = true } tasks.register("downloadClientSlim", DownloadMavenArtifact) { artifact = "net.minecraft:client:${MC_VERSION}-${MCP_VERSION}:slim" } tasks.register("downloadClientExtra", DownloadMavenArtifact) { artifact = "net.minecraft:client:${MC_VERSION}-${MCP_VERSION}:extra" } tasks.register("downloadServerSlim", DownloadMavenArtifact) { artifact = "net.minecraft:server:${MC_VERSION}-${MCP_VERSION}:slim" } tasks.register("downloadServerExtra", DownloadMavenArtifact) { artifact = "net.minecraft:server:${MC_VERSION}-${MCP_VERSION}:extra" } tasks.register("downloadJoinedSlim", DownloadMavenArtifact) { artifact = "net.minecraft:joined:${MC_VERSION}-${MCP_VERSION}:slim" } tasks.register("downloadJoinedExtra", DownloadMavenArtifact) { artifact = "net.minecraft:joined:${MC_VERSION}-${MCP_VERSION}:extra" } tasks.register("createJoinedSRG", DownloadMavenArtifact) { artifact = "net.minecraft:joined:${MC_VERSION}-${MCP_VERSION}:srg" } tasks.register("createClientSRG", RenameJar) { tool = FART args = ['--input', '{input}', '--output', '{output}', '--names', '{mappings}', '--ann-fix', '--ids-fix', '--src-fix', '--record-fix'] mappings = createMcp2Srg.srg input = downloadClientSlim.output output = file("build/createClientSRG/output.jar") } tasks.register("createServerSRG", RenameJar) { tool = FART args = ['--input', '{input}', '--output', '{output}', '--names', '{mappings}', '--ann-fix', '--ids-fix', '--src-fix', '--record-fix'] mappings = createMcp2Srg.srg input = downloadServerSlim.output output = file("build/createServerSRG/output.jar") } genClientBinPatches { tool = BINPATCH_TOOL cleanJar = createClientSRG.output } genServerBinPatches { tool = BINPATCH_TOOL cleanJar = createServerSRG.output } genJoinedBinPatches { tool = BINPATCH_TOOL cleanJar = createJoinedSRG.output } tasks.register("applyClientBinPatches", ApplyBinPatches) { tool = BINPATCH_TOOL clean = genClientBinPatches.cleanJar patch = genClientBinPatches.output } tasks.register("applyServerBinPatches", ApplyBinPatches) { tool = BINPATCH_TOOL clean = genServerBinPatches.cleanJar patch = genServerBinPatches.output } tasks.register("applyJoinedBinPatches", ApplyBinPatches) { tool = BINPATCH_TOOL clean = genJoinedBinPatches.cleanJar patch = genJoinedBinPatches.output } tasks.register('checkAll') { dependsOn 'checkLicenses' group = 'checks' } tasks.register('checkAllAndFix') { dependsOn 'findFinalizeSpawnTargets', 'findFieldInstanceChecks', 'checkLicenses' group = 'checks' } CheckTask.registerTask(tasks, 'ATs', CheckATs) { dependsOn extractInheritance, createSrg2Mcp ats.from patcher.accessTransformers inheritance = extractInheritance.output mappings = createSrg2Mcp.output } CheckTask.registerTask(tasks, 'SAS', CheckSAS) { dependsOn extractInheritance sass.from patcher.sideAnnotationStrippers inheritance = extractInheritance.output } CheckTask.registerTask(tasks, 'Excs', CheckExcs) { dependsOn jar binary = jar.archiveFile.get().asFile excs.from patcher.excs } CheckTask.registerTask(tasks, 'Patches', CheckPatches) { dependsOn genPatches patchDir = file("$rootDir/patches") patchesWithS2SArtifact = [ 'minecraft/net/minecraft/client/renderer/ViewArea.java.patch', 'minecraft/net/minecraft/data/models/blockstates/Variant.java.patch', ] } genPatches { finalizedBy checkAndFixPatches autoHeader true lineEnding = '\n' } def baseForgeVersionProperty = project.objects.property(String) baseForgeVersionProperty.set(project.provider { TeamcityRequests.attemptFindBase(rootDir) ?: getLatestForgeVersion(MC_VERSION) }) baseForgeVersionProperty.finalizeValueOnRead() def jarCompatibilityTaskSetup = { task -> task.group = 'jar compatibility' task.onlyIf { baseForgeVersionProperty.getOrNull() != null } } tasks.register('setupCheckJarCompatibility', SetupCheckJarCompatibility) { inputVersion = baseForgeVersionProperty } tasks.register('applyBaseCompatibilityJarBinPatches', ApplyBinPatches) { jarCompatibilityTaskSetup(it) clean = project.tasks.createJoinedSRG.output patch = project.tasks.named('setupCheckJarCompatibility').flatMap { it.baseBinPatchesOutput } output = project.layout.buildDirectory.dir(name).map { it.file('output.jar') } } tasks.register('mergeBaseForgeJar', MergeJars) { jarCompatibilityTaskSetup(it) inputJars.from(project.tasks.named('applyBaseCompatibilityJarBinPatches').flatMap { it.output }) inputJars.from(baseForgeVersionProperty.map { inputVersion -> def output = project.layout.buildDirectory.dir(name).map { it.file("forge-${inputVersion}-universal.jar") }.get().asFile project.rootProject.extensions.download.run { src "https://maven.minecraftforge.net/net/minecraftforge/forge/${inputVersion}/forge-${inputVersion}-universal.jar" dest output } return output }) } tasks.register('checkJarCompatibility', CheckJarCompatibility) { jarCompatibilityTaskSetup(it) dependsOn 'setupCheckJarCompatibility' baseJar = project.tasks.named('mergeBaseForgeJar').flatMap { it.output } baseLibraries.from(project.tasks.named('createJoinedSRG').flatMap { it.output }) inputJar = project.tasks.named('reobfJar').flatMap { it.output } concreteLibraries.from(project.PACKED_DEPS.collect { project.rootProject.tasks.getByPath(it).archiveFile }) commonLibraries.from(project.configurations.minecraftImplementation) commonLibraries.from(project.configurations.installer) commonLibraries.from(project.configurations.moduleonly) } task launcherJson(type: LauncherJson) { packedDependencies = [':fmlloader:jar',':fmlearlydisplay:jar'] doFirst { def forge_client = project(':forge').patcher.runs.forge_client json = [ _comment_: comment, id: id, time: timestamp, releaseTime: timestamp, type: 'release', mainClass: 'net.minecraftforge.bootstrap.BootstrapLauncher', inheritsFrom: MC_VERSION, logging: {}, arguments: [ game: ['--launchTarget', 'forge_client', '--fml.forgeVersion', FORGE_VERSION, '--fml.mcVersion', MC_VERSION, '--fml.forgeGroup', project.group, '--fml.mcpVersion', MCP_VERSION], jvm: ['-Djava.net.preferIPv6Addresses=system', "-DignoreList=${forge_client.properties.ignoreList},\${version_name}.jar", "-DmergeModules=${forge_client.properties.mergeModules}", '-DlibraryDirectory=${library_directory}', '-p', Util.getArtifacts(project, configurations.moduleonly, false).values().collect{'${library_directory}/' + it.downloads.artifact.path}.join('${classpath_separator}'), '--add-modules', 'ALL-MODULE-PATH', // Additions to these JVM module args should be mirrored to server_files/args.txt and other similar blocks in the buildscript '--add-exports', 'jdk.naming.dns/com.sun.jndi.dns=java.naming' ] ], libraries: [] ] } } task installerJson(type: InstallerJson, dependsOn: [launcherJson, genClientBinPatches, applyClientBinPatches, applyServerBinPatches, 'signUniversalJar']) { ext { // remove :fatjar BIN_PATCHER = BINPATCH_TOOL.substring(0, BINPATCH_TOOL.length() - 1 - BINPATCH_TOOL.split(':')[3].length()) } input.from applyClientBinPatches.output, applyServerBinPatches.output, genClientBinPatches.toolJar, launcherJson.output icon = rootProject.file('icon.ico') packedDependencies = PACKED_DEPS doFirst { def libs = libraries def INSTALLER_TOOLS_CLASSPATH = getClasspath(project, libs, INSTALLER_TOOLS) def JAR_SPLITTER_CLASSPATH = getClasspath(project, libs, JAR_SPLITTER) json = [ _comment_: launcherJson.comment, spec: 1, profile: project.name, version: launcherJson.id, path: null, minecraft: MC_VERSION, serverJarPath: '{LIBRARY_DIR}/net/minecraft/server/{MINECRAFT_VERSION}/server-{MINECRAFT_VERSION}.jar', data: [ MAPPINGS: [ client: "[${MCP_ARTIFACT.group}:${MCP_ARTIFACT.name}:${MCP_ARTIFACT.version}:mappings@txt]", server: "[${MCP_ARTIFACT.group}:${MCP_ARTIFACT.name}:${MCP_ARTIFACT.version}:mappings@txt]" ], MOJMAPS: [ client: "[net.minecraft:client:${MC_VERSION}-${MCP_VERSION}:mappings@txt]", server: "[net.minecraft:server:${MC_VERSION}-${MCP_VERSION}:mappings@txt]" ], MERGED_MAPPINGS: [ client: "[${MCP_ARTIFACT.group}:${MCP_ARTIFACT.name}:${MCP_ARTIFACT.version}:mappings-merged@txt]", server: "[${MCP_ARTIFACT.group}:${MCP_ARTIFACT.name}:${MCP_ARTIFACT.version}:mappings-merged@txt]" ], BINPATCH: [ client: '/data/client.lzma', server: '/data/server.lzma' ], MC_UNPACKED: [ client: "[net.minecraft:client:${MC_VERSION}-${MCP_VERSION}:unpacked]", server: "[net.minecraft:server:${MC_VERSION}-${MCP_VERSION}:unpacked]" ], MC_SLIM: [ client: "[net.minecraft:client:${MC_VERSION}-${MCP_VERSION}:slim]", server: "[net.minecraft:server:${MC_VERSION}-${MCP_VERSION}:slim]" ], MC_SLIM_SHA: [ client: "'${downloadClientSlim.output.get().asFile.sha1()}'", server: "'${downloadServerSlim.output.get().asFile.sha1()}'" ], MC_EXTRA: [ client: "[net.minecraft:client:${MC_VERSION}-${MCP_VERSION}:extra]", server: "[net.minecraft:server:${MC_VERSION}-${MCP_VERSION}:extra]" ], MC_EXTRA_SHA: [ client: "'${downloadClientExtra.output.get().asFile.sha1()}'", server: "'${downloadServerExtra.output.get().asFile.sha1()}'" ], MC_SRG: [ client: "[net.minecraft:client:${MC_VERSION}-${MCP_VERSION}:srg]", server: "[net.minecraft:server:${MC_VERSION}-${MCP_VERSION}:srg]" ], /*MC_SRG_SHA: [ client: "'${createClientSRG.output.sha1()}'", server: "'${createServerSRG.output.sha1()}'" ],*/ PATCHED: [ client: "[${project.group}:${project.name}:${project.version}:client]", server: "[${project.group}:${project.name}:${project.version}:server]" ], PATCHED_SHA: [ client: "'${applyClientBinPatches.output.get().asFile.sha1()}'", server: "'${applyServerBinPatches.output.get().asFile.sha1()}'" ], MCP_VERSION: [ client: "'${MCP_VERSION}'", server: "'${MCP_VERSION}'" ] ], processors: [ [ sides: ['server'], jar: INSTALLER_TOOLS, classpath: INSTALLER_TOOLS_CLASSPATH, args: [ '--task', 'EXTRACT_FILES', '--archive', '{INSTALLER}', '--from', 'data/run.sh', '--to', '{ROOT}/run.sh', '--exec', '{ROOT}/run.sh', //'--from', "data/run_forge_${VERSION.replace('-', '_').sh", //'--to', '{ROOT}/run_forge_${VERSION.replace('-', '_').sh', //'--exec', '{ROOT}/run_forge_${VERSION.replace('-', '_').sh', '--from', 'data/run.bat', '--to', '{ROOT}/run.bat', //'--from', 'data/run_forge_${VERSION.replace('-', '_').bat', //'--to', '{ROOT}/run_forge_${VERSION.replace('-', '_').bat', '--from', 'data/user_jvm_args.txt', '--to', '{ROOT}/user_jvm_args.txt', '--optional', '{ROOT}/user_jvm_args.txt', '--from', 'data/win_args.txt', '--to', "{ROOT}/libraries/${MAVEN_PATH}/win_args.txt", '--from', 'data/unix_args.txt', '--to', "{ROOT}/libraries/${MAVEN_PATH}/unix_args.txt" ] ], [ sides: ['server'], jar: INSTALLER_TOOLS, classpath: INSTALLER_TOOLS_CLASSPATH, args: [ '--task', 'BUNDLER_EXTRACT', '--input', '{MINECRAFT_JAR}', '--output', '{ROOT}/libraries/', '--libraries' ] ], [ sides: ['server'], jar: INSTALLER_TOOLS, classpath: INSTALLER_TOOLS_CLASSPATH, args: [ '--task', 'BUNDLER_EXTRACT', '--input', '{MINECRAFT_JAR}', '--output', '{MC_UNPACKED}', '--jar-only' ] ], [ jar: INSTALLER_TOOLS, classpath: INSTALLER_TOOLS_CLASSPATH, args: [ '--task', 'MCP_DATA', '--input', "[${MCP_ARTIFACT.descriptor}]", '--output', '{MAPPINGS}', '--key', 'mappings' ] ], [ jar: INSTALLER_TOOLS, classpath: INSTALLER_TOOLS_CLASSPATH, args: [ '--task', 'DOWNLOAD_MOJMAPS', '--version', MC_VERSION, '--side', '{SIDE}', '--output', '{MOJMAPS}' ] ], [ jar: INSTALLER_TOOLS, classpath: INSTALLER_TOOLS_CLASSPATH, args: [ '--task', 'MERGE_MAPPING', '--left', '{MAPPINGS}', '--right', '{MOJMAPS}', '--output', '{MERGED_MAPPINGS}', '--classes', '--reverse-right' ] ], [ sides: ['client'], jar: JAR_SPLITTER, classpath: JAR_SPLITTER_CLASSPATH, args: [ '--input', '{MINECRAFT_JAR}', '--slim', '{MC_SLIM}', '--extra', '{MC_EXTRA}', '--srg', '{MERGED_MAPPINGS}' ], outputs: [ '{MC_SLIM}': '{MC_SLIM_SHA}', '{MC_EXTRA}': '{MC_EXTRA_SHA}' ] ], [ sides: ['server'], jar: JAR_SPLITTER, classpath: JAR_SPLITTER_CLASSPATH, args: [ '--input', '{MC_UNPACKED}', '--slim', '{MC_SLIM}', '--extra', '{MC_EXTRA}', '--srg', '{MERGED_MAPPINGS}' ], outputs: [ '{MC_SLIM}': '{MC_SLIM_SHA}', '{MC_EXTRA}': '{MC_EXTRA_SHA}' ] ], [ jar: FART, classpath: getClasspath(project, libs, FART), args: [ '--input', '{MC_SLIM}', '--output', '{MC_SRG}', '--names', '{MERGED_MAPPINGS}', '--ann-fix', '--ids-fix', '--src-fix', '--record-fix' ]/*, outputs: [ '{MC_SRG}': '{MC_SRG_SHA}' ] */ ], [ jar: BIN_PATCHER, classpath: getClasspath(project, libs, BIN_PATCHER), args: [ '--clean', '{MC_SRG}', '--output', '{PATCHED}', '--apply', '{BINPATCH}' ]/*, Because Vignette is unstable, it screws with the entry order of the binpatched jar, so we can't use the hash right now // Re-enable this when https://github.com/CadixDev/Vignette/issues/1 is solved outputs: [ '{PATCHED}': '{PATCHED_SHA}' ]*/ ] ] ] getClasspath(project, libs, MCP_ARTIFACT.descriptor) //Tell it to download mcp_config } } universalJar { dependsOn downloadCrowdin from zipTree(downloadCrowdin.dest).matching { include 'assets/forge/lang/*.json' } from extraTxts duplicatesStrategy = 'exclude' doFirst { MANIFESTS.each{ pkg, values -> if (pkg == '/') { manifest.attributes(values) } else { manifest.attributes(values, pkg) } } } } task installerJar(type: InstallerJar, dependsOn: [genClientBinPatches, genServerBinPatches, 'signUniversalJar', launcherJson]) { packedDependencies = PACKED_DEPS from(extraTxts) from(rootProject.file('/forge_installer_logo.png')) { rename { 'big_logo.png' } } from(genClientBinPatches.output) { rename { 'data/client.lzma' } } from(genServerBinPatches.output) { rename { 'data/server.lzma' } } } tasks.register('devInstallerJar', DevInstallerJar) { input = installerJar.archiveFile } task makeMdk(type: Zip) { archiveBaseName = project.name archiveClassifier = 'mdk' archiveVersion = project.version destinationDirectory = file('build/libs') from rootProject.file('gradlew') from rootProject.file('gradlew.bat') from extraTxts from(rootProject.file('gradle/')){ into('gradle/') } from(rootProject.file('mdk/')){ rootProject.file('mdk/gitignore.txt').eachLine{ if (!it.trim().isEmpty() && !it.trim().startsWith('#')) exclude it } filter(ReplaceTokens, tokens: [ FORGE_VERSION: FORGE_VERSION, FORGE_GROUP: project.group, FORGE_NAME: project.name, MC_VERSION: MC_VERSION, MAPPING_CHANNEL: MAPPING_CHANNEL, MAPPING_VERSION: MAPPING_VERSION, FORGE_SPEC_VERSION: SPEC_VERSION.split("\\.")[0], MC_NEXT_VERSION: MC_NEXT_VERSION ]) rename 'gitignore\\.txt', '.gitignore' rename 'gitattributes\\.txt', '.gitattributes' } from(rootProject.file('src/generated_test/resources/mdk_datagen/')) { into('src/main/resources/') exclude '**/.cache/' } } license { header = file("$rootDir/LICENSE-header.txt") include 'net/minecraftforge/' exclude 'net/minecraftforge/common/LenientUnboundedMapCodec.java' tasks { main { files.from files("$rootDir/src/main/java") } test { files.from files("$rootDir/src/test/java") } } } tasks.register('genAllData') { dependsOn 'forge_data', 'forge_mdk_data', 'forge_test_data' } tasks.eclipse.dependsOn('genEclipseRuns') if (project.hasProperty('UPDATE_MAPPINGS')) { extractRangeMap { sources.from sourceSets.test.java.srcDirs addDependencies compileTestJava.classpath } applyRangeMap { sources.from sourceSets.test.java.srcDirs } sourceSets.test.java.srcDirs.each { extractMappedNew.addTarget it } } tasks.named('javadoc', Javadoc).configure { description 'Generates the combined javadocs for the FML projects and the main Forge project' var includedProjects = [ ':fmlcore', ':fmlloader', ':javafmllanguage', ':mclanguage' ] source includedProjects.collect { project(it).sourceSets.main.allJava } classpath = classpath + files(includedProjects.collect { project(it).sourceSets.main.compileClasspath }) var docsDir = rootProject.file('src/docs/') inputs.dir(docsDir) .withPropertyName('docs resources directory') .withPathSensitivity(PathSensitivity.RELATIVE) .optional() failOnError = false // Exclude the Minecraft classes if not enabled if (!project.hasProperty('generateAllDocumentation')) { exclude 'net/minecraft/**' exclude 'com/mojang/**' } exclude 'mcp/**' options.addStringOption('Xdoclint:all,-missing', '-public') options { stylesheetFile = new File(docsDir, 'stylesheet.css') tags = [ 'apiNote:a:API Note:', 'implSpec:a:Implementation Requirements:', 'implNote:a:Implementation Note:' ] groups = [ 'Forge Mod Loader': [ 'net.minecraftforge.fml.common.asm*', 'net.minecraftforge.fml.loading*', 'net.minecraftforge.fml.server*' ], 'FML Core': [ 'net.minecraftforge.fml', 'net.minecraftforge.fml.config*', 'net.minecraftforge.fml.event*', 'net.minecraftforge.fml.util*' ], 'FML Common': [ 'net.minecraftforge.fml.core', 'net.minecraftforge.fml.event.config', 'net.minecraftforge.fml.event.lifecycle' ], 'FML Java/MC Language Providers': [ 'net.minecraftforge.fml.common', 'net.minecraftforge.fml.javafmlmod', 'net.minecraftforge.fml.mclanguageprovider' ], 'Minecraft Forge API': [ 'net.minecraftforge*' ] ] author = false noSince = true noHelp = true bottom = "Minecraft Forge is an open source modding API for Minecraft: Java Edition, licensed under the Lesser GNU General Public License, version 2.1." windowTitle = "Minecraft Forge API ${VERSION}" docTitle = "Minecraft Forge API - ${FORGE_VERSION} for Minecraft ${MC_VERSION}" header = "
${FORGE_VERSION} for Minecraft ${MC_VERSION}
" } doLast { project.copy { from docsDir exclude '/stylesheet.css' into destinationDir } } } publishing { publications { mavenJava(MavenPublication) { artifact universalJar artifact installerJar artifact makeMdk artifact userdevJar artifact sourcesJar } } } // Since we need the modules in the bootstrap, we need to make sure they are compiled before we do each run afterEvaluate { prepareRuns.dependsOn(PACKED_DEPS) } // Make sure we run bin compat checking during local testing. if (!System.env.MAVEN_USER || !System.env.MAVEN_PASSWORD) publish.dependsOn(':forge:checkJarCompatibility') } tasks.register('setup') { dependsOn ':forge:extractMapped' if (findProject(':clean')) dependsOn ':clean:extractMapped' } tasks.register('doChecks') { dependsOn ':forge:checkJarCompatibility' dependsOn ':forge:publish' } if (System.env.TEAMCITY_VERSION) { //Only setup the CI environment if and only if the environment variables are set. tasks.configureTeamCity { doLast { println "##teamcity[buildNumber '${project(':forge').version}']" println "##teamcity[setParameter name='env.PUBLISHED_JAVA_ARTIFACT_VERSION' value='${project(':forge').version}']" } } } allprojects { prj -> prj.tasks.eclipse.doFirst { 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) } } }