diff --git a/build.gradle.kts b/build.gradle.kts index 6afb8f5..bb72113 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -107,17 +107,17 @@ paperweight { alwaysUpToDate { - paperRepoName.set("paperRepo") - paperBranchName.set("paperBranch") + paperRepo.set("https://github.com/PaperMC/Paper") + paperRef.set("master") paperCommitName.set("paperCommit") - purpurRepoName.set("purpurRepo") - purpurBranchName.set("purpurBranch") + purpurRepo.set("https://github.com/PlazmaMC/Purpur") + purpurRef.set("ver/1.20.6") purpurCommitName.set("purpurCommit") - pufferfishRepoName.set("pufferfishRepo") - pufferfishBranchName.set("pufferfishBranch") - pufferfishToggleName.set("usePufferfish") + pufferfishRepo.set("https://github.com/PlazmaMC/Pufferfish") + pufferfishRef.set("ver/1.20") + usePufferfish.set(true) } diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/AlwaysUpToDate.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/AlwaysUpToDate.kt index d282336..3e71935 100644 --- a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/AlwaysUpToDate.kt +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/AlwaysUpToDate.kt @@ -1,24 +1,72 @@ package org.plazmamc.alwaysuptodate +import io.papermc.paperweight.util.Git import org.gradle.api.Plugin import org.gradle.api.Project -import org.plazmamc.alwaysuptodate.tasks.CheckPaperCommitTask -import org.plazmamc.alwaysuptodate.tasks.CheckPurpurCommitTask -import org.plazmamc.alwaysuptodate.tasks.PaperUpdateTask +import org.gradle.api.provider.Property +import org.plazmamc.alwaysuptodate.utils.* +import org.plazmamc.alwaysuptodate.tasks.CheckUpstreamCommit +import org.plazmamc.alwaysuptodate.tasks.SimpleUpstreamUpdateTask +import org.plazmamc.alwaysuptodate.tasks.CreateCompareComment import org.plazmamc.alwaysuptodate.tasks.PurpurUpdateTask class AlwaysUpToDate : Plugin { - override fun apply(target: Project) = with(target) { + override fun apply(target: Project): Unit = with(target) { - extensions.create("alwaysUpToDate", AlwaysUpToDateExtension::class.java) + Git.checkForGit() - arrayOf( - "updatePaper" to PaperUpdateTask::class.java, - "updatePurpur" to PurpurUpdateTask::class.java, - "checkPaperCommit" to CheckPaperCommitTask::class.java, - "checkPurpurCommit" to CheckPurpurCommitTask::class.java, - ).forEach { tasks.register(it.first, it.second) } + val extension = extensions.create("alwaysUpToDate", AlwaysUpToDateExtension::class.java) + + val git = configureTask("checkGitStatus", "Verify that Git is available") + + fun generateTasks( + upstream: String, + provider: AlwaysUpToDateExtension.() -> Pair, Property>, Property> + ) { + registerTask("check$upstream", "Check if the $upstream commit is up to date") { + dependsOn(git) + val (repo, ref, commitProperty) = extension.provider().flatten() + this.repo.set(repo) + this.ref.set(ref) + this.commitPropertyName.set(commitProperty) + } + + registerTask("compare$upstream", "Create a comment comparing the $upstream commit") { + dependsOn(git) + val (repo, ref, commitProperty) = extension.provider().flatten() + this.repo.set(repo) + this.ref.set(ref) + this.commitPropertyName.set(commitProperty) + this.clear.set(false) + } + + registerTask("cleanCompare$upstream", "Create a comment comparing the $upstream commit") { + dependsOn(git) + val (repo, ref, commitProperty) = extension.provider().flatten() + this.repo.set(repo) + this.ref.set(ref) + this.commitPropertyName.set(commitProperty) + this.clear.set(true) + } + } + + generateTasks("Paper") { paperRepo to paperRef to paperCommitName } + generateTasks("Purpur") { purpurRepo to purpurRef to purpurCommitName } + + registerTask("updateUpstream", "Update the upstream commit") { + dependsOn(git) + repo.convention(extension.paperRepo) + ref.convention(extension.paperRef) + commitPropertyName.convention(extension.paperCommitName) + workDir.set(layout.projectDirectory) + regex.convention("paperCommit = ") + } + + registerTask("updateImplementation", "Update the implementation commit") { + dependsOn(git) + workDir.set(layout.projectDirectory) + } } diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/AlwaysUpToDateExtension.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/AlwaysUpToDateExtension.kt index 9534842..b5813c4 100644 --- a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/AlwaysUpToDateExtension.kt +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/AlwaysUpToDateExtension.kt @@ -4,16 +4,17 @@ import org.gradle.api.provider.Property interface AlwaysUpToDateExtension { - val paperBranchName: Property - val paperRepoName: Property + val paperRepo: Property + val paperRef: Property + + val purpurRepo: Property + val purpurRef: Property + + val pufferfishRepo: Property + val pufferfishRef: Property + val usePufferfish: Property + val paperCommitName: Property - - val pufferfishToggleName: Property - val pufferfishBranchName: Property - val pufferfishRepoName: Property - - val purpurBranchName: Property - val purpurRepoName: Property val purpurCommitName: Property } diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CheckUpstreamCommit.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CheckUpstreamCommit.kt new file mode 100644 index 0000000..fcf5931 --- /dev/null +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CheckUpstreamCommit.kt @@ -0,0 +1,33 @@ +package org.plazmamc.alwaysuptodate.tasks + +import org.gradle.api.Project +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.TaskAction +import org.plazmamc.alwaysuptodate.AlwaysUpToDateException +import org.plazmamc.alwaysuptodate.AlwaysUpToDateExtension +import org.plazmamc.alwaysuptodate.utils.* + +abstract class CheckUpstreamCommit : Task() { + + @get:Input + abstract val repo: Property + + @get:Input + abstract val ref: Property + + @get:Input + abstract val commitPropertyName: Property + + @TaskAction + fun check() = with(project) { println(checkCommitFor { repo to ref to commitPropertyName }) } + +} + +private fun Project.getLatest(repository: String, branch: String) = + git("ls-remote", repository).readText()?.lines() + ?.first("[a-z0-9]{40}\trefs/heads/$branch".toRegex()::matches)?.split("\t")?.first() + ?: throw AlwaysUpToDateException("Failed to get latest commit of $repository") + +fun Project.checkCommitFor(block: AlwaysUpToDateExtension.() -> Pair, Property>, Property>): Boolean = + extension.block().flatten().let { getLatest(extension { it.first }, extension { it.second }) == property { it.third } } diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CheckUpstreamCommitTasks.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CheckUpstreamCommitTasks.kt deleted file mode 100644 index e27259d..0000000 --- a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CheckUpstreamCommitTasks.kt +++ /dev/null @@ -1,61 +0,0 @@ -package org.plazmamc.alwaysuptodate.tasks - -import io.papermc.paperweight.util.Git -import io.papermc.paperweight.util.fromJson -import io.papermc.paperweight.util.gson -import org.gradle.api.Project -import org.gradle.api.tasks.TaskAction -import org.gradle.kotlin.dsl.get -import org.plazmamc.alwaysuptodate.AlwaysUpToDateException -import org.plazmamc.alwaysuptodate.AlwaysUpToDateExtension -import org.plazmamc.alwaysuptodate.utils.pathIO -import paper.libs.com.google.gson.JsonObject -import java.net.URI.create - -abstract class CheckPaperCommitTask : Task() { - - private val property = project.extensions["alwaysUpToDate"] as AlwaysUpToDateExtension - - @TaskAction - fun check() = println(project.checkCommit( - project.property(property.paperRepoName.get()).toString(), - project.property(property.paperBranchName.get()).toString(), - property.paperCommitName.get() - )) - -} - -abstract class CheckPurpurCommitTask : Task() { - - private val property = project.extensions["alwaysUpToDate"] as AlwaysUpToDateExtension - - @TaskAction - fun check() = println(project.checkCommit( - project.property(property.purpurRepoName.get()).toString(), - project.property(property.purpurBranchName.get()).toString(), - property.purpurCommitName.get() - )) - -} - -fun Project.getLatest(repository: String, branch: String) = - Git(project.pathIO)("ls-remote", repository).readText() - ?.lines()?.first("[a-z0-9]{40}\trefs/heads/$branch".toRegex()::matches)?.split("\t")?.first() - ?: throw AlwaysUpToDateException("Failed to get latest commit of $repository") - -fun Project.checkCommit(repository: String, branch: String, propertyName: String) = - project.getLatest(repository, branch) == project.properties[propertyName] as String - -fun Project.createCompareComment(repository: String, branch: String, before: String, clear: Boolean = false) { - val builder = StringBuilder() - val rawRepo = create(repository).path.substring(1) - - if (clear) builder.append("\n\nUpstream has released updates that appear to apply and compile correctly.") - else builder.append(project.file("compare.txt").readText()) - builder.append("\n\n[${rawRepo.split("/").last()} Changes]\n") - - gson.fromJson(create("https://api.github.com/repos/$rawRepo/compare/$before...$branch").toURL().readText())["commits"].asJsonArray.forEach { obj -> - obj.asJsonObject.let { builder.append("$rawRepo@${it["sha"].asString.subSequence(0, 7)}: ${it["commit"].asJsonObject["message"].asString.split("\n")[0]}\n") } - } - project.file("compare.txt").writeText(builder.toString()) -} diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CreateCompareComment.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CreateCompareComment.kt new file mode 100644 index 0000000..666d238 --- /dev/null +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/CreateCompareComment.kt @@ -0,0 +1,46 @@ +package org.plazmamc.alwaysuptodate.tasks + +import io.papermc.paperweight.util.fromJson +import io.papermc.paperweight.util.gson +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.TaskAction +import org.plazmamc.alwaysuptodate.utils.property +import paper.libs.com.google.gson.JsonObject +import java.net.URI + +abstract class CreateCompareComment : Task() { + + @get:Input + abstract val clear: Property + + @get:Input + abstract val repo: Property + + @get:Input + abstract val ref: Property + + @get:Input + abstract val commitPropertyName: Property + + @TaskAction + fun create() = with(project) { + val builder = StringBuilder() + val rawRepo = URI.create(repo.get()).path.substring(1) + + if (clear.get() || !file("compare.txt").exists()) + builder.append("\n\nUpstream has released updates that appear to apply and compile correctly.") + else + builder.append(file("compare.txt").readText()) + + builder.append("\n\n[${rawRepo.split("/").last()} Changes]\n") + + gson.fromJson( + URI.create("https://api.github.com/repos/$rawRepo/compare/${property { commitPropertyName }}...${ref.get()}") + .toURL().readText())["commits"].asJsonArray.forEach { obj -> + obj.asJsonObject.let { builder.append("$rawRepo@${it["sha"].asString.subSequence(0, 7)}: ${it["commit"].asJsonObject["message"].asString.split("\n")[0]}\n") } + } + file("compare.txt").writeText(builder.toString()) + } + +} diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/GenerateMergedAPIPatch.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/GenerateMergedAPIPatch.kt new file mode 100644 index 0000000..d474d7b --- /dev/null +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/GenerateMergedAPIPatch.kt @@ -0,0 +1,39 @@ +package org.plazmamc.alwaysuptodate.tasks + +import io.papermc.paperweight.util.Git +import io.papermc.paperweight.util.path +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.InputDirectory +import org.gradle.api.tasks.Internal +import org.gradle.api.tasks.TaskAction +import org.plazmamc.alwaysuptodate.utils.addCommit +import java.io.File + +abstract class GenerateMergedAPIPatch : Task() { + + @get:InputDirectory + abstract val inputDir: DirectoryProperty + + @get:Internal + abstract val workDir: DirectoryProperty + + @get:Input + abstract val commitTitle: Property + + @get:Input + abstract val author: Property + + @get:Input + abstract val license: Property + + @TaskAction + fun generate() = with(workDir.path) { + val dotGit = resolve(".git").toFile().also(java.io.File::deleteRecursively) + + inputDir.path.toFile().copyRecursively(dotGit, overwrite = true) + Git(this).addCommit("${commitTitle.get()}\n\n${license.get()}", "--author=${author.get()}") + } + +} diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/GenerateMergedServerPatch.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/GenerateMergedServerPatch.kt new file mode 100644 index 0000000..e5d339f --- /dev/null +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/GenerateMergedServerPatch.kt @@ -0,0 +1,51 @@ +package org.plazmamc.alwaysuptodate.tasks + +import io.papermc.paperweight.util.Git +import io.papermc.paperweight.util.path +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.Internal +import org.gradle.api.tasks.TaskAction +import org.plazmamc.alwaysuptodate.utils.addCommit +import java.io.File +import java.nio.file.Path + +abstract class GenerateMergedServerPatch : Task() { + + @get:Internal + abstract val workDir: DirectoryProperty + + @get:Input + abstract val commitTitle: Property + + @get:Input + abstract val author: Property + + @get:Input + abstract val license: Property + + @TaskAction + fun generate() = with(workDir.path) { + val dotGit = resolve(".git").toFile().also(java.io.File::deleteRecursively) + + copySource(this) + + val paper = resolve("../.gradle/caches/paperweight/upstreams/paper/Paper-Server") + copySource(paper) + + Git(paper).addCommit("Vanilla Sources", "--author=Automated ") + + paper.resolve(".git").toFile().copyRecursively(dotGit, overwrite = true) + Git(this).addCommit("${commitTitle.get()}\n\n${license.get()}", "--author=${author.get()}") + } + +} + +internal fun copySource(dir: Path) = with(dir.resolve(".gradle/caches/paperweight/mc-dev-sources")) { + val target = dir.resolve("src/main") + resolve("net").toFile().copyRecursively(target.resolve("java/net").toFile(), overwrite = true) + resolve("com").toFile().copyRecursively(target.resolve("java/com").toFile(), overwrite = true) + resolve("data").toFile().copyRecursively(target.resolve("resources/data").toFile(), overwrite = true) + resolve("assets").toFile().copyRecursively(target.resolve("resources/assets").toFile(), overwrite = true) +} diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/PaperUpdateTask.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/PaperUpdateTask.kt deleted file mode 100644 index 64615ba..0000000 --- a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/PaperUpdateTask.kt +++ /dev/null @@ -1,53 +0,0 @@ -package org.plazmamc.alwaysuptodate.tasks - -import io.papermc.paperweight.util.Git -import org.gradle.api.tasks.TaskAction -import org.gradle.kotlin.dsl.get -import org.plazmamc.alwaysuptodate.AlwaysUpToDateException -import org.plazmamc.alwaysuptodate.AlwaysUpToDateExtension -import java.io.File - -abstract class PaperUpdateTask : Task() { - - private val property = project.extensions["alwaysUpToDate"] as AlwaysUpToDateExtension - - override fun init() = outputs.upToDateWhen { - project.checkCommit( - project.property(property.paperRepoName.get()).toString(), - project.property(property.paperBranchName.get()).toString(), - property.paperCommitName.get() - ) - } - - @TaskAction - fun update() = with(project) { - if ( - checkCommit( - property(property.paperRepoName.get()).toString(), - property(property.paperBranchName.get()).toString(), - property.purpurCommitName.get() - ) - ) return - - createCompareComment( - property(property.paperRepoName.get()).toString(), - property(property.paperBranchName.get()).toString(), - property(property.paperCommitName.get()).toString(), - true - ) - - updatePaperCommit( - property(property.paperRepoName.get()).toString(), - property(property.paperBranchName.get()).toString(), - file("gradle.properties") - ) - } - -} - -fun updatePaperCommit(repo: String, branch: String, properties: File, regexRule: String = "paperCommit = ") = - (Git(properties.parentFile.toPath())("ls-remote", repo).readText()?.lines() - ?.filterNot("[a-z0-9]{40}\trefs/heads/$branch".toRegex()::matches)?.first()?.split("\t")?.first() - ?: throw AlwaysUpToDateException("Failed to get latest Paper commit")).let { - properties.writeText(properties.readText().replace("$regexRule.*".toRegex(), "$regexRule$it")) - } diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/PurpurUpdateTask.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/PurpurUpdateTask.kt index fac4200..59c0ad6 100644 --- a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/PurpurUpdateTask.kt +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/PurpurUpdateTask.kt @@ -1,24 +1,23 @@ package org.plazmamc.alwaysuptodate.tasks -import io.papermc.paperweight.util.Git -import io.papermc.paperweight.util.cache -import io.papermc.paperweight.util.path -import org.gradle.api.Project +import io.papermc.paperweight.patcher.tasks.CheckoutRepo +import io.papermc.paperweight.util.* +import org.gradle.api.file.Directory +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.provider.Provider +import org.gradle.api.tasks.Internal +import org.gradle.api.tasks.OutputDirectory import org.gradle.api.tasks.TaskAction -import org.gradle.kotlin.dsl.get -import org.plazmamc.alwaysuptodate.AlwaysUpToDateExtension -import org.plazmamc.alwaysuptodate.utils.Gradle -import org.plazmamc.alwaysuptodate.utils.addCommit -import org.plazmamc.alwaysuptodate.utils.clone -import org.plazmamc.alwaysuptodate.utils.propValue +import org.gradle.api.tasks.TaskProvider +import org.plazmamc.alwaysuptodate.utils.* import java.io.File import java.nio.file.Path import java.util.Calendar import kotlin.io.path.* +@Deprecated("It will soon be changed to be available for other upstreams.") abstract class PurpurUpdateTask : Task() { - private val property = project.extensions["alwaysUpToDate"] as AlwaysUpToDateExtension private val pufferfishHeader = """ Pufferfish Copyright (C) ${Calendar.getInstance().get(Calendar.YEAR)} Pufferfish Studios LLC @@ -36,6 +35,7 @@ abstract class PurpurUpdateTask : Task() { You should have received a copy of the GNU General Public License along with this program. If not, see . """.trimIndent() + private val pufferfishAuthor = "--author=Kevin Raneri " private val purpurHeader = """ PurpurMC Copyright (C) ${Calendar.getInstance().get(Calendar.YEAR)} PurpurMC @@ -58,90 +58,151 @@ abstract class PurpurUpdateTask : Task() { OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """.trimIndent() + private val purpurAuthor = "--author=granny " - override fun init() = outputs.upToDateWhen { - project.checkCommit( - project.propValue(property.purpurRepoName), - project.propValue(property.purpurBranchName), - property.purpurCommitName.get() - ) + @get:Internal + abstract val workDir: DirectoryProperty + + @get:OutputDirectory + abstract val purpurDir: DirectoryProperty + + @get:OutputDirectory + abstract val pufferfishDir: DirectoryProperty + + override fun init(): Unit = with(project) { + outputs.upToDateWhen { checkCommitFor { purpurRepo to purpurRef to purpurCommitName } } + + val wd = layout.cache.resolve("alwaysUpToDate/update/purpur").also { it.toFile().deleteRecursively() } + workDir.set(wd) + + val compare = configureTask("createPurpurCompareComment", "Create Purpur Compare Comment") { + clear.convention(true) + repo.convention(extension.purpurRepo) + ref.convention(extension.purpurRef) + commitPropertyName.convention(extension.purpurCommitName) + } + + val paper = dependsOn("updatePaper", "Update Paper") { + dependsOn(compare) + repo.convention(extension.paperRepo) + ref.convention(extension.paperRef) + regex.convention("paperCommit = ") + commitPropertyName.convention(extension.paperCommitName) + workDir.set(layout.projectDirectory) + } + + fun checkout(name: String, repo: Provider, ref: Provider, regex: String, block: CheckoutRepo.() -> Unit): Pair, Directory> { + val updatePaper = configureTask("update${name}Paper", "Update $name's Paper") { + this.repo.convention(extension.paperRepo) + this.ref.convention(extension.paperRef) + this.regex.convention(regex) + this.workDir.set(wd.resolve(name)) + } + + val checkout = dependsOn("checkout$name", "Checkout $name") { + this.dependsOn(paper) + this.repoName.convention(name) + this.url.convention(repo) + this.ref.convention(ref) + this.workDir.set(wd) + + this.block() + this.finalizedBy(updatePaper) + } + + return updatePaper to checkout.flatMap { it.outputDir }.get() + } + + val (checkoutPufferfish, pufferfish) = checkout("Pufferfish", extension.pufferfishRepo, extension.pufferfishRef, "paperRef=") { onlyIf { extension { usePufferfish } } } + val (checkoutPurpur, purpur) = checkout("Purpur", extension.purpurRepo, extension.purpurRef, "paperCommit = ") { dependsOn(checkoutPufferfish) } + + pufferfishDir.set(pufferfish) + purpurDir.set(purpur) + + val preparePurpur = configureTask("preparePurpur", "Prepare Purpur Sources") { + mustRunAfter(paper) + dependsOn(checkoutPurpur) + doLast { Gradle(purpur.path)("applyPatches").executeOut() } + } + val preparePufferfish = configureTask("preparePufferfish", "Prepare Pufferfish Sources") { + onlyIf { extension { usePufferfish } } + mustRunAfter(paper) + dependsOn(checkoutPurpur, checkoutPufferfish) + doLast { + val base = pufferfish.path.resolve("patches").also { it.toFile().deleteRecursively() } + val source = purpur.path.resolve("patches") + source.resolve("server").copyPatch(base.resolve("server"), "Pufferfish-Server-Changes") + source.resolve("api").copyPatch(base.resolve("api"), "Pufferfish-API-Changes") + Gradle(pufferfish.path)("applyPatches").executeOut() + } + } + + dependsOn(preparePurpur, preparePufferfish) + + val serverPatch = configureTask("generateMergedServerPatches", "Generate Merged Server Patch") { + dependsOn(preparePurpur) + if (!extension { usePufferfish }) { + workDir.convention(purpur.dir("Purpur-Server")) + commitTitle.convention("Purpur Server Changes") + license.convention(purpurHeader) + author.convention(purpurAuthor) + return@configureTask + } + + dependsOn(preparePufferfish) + workDir.convention(pufferfish.dir("pufferfish-server")) + commitTitle.convention("Pufferfish Server Changes") + license.convention(pufferfishHeader) + author.convention(pufferfishAuthor) + + doLast { + val dotGit = pufferfish.dir("pufferfish-server/.git").path.toFile() + + purpur.path.resolve("Purpur-Server").let { + val purpurDotGit = it.resolve(".git").toFile().also(File::deleteRecursively) + + copySource(it) + dotGit.copyRecursively(purpurDotGit, overwrite = true) + Git(it).addCommit("Purpur Server Changes\n\n$purpurHeader", purpurAuthor) + } + } + } + + val pufferfishAPIChanges = configureTask("generateMergedPufferfishAPIPatch", "Generate Merged Pufferfish API Patch") { + dependsOn(preparePufferfish) + inputDir.convention(pufferfish.dir(".gradle/caches/paperweight/upstreams/paper/Paper-API/.git")) + workDir.convention(pufferfish.dir("pufferfish-api")) + commitTitle.convention("Pufferfish API Changes") + license.convention(pufferfishHeader) + author.convention(pufferfishAuthor) + } + + val apiPatch = configureTask("generateMergedAPIPatches", "Generate Merged API Patches") { + dependsOn(preparePurpur) + if (extension { usePufferfish }) dependsOn(pufferfishAPIChanges) + + workDir.convention(purpur.dir("Purpur-API")) + commitTitle.convention("Purpur API Changes") + license.convention(purpurHeader) + author.convention(purpurAuthor) + inputDir.convention( + if (extension { usePufferfish }) pufferfish.dir("pufferfish-api/.git") + else purpur.dir(".gradle/caches/paperweight/upstreams/paper/Paper-API/.git") + ) + } + + dependsOn("buildPatches", "Build Merged Patches") { + dependsOn(serverPatch, apiPatch) + doLast { Gradle(purpur.path)("rebuildPatches").executeOut() } + } } @TaskAction fun update() = with(project) { - Git.checkForGit() + val purpur = purpurDir.path + val pufferfish = if (extension { usePufferfish }) pufferfishDir.path else null - if (checkCommit(propValue(property.purpurRepoName), propValue(property.purpurBranchName), property.purpurCommitName.get())) - return - - createCompareComment( - propValue(property.purpurRepoName), propValue(property.purpurBranchName), propValue(property.purpurCommitName), true - ) - - val dir = layout.cache.resolve("AlwaysUpToDate/UpdatePurpur") - - if (dir.exists()) dir.toFile().deleteRecursively() - dir.createDirectories() - - val git = Git(dir) - val purpur = git.clone("Purpur", propValue(property.purpurRepoName), propValue(property.purpurBranchName), dir) - val pufferfish = if (propValue(property.pufferfishToggleName).toBoolean()) git.clone("Pufferfish", propValue(property.pufferfishRepoName), propValue(property.pufferfishBranchName), dir) else null - - updateSourceBase(purpur) - if (pufferfish != null) updateSourceBase(pufferfish, "paperRef=") - - val latest = getLatest(property.purpurRepoName.get(), property.purpurBranchName.get()) - - val gradle = Gradle(purpur) - val patches = purpur.resolve("patches").also { patch -> - if (pufferfish == null) return@also - - val base = pufferfish.resolve("patches").also { it.toFile().deleteRecursively() } - patch.resolve("server").copyPatch(base.resolve("server"), "Pufferfish-Server-Changes") - patch.resolve("api").copyPatch(base.resolve("api"), "Pufferfish-API-Changes") - Gradle(pufferfish)("applyPatches").executeOut() - } - gradle("applyPatches").executeOut() - - (pufferfish?.resolve("pufferfish-server") ?: purpur.resolve("Purpur-Server")).let { - val dotGit = it.resolve(".git").toFile().also(File::deleteRecursively) - copySource(it) - - val paper = it.resolve("../.gradle/caches/paperweight/upstreams/paper/Paper-Server") - copySource(paper) - - Git(paper).addCommit("Vanilla Sources", "--author=Vanilla ") - Thread.sleep(1_000) - paper.resolve(".git").toFile().copyRecursively(dotGit, overwrite = true) - - if (pufferfish == null) - return@let Git(it).addCommit("Purpur Server Changes\n\n$purpurHeader", "--author=granny ") - - Git(it).addCommit("Pufferfish Server Changes\n\n$pufferfishHeader", "--author=Kevin Raneri ") - - purpur.resolve("Purpur-Server").let { that -> - val purpurDotGit = that.resolve(".git").toFile().also(File::deleteRecursively) - - copySource(that) - dotGit.copyRecursively(purpurDotGit, overwrite = true) - Git(that).addCommit("Purpur Server Changes\n\n$purpurHeader", "--author=granny ") - } - } - - with(purpur.resolve("Purpur-API")) { - val dotGit = resolve(".git").toFile().also(File::deleteRecursively) - - (pufferfish?.resolve("pufferfish-api/.git")?.toFile()?.also { - it.deleteRecursively() - it.resolve("../.gradle/caches/paperweight/upstreams/paper/Paper-API/.git").copyRecursively(it, overwrite = true) - Git(it).addCommit("Pufferfish API Changes\n\n$pufferfishHeader", "--author=Kevin Raneri ") - } ?: resolve("../.gradle/caches/paperweight/upstreams/paper/Paper-API/.git").toFile()) - .copyRecursively(dotGit, overwrite = true) - - Git(this).addCommit("Purpur API Changes\n\n$purpurHeader", "--author=granny ") - } - - gradle("rebuildPatches").executeOut() + val patches = purpur.resolve("patches") with(layout.projectDirectory.path.resolve("patches")) { patches.resolve("server").copyPatch(resolve("server"), if (pufferfish == null) "" else "Pufferfish-Server-Changes", @@ -155,34 +216,18 @@ abstract class PurpurUpdateTask : Task() { } file("gradle.properties").let { - it.writeText(it.readText().replace("purpurCommit = .*".toRegex(), "purpurCommit = $latest")) + it.writeText(it.readText().replace("purpurCommit = .*".toRegex(), "purpurCommit = ${Git(purpur).revParse()}")) } } - private fun Project.updateSourceBase(source: Path, regex: String? = null) = properties - .let { it[property.paperRepoName.get()].toString() to it[property.paperBranchName.get()].toString() } - .let { - updatePaperCommit(it.first, it.second, source.resolve("gradle.properties").toFile(), regex ?: "paperCommit = ") - - if (checkCommit(it.first, it.second, property.paperCommitName.get())) return@let - - createCompareComment(it.first, it.second, propValue(property.paperCommitName)) - updatePaperCommit(it.first, it.second, file("gradle.properties")) - } - - private fun copySource(dir: Path) = with(dir.resolve(".gradle/caches/paperweight/mc-dev-sources")) { - val target = dir.resolve("src/main") - resolve("net").toFile().copyRecursively(target.resolve("java/net").toFile(), overwrite = true) - resolve("data").toFile().copyRecursively(target.resolve("resources/data").toFile(), overwrite = true) - } - - private fun Path.copyPatch(to: Path, vararg name: String) = listDirectoryEntries() - .filter { entry -> name.any { it.endsWith(entry.name.substring(5) + ".patch") } }.map(Path::toFile) - .forEachIndexed { count, patch -> - patch.copyTo( - to.resolve(count.toString().padStart(4, '0') + "-" + name.first { patch.name.substring(5) == "$it.patch" }).toFile(), - overwrite = true - ) - } - } + +@OptIn(ExperimentalPathApi::class) +private fun Path.copyPatch(to: Path, vararg name: String) = walk().sorted() + .filter { entry -> name.any { entry.name.endsWith("$it.patch") } }.map(Path::toFile) + .forEachIndexed { count, patch -> + patch.copyTo( + to.resolve("${count + 1}".padStart(4, '0') + "-" + name.first { patch.name.substring(5) == "$it.patch" } + ".patch").toFile(), + overwrite = true + ) + } diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/SimpleUpstreamUpdateTask.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/SimpleUpstreamUpdateTask.kt new file mode 100644 index 0000000..15e71e0 --- /dev/null +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/tasks/SimpleUpstreamUpdateTask.kt @@ -0,0 +1,57 @@ +package org.plazmamc.alwaysuptodate.tasks + +import io.papermc.paperweight.util.Git +import io.papermc.paperweight.util.path +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.InputDirectory +import org.gradle.api.tasks.Optional +import org.gradle.api.tasks.TaskAction +import org.plazmamc.alwaysuptodate.AlwaysUpToDateException +import org.plazmamc.alwaysuptodate.utils.* + +abstract class SimpleUpstreamUpdateTask : Task() { + + @get:Input + abstract val repo: Property + + @get:Input + abstract val ref: Property + + @get:Input + @get:Optional + abstract val commitPropertyName: Property + + @get:InputDirectory + abstract val workDir: DirectoryProperty + + @get:Input + abstract val regex: Property + + override fun init(): Unit = with(project) { + outputs.upToDateWhen { + if (commitPropertyName.orNull != null) + checkCommitFor { repo to ref to (commitPropertyName) } + else + false + } + + dependsOn("createCompareComment", "Create Paper Compare Comment") { + clear.convention(false) + repo.convention(extension.paperRepo) + ref.convention(extension.paperRef) + commitPropertyName.convention(extension.paperCommitName) + } + } + + @TaskAction + fun update() = (Git(workDir.path)("ls-remote", repo.get()).readText()?.lines() + ?.filterNot("[a-z0-9]{40}\trefs/heads/${ref.get()}".toRegex()::matches)?.first()?.split("\t")?.first() + ?: throw AlwaysUpToDateException("Failed to get latest commit")).let { commit -> + workDir.file("gradle.properties").path.toFile().let { + it.writeText(it.readText().replace("${regex.get()}.*".toRegex(), "${regex.get()}$commit")) + } + } + +} diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Git.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Git.kt index 92bad62..d480488 100644 --- a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Git.kt +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Git.kt @@ -1,18 +1,37 @@ package org.plazmamc.alwaysuptodate.utils import io.papermc.paperweight.util.Git +import org.gradle.api.tasks.TaskAction import org.plazmamc.alwaysuptodate.AlwaysUpToDateException +import org.plazmamc.alwaysuptodate.tasks.Task import java.nio.file.Path +import kotlin.io.path.ExperimentalPathApi +import kotlin.io.path.exists import kotlin.io.path.notExists +import kotlin.io.path.walk + +val Git.path: Path + get() = Git::class.java.getDeclaredField("repo").apply { isAccessible = true }.get(this) as Path + +abstract class CheckGitTask : Task() { + + @TaskAction + fun checkGit() = Git.checkForGit() -fun Git.clone(name: String, uri: String, branch: String, dir: Path): Path { - val target = dir.resolve(name) - this("clone", "--depth", "1", "--branch", branch, uri, target.toString()).executeSilently(silenceErr = true) - if (target.notExists()) throw AlwaysUpToDateException("Failed to clone repository") - return target } +fun Git.revParse(): String = this("rev-parse", "HEAD").captureOut(true).out.trim() + fun Git.addCommit(vararg args: String) { - this("add", ".").executeOut() - this("commit", "-m", *args).executeOut() + this("add", ".").executeSilently() + this("commit", "-m", *args).executeSilently() + this.wait() +} + +fun Git.wait() { + val lockFile = path.resolve(".git/gc.pid") + while (lockFile.exists()) { + println("detected lockfile, waiting for it to be removed") + Thread.sleep(1000) + } } diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Tasks.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Tasks.kt new file mode 100644 index 0000000..b80fe5f --- /dev/null +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Tasks.kt @@ -0,0 +1,75 @@ +package org.plazmamc.alwaysuptodate.utils + +import io.papermc.paperweight.util.Git +import io.papermc.paperweight.util.configureTask +import io.papermc.paperweight.util.path +import org.gradle.api.DefaultTask +import org.gradle.api.Project +import org.gradle.api.Task +import org.gradle.api.provider.Property +import org.gradle.api.tasks.TaskProvider +import org.gradle.kotlin.dsl.get +import org.plazmamc.alwaysuptodate.AlwaysUpToDateExtension + +private var extensionAccessor: AlwaysUpToDateExtension? = null + set(value) { + if (field != null) throw IllegalAccessException("ExtensionAccessor already initialized") + field = value + } + +val Project.extension: AlwaysUpToDateExtension + get() { + if (extensionAccessor == null) extensionAccessor = project.extensions["alwaysUpToDate"] as AlwaysUpToDateExtension + return extensionAccessor!! + } + +val Project.git: Git get() = Git(layout.projectDirectory.path) + +fun Project.extension(block: AlwaysUpToDateExtension.() -> Property): T = + extension.block().get() + +fun Project.property(block: AlwaysUpToDateExtension.() -> Property) = + this.property(extension(block)) as String + +inline fun Task.dependsOn(name: String, description: String, noinline block: T.() -> Unit = {}): TaskProvider = + project.configureTask(name, description, block).also { this.dependsOn(it) } + +@JvmName("dependsOnDefaultTask") +fun Task.dependsOn(name: String, description: String, block: DefaultTask.() -> Unit = {}): TaskProvider = + project.configureTask(name, description, block).also { this.dependsOn(it) } + +inline fun Task.finalizedBy(name: String, description: String, noinline block: T.() -> Unit = {}): TaskProvider = + project.configureTask(name, description, block).also { this.finalizedBy(it) } + +@JvmName("finalizedByDefaultTask") +fun Task.finalizedBy(name: String, description: String, block: DefaultTask.() -> Unit = {}): TaskProvider = + project.configureTask(name, description, block).also { this.finalizedBy(it) } + +inline fun Task.mustRunAfter(name: String, description: String, noinline block: T.() -> Unit = {}): TaskProvider = + project.configureTask(name, description, block).also { this.mustRunAfter(it) } + +@JvmName("mustRunAfterDefaultTask") +fun Task.mustRunAfter(name: String, description: String, block: DefaultTask.() -> Unit = {}): TaskProvider = + project.configureTask(name, description, block).also { this.mustRunAfter(it) } + +inline fun Project.configureTask(name: String, description: String, noinline block: T.() -> Unit = {}): TaskProvider = + tasks.configureTask(name) { + this.group = "always up to date" + this.description = description + this.block() + } + +@JvmName("configureDefaultTask") +fun Project.configureTask(name: String, description: String, block: DefaultTask.() -> Unit = {}): TaskProvider = + tasks.configureTask(name) { + this.group = "always up to date" + this.description = description + this.block() + } + +inline fun Project.registerTask(name: String, description: String, crossinline block: T.() -> Unit = {}): TaskProvider = + tasks.register(name, T::class.java) { + this.group = "always up to date" + this.description = description + this.block() + } diff --git a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Utils.kt b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Utils.kt index baf140a..e3032b0 100644 --- a/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Utils.kt +++ b/buildSrc/src/main/kotlin/org/plazmamc/alwaysuptodate/utils/Utils.kt @@ -1,11 +1,3 @@ package org.plazmamc.alwaysuptodate.utils -import io.papermc.paperweight.util.path -import org.gradle.api.Project -import org.gradle.api.provider.Property -import java.nio.file.Path - -val Project.pathIO: Path get() = layout.projectDirectory.path - -fun Project.propValue(name: Property) = - this.property(name.get()) as String +fun Pair, C>.flatten() = Triple(first.first, first.second, second) diff --git a/gradle.properties b/gradle.properties index e65fbd1..f0b8611 100644 --- a/gradle.properties +++ b/gradle.properties @@ -25,5 +25,8 @@ pufferfishRepo = https://github.com/PlazmaMC/Pufferfish pufferfishBranch = ver/1.20 usePufferfish = true +#paperCommit = 5d8e53d78d0089894c9552b95b7b8ad9dcc8cb6f +#purpurCommit = 7095128d494cf55d8de10bece0a05f444fda183e + paperCommit = 347bbe389786d5cdae7cd1c6ec32cacba2a9aac7 purpurCommit = a5b3783e35e3486ec3b0829e54d3eff665030bb7 diff --git a/initDev b/initDev index 11a77c5..2228b43 100644 --- a/initDev +++ b/initDev @@ -1,3 +1,4 @@ +#!/bin/bash # To initialize your development environment, # run below command in your terminal: # source ./initDev @@ -23,7 +24,7 @@ alias rcc="git rebase --continue" # generate Fixup patches for Server function fs() { - cd *-Server + cd ./*-Server || exit 1 git add . git commit -m "fixup" @@ -35,7 +36,7 @@ function fs() { # generate Fixup patches for API function fa() { - cd *-API + cd ./*-API || exit 1 git add . git commit -m "fixup" @@ -47,6 +48,12 @@ function fa() { # ReApply Server Patches function rasp() { - rm -rf *-Server + rm -rf ./*-Server ./gradlew applyServerPatches } + +# Commit Updated Upstream +function cuu() { + # shellcheck disable=SC2059 + printf "Updated Upstream ($1)$(/bin/cat compare.txt)" | git commit -F - +} diff --git a/patches/api/0001-Pufferfish-API-Changes.patch b/patches/api/0001-Pufferfish-API-Changes.patch index 77db9d3..16da658 100644 --- a/patches/api/0001-Pufferfish-API-Changes.patch +++ b/patches/api/0001-Pufferfish-API-Changes.patch @@ -1,8 +1,23 @@ From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: AlphaKR93 -Date: Sun, 26 May 2024 19:50:35 +0900 +From: --author=Kevin Raneri +Date: Sun, 2 Jun 2024 20:00:52 +0900 Subject: [PATCH] Pufferfish API Changes +Pufferfish +Copyright (C) 2024 Pufferfish Studios LLC + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . diff --git a/build.gradle.kts b/build.gradle.kts index fd39ed209b20c927054b8482c400beeeeab460a3..1336685fde70c4a88a1fb591cdfcd781a8f06d0b 100644 @@ -373,6 +388,24 @@ index 0000000000000000000000000000000000000000..ae2464920c9412ac90b819a540ee58be + } + +} +diff --git a/src/main/java/io/papermc/paper/ServerBuildInfo.java b/src/main/java/io/papermc/paper/ServerBuildInfo.java +index 9df9d09aa477d4cd3c496ba0933c816df1ef0964..ad81341bdd1eb73554cd24f27ac5d655d89db791 100644 +--- a/src/main/java/io/papermc/paper/ServerBuildInfo.java ++++ b/src/main/java/io/papermc/paper/ServerBuildInfo.java +@@ -17,6 +17,13 @@ public interface ServerBuildInfo { + * The brand id for Paper. + */ + Key BRAND_PAPER_ID = Key.key("papermc", "paper"); ++ ++ // Pufferfish start ++ /** ++ * The brand id for Paper. ++ */ ++ Key BRAND_PUFFERFISH_ID = Key.key("pufferfishgg", "pufferfish"); ++ // Pufferfish end + + /** + * Gets the {@code ServerBuildInfo}. diff --git a/src/main/java/org/bukkit/map/MapPalette.java b/src/main/java/org/bukkit/map/MapPalette.java index c80faa079eca1564847070f0338fc98024639829..e632d51d3487eb4807243b6705999ad124466bf5 100644 --- a/src/main/java/org/bukkit/map/MapPalette.java diff --git a/patches/api/0002-Purpur-API-Changes.patch b/patches/api/0002-Purpur-API-Changes.patch index debaf35..18d2a65 100644 --- a/patches/api/0002-Purpur-API-Changes.patch +++ b/patches/api/0002-Purpur-API-Changes.patch @@ -1,6 +1,6 @@ From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: granny -Date: Mon, 27 May 2024 13:23:14 +0900 +From: --author=granny +Date: Sun, 2 Jun 2024 20:02:16 +0900 Subject: [PATCH] Purpur API Changes PurpurMC @@ -199,12 +199,12 @@ index ab5fea0b03224bf249352ce340e94704ff713345..3441cdad70da1bd523c5933b1a914688 } else { SIMDDetection.testRun = true; diff --git a/src/main/java/io/papermc/paper/ServerBuildInfo.java b/src/main/java/io/papermc/paper/ServerBuildInfo.java -index 9df9d09aa477d4cd3c496ba0933c816df1ef0964..7107eabf02d9d9b69d97c978ba421ad52031ec3f 100644 +index ad81341bdd1eb73554cd24f27ac5d655d89db791..fe23268c418cccbd45caf2870f7931cfed978d28 100644 --- a/src/main/java/io/papermc/paper/ServerBuildInfo.java +++ b/src/main/java/io/papermc/paper/ServerBuildInfo.java -@@ -18,6 +18,13 @@ public interface ServerBuildInfo { - */ - Key BRAND_PAPER_ID = Key.key("papermc", "paper"); +@@ -25,6 +25,13 @@ public interface ServerBuildInfo { + Key BRAND_PUFFERFISH_ID = Key.key("pufferfishgg", "pufferfish"); + // Pufferfish end + // Purpur start + /** @@ -3785,7 +3785,7 @@ index 12946bd55fcf7c40d39081779a7fa30049ee6165..9c2d605c50cbf9aefa56ec209df9f6ce } diff --git a/src/test/java/org/bukkit/AnnotationTest.java b/src/test/java/org/bukkit/AnnotationTest.java -index 88f1ca89fa640a686231b8eec87e70419b2d73ef..d6b91c49a267c89d7df2ddee7ccfe64675d117be 100644 +index 057dc3ebea3516863dda24252fe05d344c16fab3..5b341346cb9582ad5a0bb77a0d4046d8527797a3 100644 --- a/src/test/java/org/bukkit/AnnotationTest.java +++ b/src/test/java/org/bukkit/AnnotationTest.java @@ -47,6 +47,10 @@ public class AnnotationTest { diff --git a/patches/api/0004-Rebrand.patch b/patches/api/0004-Rebrand.patch index 967352c..7a28fd0 100644 --- a/patches/api/0004-Rebrand.patch +++ b/patches/api/0004-Rebrand.patch @@ -45,10 +45,10 @@ index 199789d56d22fcb1b77ebd56805cc28aa5a5ab0a..3b3bcfa6fa2dbcc7fef899cc7570da09 Logger.getGlobal().log(Level.SEVERE, "TIMING_STACK_CORRUPTION - Report this to the plugin " + last.identifier.group + " (Look for errors above this in the logs) (" + last.identifier + " did not stopTiming)", new Throwable()); } diff --git a/src/main/java/io/papermc/paper/ServerBuildInfo.java b/src/main/java/io/papermc/paper/ServerBuildInfo.java -index 7107eabf02d9d9b69d97c978ba421ad52031ec3f..098125a57409b480f045c3a8c3b58db74a6605f3 100644 +index fe23268c418cccbd45caf2870f7931cfed978d28..bcf09f735e98f8bbce7c7dfab802ad20e2f17548 100644 --- a/src/main/java/io/papermc/paper/ServerBuildInfo.java +++ b/src/main/java/io/papermc/paper/ServerBuildInfo.java -@@ -25,6 +25,29 @@ public interface ServerBuildInfo { +@@ -32,6 +32,29 @@ public interface ServerBuildInfo { Key BRAND_PURPUR_ID = Key.key("purpurmc", "purpur"); // Purpur end diff --git a/patches/server/0001-Pufferfish-Server-Changes.patch b/patches/server/0001-Pufferfish-Server-Changes.patch index c7b9f56..1548849 100644 --- a/patches/server/0001-Pufferfish-Server-Changes.patch +++ b/patches/server/0001-Pufferfish-Server-Changes.patch @@ -1,6 +1,6 @@ From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Kevin Raneri -Date: Mon, 27 May 2024 13:23:13 +0900 +From: --author=Kevin Raneri +Date: Sun, 2 Jun 2024 20:02:21 +0900 Subject: [PATCH] Pufferfish Server Changes Pufferfish @@ -20,7 +20,7 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . diff --git a/build.gradle.kts b/build.gradle.kts -index 4998aff0b7cb084dcda15c6a18bbe45e99b6000a..d877dbae82b775250739b5b8d84e163d37a39e35 100644 +index 4998aff0b7cb084dcda15c6a18bbe45e99b6000a..74425cec45d784566cb53eeb5391a5cc00d777e5 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -13,7 +13,7 @@ configurations.named(log4jPlugins.compileClasspathConfigurationName) { @@ -61,15 +61,26 @@ index 4998aff0b7cb084dcda15c6a18bbe45e99b6000a..d877dbae82b775250739b5b8d84e163d tasks.jar { archiveClassifier.set("dev") -@@ -75,7 +90,7 @@ tasks.jar { - val mcVersion = rootProject.providers.gradleProperty("mcVersion").get() - val build = System.getenv("BUILD_NUMBER") ?: null - val gitHash = git("rev-parse", "--short=7", "HEAD").getText().trim() -- val implementationVersion = "$mcVersion-${build ?: "DEV"}-$gitHash" -+ val implementationVersion = "git-Pufferfish-$gitHash" // Pufferfish - val date = git("show", "-s", "--format=%ci", gitHash).getText().trim() // Paper +@@ -80,14 +95,14 @@ tasks.jar { val gitBranch = git("rev-parse", "--abbrev-ref", "HEAD").getText().trim() // Paper attributes( + "Main-Class" to "org.bukkit.craftbukkit.Main", +- "Implementation-Title" to "Paper", ++ "Implementation-Title" to "Pufferfish", // Pufferfish + "Implementation-Version" to implementationVersion, + "Implementation-Vendor" to date, // Paper +- "Specification-Title" to "Paper", ++ "Specification-Title" to "Pufferfish", // Pufferfish + "Specification-Version" to project.version, +- "Specification-Vendor" to "Paper Team", +- "Brand-Id" to "papermc:paper", +- "Brand-Name" to "Paper", ++ "Specification-Vendor" to "Pufferfish Team", // Pufferfish ++ "Brand-Id" to "pufferfishgg:pufferfish", // Pufferfish ++ "Brand-Name" to "Pufferfish", // Pufferfish + "Build-Number" to (build ?: ""), + "Build-Time" to Instant.now().toString(), + "Git-Branch" to gitBranch, // Paper diff --git a/src/main/java/co/aikar/timings/TimingsExport.java b/src/main/java/co/aikar/timings/TimingsExport.java index 7620c72a4c243cbeea245203ce03a97cbfa7d922..b35a9f4c5f8960864c402ede8a51fb5ab9c4fcc0 100644 --- a/src/main/java/co/aikar/timings/TimingsExport.java @@ -2181,6 +2192,30 @@ index 0000000000000000000000000000000000000000..facd55463d44cb7e3d2ca6892982f549 + return backingMap.size(); + } +} +diff --git a/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java b/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java +index 790bad0494454ca12ee152e3de6da3da634d9b20..12d52f6677a1c19084a8d5c7d56850efbe203877 100644 +--- a/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java ++++ b/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java +@@ -31,6 +31,7 @@ public record ServerBuildInfoImpl( + private static final String ATTRIBUTE_GIT_COMMIT = "Git-Commit"; + + private static final String BRAND_PAPER_NAME = "Paper"; ++ private static final String BRAND_PUFFERFISH_NAME = "Pufferfish"; // Pufferfish + + private static final String BUILD_DEV = "DEV"; + +@@ -42,9 +43,9 @@ public record ServerBuildInfoImpl( + this( + getManifestAttribute(manifest, ATTRIBUTE_BRAND_ID) + .map(Key::key) +- .orElse(BRAND_PAPER_ID), ++ .orElse(BRAND_PUFFERFISH_ID), // Pufferfish + getManifestAttribute(manifest, ATTRIBUTE_BRAND_NAME) +- .orElse(BRAND_PAPER_NAME), ++ .orElse(BRAND_PUFFERFISH_NAME), // Pufferfish + SharedConstants.getCurrentVersion().getId(), + SharedConstants.getCurrentVersion().getName(), + getManifestAttribute(manifest, ATTRIBUTE_BUILD_NUMBER) diff --git a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java b/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java index 2874bc3001c4e7d9191e47ba512c5a68369c21f1..32035e37b39ba42232fea948166e7c1d4d06190c 100644 --- a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java @@ -2251,7 +2286,7 @@ index 300929a406905f5ff1ede664d5b99fb0938d4d2e..01a6b1135420ea659d092ddca499f281 throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.OUT_OF_ORDER_CHAT, org.bukkit.event.player.PlayerKickEvent.Cause.OUT_OF_ORDER_CHAT); // Paper - kick event causes } else { diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 0ed42fa899721f83b598db05be1b5f321af3614a..d3ac9185d16099daac9144d7adf6dc38827ab0dc 100644 +index 0ed42fa899721f83b598db05be1b5f321af3614a..c110559de69f61c56445f12e733021b6acbcfb4a 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -316,6 +316,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop -Date: Mon, 27 May 2024 13:23:14 +0900 +Date: Sun, 2 Jun 2024 20:02:23 +0900 Subject: [PATCH] Purpur Server Changes PurpurMC @@ -25,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/build.gradle.kts b/build.gradle.kts -index d877dbae82b775250739b5b8d84e163d37a39e35..e4c14967c18b4f2a623c17b5ba72fc076b904755 100644 +index 74425cec45d784566cb53eeb5391a5cc00d777e5..df11a8da57f07c3efef3f834b3ee724ccaffd8ed 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -13,7 +13,7 @@ configurations.named(log4jPlugins.compileClasspathConfigurationName) { @@ -48,26 +48,20 @@ index d877dbae82b775250739b5b8d84e163d37a39e35..e4c14967c18b4f2a623c17b5ba72fc07 testImplementation("io.github.classgraph:classgraph:4.8.47") // Paper - mob goal test testImplementation("org.junit.jupiter:junit-jupiter:5.10.2") testImplementation("org.hamcrest:hamcrest:2.2") -@@ -90,19 +94,19 @@ tasks.jar { - val mcVersion = rootProject.providers.gradleProperty("mcVersion").get() - val build = System.getenv("BUILD_NUMBER") ?: null - val gitHash = git("rev-parse", "--short=7", "HEAD").getText().trim() -- val implementationVersion = "git-Pufferfish-$gitHash" // Pufferfish -+ val implementationVersion = "$mcVersion-${build ?: "DEV"}-$gitHash" // Pufferfish // Purpur - val date = git("show", "-s", "--format=%ci", gitHash).getText().trim() // Paper +@@ -95,14 +99,14 @@ tasks.jar { val gitBranch = git("rev-parse", "--abbrev-ref", "HEAD").getText().trim() // Paper attributes( "Main-Class" to "org.bukkit.craftbukkit.Main", -- "Implementation-Title" to "Paper", +- "Implementation-Title" to "Pufferfish", // Pufferfish + "Implementation-Title" to "Purpur", // Purpur "Implementation-Version" to implementationVersion, "Implementation-Vendor" to date, // Paper -- "Specification-Title" to "Paper", +- "Specification-Title" to "Pufferfish", // Pufferfish + "Specification-Title" to "Purpur", // Purpur "Specification-Version" to project.version, -- "Specification-Vendor" to "Paper Team", -- "Brand-Id" to "papermc:paper", -- "Brand-Name" to "Paper", +- "Specification-Vendor" to "Pufferfish Team", // Pufferfish +- "Brand-Id" to "pufferfishgg:pufferfish", // Pufferfish +- "Brand-Name" to "Pufferfish", // Pufferfish + "Specification-Vendor" to "Purpur Team", // Purpur + "Brand-Id" to "purpurmc:purpur", // Purpur + "Brand-Name" to "Purpur", // Purpur @@ -385,30 +379,30 @@ index 1ca25529245ed369b8705075a8c2e32fa4d9b1d1..cba3d725245223c5d9e8e59dcceec61f "This can improve performance by a few percent, but has minor gameplay implications."); } diff --git a/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java b/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java -index 790bad0494454ca12ee152e3de6da3da634d9b20..a6e5950b5875cafd734300cdfbf58f5d3736f3c8 100644 +index 12d52f6677a1c19084a8d5c7d56850efbe203877..a27797afd0dc262a72dbd7906c6f00641619c7eb 100644 --- a/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java +++ b/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java -@@ -31,6 +31,7 @@ public record ServerBuildInfoImpl( - private static final String ATTRIBUTE_GIT_COMMIT = "Git-Commit"; +@@ -32,6 +32,7 @@ public record ServerBuildInfoImpl( private static final String BRAND_PAPER_NAME = "Paper"; + private static final String BRAND_PUFFERFISH_NAME = "Pufferfish"; // Pufferfish + private static final String BRAND_PURPUR_NAME = "Purpur"; // Purpur private static final String BUILD_DEV = "DEV"; -@@ -42,9 +43,9 @@ public record ServerBuildInfoImpl( +@@ -43,9 +44,9 @@ public record ServerBuildInfoImpl( this( getManifestAttribute(manifest, ATTRIBUTE_BRAND_ID) .map(Key::key) -- .orElse(BRAND_PAPER_ID), +- .orElse(BRAND_PUFFERFISH_ID), // Pufferfish + .orElse(BRAND_PURPUR_ID), // Purpur getManifestAttribute(manifest, ATTRIBUTE_BRAND_NAME) -- .orElse(BRAND_PAPER_NAME), +- .orElse(BRAND_PUFFERFISH_NAME), // Pufferfish + .orElse(BRAND_PURPUR_NAME), // Purpur SharedConstants.getCurrentVersion().getId(), SharedConstants.getCurrentVersion().getName(), getManifestAttribute(manifest, ATTRIBUTE_BUILD_NUMBER) -@@ -61,7 +62,7 @@ public record ServerBuildInfoImpl( +@@ -62,7 +63,7 @@ public record ServerBuildInfoImpl( @Override public boolean isBrandCompatible(final @NotNull Key brandId) { @@ -579,10 +573,10 @@ index f0fce4113fb07c64adbec029d177c236cbdcbae8..e94224ed280247ee69dfdff8dc960f2b } diff --git a/src/main/java/io/papermc/paper/command/brigadier/bukkit/BukkitCommandNode.java b/src/main/java/io/papermc/paper/command/brigadier/bukkit/BukkitCommandNode.java -index 10a113b057b0a4d27cce3bae975e1108aaa7b517..02597f890ac7f2dc12c94c283356b8309638dd17 100644 +index 0c3c82b28e581286b798ee58ca4193efc2faff4a..24121a43aeb5e9bce013f30c92dddd15f99736c6 100644 --- a/src/main/java/io/papermc/paper/command/brigadier/bukkit/BukkitCommandNode.java +++ b/src/main/java/io/papermc/paper/command/brigadier/bukkit/BukkitCommandNode.java -@@ -75,16 +75,16 @@ public class BukkitCommandNode extends LiteralCommandNode { +@@ -80,16 +80,16 @@ public class BukkitCommandNode extends LiteralCommandNode { // Plugins do weird things to workaround normal registration if (this.command.timings == null) { @@ -822,7 +816,7 @@ index 59d7e8a3d83d3ab7aa28606401bb129ccaeff240..684536f600cca94ea346129a139ec4aa boolean flag1 = this.source.acceptsSuccess() && !this.silent; boolean flag2 = broadcastToOps && this.source.shouldInformAdmins() && !this.silent; diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java -index 86af3494f3d86c7b9fb90ce5a877ec23f5a79e7f..36f65fd7b3b291daf2d0138278b47a9d74560a89 100644 +index 0126906e2afc8dd525f27a0c5e82116075c9d352..f3aad0d2411fcdde2845720e7d66a57a33b22742 100644 --- a/src/main/java/net/minecraft/commands/Commands.java +++ b/src/main/java/net/minecraft/commands/Commands.java @@ -166,7 +166,7 @@ public class Commands { @@ -860,7 +854,7 @@ index 86af3494f3d86c7b9fb90ce5a877ec23f5a79e7f..36f65fd7b3b291daf2d0138278b47a9d } if (environment.includeIntegrated) { -@@ -339,9 +347,9 @@ public class Commands { +@@ -345,9 +353,9 @@ public class Commands { // Paper end CommandSourceStack commandlistenerwrapper = (CommandSourceStack) parseresults.getContext().getSource(); @@ -872,7 +866,7 @@ index 86af3494f3d86c7b9fb90ce5a877ec23f5a79e7f..36f65fd7b3b291daf2d0138278b47a9d ContextChain contextchain = this.finishParsing(parseresults, s, commandlistenerwrapper, label); // CraftBukkit // Paper - Add UnknownCommandEvent try { -@@ -371,7 +379,7 @@ public class Commands { +@@ -377,7 +385,7 @@ public class Commands { Commands.LOGGER.error("'/{}' threw an exception", s, exception); } } finally { @@ -881,7 +875,7 @@ index 86af3494f3d86c7b9fb90ce5a877ec23f5a79e7f..36f65fd7b3b291daf2d0138278b47a9d } } -@@ -514,6 +522,7 @@ public class Commands { +@@ -520,6 +528,7 @@ public class Commands { private void runSync(ServerPlayer player, Collection bukkit, RootCommandNode rootcommandnode) { // Paper end - Perf: Async command map building new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendCommandsEvent(player.getBukkitEntity(), (RootCommandNode) rootcommandnode, false).callEvent(); // Paper - Brigadier API @@ -889,7 +883,7 @@ index 86af3494f3d86c7b9fb90ce5a877ec23f5a79e7f..36f65fd7b3b291daf2d0138278b47a9d PlayerCommandSendEvent event = new PlayerCommandSendEvent(player.getBukkitEntity(), new LinkedHashSet<>(bukkit)); event.getPlayer().getServer().getPluginManager().callEvent(event); -@@ -524,6 +533,7 @@ public class Commands { +@@ -530,6 +539,7 @@ public class Commands { } } // CraftBukkit end @@ -898,7 +892,7 @@ index 86af3494f3d86c7b9fb90ce5a877ec23f5a79e7f..36f65fd7b3b291daf2d0138278b47a9d } diff --git a/src/main/java/net/minecraft/commands/arguments/selector/EntitySelector.java b/src/main/java/net/minecraft/commands/arguments/selector/EntitySelector.java -index 676a1499747b071515479130875157263d3a8352..fc1bba350030c076405711716e9830f8ae7f3953 100644 +index d78ad5eccd18d89050a486a0c40090a09683bd16..2a0d54f06de7b959055459349365c85c67c11a3f 100644 --- a/src/main/java/net/minecraft/commands/arguments/selector/EntitySelector.java +++ b/src/main/java/net/minecraft/commands/arguments/selector/EntitySelector.java @@ -200,10 +200,10 @@ public class EntitySelector { @@ -1093,10 +1087,10 @@ index a024c697a65bbab27408da1d6a75e531d9719b47..e4fab82b369f2c2ea0d8c8acd814d061 // Paper end - Add drops to shear events continue; diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java -index 02833deaa2bb7e5abc655bc1bdbe15c4b3ac7119..71b021513f30376c7b09d83059deea89cc92385f 100644 +index f40420a6841f03983b0837e177ea2ae7c3a37ca1..3b66ecc4f110d0f2dc0ef6c560801296d7e0be64 100644 --- a/src/main/java/net/minecraft/network/Connection.java +++ b/src/main/java/net/minecraft/network/Connection.java -@@ -608,11 +608,20 @@ public class Connection extends SimpleChannelInboundHandler> { +@@ -609,11 +609,20 @@ public class Connection extends SimpleChannelInboundHandler> { private static final int MAX_PER_TICK = io.papermc.paper.configuration.GlobalConfiguration.get().misc.maxJoinsPerTick; // Paper - Buffer joins to world private static int joinAttemptsThisTick; // Paper - Buffer joins to world private static int currTick; // Paper - Buffer joins to world @@ -1161,7 +1155,7 @@ index 244a19ecd0234fa1d7a6ecfea20751595688605d..0f7d6da8685716604f0749d4f5b60730 Bootstrap.bootStrap(); Bootstrap.validate(); diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index d3ac9185d16099daac9144d7adf6dc38827ab0dc..4c192b138810650ca0ab5e5d4f2407c0dc3d9fd0 100644 +index c110559de69f61c56445f12e733021b6acbcfb4a..4c192b138810650ca0ab5e5d4f2407c0dc3d9fd0 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -297,6 +297,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop { -@@ -2389,6 +2438,21 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -2379,6 +2428,21 @@ public abstract class LivingEntity extends Entity implements Attackable { } } @@ -4996,7 +4990,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b if (f > 0 || !human) { if (human) { // PAIL: Be sure to drag all this code from the EntityHuman subclass each update. -@@ -2612,7 +2676,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -2602,7 +2666,7 @@ public abstract class LivingEntity extends Entity implements Attackable { @Override protected void onBelowWorld() { @@ -5005,7 +4999,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b } protected void updateSwingTime() { -@@ -2807,7 +2871,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -2797,7 +2861,7 @@ public abstract class LivingEntity extends Entity implements Attackable { } protected long lastJumpTime = 0L; // Paper - Prevent excessive velocity through repeated crits @@ -5014,7 +5008,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b float f = this.getJumpPower(); if (f > 1.0E-5F) { -@@ -2967,6 +3031,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -2957,6 +3021,7 @@ public abstract class LivingEntity extends Entity implements Attackable { if (f3 > 0.0F) { this.playSound(this.getFallDamageSound((int) f3), 1.0F, 1.0F); @@ -5022,7 +5016,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b this.hurt(this.damageSources().flyIntoWall(), f3); } } -@@ -3189,10 +3254,10 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3179,10 +3244,10 @@ public abstract class LivingEntity extends Entity implements Attackable { } this.run += (f3 - this.run) * 0.3F; @@ -5036,7 +5030,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b // Paper start - stop large pitch and yaw changes from crashing the server this.yRotO += Math.round((this.getYRot() - this.yRotO) / 360.0F) * 360.0F; -@@ -3204,7 +3269,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3194,7 +3259,7 @@ public abstract class LivingEntity extends Entity implements Attackable { this.yHeadRotO += Math.round((this.yHeadRot - this.yHeadRotO) / 360.0F) * 360.0F; // Paper end @@ -5045,7 +5039,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b this.animStep += f2; if (this.isFallFlying()) { ++this.fallFlyTicks; -@@ -3427,19 +3492,19 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3417,19 +3482,19 @@ public abstract class LivingEntity extends Entity implements Attackable { } this.setDeltaMovement(d0, d1, d2); @@ -5070,7 +5064,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b if (this.jumping && this.isAffectedByFluids()) { double d3; -@@ -3466,8 +3531,8 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3456,8 +3521,8 @@ public abstract class LivingEntity extends Entity implements Attackable { this.noJumpDelay = 0; } @@ -5081,7 +5075,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b this.xxa *= 0.98F; this.zza *= 0.98F; this.updateFallFlying(); -@@ -3492,8 +3557,8 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3482,8 +3547,8 @@ public abstract class LivingEntity extends Entity implements Attackable { this.travel(vec3d1); } @@ -5092,7 +5086,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b if (!this.level().isClientSide && !this.isDeadOrDying() && !this.freezeLocked) { // Paper - Freeze Tick Lock API int i = this.getTicksFrozen(); -@@ -3510,18 +3575,20 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3500,18 +3565,20 @@ public abstract class LivingEntity extends Entity implements Attackable { this.hurt(this.damageSources().freeze(), 1.0F); } @@ -5118,7 +5112,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b Location from = new Location(this.level().getWorld(), this.xo, this.yo, this.zo, this.yRotO, this.xRotO); Location to = new Location(this.level().getWorld(), this.getX(), this.getY(), this.getZ(), this.getYRot(), this.getXRot()); io.papermc.paper.event.entity.EntityMoveEvent event = new io.papermc.paper.event.entity.EntityMoveEvent(this.getBukkitLivingEntity(), from, to.clone()); -@@ -3531,12 +3598,48 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3521,12 +3588,48 @@ public abstract class LivingEntity extends Entity implements Attackable { this.absMoveTo(event.getTo().getX(), event.getTo().getY(), event.getTo().getZ(), event.getTo().getYaw(), event.getTo().getPitch()); } } @@ -5167,7 +5161,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b } public boolean isSensitiveToWater() { -@@ -3557,7 +3660,16 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3547,7 +3650,16 @@ public abstract class LivingEntity extends Entity implements Attackable { int j = i / 10; if (j % 2 == 0) { @@ -5186,7 +5180,7 @@ index 1405bfc9cf22265a975cca1d8abfae6020a5dd49..7894a41a212c31f96c758608f4f8fc2b this.gameEvent(GameEvent.ELYTRA_GLIDE); diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index 706555cb6b56372411d1ec607d25300d57789b7d..9245a9d38ae6985fee36ab0efea006c9e2b0632a 100644 +index 5e42bfa9e98215ecb8aca4da2486a4b3d94b38aa..1708d9b3500d907449bce86040bf5baea5b269b8 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java @@ -75,6 +75,7 @@ import net.minecraft.world.item.SpawnEggItem; @@ -9789,10 +9783,10 @@ index 6e299770fca78699f7e1988db4cdef37b99d74c1..fdf9ec418b0fc567e286ac79dbdbedda protected void randomizeAttributes(RandomSource random) { this.getAttribute(Attributes.MAX_HEALTH).setBaseValue((double)generateMaxHealth(random::nextInt)); diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java b/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java -index 1dd4290287725898ace29e46b439b55df8fdd1af..7d2a5c806fd0f1228c45b8a8b56d7ba13b899a2d 100644 +index 36d654073ab4058db54830d9447d7d959a0b25f1..f452e18829e2b05cf742a4239cba293263b3a88a 100644 --- a/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java +++ b/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java -@@ -75,9 +75,84 @@ public class Llama extends AbstractChestedHorse implements VariantHolder type, Level world) { super(type, world); + this.maxDomestication = 30; // Paper - Missing entity API; configure max temper instead of a hardcoded value + // Purpur start + this.moveControl = new org.purpurmc.purpur.controller.MoveControllerWASD(this) { + @Override @@ -9877,7 +9872,7 @@ index 1dd4290287725898ace29e46b439b55df8fdd1af..7d2a5c806fd0f1228c45b8a8b56d7ba1 } public boolean isTraderLlama() { -@@ -108,6 +183,7 @@ public class Llama extends AbstractChestedHorse implements VariantHolder set = Sets.newHashSet(); boolean flag = true; -@@ -681,7 +700,7 @@ public class Explosion { +@@ -668,7 +687,7 @@ public class Explosion { } if (flag1) { @@ -17133,7 +17128,7 @@ index 082b804f4793f72e76361f5427f0358273454b3d..133d994d9ac9d4f9527135ac0c77e574 List> list = new ArrayList(); Util.shuffle(this.toBlow, this.level.random); -@@ -759,7 +778,7 @@ public class Explosion { +@@ -746,7 +765,7 @@ public class Explosion { Block.popResource(this.level, (BlockPos) pair.getSecond(), (ItemStack) pair.getFirst()); } @@ -18957,7 +18952,7 @@ index 7b263fab4f0014400b3b8e7e33db32f9a125f6ba..f7a6ab35c95ffda73f17843916ddb624 private int ticksInHive; diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java -index 6349f2e0a5ba30d250f5ffe43771f325c0999a76..8dc1436fe78759cee5247cc28e8a18999e738a1b 100644 +index c0563260277f9f4bd9ff08993b2efb4bca9a0c60..cd0e43f4c53a746dd6183a8406269f9b11ad3571 100644 --- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java +++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java @@ -87,6 +87,12 @@ public abstract class BlockEntity { @@ -19840,18 +19835,9 @@ index 9d93130f23addb18b97d7f5ec013faef17a74529..29d2fb87a65778926aea2cfc7a5b486c + // Purpur end - OfflinePlayer API } diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 49794050997ee1f0511ce4fa6c191906e4f4ca47..54c42f43981aee3da869343b078775fd39994b9e 100644 +index 5562e2a34d6baf5949435d6c9e233d86a51d8da3..3c505f631f15fe97e380c96ac719b1f61ed22690 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -@@ -264,7 +264,7 @@ import javax.annotation.Nullable; // Paper - import javax.annotation.Nonnull; // Paper - - public final class CraftServer implements Server { -- private final String serverName = "Pufferfish"; // Paper // Pufferfish - Use dedicated VersionFetcher -+ private final String serverName = io.papermc.paper.ServerBuildInfo.buildInfo().brandName(); // Paper // Pufferfish - Use dedicated VersionFetcher // Purpur - private final String serverVersion; - private final String bukkitVersion = Versioning.getBukkitVersion(); - private final Logger logger = Logger.getLogger("Minecraft"); @@ -405,6 +405,20 @@ public final class CraftServer implements Server { this.paperPluginManager = new io.papermc.paper.plugin.manager.PaperPluginManagerImpl(this, this.commandMap, pluginManager); this.pluginManager.paperPluginManager = this.paperPluginManager; @@ -19897,7 +19883,7 @@ index 49794050997ee1f0511ce4fa6c191906e4f4ca47..54c42f43981aee3da869343b078775fd this.overrideAllCommandBlockCommands = this.commandsConfiguration.getStringList("command-block-overrides").contains("*"); this.ignoreVanillaPermissions = this.commandsConfiguration.getBoolean("ignore-vanilla-permissions"); -@@ -1572,6 +1589,55 @@ public final class CraftServer implements Server { +@@ -1573,6 +1590,55 @@ public final class CraftServer implements Server { return true; } @@ -19953,7 +19939,7 @@ index 49794050997ee1f0511ce4fa6c191906e4f4ca47..54c42f43981aee3da869343b078775fd @Override public List getRecipesFor(ItemStack result) { Preconditions.checkArgument(result != null, "ItemStack cannot be null"); -@@ -3034,6 +3100,18 @@ public final class CraftServer implements Server { +@@ -3035,6 +3101,18 @@ public final class CraftServer implements Server { return CraftServer.this.console.paperConfigurations.createLegacyObject(CraftServer.this.console); } @@ -19972,7 +19958,7 @@ index 49794050997ee1f0511ce4fa6c191906e4f4ca47..54c42f43981aee3da869343b078775fd @Override public void restart() { org.spigotmc.RestartCommand.restart(); -@@ -3063,6 +3141,7 @@ public final class CraftServer implements Server { +@@ -3064,6 +3142,7 @@ public final class CraftServer implements Server { @Override public double[] getTPS() { return new double[] { @@ -19980,7 +19966,7 @@ index 49794050997ee1f0511ce4fa6c191906e4f4ca47..54c42f43981aee3da869343b078775fd net.minecraft.server.MinecraftServer.getServer().tps1.getAverage(), net.minecraft.server.MinecraftServer.getServer().tps5.getAverage(), net.minecraft.server.MinecraftServer.getServer().tps15.getAverage() -@@ -3261,4 +3340,16 @@ public final class CraftServer implements Server { +@@ -3262,4 +3341,16 @@ public final class CraftServer implements Server { return this.potionBrewer; } // Paper end @@ -20384,10 +20370,10 @@ index 30d62ee4d5cd2ddacb8783b5bbbf475d592b3e02..5c1cda88080850314dac196dbe71ff12 + // Purpur end } diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java -index 2d4e49f386be35ee8912c1bca38f74b8d8926f3a..9060380754e5553b1628f17402bcb80ba9042fae 100644 +index 18af8736f30780b48313257a09973e30df6d0e2f..1284c941a4c863c287098a0a04efcc723e727bb3 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java -@@ -505,7 +505,7 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity { +@@ -512,7 +512,7 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity { net.minecraft.server.level.ServerPlayer entityPlayer = killer == null ? null : ((CraftPlayer) killer).getHandle(); getHandle().lastHurtByPlayer = entityPlayer; getHandle().lastHurtByMob = entityPlayer; @@ -20396,7 +20382,7 @@ index 2d4e49f386be35ee8912c1bca38f74b8d8926f3a..9060380754e5553b1628f17402bcb80b } // Paper end -@@ -1173,4 +1173,22 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity { +@@ -1180,4 +1180,22 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity { this.getHandle().setYBodyRot(bodyYaw); } // Paper end - body yaw API @@ -20654,7 +20640,7 @@ index 86574da257731de7646a712ed73384955fe35aa3..e223234dd64b0e41441c3b9f649f0b64 + // Purpur end } diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -index 34b91eff3190848bae38b20e1d956ece497b1473..e650b85464ac886b4adb1a8924026d34f805aba6 100644 +index dfbe0914ab2771ac632fd064719878ac47559e9f..5308dc55bcc334ad6bef927de6c2d9b9364d99ff 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java @@ -592,6 +592,15 @@ public class CraftEventFactory { @@ -20894,10 +20880,10 @@ index b3e1adeb932da9b3bed16acd94e2f16da48a7c72..d3ec817e95628f1fc8be4a29c9a0f13c // Paper end - add timings for scoreboard search } diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java -index d9f1164ab63017124a9601f980ee6a6ddb3626eb..6f24422beb7d3db6dbed0efcba2935f542519827 100644 +index aa9e901b243a0296966254f802437cb7c1a3a846..5f4dbd71fbf9ac498e8cd23ea8801360ce442d3b 100644 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java -@@ -502,7 +502,7 @@ public final class CraftMagicNumbers implements UnsafeValues { +@@ -503,7 +503,7 @@ public final class CraftMagicNumbers implements UnsafeValues { @Override public com.destroystokyo.paper.util.VersionFetcher getVersionFetcher() { diff --git a/patches/server/0004-Fork-friendly-Rebranding.patch b/patches/server/0004-Fork-friendly-Rebranding.patch index 5c088df..e764fbe 100644 --- a/patches/server/0004-Fork-friendly-Rebranding.patch +++ b/patches/server/0004-Fork-friendly-Rebranding.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Fork-friendly Rebranding diff --git a/build.gradle.kts b/build.gradle.kts -index 80343712d0cb4e10d31581f36e487a0b35711cfe..afa4877ade6cf8b615ba70c1cf7a8c92040e924a 100644 +index 732670587ecf0877be2493f67baade9c27b88f2b..54a30184392815a01f20b8fc841690e4ae5b3cc6 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -13,7 +13,7 @@ configurations.named(log4jPlugins.compileClasspathConfigurationName) { @@ -164,20 +164,21 @@ index 0000000000000000000000000000000000000000..af534fb15be2be3e5b4258c522e0e6c9 + +} diff --git a/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java b/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java -index a6e5950b5875cafd734300cdfbf58f5d3736f3c8..a337e2c9576fb70a8ee9082e9b69719c804b286e 100644 +index a27797afd0dc262a72dbd7906c6f00641619c7eb..a4af02bddf744b6ab271096d1b526cc4c0ec97eb 100644 --- a/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java +++ b/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java -@@ -30,9 +30,6 @@ public record ServerBuildInfoImpl( +@@ -30,10 +30,6 @@ public record ServerBuildInfoImpl( private static final String ATTRIBUTE_GIT_BRANCH = "Git-Branch"; private static final String ATTRIBUTE_GIT_COMMIT = "Git-Commit"; - private static final String BRAND_PAPER_NAME = "Paper"; +- private static final String BRAND_PUFFERFISH_NAME = "Pufferfish"; // Pufferfish - private static final String BRAND_PURPUR_NAME = "Purpur"; // Purpur - private static final String BUILD_DEV = "DEV"; public ServerBuildInfoImpl() { -@@ -43,9 +40,9 @@ public record ServerBuildInfoImpl( +@@ -44,9 +40,9 @@ public record ServerBuildInfoImpl( this( getManifestAttribute(manifest, ATTRIBUTE_BRAND_ID) .map(Key::key) @@ -185,11 +186,11 @@ index a6e5950b5875cafd734300cdfbf58f5d3736f3c8..a337e2c9576fb70a8ee9082e9b69719c + .orElse(BRAND_ID), // Purpur // Plazma - Fork-friendly Rebranding getManifestAttribute(manifest, ATTRIBUTE_BRAND_NAME) - .orElse(BRAND_PURPUR_NAME), // Purpur -+ .orElse(ServerBrandConstants.BRAND_NAME), // Purpur // Plazma - Fork-friendly Rebranding ++ .orElse(BRAND_NAME), // Purpur // Plazma - Fork-friendly Rebranding SharedConstants.getCurrentVersion().getId(), SharedConstants.getCurrentVersion().getName(), getManifestAttribute(manifest, ATTRIBUTE_BUILD_NUMBER) -@@ -62,7 +59,7 @@ public record ServerBuildInfoImpl( +@@ -63,7 +59,7 @@ public record ServerBuildInfoImpl( @Override public boolean isBrandCompatible(final @NotNull Key brandId) { diff --git a/patches/server/0006-Plazma-Configurations.patch b/patches/server/0006-Plazma-Configurations.patch index 82ac153..e543c5c 100644 --- a/patches/server/0006-Plazma-Configurations.patch +++ b/patches/server/0006-Plazma-Configurations.patch @@ -693,7 +693,7 @@ index 6fab30d186d64d51f7dd9af00fccded4c388844c..df73867ee5682fb966b69dd85da61a69 this.playerBreedingCooldowns = this.getNewBreedingCooldownCache(); // Purpur this.generator = gen; diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 54c42f43981aee3da869343b078775fd39994b9e..58878900a1985d4dd23104ac594d52368db580d5 100644 +index 3c505f631f15fe97e380c96ac719b1f61ed22690..02037da80f2f3cada359bbe0f58160fd15761b77 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -1047,6 +1047,7 @@ public final class CraftServer implements Server { @@ -704,7 +704,7 @@ index 54c42f43981aee3da869343b078775fd39994b9e..58878900a1985d4dd23104ac594d5236 org.purpurmc.purpur.PurpurConfig.init((File) console.options.valueOf("purpur-settings")); // Purpur for (ServerLevel world : this.console.getAllLevels()) { // world.serverLevelData.setDifficulty(config.difficulty); // Paper - per level difficulty -@@ -3112,6 +3113,13 @@ public final class CraftServer implements Server { +@@ -3113,6 +3114,13 @@ public final class CraftServer implements Server { } // Purpur end diff --git a/patches/server/0016-Completely-remove-Mojang-Profiler.patch b/patches/server/0016-Completely-remove-Mojang-Profiler.patch index 9f2d3a9..c8e7cb6 100644 --- a/patches/server/0016-Completely-remove-Mojang-Profiler.patch +++ b/patches/server/0016-Completely-remove-Mojang-Profiler.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Completely remove Mojang Profiler diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java -index 36f65fd7b3b291daf2d0138278b47a9d74560a89..dd81cea56d00f576e0b611b212fd17c18d4f9659 100644 +index f3aad0d2411fcdde2845720e7d66a57a33b22742..17608cfa1e742761928e70c64f36a6bfeb77f104 100644 --- a/src/main/java/net/minecraft/commands/Commands.java +++ b/src/main/java/net/minecraft/commands/Commands.java -@@ -442,7 +442,7 @@ public class Commands { +@@ -448,7 +448,7 @@ public class Commands { int j = minecraftserver.getGameRules().getInt(GameRules.RULE_MAX_COMMAND_FORK_COUNT); try { @@ -2618,7 +2618,7 @@ index 97c129f5949ca7cb7430e1cf56e881c00f129530..5c4d902a6febe8ffadecbbc64b50ecdc + */ // Plazma - Completely remove Mojang's Profiler } diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index 9245a9d38ae6985fee36ab0efea006c9e2b0632a..2f5250d3baba15e914290ce30f813ad63f6bd943 100644 +index 1708d9b3500d907449bce86040bf5baea5b269b8..05c41e1c2f4a1c714dc842dc019acda46fc41e7b 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java @@ -37,7 +37,7 @@ import net.minecraft.sounds.SoundEvent; diff --git a/patches/server/0031-Improve-SwingTime-ticking.patch b/patches/server/0031-Improve-SwingTime-ticking.patch index f55bd85..647bbdd 100644 --- a/patches/server/0031-Improve-SwingTime-ticking.patch +++ b/patches/server/0031-Improve-SwingTime-ticking.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Improve SwingTime ticking diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 7894a41a212c31f96c758608f4f8fc2b50e63661..43673b4edeae610196950c088d916e87b008647e 100644 +index f0d611f370966c12e076252ffd020a05c40f3588..8da257e5d305e4ec978f4933d5011f84976e6bb9 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -2680,6 +2680,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -2670,6 +2670,7 @@ public abstract class LivingEntity extends Entity implements Attackable { } protected void updateSwingTime() {