diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index d524552..65a785a 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -27,6 +27,6 @@ jobs: - name: Configure Git User Details run: git config --global user.email "actions@github.com" && git config --global user.name "Github Actions" - name: Apply Patches - run: ./gradlew applyPatches --stacktrace + run: ./gradlew applyAllPatches --stacktrace - name: Build run: ./gradlew build --stacktrace diff --git a/.gitignore b/.gitignore index 615b683..7edacaa 100644 --- a/.gitignore +++ b/.gitignore @@ -50,3 +50,10 @@ forktest-server forktest-api !gradle/wrapper/gradle-wrapper.jar + +nabulus-api/src +nabulus-api/build.gradle.kts +nabulus-server/src +nabulus-server/build.gradle.kts +paper-server +patches diff --git a/build.gradle.kts b/build.gradle.kts index f917e03..5899222 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,40 +1,58 @@ -import io.papermc.paperweight.util.constants.* +import org.gradle.api.tasks.testing.logging.TestExceptionFormat +import org.gradle.api.tasks.testing.logging.TestLogEvent plugins { - java - `maven-publish` - id("com.github.johnrengelman.shadow") version "8.1.0" apply false - id("io.papermc.paperweight.patcher") version "1.7.1" + id("io.papermc.paperweight.patcher") version "2.0.0-beta.14" } -repositories { - mavenCentral() - maven("https://papermc.io/repo/repository/maven-public/") { - content { onlyForConfigurations(PAPERCLIP_CONFIG) } +paperweight { + upstreams.paper { + ref = providers.gradleProperty("paperRef") + + patchFile { + path = "paper-server/build.gradle.kts" + outputFile = file("nabulus-server/build.gradle.kts") + patchFile = file("nabulus-server/build.gradle.kts.patch") + } + patchFile { + path = "paper-api/build.gradle.kts" + outputFile = file("nabulus-api/build.gradle.kts") + patchFile = file("nabulus-api/build.gradle.kts.patch") + } + patchDir("paperApi") { + upstreamPath = "paper-api" + excludes = setOf("build.gradle.kts") + patchesDir = file("nabulus-api/paper-patches") + outputDir = file("paper-api") + } } } -dependencies { - remapper("net.fabricmc:tiny-remapper:0.10.3:fat") - decompiler("org.vineflower:vineflower:1.10.1") - paperclip("io.papermc:paperclip:3.0.3") -} +val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/" -allprojects { - apply(plugin = "java") +subprojects { + apply(plugin = "java-library") apply(plugin = "maven-publish") - java { + extensions.configure { toolchain { - languageVersion.set(JavaLanguageVersion.of(21)) + languageVersion = JavaLanguageVersion.of(21) } } -} -subprojects { + repositories { + mavenCentral() + maven(paperMavenPublicUrl) + } + + tasks.withType().configureEach { + isPreserveFileTimestamps = false + isReproducibleFileOrder = true + } tasks.withType { options.encoding = Charsets.UTF_8.name() - options.release.set(21) + options.release = 21 + options.isFork = true } tasks.withType { options.encoding = Charsets.UTF_8.name() @@ -42,81 +60,22 @@ subprojects { tasks.withType { filteringCharset = Charsets.UTF_8.name() } - - repositories { - mavenCentral() - maven("https://oss.sonatype.org/content/groups/public/") - maven("https://papermc.io/repo/repository/maven-public/") - maven("https://ci.emc.gs/nexus/content/groups/aikar/") - maven("https://repo.aikar.co/content/groups/aikar") - maven("https://repo.md-5.net/content/repositories/releases/") - maven("https://hub.spigotmc.org/nexus/content/groups/public/") - maven("https://jitpack.io") - maven("https://s01.oss.sonatype.org/content/repositories/snapshots/") // TODO - Adventure snapshot - } -} - -paperweight { - serverProject.set(project(":nabulus-server")) - - remapRepo.set("https://maven.fabricmc.net/") - decompileRepo.set("https://files.minecraftforge.net/maven/") - -/* usePaperUpstream(providers.gradleProperty("paperRef")) { - withPaperPatcher { - apiPatchDir.set(layout.projectDirectory.dir("patches/api")) - apiOutputDir.set(layout.projectDirectory.dir("nabulus-api")) - - serverPatchDir.set(layout.projectDirectory.dir("patches/server")) - serverOutputDir.set(layout.projectDirectory.dir("nabulus-server")) - } - - patchTasks.register("generatedApi") { - isBareDirectory = true - upstreamDirPath = "paper-api-generator/generated" - patchDir = layout.projectDirectory.dir("patches/generated-api") - outputDir = layout.projectDirectory.dir("paper-api-generator/generated") - } - } */ - - useStandardUpstream("pufferfish") { - url.set(github("pufferfish-gg", "Pufferfish")) - ref.set(providers.gradleProperty("paperRef")) - - withStandardPatcher { - apiSourceDirPath.set("pufferfish-api") - serverSourceDirPath.set("pufferfish-server") - - apiPatchDir.set(layout.projectDirectory.dir("patches/api")) - apiOutputDir.set(layout.projectDirectory.dir("nabulus-api")) - - serverPatchDir.set(layout.projectDirectory.dir("patches/server")) - serverOutputDir.set(layout.projectDirectory.dir("nabulus-server")) + tasks.withType { + testLogging { + showStackTraces = true + exceptionFormat = TestExceptionFormat.FULL + events(TestLogEvent.STANDARD_OUT) } + } - patchTasks.register("generatedApi") { - isBareDirectory = true - upstreamDirPath = "paper-api-generator/generated" - patchDir = layout.projectDirectory.dir("patches/generated-api") - outputDir = layout.projectDirectory.dir("paper-api-generator/generated") + extensions.configure { + repositories { + /* + maven("https://repo.papermc.io/repository/maven-snapshots/") { + name = "paperSnapshots" + credentials(PasswordCredentials::class) + } + */ } } - -} - -// -// Everything below here is optional if you don't care about publishing API or dev bundles to your repository -// - -tasks.generateDevelopmentBundle { - apiCoordinates.set("com.froobworld.nabulus:nabulus-api") - libraryRepositories.set( - listOf( - "https://repo.maven.apache.org/maven2/", - "https://libraries.minecraft.net/", - "https://papermc.io/repo/repository/maven-public/", - "https://maven.quiltmc.org/repository/release/", - // "https://my.repo/", // This should be a repo hosting your API (in this example, 'com.example.paperfork:forktest-api') - ) - ) -} +} \ No newline at end of file diff --git a/gradle.properties b/gradle.properties index e6196d5..547c9aa 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,9 +1,10 @@ group=com.froobworld.nabulus -version=1.21.1-R0.1-SNAPSHOT +version=1.21.4-R0.1-SNAPSHOT -mcVersion=1.21.1 -paperRef=cfa3c6122d26078e3c4432b792599c48f7c1a637 +mcVersion=1.21.4 +paperRef=8eb8e44ac32a99f53da7af50e800ac8831030580 +org.gradle.configuration-cache=true org.gradle.caching=true org.gradle.parallel=true -org.gradle.vfs.watch=false +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 index d64cd49..a4b76b9 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 3fa8f86..cea7a79 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/gradlew b/gradlew index 1aa94a4..f5feea6 100755 --- a/gradlew +++ b/gradlew @@ -15,6 +15,8 @@ # See the License for the specific language governing permissions and # limitations under the License. # +# SPDX-License-Identifier: Apache-2.0 +# ############################################################################## # @@ -55,7 +57,7 @@ # Darwin, MinGW, and NonStop. # # (3) This script is generated from the Groovy template -# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt # within the Gradle project. # # You can find Gradle at https://github.com/gradle/gradle/. @@ -84,7 +86,8 @@ done # shellcheck disable=SC2034 APP_BASE_NAME=${0##*/} # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) -APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s +' "$PWD" ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD=maximum diff --git a/gradlew.bat b/gradlew.bat index 93e3f59..9d21a21 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -13,6 +13,8 @@ @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem @if "%DEBUG%"=="" @echo off @rem ########################################################################## @@ -43,11 +45,11 @@ set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if %ERRORLEVEL% equ 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. +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 goto fail @@ -57,11 +59,11 @@ 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. +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 goto fail diff --git a/nabulus-api/build.gradle.kts.patch b/nabulus-api/build.gradle.kts.patch new file mode 100644 index 0000000..6c87ef5 --- /dev/null +++ b/nabulus-api/build.gradle.kts.patch @@ -0,0 +1,54 @@ +--- a/paper-api/build.gradle.kts ++++ b/paper-api/build.gradle.kts +@@ -93,7 +93,7 @@ dependencies { + testRuntimeOnly("org.junit.platform:junit-platform-launcher") + } + +-val generatedApiPath: java.nio.file.Path = layout.projectDirectory.dir("src/generated/java").asFile.toPath() ++val generatedApiPath: java.nio.file.Path = rootProject.layout.projectDirectory.dir("paper-api/src/generated/java").asFile.toPath() + idea { + module { + generatedSourceDirs.add(generatedApiPath.toFile()) +@@ -103,6 +103,19 @@ sourceSets { + main { + java { + srcDir(generatedApiPath) ++ srcDir(file("../paper-api/src/main/java")) ++ } ++ resources { ++ srcDir(file("../paper-api/src/main/resources")) ++ } ++ ++ } ++ test { ++ java { ++ srcDir(file("../paper-api/src/test/java")) ++ } ++ resources { ++ srcDir(file("../paper-api/src/test/resources")) + } + } + } +@@ -169,7 +182,7 @@ val services = objects.newInstance() + + tasks.withType { + val options = options as StandardJavadocDocletOptions +- options.overview = "src/main/javadoc/overview.html" ++ options.overview = "../paper-api/src/main/javadoc/overview.html" + options.use() + options.isDocFilesSubDirs = true + options.links( +@@ -202,11 +215,11 @@ tasks.withType { + } + + // workaround for https://github.com/gradle/gradle/issues/4046 +- inputs.dir("src/main/javadoc").withPropertyName("javadoc-sourceset") ++ inputs.dir("../paper-api/src/main/javadoc").withPropertyName("javadoc-sourceset") + val fsOps = services.fileSystemOperations + doLast { + fsOps.copy { +- from("src/main/javadoc") { ++ from("../paper-api/src/main/javadoc") { + include("**/doc-files/**") + } + into("build/docs/javadoc") \ No newline at end of file diff --git a/nabulus-server/build.gradle.kts.patch b/nabulus-server/build.gradle.kts.patch new file mode 100644 index 0000000..6f7610c --- /dev/null +++ b/nabulus-server/build.gradle.kts.patch @@ -0,0 +1,68 @@ +--- a/paper-server/build.gradle.kts ++++ b/paper-server/build.gradle.kts +@@ -21,6 +21,17 @@ paperweight { + // macheOldPath = file("F:\\Projects\\PaperTooling\\mache\\versions\\1.21.4\\src\\main\\java") + // gitFilePatches = true + ++ val fork = forks.register("nabulus") { ++ upstream.patchDir("paperServer") { ++ upstreamPath = "paper-server" ++ excludes = setOf("src/minecraft", "patches", "build.gradle.kts") ++ patchesDir = rootDirectory.dir("nabulus-server/paper-patches") ++ outputDir = rootDirectory.dir("paper-server") ++ } ++ } ++ ++ activeFork = fork ++ + spigot { + buildDataRef = "3edaf46ec1eed4115ce1b18d2846cded42577e42" + packageVersion = "v1_21_R3" // also needs to be updated in MappingEnvironment +@@ -101,7 +112,20 @@ if (project.providers.gradleProperty("publishDevBundle").isPresent) { + } + } + +-val log4jPlugins = sourceSets.create("log4jPlugins") ++sourceSets { ++ main { ++ java { srcDir("../paper-server/src/main/java") } ++ resources { srcDir("../paper-server/src/main/resources") } ++ } ++ test { ++ java { srcDir("../paper-server/src/test/java") } ++ resources { srcDir("../paper-server/src/test/resources") } ++ } ++} ++ ++val log4jPlugins = sourceSets.create("log4jPlugins") { ++ java { srcDir("../paper-server/src/log4jPlugins/java") } ++} + configurations.named(log4jPlugins.compileClasspathConfigurationName) { + extendsFrom(configurations.compileClasspath.get()) + } +@@ -119,7 +143,7 @@ abstract class MockitoAgentProvider : CommandLineArgumentProvider { + } + + dependencies { +- implementation(project(":paper-api")) ++ implementation(project(":nabulus-api")) + implementation("ca.spottedleaf:concurrentutil:0.0.3") + implementation("org.jline:jline-terminal-ffm:3.27.1") // use ffm on java 22+ + implementation("org.jline:jline-terminal-jni:3.27.1") // fall back to jni on java 21 +@@ -188,14 +212,14 @@ tasks.jar { + val gitBranch = git.exec(providers, "rev-parse", "--abbrev-ref", "HEAD").get().trim() + attributes( + "Main-Class" to "org.bukkit.craftbukkit.Main", +- "Implementation-Title" to "Paper", ++ "Implementation-Title" to "Nabulus", // Nabulus + "Implementation-Version" to implementationVersion, + "Implementation-Vendor" to date, + "Specification-Title" to "Paper", + "Specification-Version" to project.version, + "Specification-Vendor" to "Paper Team", + "Brand-Id" to "papermc:paper", +- "Brand-Name" to "Paper", ++ "Brand-Name" to "Nabulus", // Nabulus + "Build-Number" to (build ?: ""), + "Build-Time" to buildTime.toString(), + "Git-Branch" to gitBranch, diff --git a/nabulus-server/minecraft-patches/features/0001-Separate-creative-levels.patch b/nabulus-server/minecraft-patches/features/0001-Separate-creative-levels.patch new file mode 100644 index 0000000..ac7395f --- /dev/null +++ b/nabulus-server/minecraft-patches/features/0001-Separate-creative-levels.patch @@ -0,0 +1,271 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Sun, 27 Feb 2022 21:27:01 +0930 +Subject: [PATCH] Separate creative levels + + +diff --git a/ca/spottedleaf/dataconverter/minecraft/versions/V1022.java b/ca/spottedleaf/dataconverter/minecraft/versions/V1022.java +index 4f35484ed524dbf09cf9e8b1bb999fc98ec0bb0f..0ca38444ac9e9282d1bb4500eb0740d0c954e0ce 100644 +--- a/ca/spottedleaf/dataconverter/minecraft/versions/V1022.java ++++ b/ca/spottedleaf/dataconverter/minecraft/versions/V1022.java +@@ -17,6 +17,7 @@ public final class V1022 { + + WalkerUtils.convertList(MCTypeRegistry.ITEM_STACK, data, "Inventory", fromVersion, toVersion); + WalkerUtils.convertList(MCTypeRegistry.ITEM_STACK, data, "EnderItems", fromVersion, toVersion); ++ WalkerUtils.convertList(MCTypeRegistry.ITEM_STACK, data, "Nabulus.CreativeLevelInventory", fromVersion, toVersion); + + WalkerUtils.convert(MCTypeRegistry.ENTITY, data, "ShoulderEntityLeft", fromVersion, toVersion); + WalkerUtils.convert(MCTypeRegistry.ENTITY, data, "ShoulderEntityRight", fromVersion, toVersion); +diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java +index 57d432dc9e8d8e9a3e088e7c40b35178c30fe786..8c057b93b12673eaa822222d7cdc3e1360fd72f3 100644 +--- a/net/minecraft/server/level/ServerPlayer.java ++++ b/net/minecraft/server/level/ServerPlayer.java +@@ -732,6 +732,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc + } + this.setLevel(level); + this.gameMode.setLevel(level); ++ this.chooseInventory(); // Nabulus + } + // CraftBukkit end + +@@ -1447,6 +1448,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc + this.unsetRemoved(); + // CraftBukkit end + this.setServerLevel(level); ++ this.chooseInventory(); // Nabulus + this.connection.internalTeleport(PositionMoveRotation.of(teleportTransition), teleportTransition.relatives()); // CraftBukkit - use internal teleport without event + this.connection.resetPosition(); + level.addDuringTeleport(this); +@@ -2040,10 +2042,20 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc + } + + public void restoreFrom(ServerPlayer that, boolean keepEverything) { ++ // Nabulus start ++ this.restoreFrom(that, keepEverything, false); ++ } ++ public void restoreFrom(ServerPlayer that, boolean keepEverything, boolean toOrFromCreativeLevel) { ++ // Nabulus end + this.wardenSpawnTracker = that.wardenSpawnTracker; + this.chatSession = that.chatSession; + this.gameMode.setGameModeForPlayer(that.gameMode.getGameModeForPlayer(), that.gameMode.getPreviousGameModeForPlayer()); + this.onUpdateAbilities(); ++ // Nabulus start ++ this.normalInventory.replaceWith(that.normalInventory); ++ this.creativeLevelInventory.replaceWith(that.creativeLevelInventory); ++ this.usingNormalInventory = that.usingNormalInventory; ++ // Nabulus end + if (keepEverything) { + this.getAttributes().assignBaseValues(that.getAttributes()); + // this.getAttributes().assignPermanentModifiers(that.getAttributes()); // CraftBukkit +@@ -2082,6 +2094,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc + this.seenCredits = that.seenCredits; + this.enteredNetherPosition = that.enteredNetherPosition; + this.chunkTrackingView = that.chunkTrackingView; ++ if (toOrFromCreativeLevel) return; // Nabulus + this.setShoulderEntityLeft(that.getShoulderEntityLeft()); + this.setShoulderEntityRight(that.getShoulderEntityRight()); + this.setLastDeathLocation(that.getLastDeathLocation()); +diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java +index 5a4960fdbd97d830ac79845697eea9372c48a13b..9279e4bb6cd1b108ebffd8fe9887f4d231413376 100644 +--- a/net/minecraft/server/players/PlayerList.java ++++ b/net/minecraft/server/players/PlayerList.java +@@ -725,8 +725,27 @@ public abstract class PlayerList { + Level fromWorld = player.level(); + player.wonGame = false; + // CraftBukkit end ++ // Nabulus start - moved from below ++ boolean isRespawn = false; ++ TeleportTransition teleportTransition; ++ if (location == null) { ++ teleportTransition = player.findRespawnPositionAndUseSpawnBlock(!keepInventory, TeleportTransition.DO_NOTHING, eventReason); ++ ++ if (!keepInventory) player.reset(); // SPIGOT-4785 ++ isRespawn = true; ++ } else { ++ teleportTransition = new TeleportTransition(((org.bukkit.craftbukkit.CraftWorld) location.getWorld()).getHandle(), org.bukkit.craftbukkit.util.CraftLocation.toVec3D(location), Vec3.ZERO, location.getYaw(), location.getPitch(), TeleportTransition.DO_NOTHING); ++ } ++ // Nabulus end ++ // Nabulus start ++ boolean toOrFromCreativeLevel = ((net.minecraft.world.level.storage.PrimaryLevelData) teleportTransition.newLevel().levelData).creativeLevel || ((net.minecraft.world.level.storage.PrimaryLevelData) player.level().levelData).creativeLevel; ++ if (toOrFromCreativeLevel) { ++ serverPlayer.releaseLeftShoulderEntity(); ++ serverPlayer.releaseRightShoulderEntity(); ++ } ++ // Nabulus end + serverPlayer.connection = player.connection; +- serverPlayer.restoreFrom(player, keepInventory); ++ serverPlayer.restoreFrom(player, keepInventory, toOrFromCreativeLevel); // Nabulus + serverPlayer.setId(player.getId()); + serverPlayer.setMainArm(player.getMainArm()); + // CraftBukkit - not required, just copies old location into reused entity +@@ -739,10 +758,12 @@ public abstract class PlayerList { + } + // Paper start - Add PlayerPostRespawnEvent + boolean isBedSpawn = false; +- boolean isRespawn = false; ++ //boolean isRespawn = false; // Nabulus - moved up + // Paper end - Add PlayerPostRespawnEvent + + // CraftBukkit start - fire PlayerRespawnEvent ++ // Nabulus start - moved up ++ /* + TeleportTransition teleportTransition; + if (location == null) { + teleportTransition = player.findRespawnPositionAndUseSpawnBlock(!keepInventory, TeleportTransition.DO_NOTHING, eventReason); +@@ -756,6 +777,8 @@ public abstract class PlayerList { + } else { + teleportTransition = new TeleportTransition(((org.bukkit.craftbukkit.CraftWorld) location.getWorld()).getHandle(), org.bukkit.craftbukkit.util.CraftLocation.toVec3D(location), Vec3.ZERO, location.getYaw(), location.getPitch(), TeleportTransition.DO_NOTHING); + } ++ */ ++ // Nabulus end + // Spigot start + if (teleportTransition == null) { // Paper - Add PlayerPostRespawnEvent - diff on change - spigot early returns if respawn pos is null, that is how they handle disconnected player in respawn event + return player; +diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java +index 1b54cf07616a10d93e9336dbd299ba5f09678a28..a4cd4fa01bf7a64f1902b59fbf6dd7c4e660a1f4 100644 +--- a/net/minecraft/world/entity/Entity.java ++++ b/net/minecraft/world/entity/Entity.java +@@ -3732,6 +3732,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess + } + // Paper end - Fix item duplication and teleport issues + if (this.level() instanceof ServerLevel serverLevel && !this.isRemoved()) { ++ // Nabulus start ++ if (!this.level.equals(serverLevel) && ((net.minecraft.world.level.storage.PrimaryLevelData) this.level().levelData).creativeLevel) { ++ return null; ++ } ++ // Nabulus end + // CraftBukkit start + PositionMoveRotation absolutePosition = PositionMoveRotation.calculateAbsolute(PositionMoveRotation.of(this), PositionMoveRotation.of(teleportTransition), teleportTransition.relatives()); + Vec3 velocity = absolutePosition.deltaMovement(); // Paper +diff --git a/net/minecraft/world/entity/PortalProcessor.java b/net/minecraft/world/entity/PortalProcessor.java +index 88b07fbb96b20124777889830afa480673629d43..15135544bd6916bc61d7e17ecee2369026820379 100644 +--- a/net/minecraft/world/entity/PortalProcessor.java ++++ b/net/minecraft/world/entity/PortalProcessor.java +@@ -30,6 +30,11 @@ public class PortalProcessor { + + @Nullable + public TeleportTransition getPortalDestination(ServerLevel level, Entity entity) { ++ // Nabulus start ++ if (((net.minecraft.world.level.storage.PrimaryLevelData) entity.level().levelData).creativeLevel) { ++ return null; ++ } ++ // Nabulus end + return this.portal.getPortalDestination(level, entity, this.entryPosition); + } + +diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java +index a0813aa9ebf5b32375b1bc9f294d8fc34cc867fe..141478c5bf94827eaf89688cb47346fde0394d03 100644 +--- a/net/minecraft/world/entity/player/Player.java ++++ b/net/minecraft/world/entity/player/Player.java +@@ -205,6 +205,40 @@ public abstract class Player extends LivingEntity { + public boolean fauxSleeping; + public int oldLevel = -1; + ++ // Nabulus start ++ protected final Inventory normalInventory = new Inventory(this); ++ protected final Inventory creativeLevelInventory = new Inventory(this); ++ private boolean inventoriesLoaded = false; ++ public boolean usingNormalInventory = true; ++ ++ public void chooseInventory() { ++ if (!inventoriesLoaded) { ++ return; ++ } ++ if (((net.minecraft.world.level.storage.PrimaryLevelData)this.level().levelData).creativeLevel) { ++ if (usingNormalInventory) { ++ this.normalInventory.replaceWith(this.inventory); ++ this.inventory.replaceWith(this.creativeLevelInventory); ++ usingNormalInventory = false; ++ } ++ } else { ++ if (!usingNormalInventory) { ++ this.creativeLevelInventory.replaceWith(this.inventory); ++ this.inventory.replaceWith(this.normalInventory); ++ usingNormalInventory = true; ++ } ++ } ++ } ++ ++ public Inventory getNormalInventory() { ++ return usingNormalInventory ? this.inventory : this.normalInventory; ++ } ++ ++ public Inventory getCreativeLevelInventory() { ++ return usingNormalInventory ? this.creativeLevelInventory : this.inventory; ++ } ++ // Nabulus end ++ + @Override + public org.bukkit.craftbukkit.entity.CraftHumanEntity getBukkitEntity() { + return (org.bukkit.craftbukkit.entity.CraftHumanEntity) super.getBukkitEntity(); +@@ -215,6 +249,7 @@ public abstract class Player extends LivingEntity { + super(EntityType.PLAYER, level); + this.setUUID(gameProfile.getId()); + this.gameProfile = gameProfile; ++ this.chooseInventory(); + this.inventoryMenu = new InventoryMenu(this.inventory, !level.isClientSide, this); + this.containerMenu = this.inventoryMenu; + this.moveTo(pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, yRot, 0.0F); +@@ -817,6 +852,15 @@ public abstract class Player extends LivingEntity { + ListTag list = compound.getList("Inventory", 10); + this.inventory.load(list); + this.inventory.selected = compound.getInt("SelectedItemSlot"); ++ // Nabulus start ++ this.normalInventory.load(list); ++ this.normalInventory.selected = compound.getInt("SelectedItemSlot"); ++ ListTag creativeLevelInventoryTagList = compound.getList("Nabulus.CreativeLevelInventory", 10); ++ this.creativeLevelInventory.load(creativeLevelInventoryTagList); ++ this.creativeLevelInventory.selected = compound.getInt("Nabulus.CreativeLevelSelectedItemSlot"); ++ this.inventoriesLoaded = true; ++ this.usingNormalInventory = true; ++ // Nabulus end + this.sleepCounter = compound.getShort("SleepTimer"); + this.experienceProgress = compound.getFloat("XpP"); + this.experienceLevel = compound.getInt("XpLevel"); +@@ -861,8 +905,12 @@ public abstract class Player extends LivingEntity { + public void addAdditionalSaveData(CompoundTag compound) { + super.addAdditionalSaveData(compound); + NbtUtils.addCurrentDataVersion(compound); +- compound.put("Inventory", this.inventory.save(new ListTag())); +- compound.putInt("SelectedItemSlot", this.inventory.selected); ++ compound.put("Inventory", this.getNormalInventory().save(new ListTag())); // Nabulus ++ compound.putInt("SelectedItemSlot", this.getNormalInventory().selected); // Nabulus ++ // Nabulus start ++ compound.put("Nabulus.CreativeLevelInventory", this.getCreativeLevelInventory().save(new ListTag())); ++ compound.putInt("Nabulus.CreativeLevelSelectedItemSlot", this.getCreativeLevelInventory().selected); ++ // Nabulus end + compound.putShort("SleepTimer", (short)this.sleepCounter); + compound.putFloat("XpP", this.experienceProgress); + compound.putInt("XpLevel", this.experienceLevel); +diff --git a/net/minecraft/world/level/storage/LevelStorageSource.java b/net/minecraft/world/level/storage/LevelStorageSource.java +index de43e54698125ce9f319d4889dd49f7029fe95e0..976d512de5c1d8cfb41b3a1dc1c4401386dc2f36 100644 +--- a/net/minecraft/world/level/storage/LevelStorageSource.java ++++ b/net/minecraft/world/level/storage/LevelStorageSource.java +@@ -146,6 +146,7 @@ public class LevelStorageSource { + dynamic, levelSettings, complete.specialWorldProperty(), worldGenSettings.options(), lifecycle + ); + primaryLevelData.pdc = (Tag) dynamic.getElement("BukkitValues", null); // CraftBukkit - Add PDC to world ++ primaryLevelData.creativeLevel = ((Dynamic) dynamic).get("Nabulus.CreativeLevel").asBoolean(false); // Nabulus + return new LevelDataAndDimensions(primaryLevelData, complete); + } + +diff --git a/net/minecraft/world/level/storage/PrimaryLevelData.java b/net/minecraft/world/level/storage/PrimaryLevelData.java +index 2f4922a2035cc7d628dd2c979137163feb90e19f..2ada2da9288edbe2c2ff797e4cd36c8e1b2c790d 100644 +--- a/net/minecraft/world/level/storage/PrimaryLevelData.java ++++ b/net/minecraft/world/level/storage/PrimaryLevelData.java +@@ -78,6 +78,7 @@ public class PrimaryLevelData implements ServerLevelData, WorldData { + public net.minecraft.core.Registry customDimensions; + private net.minecraft.server.level.ServerLevel world; + protected net.minecraft.nbt.Tag pdc; ++ public boolean creativeLevel; + + public void setWorld(net.minecraft.server.level.ServerLevel world) { + if (this.world != null) { +@@ -298,6 +299,7 @@ public class PrimaryLevelData implements ServerLevelData, WorldData { + } + nbt.putString("Bukkit.Version", org.bukkit.Bukkit.getName() + "/" + org.bukkit.Bukkit.getVersion() + "/" + org.bukkit.Bukkit.getBukkitVersion()); // CraftBukkit + this.world.getWorld().storeBukkitValues(nbt); // CraftBukkit - add pdc ++ nbt.putBoolean("Nabulus.CreativeLevel", this.creativeLevel); // Nabulus + } + + private static ListTag stringCollectionToTag(Set stringCollection) { diff --git a/nabulus-server/minecraft-patches/features/0002-Show-hidden-players-in-playerlist-and-tab-suggestion.patch b/nabulus-server/minecraft-patches/features/0002-Show-hidden-players-in-playerlist-and-tab-suggestion.patch new file mode 100644 index 0000000..786dee4 --- /dev/null +++ b/nabulus-server/minecraft-patches/features/0002-Show-hidden-players-in-playerlist-and-tab-suggestion.patch @@ -0,0 +1,49 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Tue, 1 Mar 2022 19:44:48 +0930 +Subject: [PATCH] Show hidden players in playerlist and tab suggestions + + +diff --git a/net/minecraft/server/commands/ListPlayersCommand.java b/net/minecraft/server/commands/ListPlayersCommand.java +index c6ae34f91b3629990294fc5e69237a1e600ef038..eef9e2be7be153a3537df3602c53df35bfc4170d 100644 +--- a/net/minecraft/server/commands/ListPlayersCommand.java ++++ b/net/minecraft/server/commands/ListPlayersCommand.java +@@ -36,7 +36,7 @@ public class ListPlayersCommand { + List playersTemp = playerList.getPlayers(); + if (source.getBukkitSender() instanceof org.bukkit.entity.Player) { + org.bukkit.entity.Player sender = (org.bukkit.entity.Player) source.getBukkitSender(); +- playersTemp = playersTemp.stream().filter((ep) -> sender.canSee(ep.getBukkitEntity())).collect(java.util.stream.Collectors.toList()); ++ //playersTemp = playersTemp.stream().filter((ep) -> sender.canSee(ep.getBukkitEntity())).collect(java.util.stream.Collectors.toList()); // Nabulus + } + final List players = playersTemp; + // CraftBukkit end +diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java +index 9279e4bb6cd1b108ebffd8fe9887f4d231413376..deaf5bc060e3eda99ff3fc50b41938ca1afc9613 100644 +--- a/net/minecraft/server/players/PlayerList.java ++++ b/net/minecraft/server/players/PlayerList.java +@@ -345,7 +345,7 @@ public abstract class PlayerList { + for (int i = 0; i < this.players.size(); ++i) { + ServerPlayer entityplayer1 = (ServerPlayer) this.players.get(i); + +- if (entityplayer1.getBukkitEntity().canSee(bukkitPlayer)) { ++ if (entityplayer1.getBukkitEntity().canSee(bukkitPlayer) || true) { // Nabulus + // Paper start - Add Listing API for Player + if (entityplayer1.getBukkitEntity().isListed(bukkitPlayer)) { + // Paper end - Add Listing API for Player +@@ -358,7 +358,7 @@ public abstract class PlayerList { + } + + if (entityplayer1 == player || !bukkitPlayer.canSee(entityplayer1.getBukkitEntity())) { // Paper - Use single player info update packet on join; Don't include joining player +- continue; ++ //continue; // Nabulus + } + + onlinePlayers.add(entityplayer1); // Paper - Use single player info update packet on join +@@ -590,6 +590,7 @@ public abstract class PlayerList { + if (otherPlayer.getBukkitEntity().canSee(player.getBukkitEntity())) { + otherPlayer.connection.send(packet); + } else { ++ otherPlayer.connection.send(packet); // Nabulus + otherPlayer.getBukkitEntity().onEntityRemove(player); + } + } diff --git a/nabulus-server/minecraft-patches/features/0003-Use-system-messages-for-player-chat-until-Velocity-s.patch b/nabulus-server/minecraft-patches/features/0003-Use-system-messages-for-player-chat-until-Velocity-s.patch new file mode 100644 index 0000000..98ffc24 --- /dev/null +++ b/nabulus-server/minecraft-patches/features/0003-Use-system-messages-for-player-chat-until-Velocity-s.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Sat, 6 Aug 2022 13:21:50 +0930 +Subject: [PATCH] Use system messages for player chat until Velocity support + added + + +diff --git a/net/minecraft/network/chat/OutgoingChatMessage.java b/net/minecraft/network/chat/OutgoingChatMessage.java +index 4635182c73f28f63ba84982cb6bcb422221b738e..19d87c84ebd788ff6ed09dfd1b45ddc8a9f8be64 100644 +--- a/net/minecraft/network/chat/OutgoingChatMessage.java ++++ b/net/minecraft/network/chat/OutgoingChatMessage.java +@@ -27,6 +27,7 @@ public interface OutgoingChatMessage { + } + public void sendToPlayer(ServerPlayer player, boolean filtered, ChatType.Bound boundType, @javax.annotation.Nullable Component unsigned) { + player.connection.sendDisguisedChatMessage(unsigned != null ? unsigned : this.content, boundType); ++ player.connection.sendDisguisedChatMessage(this.content, boundType); // Nabulus + // Paper end + } + } diff --git a/nabulus-server/minecraft-patches/features/0004-Add-silent-chest-flag-to-players.patch b/nabulus-server/minecraft-patches/features/0004-Add-silent-chest-flag-to-players.patch new file mode 100644 index 0000000..8a4e334 --- /dev/null +++ b/nabulus-server/minecraft-patches/features/0004-Add-silent-chest-flag-to-players.patch @@ -0,0 +1,69 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Fri, 10 Feb 2023 19:54:12 +0930 +Subject: [PATCH] Add silent chest flag to players + + +diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java +index 141478c5bf94827eaf89688cb47346fde0394d03..ca792b5da7391b1cc406dc013ca8319f432af830 100644 +--- a/net/minecraft/world/entity/player/Player.java ++++ b/net/minecraft/world/entity/player/Player.java +@@ -206,6 +206,7 @@ public abstract class Player extends LivingEntity { + public int oldLevel = -1; + + // Nabulus start ++ public boolean silentChests = false; + protected final Inventory normalInventory = new Inventory(this); + protected final Inventory creativeLevelInventory = new Inventory(this); + private boolean inventoriesLoaded = false; +diff --git a/net/minecraft/world/level/block/entity/ContainerOpenersCounter.java b/net/minecraft/world/level/block/entity/ContainerOpenersCounter.java +index de3fc7062377d7579c74b8adcfc54c87bca23fe5..11be1505d28109876850ad7fab803d2ebf572e69 100644 +--- a/net/minecraft/world/level/block/entity/ContainerOpenersCounter.java ++++ b/net/minecraft/world/level/block/entity/ContainerOpenersCounter.java +@@ -38,6 +38,7 @@ public abstract class ContainerOpenersCounter { + protected abstract boolean isOwnContainer(Player player); + + public void incrementOpeners(Player player, Level level, BlockPos pos, BlockState state) { ++ if (player.silentChests) return; // Nabulus + int oldPower = Math.max(0, Math.min(15, this.openCount)); // CraftBukkit - Get power before new viewer is added + int i = this.openCount++; + +@@ -62,6 +63,7 @@ public abstract class ContainerOpenersCounter { + } + + public void decrementOpeners(Player player, Level level, BlockPos pos, BlockState state) { ++ if (player.silentChests) return; // Nabulus + int oldPower = Math.max(0, Math.min(15, this.openCount)); // CraftBukkit - Get power before new viewer is added + if (this.openCount == 0) return; // Paper - Prevent ContainerOpenersCounter openCount from going negative + int i = this.openCount--; +@@ -88,7 +90,7 @@ public abstract class ContainerOpenersCounter { + private List getPlayersWithContainerOpen(Level level, BlockPos pos) { + double d = this.maxInteractionRange + 4.0; + AABB aabb = new AABB(pos).inflate(d); +- return level.getEntities(EntityTypeTest.forClass(Player.class), aabb, this::isOwnContainer); ++ return level.getEntities(EntityTypeTest.forClass(Player.class), aabb, player -> this.isOwnContainer(player) && !player.silentChests); // Nabulus - add silent chest check + } + + public void recheckOpeners(Level level, BlockPos pos, BlockState state) { +diff --git a/net/minecraft/world/level/block/entity/ShulkerBoxBlockEntity.java b/net/minecraft/world/level/block/entity/ShulkerBoxBlockEntity.java +index a2ae4b47d742e7fb9809cfc4575517c06400ec61..854f3475236b41bed38e2d14d181926ba3b3afe6 100644 +--- a/net/minecraft/world/level/block/entity/ShulkerBoxBlockEntity.java ++++ b/net/minecraft/world/level/block/entity/ShulkerBoxBlockEntity.java +@@ -192,7 +192,7 @@ public class ShulkerBoxBlockEntity extends RandomizableContainerBlockEntity impl + + @Override + public void startOpen(Player player) { +- if (!this.remove && !player.isSpectator()) { ++ if (!this.remove && !player.isSpectator() && !player.silentChests) { // Nabulus + if (this.openCount < 0) { + this.openCount = 0; + } +@@ -210,7 +210,7 @@ public class ShulkerBoxBlockEntity extends RandomizableContainerBlockEntity impl + + @Override + public void stopOpen(Player player) { +- if (!this.remove && !player.isSpectator()) { ++ if (!this.remove && !player.isSpectator() && !player.silentChests) { // Nabulus + this.openCount--; + if (this.opened) return; // CraftBukkit - only animate if the ShulkerBox hasn't been forced open already by an API call. + this.level.blockEvent(this.worldPosition, this.getBlockState().getBlock(), 1, this.openCount); diff --git a/nabulus-server/minecraft-patches/features/0005-Throttle-spawn-attempts-after-consistent-failures.patch b/nabulus-server/minecraft-patches/features/0005-Throttle-spawn-attempts-after-consistent-failures.patch new file mode 100644 index 0000000..7ecc203 --- /dev/null +++ b/nabulus-server/minecraft-patches/features/0005-Throttle-spawn-attempts-after-consistent-failures.patch @@ -0,0 +1,61 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Sat, 12 Aug 2023 16:19:59 +0930 +Subject: [PATCH] Throttle spawn attempts after consistent failures + + +diff --git a/net/minecraft/world/level/NaturalSpawner.java b/net/minecraft/world/level/NaturalSpawner.java +index 17ce115e887cbbb06ad02ab7ddb488e27342c0e4..29022c6be20764cfbe0b04ec44a98b93aa4e369a 100644 +--- a/net/minecraft/world/level/NaturalSpawner.java ++++ b/net/minecraft/world/level/NaturalSpawner.java +@@ -162,6 +162,11 @@ public final class NaturalSpawner { + profilerFiller.push("spawner"); + + for (MobCategory mobCategory : categories) { ++ // Nabulus start - throttle spawn attempts after consistent failures ++ if (!spawnState.attemptFailedChunks && chunk.failedSpawnAttempts.getOrDefault(mobCategory, 0) > 1200) { ++ continue; ++ } ++ // Nabulus end + // Paper start - Optional per player mob spawns + final boolean canSpawn; + int maxSpawns = Integer.MAX_VALUE; +@@ -190,8 +195,17 @@ public final class NaturalSpawner { + canSpawn = spawnState.canSpawnForCategoryLocal(mobCategory, chunk.getPos()); + } + if (canSpawn) { ++ // Nabulus start - throttle spawn attempts after consistent failures ++ chunk.failedSpawnAttempts.compute(mobCategory, (k, v) -> (v == null ? 0 : v) + 1); ++ final Consumer trackEntity = entity -> { ++ if (level.paperConfig().entities.spawning.perPlayerMobSpawns) { ++ level.getChunkSource().chunkMap.updatePlayerMobTypeMap(entity); ++ } ++ chunk.failedSpawnAttempts.put(mobCategory, 0); ++ }; ++ // Nabulus end + spawnCategoryForChunk(mobCategory, level, chunk, spawnState::canSpawn, spawnState::afterSpawn, +- maxSpawns, level.paperConfig().entities.spawning.perPlayerMobSpawns ? level.getChunkSource().chunkMap::updatePlayerMobTypeMap : null); ++ maxSpawns, trackEntity); // Nabulus + // Paper end - Optional per player mob spawns + } + } +@@ -583,6 +597,7 @@ public final class NaturalSpawner { + @Nullable + private EntityType lastCheckedType; + private double lastCharge; ++ public final boolean attemptFailedChunks = Entity.SHARED_RANDOM.nextInt(10) == 0; // Nabulus + + SpawnState( + int spawnableChunkCount, +diff --git a/net/minecraft/world/level/chunk/LevelChunk.java b/net/minecraft/world/level/chunk/LevelChunk.java +index 761fdcd4a4e18f45547afd8edff44f61c6eeacb4..278c1fe2410965e63848ea3cf77b5058e231a2b5 100644 +--- a/net/minecraft/world/level/chunk/LevelChunk.java ++++ b/net/minecraft/world/level/chunk/LevelChunk.java +@@ -84,6 +84,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p + private final Int2ObjectMap gameEventListenerRegistrySections; + private final LevelChunkTicks blockTicks; + private final LevelChunkTicks fluidTicks; ++ public final Map failedSpawnAttempts = new java.util.EnumMap<>(net.minecraft.world.entity.MobCategory.class); // Nabulus + private LevelChunk.UnsavedListener unsavedListener = chunkPos -> {}; + // CraftBukkit start + public boolean mustNotSave; diff --git a/nabulus-server/minecraft-patches/features/0006-Implement-tick-rate-options-for-OneShot-behaviors.patch b/nabulus-server/minecraft-patches/features/0006-Implement-tick-rate-options-for-OneShot-behaviors.patch new file mode 100644 index 0000000..3360151 --- /dev/null +++ b/nabulus-server/minecraft-patches/features/0006-Implement-tick-rate-options-for-OneShot-behaviors.patch @@ -0,0 +1,101 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Wed, 15 Nov 2023 17:15:10 +0930 +Subject: [PATCH] Implement tick rate options for OneShot behaviors + + +diff --git a/net/minecraft/world/entity/ai/behavior/Behavior.java b/net/minecraft/world/entity/ai/behavior/Behavior.java +index 5b0cadd2544fb2a627822e645ff32fec2e9cfda9..9a56c3a9dc97c5880bd6ac6f703d640fefb80be1 100644 +--- a/net/minecraft/world/entity/ai/behavior/Behavior.java ++++ b/net/minecraft/world/entity/ai/behavior/Behavior.java +@@ -15,6 +15,16 @@ public abstract class Behavior implements BehaviorContro + private final int minDuration; + private final int maxDuration; + private final String configKey; // Paper - configurable behavior tick rate and timings ++ // Nabulus start ++ public static String getConfigKey(String behaviorClass) { ++ String key = io.papermc.paper.util.MappingEnvironment.reobf() ? io.papermc.paper.util.ObfHelper.INSTANCE.deobfClassName(behaviorClass.getClass().getName()) : behaviorClass.getClass().getName(); ++ int lastSeparator = key.lastIndexOf('.'); ++ if (lastSeparator != -1) { ++ key = key.substring(lastSeparator + 1); ++ } ++ return key.toLowerCase(java.util.Locale.ROOT); ++ } ++ // Nabulus end + + public Behavior(Map, MemoryStatus> entryCondition) { + this(entryCondition, 60); +@@ -29,12 +39,7 @@ public abstract class Behavior implements BehaviorContro + this.maxDuration = maxDuration; + this.entryCondition = entryCondition; + // Paper start - configurable behavior tick rate and timings +- String key = io.papermc.paper.util.MappingEnvironment.reobf() ? io.papermc.paper.util.ObfHelper.INSTANCE.deobfClassName(this.getClass().getName()) : this.getClass().getName(); +- int lastSeparator = key.lastIndexOf('.'); +- if (lastSeparator != -1) { +- key = key.substring(lastSeparator + 1); +- } +- this.configKey = key.toLowerCase(java.util.Locale.ROOT); ++ this.configKey = getConfigKey(this.getClass().getName()); // Nabulus + // Paper end - configurable behavior tick rate and timings + } + +diff --git a/net/minecraft/world/entity/ai/behavior/OneShot.java b/net/minecraft/world/entity/ai/behavior/OneShot.java +index b43335515a89a5d6ab0edcf00e6447e25d8cd91c..ab6c5aaa63e0069c20e9db3529ddcc4bf8e0ad61 100644 +--- a/net/minecraft/world/entity/ai/behavior/OneShot.java ++++ b/net/minecraft/world/entity/ai/behavior/OneShot.java +@@ -6,6 +6,18 @@ import net.minecraft.world.entity.ai.behavior.declarative.Trigger; + + public abstract class OneShot implements BehaviorControl, Trigger { + private Behavior.Status status = Behavior.Status.STOPPED; ++ // Nabulus start - configurable behavior tick rate ++ private final String configKey; ++ private long lastRun; ++ ++ public OneShot() { ++ this("unknown"); ++ } ++ ++ public OneShot(String configKey) { ++ this.configKey = configKey; ++ } ++ // Nabulus end + + @Override + public final Behavior.Status getStatus() { +@@ -14,8 +26,15 @@ public abstract class OneShot implements BehaviorControl + + @Override + public final boolean tryStart(ServerLevel level, E entity, long gameTime) { ++ // Nabulus start - behavior tick rate and timings ++ int tickRate = java.util.Objects.requireNonNullElse(level.paperConfig().tickRates.behavior.get(entity.getType(), this.configKey), -1); ++ if (tickRate > -1 && gameTime < this.lastRun + tickRate) { ++ return false; ++ } ++ // Nabulus end + if (this.trigger(level, entity, gameTime)) { + this.status = Behavior.Status.RUNNING; ++ this.lastRun = gameTime; // Nabulus - behavior tick rate + return true; + } else { + return false; +diff --git a/net/minecraft/world/entity/ai/behavior/declarative/BehaviorBuilder.java b/net/minecraft/world/entity/ai/behavior/declarative/BehaviorBuilder.java +index 07e3d0070c015cbfb83a961eb70fa5a0b6ed1110..240b642169c0c6a1992cb769341eb59df81694ca 100644 +--- a/net/minecraft/world/entity/ai/behavior/declarative/BehaviorBuilder.java ++++ b/net/minecraft/world/entity/ai/behavior/declarative/BehaviorBuilder.java +@@ -37,7 +37,15 @@ public class BehaviorBuilder implements App, ? extends App, Trigger>> initializer + ) { + final BehaviorBuilder.TriggerWithResult> triggerWithResult = get((App, Trigger>)initializer.apply(instance())); +- return new OneShot() { ++ // Nabulus start - configurable tick rates ++ java.lang.StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace(); ++ String callingClass = null; ++ if (stackTraceElements.length > 2) { ++ callingClass = stackTraceElements[2].getClassName(); ++ } ++ final String configKey = callingClass == null ? "unknown" : net.minecraft.world.entity.ai.behavior.Behavior.getConfigKey(callingClass); ++ // Nabulus end ++ return new OneShot(configKey) { // Nabulus + @Override + public boolean trigger(ServerLevel level, E entity, long gameTime) { + Trigger trigger = triggerWithResult.tryTrigger(level, entity, gameTime); diff --git a/nabulus-server/minecraft-patches/features/0007-Don-t-show-smoke-for-silent-fireworks.patch b/nabulus-server/minecraft-patches/features/0007-Don-t-show-smoke-for-silent-fireworks.patch new file mode 100644 index 0000000..52a6d31 --- /dev/null +++ b/nabulus-server/minecraft-patches/features/0007-Don-t-show-smoke-for-silent-fireworks.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Sat, 16 Dec 2023 15:18:46 +0930 +Subject: [PATCH] Don't show smoke for silent fireworks + + +diff --git a/net/minecraft/world/entity/projectile/FireworkRocketEntity.java b/net/minecraft/world/entity/projectile/FireworkRocketEntity.java +index 774ca9e0b56fd175ae246051de762d0c4256ca58..1d340b1176a201e6bfacc70c453fbbc33dfd1d48 100644 +--- a/net/minecraft/world/entity/projectile/FireworkRocketEntity.java ++++ b/net/minecraft/world/entity/projectile/FireworkRocketEntity.java +@@ -184,7 +184,7 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier { + } + + this.life++; +- if (this.level().isClientSide && this.life % 2 < 2) { ++ if (this.level().isClientSide && this.life % 2 < 2 && !this.isSilent()) { // Nabulus - don't show firework smoke for silent fireworks + this.level() + .addParticle( + ParticleTypes.FIREWORK, diff --git a/patches/server/0010-Allow-players-to-hide-wither-boss-bar.patch b/nabulus-server/minecraft-patches/features/0008-Allow-players-to-hide-wither-boss-bar.patch similarity index 53% rename from patches/server/0010-Allow-players-to-hide-wither-boss-bar.patch rename to nabulus-server/minecraft-patches/features/0008-Allow-players-to-hide-wither-boss-bar.patch index 4a5dfd8..4d20666 100644 --- a/patches/server/0010-Allow-players-to-hide-wither-boss-bar.patch +++ b/nabulus-server/minecraft-patches/features/0008-Allow-players-to-hide-wither-boss-bar.patch @@ -4,14 +4,14 @@ Date: Mon, 11 Mar 2024 18:40:31 +0930 Subject: [PATCH] Allow players to hide wither boss bar -diff --git a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java -index 82921c56c49edb0ca07425da563aa4876d4e6fb1..83b2788fe8a5d12a4c73056110e3a922253c79d5 100644 ---- a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java -+++ b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java -@@ -93,6 +93,21 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob - - public void setCanTravelThroughPortals(boolean canPortal) { this.canPortal = canPortal; } - // Paper end +diff --git a/net/minecraft/world/entity/boss/wither/WitherBoss.java b/net/minecraft/world/entity/boss/wither/WitherBoss.java +index afe43600c4976e01e61d716034a2823d50fb55cb..2553126e05d08eca41ee145e7a08f7e5456af7fb 100644 +--- a/net/minecraft/world/entity/boss/wither/WitherBoss.java ++++ b/net/minecraft/world/entity/boss/wither/WitherBoss.java +@@ -77,6 +77,21 @@ public class WitherBoss extends Monster implements RangedAttackMob { + private static final TargetingConditions.Selector LIVING_ENTITY_SELECTOR = (entity, level) -> !entity.getType().is(EntityTypeTags.WITHER_FRIENDS) + && entity.attackable(); + private static final TargetingConditions TARGETING_CONDITIONS = TargetingConditions.forCombat().range(20.0).selector(LIVING_ENTITY_SELECTOR); + // Nabulus start + public boolean hideBossBar = false; + private void updateBossBar() { @@ -28,9 +28,9 @@ index 82921c56c49edb0ca07425da563aa4876d4e6fb1..83b2788fe8a5d12a4c73056110e3a922 + } + // Nabulus end - public WitherBoss(EntityType type, Level world) { - super(type, world); -@@ -151,6 +166,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob + public WitherBoss(EntityType entityType, Level level) { + super(entityType, level); +@@ -131,6 +146,7 @@ public class WitherBoss extends Monster implements RangedAttackMob { @Override public void setCustomName(@Nullable Component name) { super.setCustomName(name); @@ -38,7 +38,7 @@ index 82921c56c49edb0ca07425da563aa4876d4e6fb1..83b2788fe8a5d12a4c73056110e3a922 this.bossEvent.setName(this.getDisplayName()); } -@@ -422,7 +438,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -401,7 +417,7 @@ public class WitherBoss extends Monster implements RangedAttackMob { @Override public void startSeenByPlayer(ServerPlayer player) { super.startSeenByPlayer(player); diff --git a/nabulus-server/paper-patches/features/0001-Nabulus-branding.patch b/nabulus-server/paper-patches/features/0001-Nabulus-branding.patch new file mode 100644 index 0000000..fe0bd7a --- /dev/null +++ b/nabulus-server/paper-patches/features/0001-Nabulus-branding.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Sun, 27 Feb 2022 17:45:40 +0930 +Subject: [PATCH] Nabulus branding + + +diff --git a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java +index 774556a62eb240da42e84db4502e2ed43495be17..df1fe60f2f26b1dae0a724cb55a2337d75c7d7a4 100644 +--- a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java ++++ b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java +@@ -11,7 +11,7 @@ public final class Versioning { + public static String getBukkitVersion() { + String result = "Unknown-Version"; + +- InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/io.papermc.paper/paper-api/pom.properties"); ++ InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/com.froobworld.nabulus/nabulus-api/pom.properties"); // Nabulus + Properties properties = new Properties(); + + if (stream != null) { diff --git a/nabulus-server/paper-patches/features/0002-Show-hidden-players-in-playerlist-and-tab-suggestion.patch b/nabulus-server/paper-patches/features/0002-Show-hidden-players-in-playerlist-and-tab-suggestion.patch new file mode 100644 index 0000000..15f3731 --- /dev/null +++ b/nabulus-server/paper-patches/features/0002-Show-hidden-players-in-playerlist-and-tab-suggestion.patch @@ -0,0 +1,68 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: froobynooby +Date: Tue, 1 Mar 2022 19:44:48 +0930 +Subject: [PATCH] Show hidden players in playerlist and tab suggestions + + +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java +index 59eddee7e75e1de332346ffe73fb88eb1ae14db6..abfa6d1ac96866094e6810893e40b6143f0a9308 100644 +--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java ++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java +@@ -2631,7 +2631,7 @@ public final class CraftServer implements Server { + PlayerChatTabCompleteEvent event = new PlayerChatTabCompleteEvent(player, message, completions); + String token = event.getLastToken(); + for (Player p : this.getOnlinePlayers()) { +- if (player.canSee(p) && StringUtil.startsWithIgnoreCase(p.getName(), token)) { ++ if (StringUtil.startsWithIgnoreCase(p.getName(), token)) { // Nabulus - remove canSee check + completions.add(p.getName()); + } + } +diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +index 3260f20b667918dd7cd641d5d96688721fce2f9c..6b0093ce63f36b54d6af368251d62ccb0575e1f1 100644 +--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java ++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +@@ -567,7 +567,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { + getHandle().listName = name == null ? null : io.papermc.paper.adventure.PaperAdventure.asVanilla(name); + if (getHandle().connection == null) return; // Updates are possible before the player has fully joined + for (ServerPlayer player : server.getHandle().players) { +- if (player.getBukkitEntity().canSee(this)) { ++ if (player.getBukkitEntity().canSee(this) || true) { // Nabulus + player.connection.send(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME, getHandle())); + } + } +@@ -598,7 +598,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { + this.getHandle().listName = name.equals(this.getName()) ? null : CraftChatMessage.fromStringOrNull(name); + if (this.getHandle().connection == null) return; // Paper - Updates are possible before the player has fully joined + for (ServerPlayer player : (List) this.server.getHandle().players) { +- if (player.getBukkitEntity().canSee(this)) { ++ if (player.getBukkitEntity().canSee(this) || true) { // Nabulus + player.connection.send(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME, this.getHandle())); + } + } +@@ -2068,11 +2068,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player { + // Remove this entity from the hidden player's EntityTrackerEntry + // Paper start + Entity other = ((CraftEntity) entity).getHandle(); +- unregisterEntity(other); ++ unregisterEntity(other, false); // Nabulus + + server.getPluginManager().callEvent(new PlayerHideEntityEvent(this, entity)); + } + private void unregisterEntity(Entity other) { ++ // Nabulus start ++ unregisterEntity(other, true); ++ } ++ private void unregisterEntity(Entity other, boolean removeFromPlayerList) { ++ // Nabulus end + // Paper end + ChunkMap tracker = ((ServerLevel) this.getHandle().level()).getChunkSource().chunkMap; + ChunkMap.TrackedEntity entry = tracker.entityMap.get(other.getId()); +@@ -2081,7 +2086,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { + } + + // Remove the hidden entity from this player user list, if they're on it +- if (other instanceof ServerPlayer) { ++ if (other instanceof ServerPlayer && removeFromPlayerList) { // Nabulus + ServerPlayer otherPlayer = (ServerPlayer) other; + if (otherPlayer.sentListPacket) { + this.getHandle().connection.send(new ClientboundPlayerInfoRemovePacket(List.of(otherPlayer.getUUID()))); diff --git a/patches/server/0006-Fix-pardoning-uncached-game-profiles.patch b/nabulus-server/paper-patches/features/0003-Fix-pardoning-uncached-game-profiles.patch similarity index 100% rename from patches/server/0006-Fix-pardoning-uncached-game-profiles.patch rename to nabulus-server/paper-patches/features/0003-Fix-pardoning-uncached-game-profiles.patch diff --git a/patches/server/0001-Nabulus-branding.patch b/patches/server/0001-Nabulus-branding.patch deleted file mode 100644 index b01b03c..0000000 --- a/patches/server/0001-Nabulus-branding.patch +++ /dev/null @@ -1,49 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: froobynooby -Date: Sun, 27 Feb 2022 17:45:40 +0930 -Subject: [PATCH] Nabulus branding - - -diff --git a/build.gradle.kts b/build.gradle.kts -index 91b7db7128ace54beaa6ea4e29a5a6f157a4acf9..45799ff3a08dcbb9807d4a2ef3396462b6d1abb3 100644 ---- a/build.gradle.kts -+++ b/build.gradle.kts -@@ -13,7 +13,7 @@ configurations.named(log4jPlugins.compileClasspathConfigurationName) { - val alsoShade: Configuration by configurations.creating - - dependencies { -- implementation(project(":pufferfish-api")) // Pufferfish // Paper -+ implementation(project(":nabulus-api")) // Nabulus - // Paper start - implementation("org.jline:jline-terminal-jansi:3.21.0") - implementation("net.minecrell:terminalconsoleappender:1.3.0") -@@ -101,14 +101,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 "Pufferfish", // Pufferfish -+ "Implementation-Title" to "Nabulus", // Nabulus - "Implementation-Version" to implementationVersion, - "Implementation-Vendor" to date, // Paper - "Specification-Title" to "Pufferfish", // Pufferfish - "Specification-Version" to project.version, - "Specification-Vendor" to "Pufferfish Studios LLC", // Pufferfish - "Brand-Id" to "pufferfish:pufferfish", // Pufferfish -- "Brand-Name" to "Pufferfish", // Pufferfish -+ "Brand-Name" to "Nabulus", // Pufferfish // Nabulus - "Build-Number" to (build ?: ""), - "Build-Time" to Instant.now().toString(), - "Git-Branch" to gitBranch, // Paper -diff --git a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java -index 80553face9c70c2a3d897681e7761df85b22d464..df1fe60f2f26b1dae0a724cb55a2337d75c7d7a4 100644 ---- a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java -+++ b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java -@@ -11,7 +11,7 @@ public final class Versioning { - public static String getBukkitVersion() { - String result = "Unknown-Version"; - -- InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/gg.pufferfish.pufferfish/pufferfish-api/pom.properties"); // Pufferfish -+ InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/com.froobworld.nabulus/nabulus-api/pom.properties"); // Nabulus - Properties properties = new Properties(); - - if (stream != null) { diff --git a/patches/server/0002-Separate-creative-levels.patch b/patches/server/0002-Separate-creative-levels.patch deleted file mode 100644 index ddfd62a..0000000 --- a/patches/server/0002-Separate-creative-levels.patch +++ /dev/null @@ -1,273 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: froobynooby -Date: Sun, 27 Feb 2022 21:27:01 +0930 -Subject: [PATCH] Separate creative levels - - -diff --git a/src/main/java/ca/spottedleaf/dataconverter/minecraft/versions/V1022.java b/src/main/java/ca/spottedleaf/dataconverter/minecraft/versions/V1022.java -index c1510d9167f466d3b7e3756353224f12f3876442..d4f0561741e71e10bf08448a0237320728cc3629 100644 ---- a/src/main/java/ca/spottedleaf/dataconverter/minecraft/versions/V1022.java -+++ b/src/main/java/ca/spottedleaf/dataconverter/minecraft/versions/V1022.java -@@ -15,6 +15,7 @@ public final class V1022 { - - WalkerUtils.convertList(MCTypeRegistry.ITEM_STACK, data, "Inventory", fromVersion, toVersion); - WalkerUtils.convertList(MCTypeRegistry.ITEM_STACK, data, "EnderItems", fromVersion, toVersion); -+ WalkerUtils.convertList(MCTypeRegistry.ITEM_STACK, data, "Nabulus.CreativeLevelInventory", fromVersion, toVersion); - - WalkerUtils.convert(MCTypeRegistry.ENTITY, data, "ShoulderEntityLeft", fromVersion, toVersion); - WalkerUtils.convert(MCTypeRegistry.ENTITY, data, "ShoulderEntityRight", fromVersion, toVersion); -diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java -index c396580a9cfd86ff261bed439bb4662ae88010b5..7e5f08b33abc93d98622c504a48a295b6a8bfb50 100644 ---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java -+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java -@@ -697,6 +697,7 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple - this.setPosRaw(position.x(), position.y(), position.z()); // Paper - don't register to chunks yet - } - this.gameMode.setLevel((ServerLevel) world); -+ this.chooseInventory(); // Nabulus - } - // CraftBukkit end - -@@ -1402,6 +1403,7 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple - this.unsetRemoved(); - // CraftBukkit end - this.setServerLevel(worldserver); -+ this.chooseInventory(); // Nabulus - this.connection.teleport(exit); // CraftBukkit - use internal teleport without event - this.connection.resetPosition(); - worldserver.addDuringTeleport(this); -@@ -2035,12 +2037,22 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple - } - - public void restoreFrom(ServerPlayer oldPlayer, boolean alive) { -+ // Nabulus start -+ this.restoreFrom(oldPlayer, alive, false); -+ } -+ public void restoreFrom(ServerPlayer oldPlayer, boolean alive, boolean toOrFromCreativeLevel) { -+ // Nabulus end - this.wardenSpawnTracker = oldPlayer.wardenSpawnTracker; - this.chatSession = oldPlayer.chatSession; - this.gameMode.setGameModeForPlayer(oldPlayer.gameMode.getGameModeForPlayer(), oldPlayer.gameMode.getPreviousGameModeForPlayer()); - this.onUpdateAbilities(); - this.getAttributes().assignBaseValues(oldPlayer.getAttributes()); - // this.setHealth(this.getMaxHealth()); // CraftBukkit -+ // Nabulus start -+ this.normalInventory.replaceWith(oldPlayer.normalInventory); -+ this.creativeLevelInventory.replaceWith(oldPlayer.creativeLevelInventory); -+ this.usingNormalInventory = oldPlayer.usingNormalInventory; -+ // Nabulus end - if (alive) { - this.getInventory().replaceWith(oldPlayer.getInventory()); - this.setHealth(oldPlayer.getHealth()); -@@ -2076,6 +2088,7 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple - this.seenCredits = oldPlayer.seenCredits; - this.enteredNetherPosition = oldPlayer.enteredNetherPosition; - this.chunkTrackingView = oldPlayer.chunkTrackingView; -+ if (toOrFromCreativeLevel) return; // Nabulus - this.setShoulderEntityLeft(oldPlayer.getShoulderEntityLeft()); - this.setShoulderEntityRight(oldPlayer.getShoulderEntityRight()); - this.setLastDeathLocation(oldPlayer.getLastDeathLocation()); -diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 5e2c4969e77c669acbb4a13c07033cb267c3d586..6f4fd5659a2e5f537ab1cdf4d1ac63e7af21aa5e 100644 ---- a/src/main/java/net/minecraft/server/players/PlayerList.java -+++ b/src/main/java/net/minecraft/server/players/PlayerList.java -@@ -819,9 +819,27 @@ public abstract class PlayerList { - Level fromWorld = entityplayer.level(); - entityplayer.wonGame = false; - // CraftBukkit end -+ // Nabulus start - moved from below -+ boolean isRespawn = false; -+ DimensionTransition dimensiontransition; -+ if (location == null) { -+ dimensiontransition = entityplayer.findRespawnPositionAndUseSpawnBlock(flag, DimensionTransition.DO_NOTHING, reason); - -+ if (!flag) entityplayer.reset(); // SPIGOT-4785 -+ isRespawn = true; // Paper - Add PlayerPostRespawnEvent -+ } else { -+ dimensiontransition = new DimensionTransition(((CraftWorld) location.getWorld()).getHandle(), CraftLocation.toVec3D(location), Vec3.ZERO, location.getYaw(), location.getPitch(), DimensionTransition.DO_NOTHING); -+ } -+ // Nabulus end -+ // Nabulus start -+ boolean toOrFromCreativeLevel = ((net.minecraft.world.level.storage.PrimaryLevelData) dimensiontransition.newLevel().levelData).creativeLevel || ((net.minecraft.world.level.storage.PrimaryLevelData) entityplayer.level().levelData).creativeLevel; -+ if (toOrFromCreativeLevel) { -+ entityplayer.releaseLeftShoulderEntity(); -+ entityplayer.releaseRightShoulderEntity(); -+ } -+ // Nabulus end - entityplayer1.connection = entityplayer.connection; -- entityplayer1.restoreFrom(entityplayer, flag); -+ entityplayer1.restoreFrom(entityplayer, flag, toOrFromCreativeLevel); // Nabulus - entityplayer1.setId(entityplayer.getId()); - entityplayer1.setMainArm(entityplayer.getMainArm()); - // CraftBukkit - not required, just copies old location into reused entity -@@ -841,10 +859,12 @@ public abstract class PlayerList { - } - // Paper start - Add PlayerPostRespawnEvent - boolean isBedSpawn = false; -- boolean isRespawn = false; -+ //boolean isRespawn = false; // Nabulus - moved up - // Paper end - Add PlayerPostRespawnEvent - - // CraftBukkit start - fire PlayerRespawnEvent -+ // Nabulus start - moved up -+ /* - DimensionTransition dimensiontransition; - if (location == null) { - dimensiontransition = entityplayer.findRespawnPositionAndUseSpawnBlock(flag, DimensionTransition.DO_NOTHING, reason); -@@ -858,6 +878,8 @@ public abstract class PlayerList { - } else { - dimensiontransition = new DimensionTransition(((CraftWorld) location.getWorld()).getHandle(), CraftLocation.toVec3D(location), Vec3.ZERO, location.getYaw(), location.getPitch(), DimensionTransition.DO_NOTHING); - } -+ */ -+ // Nabulus end - // Spigot Start - if (dimensiontransition == null) { // Paper - Add PlayerPostRespawnEvent - diff on change - spigot early returns if respawn pos is null, that is how they handle disconnected player in respawn event - return entityplayer; -diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 8492421ed2186c0eab517a67f3140b9988f65250..600dfd3f75538de7c1d21ee339836fcff0a94439 100644 ---- a/src/main/java/net/minecraft/world/entity/Entity.java -+++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -3733,6 +3733,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess - // Paper end - Fix item duplication and teleport issues - if (world instanceof ServerLevel worldserver) { - if (!this.isRemoved()) { -+ // Nabulus start -+ if (!this.level.equals(worldserver) && ((net.minecraft.world.level.storage.PrimaryLevelData) this.level().levelData).creativeLevel) { -+ return null; -+ } -+ // Nabulus end - // CraftBukkit start - Location to = new Location(teleportTarget.newLevel().getWorld(), teleportTarget.pos().x, teleportTarget.pos().y, teleportTarget.pos().z, teleportTarget.yRot(), this.getXRot()); // Paper - use getXRot (doesn't respect DimensionTransition pitch) - // Paper start - gateway-specific teleport event -diff --git a/src/main/java/net/minecraft/world/entity/PortalProcessor.java b/src/main/java/net/minecraft/world/entity/PortalProcessor.java -index 45761c113116ae7417e6ae99069bff35dbccdf30..3dd19ef284dcab420dfc56c100ccf1df3baefe1e 100644 ---- a/src/main/java/net/minecraft/world/entity/PortalProcessor.java -+++ b/src/main/java/net/minecraft/world/entity/PortalProcessor.java -@@ -30,6 +30,11 @@ public class PortalProcessor { - - @Nullable - public DimensionTransition getPortalDestination(ServerLevel world, Entity entity) { -+ // Nabulus start -+ if (((net.minecraft.world.level.storage.PrimaryLevelData) entity.level().levelData).creativeLevel) { -+ return null; -+ } -+ // Nabulus end - return this.portal.getPortalDestination(world, entity, this.entryPosition); - } - -diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java -index 09bcbc0ae36e4e69fee87a7e0c49acf496117a39..591797efe64ca85da29fb876d00cf7fa8dd84ecc 100644 ---- a/src/main/java/net/minecraft/world/entity/player/Player.java -+++ b/src/main/java/net/minecraft/world/entity/player/Player.java -@@ -202,6 +202,40 @@ public abstract class Player extends LivingEntity { - public boolean fauxSleeping; - public int oldLevel = -1; - -+ // Nabulus start -+ protected final Inventory normalInventory = new Inventory(this); -+ protected final Inventory creativeLevelInventory = new Inventory(this); -+ private boolean inventoriesLoaded = false; -+ public boolean usingNormalInventory = true; -+ -+ public void chooseInventory() { -+ if (!inventoriesLoaded) { -+ return; -+ } -+ if (((net.minecraft.world.level.storage.PrimaryLevelData)this.level().levelData).creativeLevel) { -+ if (usingNormalInventory) { -+ this.normalInventory.replaceWith(this.inventory); -+ this.inventory.replaceWith(this.creativeLevelInventory); -+ usingNormalInventory = false; -+ } -+ } else { -+ if (!usingNormalInventory) { -+ this.creativeLevelInventory.replaceWith(this.inventory); -+ this.inventory.replaceWith(this.normalInventory); -+ usingNormalInventory = true; -+ } -+ } -+ } -+ -+ public Inventory getNormalInventory() { -+ return usingNormalInventory ? this.inventory : this.normalInventory; -+ } -+ -+ public Inventory getCreativeLevelInventory() { -+ return usingNormalInventory ? this.creativeLevelInventory : this.inventory; -+ } -+ // Nabulus end -+ - @Override - public CraftHumanEntity getBukkitEntity() { - return (CraftHumanEntity) super.getBukkitEntity(); -@@ -215,6 +249,7 @@ public abstract class Player extends LivingEntity { - this.lastDeathLocation = Optional.empty(); - this.setUUID(gameProfile.getId()); - this.gameProfile = gameProfile; -+ this.chooseInventory(); // Nabulus - this.inventoryMenu = new InventoryMenu(this.inventory, !world.isClientSide, this); - this.containerMenu = this.inventoryMenu; - this.moveTo((double) pos.getX() + 0.5D, (double) (pos.getY() + 1), (double) pos.getZ() + 0.5D, yaw, 0.0F); -@@ -877,6 +912,15 @@ public abstract class Player extends LivingEntity { - - this.inventory.load(nbttaglist); - this.inventory.selected = nbt.getInt("SelectedItemSlot"); -+ // Nabulus start -+ this.normalInventory.load(nbttaglist); -+ this.normalInventory.selected = nbt.getInt("SelectedItemSlot"); -+ ListTag creativeLevelInventoryTagList = nbt.getList("Nabulus.CreativeLevelInventory", 10); -+ this.creativeLevelInventory.load(creativeLevelInventoryTagList); -+ this.creativeLevelInventory.selected = nbt.getInt("Nabulus.CreativeLevelSelectedItemSlot"); -+ this.inventoriesLoaded = true; -+ this.usingNormalInventory = true; -+ // Nabulus end - this.sleepCounter = nbt.getShort("SleepTimer"); - this.experienceProgress = nbt.getFloat("XpP"); - this.experienceLevel = nbt.getInt("XpLevel"); -@@ -928,8 +972,12 @@ public abstract class Player extends LivingEntity { - public void addAdditionalSaveData(CompoundTag nbt) { - super.addAdditionalSaveData(nbt); - NbtUtils.addCurrentDataVersion(nbt); -- nbt.put("Inventory", this.inventory.save(new ListTag())); -- nbt.putInt("SelectedItemSlot", this.inventory.selected); -+ nbt.put("Inventory", this.getNormalInventory().save(new ListTag())); // Nabulus -+ nbt.putInt("SelectedItemSlot", this.getNormalInventory().selected); // Nabulus -+ // Nabulus start -+ nbt.put("Nabulus.CreativeLevelInventory", this.getCreativeLevelInventory().save(new ListTag())); -+ nbt.putInt("Nabulus.CreativeLevelSelectedItemSlot", this.getCreativeLevelInventory().selected); -+ // Nabulus end - nbt.putShort("SleepTimer", (short) this.sleepCounter); - nbt.putFloat("XpP", this.experienceProgress); - nbt.putInt("XpLevel", this.experienceLevel); -diff --git a/src/main/java/net/minecraft/world/level/storage/LevelStorageSource.java b/src/main/java/net/minecraft/world/level/storage/LevelStorageSource.java -index 85ba843ce7e1f62971e736fa2cc028c47b274ce4..dfcea62791961e82bc1f0dd26632d239a8322cda 100644 ---- a/src/main/java/net/minecraft/world/level/storage/LevelStorageSource.java -+++ b/src/main/java/net/minecraft/world/level/storage/LevelStorageSource.java -@@ -167,6 +167,7 @@ public class LevelStorageSource { - Lifecycle lifecycle = worlddimensions_b.lifecycle().add(registryManager.allRegistriesLifecycle()); - PrimaryLevelData worlddataserver = PrimaryLevelData.parse(dynamic1, worldsettings, worlddimensions_b.specialWorldProperty(), generatorsettings.options(), lifecycle); - worlddataserver.pdc = ((Dynamic) dynamic1).getElement("BukkitValues", null); // CraftBukkit - Add PDC to world -+ worlddataserver.creativeLevel = ((Dynamic) dynamic1).get("Nabulus.CreativeLevel").asBoolean(false); // Nabulus - - return new LevelDataAndDimensions(worlddataserver, worlddimensions_b); - } -diff --git a/src/main/java/net/minecraft/world/level/storage/PrimaryLevelData.java b/src/main/java/net/minecraft/world/level/storage/PrimaryLevelData.java -index efd0bcfebb3b4f63018d4e20a6a89f79192898d1..0ff5e2056ae0a7aee5654a6c249565cdc31d8fca 100644 ---- a/src/main/java/net/minecraft/world/level/storage/PrimaryLevelData.java -+++ b/src/main/java/net/minecraft/world/level/storage/PrimaryLevelData.java -@@ -94,6 +94,7 @@ public class PrimaryLevelData implements ServerLevelData, WorldData { - public Registry customDimensions; - private ServerLevel world; - protected Tag pdc; -+ public boolean creativeLevel; - - public void setWorld(ServerLevel world) { - if (this.world != null) { -@@ -257,6 +258,7 @@ public class PrimaryLevelData implements ServerLevelData, WorldData { - - levelNbt.putString("Bukkit.Version", Bukkit.getName() + "/" + Bukkit.getVersion() + "/" + Bukkit.getBukkitVersion()); // CraftBukkit - this.world.getWorld().storeBukkitValues(levelNbt); // CraftBukkit - add pdc -+ levelNbt.putBoolean("Nabulus.CreativeLevel", this.creativeLevel); // Nabulus - } - - private static ListTag stringCollectionToTag(Set strings) { diff --git a/patches/server/0003-Show-hidden-players-in-playerlist-and-tab-suggestion.patch b/patches/server/0003-Show-hidden-players-in-playerlist-and-tab-suggestion.patch deleted file mode 100644 index f0beb60..0000000 --- a/patches/server/0003-Show-hidden-players-in-playerlist-and-tab-suggestion.patch +++ /dev/null @@ -1,120 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: froobynooby -Date: Tue, 1 Mar 2022 19:44:48 +0930 -Subject: [PATCH] Show hidden players in playerlist and tab suggestions - - -diff --git a/src/main/java/net/minecraft/server/commands/ListPlayersCommand.java b/src/main/java/net/minecraft/server/commands/ListPlayersCommand.java -index 73180c617945610e11b777733655f9e2c4c1dd0c..aec6ec9bc92dc784ea1c2907b051a3f9bc2bd3c7 100644 ---- a/src/main/java/net/minecraft/server/commands/ListPlayersCommand.java -+++ b/src/main/java/net/minecraft/server/commands/ListPlayersCommand.java -@@ -39,7 +39,7 @@ public class ListPlayersCommand { - List players = playerlist.getPlayers(); - if (source.getBukkitSender() instanceof org.bukkit.entity.Player) { - org.bukkit.entity.Player sender = (org.bukkit.entity.Player) source.getBukkitSender(); -- players = players.stream().filter((ep) -> sender.canSee(ep.getBukkitEntity())).collect(java.util.stream.Collectors.toList()); -+ //players = players.stream().filter((ep) -> sender.canSee(ep.getBukkitEntity())).collect(java.util.stream.Collectors.toList()); // Nabulus - } - List list = players; - // CraftBukkit end -diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 6f4fd5659a2e5f537ab1cdf4d1ac63e7af21aa5e..ffddfe2a874ff0ecd9015d4f2bab348be03bb8a4 100644 ---- a/src/main/java/net/minecraft/server/players/PlayerList.java -+++ b/src/main/java/net/minecraft/server/players/PlayerList.java -@@ -365,7 +365,7 @@ public abstract class PlayerList { - for (int i = 0; i < this.players.size(); ++i) { - ServerPlayer entityplayer1 = (ServerPlayer) this.players.get(i); - -- if (entityplayer1.getBukkitEntity().canSee(bukkitPlayer)) { -+ if (entityplayer1.getBukkitEntity().canSee(bukkitPlayer) || true) { // Nabulus - // Paper start - Add Listing API for Player - if (entityplayer1.getBukkitEntity().isListed(bukkitPlayer)) { - // Paper end - Add Listing API for Player -@@ -378,7 +378,7 @@ public abstract class PlayerList { - } - - if (entityplayer1 == player || !bukkitPlayer.canSee(entityplayer1.getBukkitEntity())) { // Paper - Use single player info update packet on join; Don't include joining player -- continue; -+ //continue; // Nabulus - } - - onlinePlayers.add(entityplayer1); // Paper - Use single player info update packet on join -@@ -674,6 +674,7 @@ public abstract class PlayerList { - if (entityplayer2.getBukkitEntity().canSee(entityplayer.getBukkitEntity())) { - entityplayer2.connection.send(packet); - } else { -+ entityplayer2.connection.send(packet); // Nabulus - entityplayer2.getBukkitEntity().onEntityRemove(entityplayer); - } - } -@@ -1008,7 +1009,7 @@ public abstract class PlayerList { - target.connection.send(new ClientboundPlayerInfoUpdatePacket(EnumSet.of(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LATENCY), this.players.stream().filter(new Predicate() { - @Override - public boolean test(ServerPlayer input) { -- return target.getBukkitEntity().canSee(input.getBukkitEntity()); -+ return target.getBukkitEntity().canSee(input.getBukkitEntity()) || true; // Nabulus - } - }).collect(Collectors.toList()))); - } -diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index c7df339aeb62ee627edaf1bb4c8474b61e357ba6..d2ce1e7f251a99ddb5917cf8ba64768131e36496 100644 ---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java -+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -@@ -2600,7 +2600,7 @@ public final class CraftServer implements Server { - PlayerChatTabCompleteEvent event = new PlayerChatTabCompleteEvent(player, message, completions); - String token = event.getLastToken(); - for (Player p : this.getOnlinePlayers()) { -- if (player.canSee(p) && StringUtil.startsWithIgnoreCase(p.getName(), token)) { -+ if (StringUtil.startsWithIgnoreCase(p.getName(), token)) { // Nabulus - remove canSee check - completions.add(p.getName()); - } - } -diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -index 42d7660efe5baa6f796f2a7606686c765b6f2478..a96e7e9cc98e255aaf7f3640b8e797b6a546f86f 100644 ---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -@@ -553,7 +553,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { - getHandle().listName = name == null ? null : io.papermc.paper.adventure.PaperAdventure.asVanilla(name); - if (getHandle().connection == null) return; // Updates are possible before the player has fully joined - for (ServerPlayer player : server.getHandle().players) { -- if (player.getBukkitEntity().canSee(this)) { -+ if (player.getBukkitEntity().canSee(this) || true) { // Nabulus - player.connection.send(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME, getHandle())); - } - } -@@ -584,7 +584,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { - this.getHandle().listName = name.equals(this.getName()) ? null : CraftChatMessage.fromStringOrNull(name); - if (this.getHandle().connection == null) return; // Paper - Updates are possible before the player has fully joined - for (ServerPlayer player : (List) this.server.getHandle().players) { -- if (player.getBukkitEntity().canSee(this)) { -+ if (player.getBukkitEntity().canSee(this) || true) { // Nabulus - player.connection.send(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME, this.getHandle())); - } - } -@@ -2057,11 +2057,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player { - // Remove this entity from the hidden player's EntityTrackerEntry - // Paper start - Entity other = ((CraftEntity) entity).getHandle(); -- unregisterEntity(other); -+ unregisterEntity(other, false); // Nabulus - - server.getPluginManager().callEvent(new PlayerHideEntityEvent(this, entity)); - } - private void unregisterEntity(Entity other) { -+ // Nabulus start -+ unregisterEntity(other, true); -+ } -+ private void unregisterEntity(Entity other, boolean removeFromPlayerList) { -+ // Nabulus end - // Paper end - ChunkMap tracker = ((ServerLevel) this.getHandle().level()).getChunkSource().chunkMap; - ChunkMap.TrackedEntity entry = tracker.entityMap.get(other.getId()); -@@ -2070,7 +2075,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { - } - - // Remove the hidden entity from this player user list, if they're on it -- if (other instanceof ServerPlayer) { -+ if (other instanceof ServerPlayer && removeFromPlayerList) { // Nabulus - ServerPlayer otherPlayer = (ServerPlayer) other; - if (otherPlayer.sentListPacket) { - this.getHandle().connection.send(new ClientboundPlayerInfoRemovePacket(List.of(otherPlayer.getUUID()))); diff --git a/patches/server/0004-Use-system-messages-for-player-chat-until-Velocity-s.patch b/patches/server/0004-Use-system-messages-for-player-chat-until-Velocity-s.patch deleted file mode 100644 index d0d2295..0000000 --- a/patches/server/0004-Use-system-messages-for-player-chat-until-Velocity-s.patch +++ /dev/null @@ -1,20 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: froobynooby -Date: Sat, 6 Aug 2022 13:21:50 +0930 -Subject: [PATCH] Use system messages for player chat until Velocity support - added - - -diff --git a/src/main/java/net/minecraft/network/chat/OutgoingChatMessage.java b/src/main/java/net/minecraft/network/chat/OutgoingChatMessage.java -index c87b708c368713a23a10ad97704575ee4df27891..55c78d906c66b4d83bd6787ae323edab50e962a5 100644 ---- a/src/main/java/net/minecraft/network/chat/OutgoingChatMessage.java -+++ b/src/main/java/net/minecraft/network/chat/OutgoingChatMessage.java -@@ -26,7 +26,7 @@ public interface OutgoingChatMessage { - this.sendToPlayer(sender, filterMaskEnabled, params, null); - } - public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params, @javax.annotation.Nullable Component unsigned) { -- sender.connection.sendDisguisedChatMessage(unsigned != null ? unsigned : this.content, params); -+ sender.connection.sendDisguisedChatMessage(this.content, params); // Nabulus - // Paper end - } - } diff --git a/patches/server/0005-Add-silent-chest-flag-to-players.patch b/patches/server/0005-Add-silent-chest-flag-to-players.patch deleted file mode 100644 index 266af8a..0000000 --- a/patches/server/0005-Add-silent-chest-flag-to-players.patch +++ /dev/null @@ -1,69 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: froobynooby -Date: Fri, 10 Feb 2023 19:54:12 +0930 -Subject: [PATCH] Add silent chest flag to players - - -diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java -index 591797efe64ca85da29fb876d00cf7fa8dd84ecc..d6cf805d09856c30b62620e29ce1798543979de6 100644 ---- a/src/main/java/net/minecraft/world/entity/player/Player.java -+++ b/src/main/java/net/minecraft/world/entity/player/Player.java -@@ -203,6 +203,7 @@ public abstract class Player extends LivingEntity { - public int oldLevel = -1; - - // Nabulus start -+ public boolean silentChests = false; - protected final Inventory normalInventory = new Inventory(this); - protected final Inventory creativeLevelInventory = new Inventory(this); - private boolean inventoriesLoaded = false; -diff --git a/src/main/java/net/minecraft/world/level/block/entity/ContainerOpenersCounter.java b/src/main/java/net/minecraft/world/level/block/entity/ContainerOpenersCounter.java -index 86dce6796f92a5b0ae2b1bd837267c4e3f6754d0..ff1df9c403160adf7b9af7c7653d50731a3f071d 100644 ---- a/src/main/java/net/minecraft/world/level/block/entity/ContainerOpenersCounter.java -+++ b/src/main/java/net/minecraft/world/level/block/entity/ContainerOpenersCounter.java -@@ -44,6 +44,7 @@ public abstract class ContainerOpenersCounter { - protected abstract boolean isOwnContainer(Player player); - - public void incrementOpeners(Player player, Level world, BlockPos pos, BlockState state) { -+ if (player.silentChests) return; // Nabulus - int oldPower = Math.max(0, Math.min(15, this.openCount)); // CraftBukkit - Get power before new viewer is added - int i = this.openCount++; - -@@ -68,6 +69,7 @@ public abstract class ContainerOpenersCounter { - } - - public void decrementOpeners(Player player, Level world, BlockPos pos, BlockState state) { -+ if (player.silentChests) return; // Nabulus - int oldPower = Math.max(0, Math.min(15, this.openCount)); // CraftBukkit - Get power before new viewer is added - if (this.openCount == 0) return; // Paper - Prevent ContainerOpenersCounter openCount from going negative - int i = this.openCount--; -@@ -95,7 +97,7 @@ public abstract class ContainerOpenersCounter { - double d0 = this.maxInteractionRange + 4.0D; - AABB axisalignedbb = (new AABB(pos)).inflate(d0); - -- return world.getEntities(EntityTypeTest.forClass(Player.class), axisalignedbb, this::isOwnContainer); -+ return world.getEntities(EntityTypeTest.forClass(Player.class), axisalignedbb, player -> this.isOwnContainer(player) && !player.silentChests); // Nabulus - add silent chest check - } - - public void recheckOpeners(Level world, BlockPos pos, BlockState state) { -diff --git a/src/main/java/net/minecraft/world/level/block/entity/ShulkerBoxBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/ShulkerBoxBlockEntity.java -index 0d68db20f5fbe5e834f12c1e8fd429099a44e4b6..b14b82a9c38dad5153958a0b25e3f20e863ea831 100644 ---- a/src/main/java/net/minecraft/world/level/block/entity/ShulkerBoxBlockEntity.java -+++ b/src/main/java/net/minecraft/world/level/block/entity/ShulkerBoxBlockEntity.java -@@ -202,7 +202,7 @@ public class ShulkerBoxBlockEntity extends RandomizableContainerBlockEntity impl - - @Override - public void startOpen(Player player) { -- if (!this.remove && !player.isSpectator()) { -+ if (!this.remove && !player.isSpectator() && !player.silentChests) { // Nabulus - if (this.openCount < 0) { - this.openCount = 0; - } -@@ -220,7 +220,7 @@ public class ShulkerBoxBlockEntity extends RandomizableContainerBlockEntity impl - - @Override - public void stopOpen(Player player) { -- if (!this.remove && !player.isSpectator()) { -+ if (!this.remove && !player.isSpectator() && !player.silentChests) { // Nabulus - --this.openCount; - if (this.opened) return; // CraftBukkit - only animate if the ShulkerBox hasn't been forced open already by an API call. - this.level.blockEvent(this.worldPosition, this.getBlockState().getBlock(), 1, this.openCount); diff --git a/patches/server/0007-Throttle-spawn-attempts-after-consistent-failures.patch b/patches/server/0007-Throttle-spawn-attempts-after-consistent-failures.patch deleted file mode 100644 index b34f503..0000000 --- a/patches/server/0007-Throttle-spawn-attempts-after-consistent-failures.patch +++ /dev/null @@ -1,48 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: froobynooby -Date: Sat, 12 Aug 2023 16:19:59 +0930 -Subject: [PATCH] Throttle spawn attempts after consistent failures - - -diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java -index e524b27d185da3e88668f8ef107517272860bd66..545109edc80c4c48d1e12398aa2161bf71e92665 100644 ---- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java -+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java -@@ -139,9 +139,10 @@ public final class NaturalSpawner { - // CraftBukkit start - Use per-world spawn limits - boolean spawnThisTick = true; - int limit = enumcreaturetype.getMaxInstancesPerChunk(); -+ int spawnRateMultiplier = chunk.failedSpawnAttempts.getOrDefault(enumcreaturetype, 0) > 1200 ? 10 : 1; // Nabulus - SpawnCategory spawnCategory = CraftSpawnCategory.toBukkit(enumcreaturetype); - if (CraftSpawnCategory.isValidForLimits(spawnCategory)) { -- spawnThisTick = world.ticksPerSpawnCategory.getLong(spawnCategory) != 0 && worlddata.getGameTime() % world.ticksPerSpawnCategory.getLong(spawnCategory) == 0; -+ spawnThisTick = world.ticksPerSpawnCategory.getLong(spawnCategory) != 0 && worlddata.getGameTime() % (world.ticksPerSpawnCategory.getLong(spawnCategory) * spawnRateMultiplier) == 0; // Nabulus - limit = world.getWorld().getSpawnLimit(spawnCategory); - } - -@@ -178,6 +179,13 @@ public final class NaturalSpawner { - difference, world.paperConfig().entities.spawning.perPlayerMobSpawns ? world.getChunkSource().chunkMap::updatePlayerMobTypeMap : null); - info.mobCategoryCounts.mergeInt(enumcreaturetype, spawnCount, Integer::sum); - // Paper end - Optional per player mob spawns -+ // Nabulus start -+ if (spawnCount == 0) { -+ chunk.failedSpawnAttempts.compute(enumcreaturetype, (k, v) -> (v == null ? 0 : v) + 1); -+ } else { -+ chunk.failedSpawnAttempts.put(enumcreaturetype, 0); -+ } -+ // Nabulus end - } - } - -diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -index 8ccd3b8fcaa80f60b91a6c066e312542d349246a..7bf5219bb846f0f8b57fda04f189a6f45f3bb65e 100644 ---- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -@@ -85,6 +85,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p - private final Int2ObjectMap gameEventListenerRegistrySections; - private final LevelChunkTicks blockTicks; - private final LevelChunkTicks fluidTicks; -+ public final Map failedSpawnAttempts = new java.util.EnumMap<>(net.minecraft.world.entity.MobCategory.class); // Nabulus - - // Pufferfish start - instead of using a random every time the chunk is ticked, define when lightning strikes preemptively - private int lightningTick; diff --git a/patches/server/0008-Implement-tick-rate-options-for-OneShot-behaviors.patch b/patches/server/0008-Implement-tick-rate-options-for-OneShot-behaviors.patch deleted file mode 100644 index e4e6dec..0000000 --- a/patches/server/0008-Implement-tick-rate-options-for-OneShot-behaviors.patch +++ /dev/null @@ -1,110 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: froobynooby -Date: Wed, 15 Nov 2023 17:15:10 +0930 -Subject: [PATCH] Implement tick rate options for OneShot behaviors - - -diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java b/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java -index 9379dd4056018b52c93ed4888dcdc94579bd9691..5b7f5ae6c2046d8aec59c348a12a028249fe466f 100644 ---- a/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java -+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java -@@ -18,6 +18,16 @@ public abstract class Behavior implements BehaviorContro - private final String configKey; - private final co.aikar.timings.Timing timing; - // Paper end - configurable behavior tick rate and timings -+ // Nabulus start -+ public static String getConfigKey(String behaviorClass) { -+ String key = io.papermc.paper.util.ObfHelper.INSTANCE.deobfClassName(behaviorClass); -+ int lastSeparator = key.lastIndexOf('.'); -+ if (lastSeparator != -1) { -+ key = key.substring(lastSeparator + 1); -+ } -+ return key.toLowerCase(java.util.Locale.ROOT); -+ } -+ // Nabulus end - - public Behavior(Map, MemoryStatus> requiredMemoryState) { - this(requiredMemoryState, 60); -@@ -32,12 +42,7 @@ public abstract class Behavior implements BehaviorContro - this.maxDuration = maxRunTime; - this.entryCondition = requiredMemoryState; - // Paper start - configurable behavior tick rate and timings -- String key = io.papermc.paper.util.MappingEnvironment.reobf() ? io.papermc.paper.util.ObfHelper.INSTANCE.deobfClassName(this.getClass().getName()) : this.getClass().getName(); -- int lastSeparator = key.lastIndexOf('.'); -- if (lastSeparator != -1) { -- key = key.substring(lastSeparator + 1); -- } -- this.configKey = key.toLowerCase(java.util.Locale.ROOT); -+ this.configKey = getConfigKey(this.getClass().getName()); // Nabulus - this.timing = co.aikar.timings.MinecraftTimings.getBehaviorTimings(configKey); - // Paper end - configurable behavior tick rate and timings - } -diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/OneShot.java b/src/main/java/net/minecraft/world/entity/ai/behavior/OneShot.java -index dde5c53550ddbdfc8288f725468924b35ea5b05e..ca2d3a0f67a2f07ec33394d1aa3f2ca2f29af404 100644 ---- a/src/main/java/net/minecraft/world/entity/ai/behavior/OneShot.java -+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/OneShot.java -@@ -6,6 +6,20 @@ import net.minecraft.world.entity.ai.behavior.declarative.Trigger; - - public abstract class OneShot implements BehaviorControl, Trigger { - private Behavior.Status status = Behavior.Status.STOPPED; -+ // Nabulus start - configurable behavior tick rate and timings -+ private final String configKey; -+ private final co.aikar.timings.Timing timing; -+ private long lastRun; -+ -+ public OneShot() { -+ this("unknown"); -+ } -+ -+ public OneShot(String configKey) { -+ this.configKey = configKey; -+ this.timing = co.aikar.timings.MinecraftTimings.getBehaviorTimings(configKey); -+ } -+ // Nabulus end - - @Override - public final Behavior.Status getStatus() { -@@ -14,10 +28,22 @@ public abstract class OneShot implements BehaviorControl - - @Override - public final boolean tryStart(ServerLevel world, E entity, long time) { -+ // Nabulus start - behavior tick rate and timings -+ int tickRate = java.util.Objects.requireNonNullElse(world.paperConfig().tickRates.behavior.get(entity.getType(), this.configKey), -1); -+ if (tickRate > -1 && time < this.lastRun + tickRate) { -+ return false; -+ } -+ this.timing.startTiming(); -+ // Nabulus end - if (this.trigger(world, entity, time)) { - this.status = Behavior.Status.RUNNING; -+ // Nabulus start - behavior tick rate and timings -+ this.lastRun = time; -+ this.timing.stopTiming(); -+ // Nabulus end - return true; - } else { -+ this.timing.stopTiming(); // Nabulus - behavior timings - return false; - } - } -diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/declarative/BehaviorBuilder.java b/src/main/java/net/minecraft/world/entity/ai/behavior/declarative/BehaviorBuilder.java -index 79326bab2c18aa8b488c8cb11c0dd18b1ea5e495..c1711ab106357c5d0663d76bbde73d2c889e066d 100644 ---- a/src/main/java/net/minecraft/world/entity/ai/behavior/declarative/BehaviorBuilder.java -+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/declarative/BehaviorBuilder.java -@@ -35,7 +35,15 @@ public class BehaviorBuilder implements App OneShot create(Function, ? extends App, Trigger>> creator) { - final BehaviorBuilder.TriggerWithResult> triggerWithResult = get((App, Trigger>)creator.apply(instance())); -- return new OneShot() { -+ // Nabulus start - configurable tick rates -+ java.lang.StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace(); -+ String callingClass = null; -+ if (stackTraceElements.length > 2) { -+ callingClass = stackTraceElements[2].getClassName(); -+ } -+ final String configKey = callingClass == null ? "unknown" : net.minecraft.world.entity.ai.behavior.Behavior.getConfigKey(callingClass); -+ // Nabulus end -+ return new OneShot(configKey) { // Nabulus - @Override - public boolean trigger(ServerLevel world, E entity, long time) { - Trigger trigger = triggerWithResult.tryTrigger(world, entity, time); diff --git a/patches/server/0009-Don-t-show-smoke-for-silent-fireworks.patch b/patches/server/0009-Don-t-show-smoke-for-silent-fireworks.patch deleted file mode 100644 index 8751c9f..0000000 --- a/patches/server/0009-Don-t-show-smoke-for-silent-fireworks.patch +++ /dev/null @@ -1,19 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: froobynooby -Date: Sat, 16 Dec 2023 15:18:46 +0930 -Subject: [PATCH] Don't show smoke for silent fireworks - - -diff --git a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java -index 09d465947a5720e05c350d455c86002682104079..7466eeb80f6db746a19a87abe070b8cdd8927859 100644 ---- a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java -+++ b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java -@@ -178,7 +178,7 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier { - } - - ++this.life; -- if (this.level().isClientSide && this.life % 2 < 2) { -+ if (this.level().isClientSide && this.life % 2 < 2 && !this.isSilent()) { // Nabulus - don't show firework smoke for silent fireworks - this.level().addParticle(ParticleTypes.FIREWORK, this.getX(), this.getY(), this.getZ(), this.random.nextGaussian() * 0.05D, -this.getDeltaMovement().y * 0.5D, this.random.nextGaussian() * 0.05D); - } - diff --git a/settings.gradle.kts b/settings.gradle.kts index 45e6a0f..f3d9851 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -1,10 +1,15 @@ pluginManagement { repositories { gradlePluginPortal() - maven("https://papermc.io/repo/repository/maven-public/") + mavenLocal() + maven("https://repo.papermc.io/repository/maven-public/") } } +plugins { + id("org.gradle.toolchains.foojay-resolver-convention") version "0.9.0" +} + rootProject.name = "nabulus" include("nabulus-api", "nabulus-server")