commit ef2eaf71911cfb6e526d34911a84665558e4d344 Author: zhangyuheng Date: Mon Feb 26 21:37:40 2024 +0800 Init diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b63da45 --- /dev/null +++ b/.gitignore @@ -0,0 +1,42 @@ +.gradle +build/ +!gradle/wrapper/gradle-wrapper.jar +!**/src/main/**/build/ +!**/src/test/**/build/ + +### IntelliJ IDEA ### +.idea/modules.xml +.idea/jarRepositories.xml +.idea/compiler.xml +.idea/libraries/ +*.iws +*.iml +*.ipr +out/ +!**/src/main/**/out/ +!**/src/test/**/out/ + +### Eclipse ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache +bin/ +!**/src/main/**/bin/ +!**/src/test/**/bin/ + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ + +### VS Code ### +.vscode/ + +### Mac OS ### +.DS_Store \ No newline at end of file diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..35410ca --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# 默认忽略的文件 +/shelf/ +/workspace.xml +# 基于编辑器的 HTTP 客户端请求 +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/gradle.xml b/.idea/gradle.xml new file mode 100644 index 0000000..f4735f0 --- /dev/null +++ b/.idea/gradle.xml @@ -0,0 +1,18 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml new file mode 100644 index 0000000..2d95299 --- /dev/null +++ b/.idea/kotlinc.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..fe0b0da --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..965d8a2 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..4281b81 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,498 @@ +Contributing to Paper +========================== +PaperMC is happy you're willing to contribute to our projects. We are usually +very lenient with all submitted PRs, but there are still some guidelines you +can follow to make the approval process go more smoothly. + +## Use a Personal Fork and not an Organization + +Paper will routinely modify your PR, whether it's a quick rebase or to take care +of any minor nitpicks we might have. Often, it's better for us to solve these +problems for you than make you go back and forth trying to fix them yourself. + +Unfortunately, if you use an organization for your PR, it prevents Paper from +modifying it. This requires us to manually merge your PR, resulting in us +closing the PR instead of marking it as merged. + +We much prefer to have PRs show as merged, so please do not use repositories +on organizations for PRs. + +See for more information on the +issue. + +## Requirements + +To get started with PRing changes, you'll need the following software, most of +which can be obtained in (most) package managers such as `apt` (Debian / Ubuntu; +you will most likely use this for WSL), `homebrew` (macOS / Linux), and more: + +- `git` (package `git` everywhere); +- A Java 17 or later JDK (packages vary, use Google/DuckDuckGo/etc.). + - [Adoptium](https://adoptium.net/) has builds for most operating systems. + - Paper requires JDK 17 to build, however, makes use of Gradle's + [Toolchains](https://docs.gradle.org/current/userguide/toolchains.html) + feature to allow building with only JRE 11 or later installed. (Gradle will + automatically provision JDK 17 for compilation if it cannot find an existing + install). + +If you're on Windows, check +[the section on WSL](#patching-and-building-is-really-slow-what-can-i-do). + +If you're compiling with Docker, you can use Adoptium's +[`eclipse-temurin`](https://hub.docker.com/_/eclipse-temurin/) images like so: + +```console +# docker run -it -v "$(pwd)":/data --rm eclipse-temurin:17.0.1_12-jdk bash +Pulling image... + +root@abcdefg1234:/# javac -version +javac 17.0.1 +``` + +## Understanding Patches + +Paper is mostly patches and extensions to Spigot. These patches/extensions are +split into different directories which target certain parts of the code. These +directories are: + +- `Paper-API` - Modifications to `Spigot-API`/`Bukkit`; +- `Paper-MojangAPI` - An API for [Mojang's Brigadier](https://github.com/Mojang/brigadier); +- `Paper-Server` - Modifications to `Spigot`/`CraftBukkit`. + +Because the entire structure is based on patches and git, a basic understanding +of how to use git is required. A basic tutorial can be found here: +. + +Assuming you have already forked the repository: + +1. Clone your fork to your local machine; +2. Type `./gradlew applyPatches` in a terminal to apply the changes from upstream. + On Windows, replace the `./` with `.\` at the beginning for all `gradlew` commands; +3. cd into `Paper-Server` for server changes, and `Paper-API` for API changes. + + +`Paper-Server` and `Paper-API` aren't git repositories in the traditional sense: + +- `base` points to the unmodified source before Paper patches have been applied. +- Each commit after `base` is a patch. + +## Adding Patches + +Adding patches to Paper is very simple: + +1. Modify `Paper-Server` and/or `Paper-API` with the appropriate changes; +1. Type `git add .` inside these directories to add your changes; +1. Run `git commit` with the desired patch message; +1. Run `./gradlew rebuildPatches` in the main directory to convert your commit into a new + patch; +1. PR the generated patch file(s) back to this repository. + +Your commit will be converted into a patch that you can then PR into Paper. + +> ❗ Please note that if you have some specific implementation detail you'd like +> to document, you should do so in the patch message *or* in comments. + +## Modifying Patches + +Modifying previous patches is a bit more complex: + +### Method 1 + +This method works by temporarily resetting your `HEAD` to the desired commit to +edit it using `git rebase`. + +> ❗ While in the middle of an edit, you will not be able to compile unless you +> *also* reset the opposing module(s) to a related commit. In the API's case, +> you must reset the Server, and reset the API if you're editing the Server. +> Note also that either module _may_ not compile when doing so. This is not +> ideal nor intentional, but it happens. Feel free to fix this in a PR to us! + +1. If you have changes you are working on, type `git stash` to store them for + later; + - You can type `git stash pop` to get them back at any point. +1. Type `git rebase -i base`; + - It should show something like + [this](https://gist.github.com/zachbr/21e92993cb99f62ffd7905d7b02f3159) in + the text editor you get. + - If your editor does not have a "menu" at the bottom, you're using `vim`. + If you don't know how to use `vim` and don't want to + learn, enter `:q!` and press enter. Before redoing this step, do + `export EDITOR=nano` for an easier editor to use. +1. Replace `pick` with `edit` for the commit/patch you want to modify, and + "save" the changes; + - Only do this for **one** commit at a time. +1. Make the changes you want to make to the patch; +1. Type `git add .` to add your changes; +1. Type `git commit --amend` to commit; + - **Make sure to add `--amend`** or else a new patch will be created. + - You can also modify the commit message and author here. +1. Type `git rebase --continue` to finish rebasing; +1. Type `./gradlew rebuildPatches` in the root directory; + - This will modify the appropriate patches based on your commits. +1. PR your modified patch file(s) back to this repository. + +### Method 2 - Fixup commits + +If you are simply editing a more recent commit or your change is small, simply +making the change at HEAD and then moving the commit after you have tested it +may be easier. + +This method has the benefit of being able to compile to test your change without +messing with your HEADs. + +#### Manual method + +1. Make your change while at HEAD; +1. Make a temporary commit. You don't need to make a message for this; +1. Type `git rebase -i base`, move (cut) your temporary commit and + move it under the line of the patch you wish to modify; +1. Change the `pick` to the appropriate action: + 1. `f`/`fixup`: Merge your changes into the patch without touching the + message. + 1. `s`/`squash`: Merge your changes into the patch and use your commit message + and subject. +1. Type `./gradlew rebuildPatches` in the root directory; + - This will modify the appropriate patches based on your commits. +1. PR your modified patch file(s) back to this repository. + +#### Automatic method + +1. Make your change while at HEAD; +1. Make a fixup commit. `git commit -a --fixup `; + - You can also use `--squash` instead of `--fixup` if you want the commit + message to also be changed. + - You can get the hash by looking at `git log` or `git blame`; your IDE can + assist you too. + - Alternatively, if you only know the name of the patch, you can do + `git commit -a --fixup "Subject of Patch name"`. +1. Rebase with autosquash: `git rebase -i --autosquash base`. + This will automatically move your fixup commit to the right place, and you just + need to "save" the changes. +1. Type `./gradlew rebuildPatches` in the root directory; + - This will modify the appropriate patches based on your commits. +1. PR your modified patch file(s) back to this repository. + +## Rebasing PRs + +Steps to rebase a PR to include the latest changes from `master`. +These steps assume the `origin` remote is your fork of this repository and `upstream` is the official PaperMC repository. + +1. Pull the latest changes from upstreams master: `git checkout master && git pull upstream master`. +1. Checkout feature/fix branch and rebase on master: `git checkout patch-branch && git rebase master`. +1. Apply updated patches: `./gradlew applyPatches`. +1. If there are conflicts, fix them. +1. If your PR creates new patches instead of modifying existing ones, in both the `Paper-Server` and `Paper-API` directories, ensure your newly-created patch is the last commit by either: + * Renaming the patch file with a large 4-digit number in front (e.g. 9999-Patch-to-add-some-new-stuff.patch), and re-applying patches. + * Running `git rebase --interactive base` and moving the commits to the end. +1. Rebuild patches: `./gradlew rebuildPatches`. +1. Commit modified patches. +1. Force push changes: `git push --force`. + +## PR Policy + +We'll accept changes that make sense. You should be able to justify their +existence, along with any maintenance costs that come with them. Using +[obfuscation helpers](#obfuscation-helpers) aids in the maintenance costs. +Remember that these changes will affect everyone who runs Paper, not just you +and your server. + +While we will fix minor formatting issues, you should stick to the guide below +when making and submitting changes. + +## Formatting + +All modifications to non-Paper files should be marked. The one exception to this is +when modifying javadoc comments, which should not have these markers. + +- You need to add a comment with a short and identifiable description of the patch: + `// Paper start - ` + - The comments should generally be about the reason the change was made, what + it was before, or what the change is. + - After the general commit description, you can add additional information either + after a `;` or in the next line. +- Multi-line changes start with `// Paper start - ` and end + with `// Paper end - `. +- One-line changes should have `// Paper - ` at the end of the line. + +Here's an example of how to mark changes by Paper: + +```java +entity.getWorld().dontBeStupid(); // Paper - Was beStupid(), which is bad +entity.getFriends().forEach(Entity::explode); +entity.updateFriends(); + +// Paper start - Use plugin-set spawn +// entity.getWorld().explode(entity.getWorld().getSpawn()); +Location spawnLocation = ((CraftWorld)entity.getWorld()).getSpawnLocation(); +entity.getWorld().explode(new BlockPosition(spawnLocation.getX(), spawnLocation.getY(), spawnLocation.getZ())); +// Paper end - Use plugin-set spawn +``` + +We generally follow the usual Java style (aka. Oracle style), or what is programmed +into most IDEs and formatters by default. There are a few notes, however: +- It is fine to go over 80 lines as long as it doesn't hurt readability. + There are exceptions, especially in Spigot-related files +- When in doubt or the code around your change is in a clearly different style, + use the same style as the surrounding code. + +### Imports +When adding new imports to a class in a file not created by the current patch, use the fully qualified class name +instead of adding a new import to the top of the file. If you are using a type a significant number of times, you +can add an import with a comment. However, if its only used a couple of times, the FQN is preferred to prevent future +patch conflicts in the import section of the file. + +```java +import org.bukkit.event.Event; +// don't add import here, use FQN like below + +public class SomeEvent extends Event { + public final org.bukkit.Location newLocation; // Paper - add location +} +``` + +## Access Transformers +Sometimes, vanilla or CraftBukkit code already contains a field, method, or type you want to access +but the visibility is too low (e.g. a private field in an entity class). Paper can use access transformers +to change the visibility or remove the final modifier from fields, methods, and classes. Inside the `build-data/paper.at` +file, you can add ATs that are applied when you `./gradlew applyPatches`. You can read about the format of ATs +[here](https://mcforge.readthedocs.io/en/latest/advanced/accesstransformers/#access-modifiers). + +### Important +ATs should be included in the patch file which requires them within the commit message. Do not commit any changes to the +`build-data/paper.at` file, just use it to initially change the visibility of members until you have finalized what you +need. Then, in the commit message for the patch which requires the ATs, add a header at the bottom of the commit message +before any co-authors. It should look like the following after you `./gradlew rebuildPatches`. +``` +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Jake Potrebic +Date: Wed, 8 Jun 2022 22:20:16 -0700 +Subject: [PATCH] Paper config files + +This patch adds Paper configuration files. +Access transformers for this patch are below, but before the co-authors. + +== AT == +public org.spigotmc.SpigotWorldConfig getBoolean(Ljava/lang/String;Z)Z +public net.minecraft.world.level.NaturalSpawner SPAWNING_CATEGORIES + +Co-authored-by: Jason Penilla <11360596+jpenilla@users.noreply.github.com> + +diff --git a/build.gradle.kts b/build.gradle.kts +... +``` + +## Patch Notes + +When submitting patches to Paper, we may ask you to add notes to the patch +header. While we do not require it for all changes, you should add patch notes +when the changes you're making are technical, complex, or require an explanation +of some kind. It is very likely that your patch will remain long after we've all +forgotten about the details of your PR; patch notes will help us maintain it +without having to dig back through GitHub history looking for your PR. + +These notes should express the intent of your patch, as well as any pertinent +technical details we should keep in mind long-term. Ultimately, they exist to +make it easier for us to maintain the patch across major version changes. + +If you add a message to your commit in the `Paper-Server`/`Paper-API` +directories, the rebuild patches script will handle these patch notes +automatically as part of generating the patch file. If you are not +extremely careful, you should always just `squash` or `amend` a patch (see the +above sections on modifying patches) and rebuild. + +Editing messages and patches by hand is possible, but you should patch and +rebuild afterwards to make sure you did it correctly. This is slower than just +modifying the patches properly after a few times, so you will not really gain +anything but headaches from doing it by hand. + +Underneath is an example patch header/note: + +```patch +From 02abc033533f70ef3165a97bfda3f5c2fa58633a Mon Sep 17 00:00:00 2001 +From: Shane Freeder +Date: Sun, 15 Oct 2017 00:29:07 +0100 +Subject: [PATCH] revert serverside behavior of keepalives + +This patch intends to bump up the time that a client has to reply to the +server back to 30 seconds as per pre 1.12.2, which allowed clients +more than enough time to reply potentially allowing them to be less +tempermental due to lag spikes on the network thread, e.g. that caused +by plugins that are interacting with netty. + +We also add a system property to allow people to tweak how long the server +will wait for a reply. There is a compromise here between lower and higher +values, lower values will mean that dead connections can be closed sooner, +whereas higher values will make this less sensitive to issues such as spikes +from networking or during connections flood of chunk packets on slower clients, + at the cost of dead connections being kept open for longer. + +diff --git a/src/main/java/net/minecraft/server/PlayerConnection.java b/src/main/java/net/minecraft/server/PlayerConnection.java +index a92bf8967..d0ab87d0f 100644 +--- a/src/main/java/net/minecraft/server/PlayerConnection.java ++++ b/src/main/java/net/minecraft/server/PlayerConnection.java +``` + +## Obfuscation Helpers + +While rarely needed, obfuscation helpers are sometimes useful when it comes +to unmapped local variables, or poorly named method parameters. In an effort +to make future updates easier on ourselves, Paper tries to use obfuscation +helpers wherever it makes sense. The purpose of these helpers is to make the +code more readable and maintainable. These helpers should be made easy to +inline by the JVM wherever possible. + +An example of an obfuscation helper for a local variable: +```java +double d0 = entity.getX(); final double fromX = d0; // Paper - OBFHELPER +// ... +this.someMethod(fromX); // Paper +``` + +While they may not always be done in exactly the same way, the general goal is +always to improve readability and maintainability. Use your best judgment and do +what fits best in your situation. + +## Configuration files + +To use a configurable value in your patch, add a new field in either the +`GlobalConfiguration` or `WorldConfiguration` classes (inside the +`io.papermc.paper.configuration` package). Use `GlobalConfiguration` if a value +must remain the same throughout all worlds, or the latter if it can change +between worlds. World-specific configuration options are preferred whenever +possible. + +### Example +This is adding a new miscellaneous setting that doesn't seem to fit in other categories. +Try to check and see if an existing category (inner class) exists that matches +whatever configuration option you are adding. +```java +public class GlobalConfiguration { + // other sections + public class Misc extends ConfigurationPart { + // other settings + public boolean lagCompensateBlockBreaking = true; + public boolean useDimensionTypeForCustomSpawners = false; + public int maxNumOfPlayers = 20; // This is the new setting + } +} +``` +You set the type of the setting as the field type, and the default value is the +initial field value. The name of the setting defaults to the snake-case of the +field name, so in this case it would be `misc.max-num-of-players`. You can use +the `@Setting` annotation to override that, but generally just try to set the +field name to what you want the setting to be called. + +#### Accessing the value +If you added a new global config value, you can access it in the code just by +doing +```java +int maxPlayers = GlobalConfiguration.get().misc.maxNumOfPlayers; +``` +Generally for global config values you will use the fully qualified class name, +`io.papermc.paper.configuration.GlobalConfiguration` since it's not imported in +most places. +--- +If you are adding a new world config value, you must have access to an instance +of the `net.minecraft.world.level.Level` which you can then access the config by doing +```java +int maxPlayers = level.paperConfig().misc.maxNumOfPlayers; +``` + +#### Committing changes +All changes to the `GlobalConfiguration` and `WorldConfiguration` files +should be done in the commit that created them. So do an interactive rebase +or fixup to apply just those changes to that commit, then add a new commit +that includes the logic that uses that option in the server somewhere. + +## Testing API changes + +### Using the Paper Test Plugin + +The Paper project has a `test-plugin` module for easily testing out API changes +and additions. To use the test plugin, enable it in `test-plugin.settings.gradle.kts`, +which will be generated after running Gradle at least once. After this, you can edit +the test plugin, and run a server with the plugin using `./gradlew runDev` (or any +of the other Paper run tasks). + +### Publishing to Maven local (use in external plugins) + +To build and install the Paper APIs and Server to your local Maven repository, do the following: + +- Run `./gradlew publishToMavenLocal` in the base directory. + +If you use Gradle to build your plugin: +- Add `mavenLocal()` as a repository. Gradle checks repositories in the order they are declared, + so if you also have the Paper repository added, put the local repository above Paper's. +- Make sure to remove `mavenLocal()` when you are done testing, see the [Gradle docs](https://docs.gradle.org/current/userguide/declaring_repositories.html#sec:case-for-maven-local) + for more details. + +If you use Maven to build your plugin: +- If you later need to use the Paper-API, you might want to remove the jar + from your local Maven repository. + If you use Windows and don't usually build using WSL, you might not need to + do this. + +## Frequently Asked Questions + +### I can't find the NMS file I need! + +By default, Paper (and upstream) only import files we make changes to. If you +would like to make changes to a file that isn't present in `Paper-Server`'s +source directory, you just need to add it to our import script ran during the +patching process. + +1. Save (rebuild) any patches you are in the middle of working on! Their + progress will be lost if you do not; +1. Identify the name(s) of the file(s) you want to import. + - A complete list of all possible file names can be found at + `./Paper-Server/.gradle/caches/paperweight/mc-dev-sources/net/minecraft/`. You might find + [MappingViewer] useful if you need to translate between Mojang and Spigot mapped names. +1. Open the file at `./build-data/dev-imports.txt` and add the name of your file to + the script. Follow the instructions there; +1. Re-patch the server `./gradlew applyPatches`; +1. Edit away! + +> ❗ This change is temporary! **DO NOT COMMIT CHANGES TO THIS FILE!** +> Once you have made your changes to the new file, and rebuilt patches, you may +> undo your changes to `dev-imports.txt`. + +Any file modified in a patch file gets automatically imported, so you only need +this temporarily to import it to create the first patch. + +To undo your changes to the file, type `git checkout build-data/dev-imports.txt`. + +### My commit doesn't need a build, what do I do? + +Well, quite simple: You add `[ci skip]` to the start of your commit subject. + +This case most often applies to changes to files like `README.md`, this very +file (`CONTRIBUTING.md`), the `LICENSE.md` file, and so forth. + +### Patching and building is *really* slow, what can I do? + +This only applies if you're running Windows. If you're running a prior Windows +release, either update to Windows 10/11 or move to macOS/Linux/BSD. + +In order to speed up patching process on Windows, it's recommended you get WSL +2. This is available in Windows 10 v2004, build 19041 or higher. (You can check + your version by running `winver` in the run window (Windows key + R)). If you're + using an out of date version of Windows 10, update your system with the + [Windows 10 Update Assistant](https://www.microsoft.com/en-us/software-download/windows10) or [Windows 11 Update Assistant](https://www.microsoft.com/en-us/software-download/windows11). + +To set up WSL 2, follow the information here: + + +You will most likely want to use the Ubuntu apps. Once it's set up, install the +required tools with `sudo apt-get update && sudo apt-get install $TOOL_NAMES +-y`. Replace `$TOOL_NAMES` with the packages found in the +[requirements](#requirements). You can now clone the repository and do +everything like usual. + +> ❗ Do not use the `/mnt/` directory in WSL! Instead, mount the WSL directories +> in Windows like described here: +> + +[MappingViewer]: https://mappings.cephx.dev/ \ No newline at end of file diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 0000000..c263962 --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,101 @@ +import io.papermc.paperweight.util.* + +plugins { + java + id("com.github.johnrengelman.shadow") version "8.1.1" apply false + id("io.papermc.paperweight.patcher") version "1.5.11" +} + +allprojects { + apply(plugin = "java") + + java { + toolchain { + languageVersion.set(JavaLanguageVersion.of(17)) + } + } +} + +val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/" + +repositories { + mavenCentral() + maven(paperMavenPublicUrl) { + content { + onlyForConfigurations(configurations.paperclip.name) + } + } +} + +dependencies { + remapper("net.fabricmc:tiny-remapper:0.8.10:fat") + decompiler("net.minecraftforge:forgeflower:2.0.627.2") + paperclip("io.papermc:paperclip:3.0.3") +} + +subprojects { + tasks.withType().configureEach { + options.encoding = Charsets.UTF_8.name() + options.release = 17 + } + tasks.withType { + options.encoding = Charsets.UTF_8.name() + } + tasks.withType { + filteringCharset = Charsets.UTF_8.name() + } + + repositories { + mavenCentral() + maven(paperMavenPublicUrl) + } +} + +paperweight { + serverProject.set(project(":deer-folia-server")) + + remapRepo.set(paperMavenPublicUrl) + decompileRepo.set(paperMavenPublicUrl) + + useStandardUpstream("Folia") { + url.set("https://ssl.lunadeer.cn:14446/mirror/Folia.git") + ref.set(providers.gradleProperty("foliaRef")) + + withStandardPatcher { + baseName("Folia") + + apiPatchDir.set(layout.projectDirectory.dir("patches/api")) + apiOutputDir.set(layout.projectDirectory.dir("deer-folia-api")) + + serverPatchDir.set(layout.projectDirectory.dir("patches/server")) + serverOutputDir.set(layout.projectDirectory.dir("deer-folia-server")) + } + } +} + +tasks.register("updateFoliaRef") { + // 更新 Folia 依赖的最新 commit + val tempDir = layout.cacheDir("foliaRefLatest"); + val file = "gradle.properties"; + + doFirst { + val foliaLatestCommitJson = layout.cache.resolve("foliaLatestCommit.json"); + download.get().download("https://ssl.lunadeer.cn:14446/api/v1/repos/mirror/Folia/commits?sha=master", foliaLatestCommitJson); + val foliaLatestCommit = gson.fromJson(foliaLatestCommitJson).get(0).asJsonObject.get("sha").asString; + + copy { + from(file) + into(tempDir) + filter { line: String -> + line.replace("foliaRef = .*".toRegex(), "foliaRef = $foliaLatestCommit") + } + } + } + + doLast { + copy { + from(tempDir.file("gradle.properties")) + into(project.file(file).parent) + } + } +} \ No newline at end of file diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 0000000..9ead663 --- /dev/null +++ b/gradle.properties @@ -0,0 +1,9 @@ +group = cn.lunadeer +version = 1.20.4-R0.1-SNAPSHOT +mcVersion = 1.20.4 + +foliaRef = e97b1eee63b802568447d344bac5a66bf90c6c71 + +org.gradle.caching=true +org.gradle.parallel=true +org.gradle.vfs.watch=false \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000..249e583 Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..8824a43 --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,6 @@ +#Mon Feb 26 15:32:38 CST 2024 +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew new file mode 100755 index 0000000..1b6c787 --- /dev/null +++ b/gradlew @@ -0,0 +1,234 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit + +APP_NAME="Gradle" +APP_BASE_NAME=${0##*/} + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + +# Collect all arguments for the java command; +# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of +# shell script including quotes and variable substitutions, so put them in +# double quotes to make sure that they get re-expanded; and +# * put everything else in single quotes, so that it's not re-expanded. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..107acd3 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/patches/server/0001-Update-gradle-script-to-custom.patch b/patches/server/0001-Update-gradle-script-to-custom.patch new file mode 100644 index 0000000..7bba2bf --- /dev/null +++ b/patches/server/0001-Update-gradle-script-to-custom.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: zhangyuheng +Date: Mon, 26 Feb 2024 18:00:41 +0800 +Subject: [PATCH] Update gradle script to custom + + +diff --git a/build.gradle.kts b/build.gradle.kts +index 08d434023226af0d2c469055a3b2188fe8a4ed38..b09877db43215896d4c775f76605880f2d6bd0f9 100644 +--- a/build.gradle.kts ++++ b/build.gradle.kts +@@ -14,7 +14,7 @@ val alsoShade: Configuration by configurations.creating + + dependencies { + // Folia start +- implementation(project(":folia-api")) ++ implementation(project(":deer-folia-api")) + implementation("io.papermc.paper:paper-mojangapi:${project.version}") { + exclude("io.papermc.paper", "paper-api") + } diff --git a/patches/server/0002-Allow-void-trading.patch b/patches/server/0002-Allow-void-trading.patch new file mode 100644 index 0000000..3d5c613 --- /dev/null +++ b/patches/server/0002-Allow-void-trading.patch @@ -0,0 +1,25 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: zhangyuheng +Date: Mon, 26 Feb 2024 18:03:17 +0800 +Subject: [PATCH] Allow void trading + + +diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java +index ec25610cbffe30fecaeaadf9098e187bc15b5405..1de531dcb0d5c64a5459d9057b50fadcd9089b87 100644 +--- a/src/main/java/net/minecraft/server/level/ServerLevel.java ++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java +@@ -3044,10 +3044,11 @@ public class ServerLevel extends Level implements WorldGenLevel { + // Spigot end + // Spigot Start + if (entity.getBukkitEntity() instanceof org.bukkit.inventory.InventoryHolder && (!(entity instanceof ServerPlayer) || entity.getRemovalReason() != Entity.RemovalReason.KILLED)) { // SPIGOT-6876: closeInventory clears death message ++ // DeerFolia - Allow void trading + // Paper start - Fix merchant inventory not closing on entity removal +- if (entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null) { +- merchant.getTrader().closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED); +- } ++ // if (entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null) { ++ // merchant.getTrader().closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED); ++ // } + // Paper end - Fix merchant inventory not closing on entity removal + for (org.bukkit.entity.HumanEntity h : Lists.newArrayList(((org.bukkit.inventory.InventoryHolder) entity.getBukkitEntity()).getInventory().getViewers())) { + h.closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED); // Paper - Inventory close reason diff --git a/settings.gradle.kts b/settings.gradle.kts new file mode 100644 index 0000000..452814d --- /dev/null +++ b/settings.gradle.kts @@ -0,0 +1,14 @@ +pluginManagement { + repositories { + gradlePluginPortal() + maven("https://papermc.io/repo/repository/maven-public/") + } +} + +plugins { + id("org.gradle.toolchains.foojay-resolver-convention") version "0.7.0" +} + +rootProject.name = "DeerFolia" + +include("deer-folia-api", "deer-folia-server") \ No newline at end of file