diff --git a/patches/server/0044-Gale-Optimize-world-generation-chunk-and-block-acces.patch b/patches/server/0044-Gale-Optimize-world-generation-chunk-and-block-acces.patch new file mode 100644 index 0000000..1ef32fd --- /dev/null +++ b/patches/server/0044-Gale-Optimize-world-generation-chunk-and-block-acces.patch @@ -0,0 +1,192 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrHua269 +Date: Fri, 9 Feb 2024 23:43:16 +0000 +Subject: [PATCH] Gale Optimize world generation chunk and block access + + +diff --git a/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java b/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java +new file mode 100644 +index 0000000000000000000000000000000000000000..f2f10b651e4fbecdd1ea1bc28ebf40d685a67cee +--- /dev/null ++++ b/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java +@@ -0,0 +1,95 @@ ++// Gale - Lithium - position utility ++ ++package me.jellysquid.mods.lithium.common.util; ++ ++import net.minecraft.core.SectionPos; ++import net.minecraft.world.level.LevelHeightAccessor; ++ ++public class Pos { ++ ++ public static class BlockCoord { ++ public static int getYSize(LevelHeightAccessor view) { ++ return view.getHeight(); ++ } ++ public static int getMinY(LevelHeightAccessor view) { ++ return view.getMinBuildHeight(); ++ } ++ public static int getMaxYInclusive(LevelHeightAccessor view) { ++ return view.getMaxBuildHeight() - 1; ++ } ++ public static int getMaxYExclusive(LevelHeightAccessor view) { ++ return view.getMaxBuildHeight(); ++ } ++ ++ public static int getMaxInSectionCoord(int sectionCoord) { ++ return 15 + getMinInSectionCoord(sectionCoord); ++ } ++ ++ public static int getMaxYInSectionIndex(LevelHeightAccessor view, int sectionIndex){ ++ return getMaxInSectionCoord(SectionYCoord.fromSectionIndex(view, sectionIndex)); ++ } ++ ++ public static int getMinInSectionCoord(int sectionCoord) { ++ return SectionPos.sectionToBlockCoord(sectionCoord); ++ } ++ ++ public static int getMinYInSectionIndex(LevelHeightAccessor view, int sectionIndex) { ++ return getMinInSectionCoord(SectionYCoord.fromSectionIndex(view, sectionIndex)); ++ } ++ } ++ ++ public static class ChunkCoord { ++ public static int fromBlockCoord(int blockCoord) { ++ return SectionPos.blockToSectionCoord(blockCoord); ++ } ++ ++ public static int fromBlockSize(int i) { ++ return i >> 4; //same method as fromBlockCoord, just be clear about coord/size semantic difference ++ } ++ } ++ ++ public static class SectionYCoord { ++ public static int getNumYSections(LevelHeightAccessor view) { ++ return view.getSectionsCount(); ++ } ++ public static int getMinYSection(LevelHeightAccessor view) { ++ return view.getMinSection(); ++ } ++ public static int getMaxYSectionInclusive(LevelHeightAccessor view) { ++ return view.getMaxSection() - 1; ++ } ++ public static int getMaxYSectionExclusive(LevelHeightAccessor view) { ++ return view.getMaxSection(); ++ } ++ ++ public static int fromSectionIndex(LevelHeightAccessor view, int sectionCoord) { ++ return sectionCoord + SectionYCoord.getMinYSection(view); ++ } ++ public static int fromBlockCoord(int blockCoord) { ++ return SectionPos.blockToSectionCoord(blockCoord); ++ } ++ } ++ ++ public static class SectionYIndex { ++ public static int getNumYSections(LevelHeightAccessor view) { ++ return view.getSectionsCount(); ++ } ++ public static int getMinYSectionIndex(LevelHeightAccessor view) { ++ return 0; ++ } ++ public static int getMaxYSectionIndexInclusive(LevelHeightAccessor view) { ++ return view.getSectionsCount() - 1; ++ } ++ public static int getMaxYSectionIndexExclusive(LevelHeightAccessor view) { ++ return view.getSectionsCount(); ++ } ++ ++ public static int fromSectionCoord(LevelHeightAccessor view, int sectionCoord) { ++ return sectionCoord - SectionYCoord.getMinYSection(view); ++ } ++ public static int fromBlockCoord(LevelHeightAccessor view, int blockCoord) { ++ return fromSectionCoord(view, SectionPos.blockToSectionCoord(blockCoord)); ++ } ++ } ++ ++} +diff --git a/src/main/java/net/minecraft/server/level/WorldGenRegion.java b/src/main/java/net/minecraft/server/level/WorldGenRegion.java +index 33c1ef45ed620f8424c2c83dd30b674892ddffe3..60db67956d8455d02c7b315cbdcb952206d776db 100644 +--- a/src/main/java/net/minecraft/server/level/WorldGenRegion.java ++++ b/src/main/java/net/minecraft/server/level/WorldGenRegion.java +@@ -8,6 +8,7 @@ import java.util.concurrent.atomic.AtomicLong; + import java.util.function.Predicate; + import java.util.function.Supplier; + import javax.annotation.Nullable; ++ + import net.minecraft.Util; + import net.minecraft.core.BlockPos; + import net.minecraft.core.Direction; +@@ -83,6 +84,10 @@ public class WorldGenRegion implements WorldGenLevel { + private Supplier currentlyGenerating; + private final AtomicLong subTickCount = new AtomicLong(); + private static final ResourceLocation WORLDGEN_REGION_RANDOM = new ResourceLocation("worldgen_region_random"); ++ // Gale start - Lithium - optimize world generation chunk and block access ++ private ChunkAccess[] chunksArr; ++ private int minChunkX, minChunkZ; ++ // Gale end - Lithium - optimize world generation chunk and block access + + // Folia start - region threading + @Override +@@ -112,6 +117,11 @@ public class WorldGenRegion implements WorldGenLevel { + this.lastPos = ((ChunkAccess) chunks.get(chunks.size() - 1)).getPos(); + this.structureManager = world.structureManager().forWorldGenRegion(this); + } ++ // Gale start - Lithium - optimize world generation chunk and block access ++ this.minChunkX = this.firstPos.x; ++ this.minChunkZ = this.firstPos.z; ++ this.chunksArr = chunks.toArray(new ChunkAccess[0]); ++ // Gale end - Lithium - optimize world generation chunk and block access + } + + // Paper start - starlight +@@ -150,9 +160,29 @@ public class WorldGenRegion implements WorldGenLevel { + + @Override + public ChunkAccess getChunk(int chunkX, int chunkZ) { +- return this.getChunk(chunkX, chunkZ, ChunkStatus.EMPTY); ++ // Gale start - Lithium - optimize world generation chunk and block access - use the chunk array for faster access ++ int x = chunkX - this.minChunkX; ++ int z = chunkZ - this.minChunkZ; ++ int w = this.size; ++ ++ if (x >= 0 && z >= 0 && x < w && z < w) { ++ return this.chunksArr[x + z * w]; ++ } else { ++ throw new NullPointerException("No chunk exists at " + new ChunkPos(chunkX, chunkZ)); ++ } ++ // Gale end - Lithium - optimize world generation chunk and block access - use the chunk array for faster access + } + ++ // Gale start - Lithium - optimize world generation chunk and block access ++ /** ++ * Use our chunk fetch function ++ */ ++ public ChunkAccess getChunk(BlockPos pos) { ++ // Skip checking chunk.getStatus().isAtLeast(ChunkStatus.EMPTY) here, because it is always true ++ return this.getChunk(SectionPos.blockToSectionCoord(pos.getX()), SectionPos.blockToSectionCoord(pos.getZ())); ++ } ++ // Gale end - Lithium - optimize world generation chunk and block access ++ + @Nullable + @Override + public ChunkAccess getChunk(int chunkX, int chunkZ, ChunkStatus leastStatus, boolean create) { +@@ -210,7 +240,17 @@ public class WorldGenRegion implements WorldGenLevel { + + @Override + public BlockState getBlockState(BlockPos pos) { +- return this.getChunk(SectionPos.blockToSectionCoord(pos.getX()), SectionPos.blockToSectionCoord(pos.getZ())).getBlockState(pos); ++ // Gale start - Lithium - optimize world generation chunk and block access - avoid pointer de-referencing, make method easier to inline ++ int x = SectionPos.blockToSectionCoord(pos.getX()) - this.minChunkX; ++ int z = SectionPos.blockToSectionCoord(pos.getZ()) - this.minChunkZ; ++ int w = this.size; ++ ++ if (x >= 0 && z >= 0 && x < w && z < w) { ++ return this.chunksArr[x + z * w].getBlockState(pos); ++ } else { ++ throw new NullPointerException("No chunk exists at " + new ChunkPos(pos)); ++ } ++ // Gale end - Lithium - optimize world generation chunk and block access - avoid pointer de-referencing, make method easier to inline + } + + @Override diff --git a/patches/server/0045-Gale-Optimize-noise-generation.patch b/patches/server/0045-Gale-Optimize-noise-generation.patch new file mode 100644 index 0000000..626843e --- /dev/null +++ b/patches/server/0045-Gale-Optimize-noise-generation.patch @@ -0,0 +1,239 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrHua269 +Date: Fri, 9 Feb 2024 23:44:23 +0000 +Subject: [PATCH] Gale Optimize noise generation + + +diff --git a/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java b/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java +index fb84d703b4461343d50510d7c9be32fc1f09ed22..93a11c95f96f975fafe03e77a2caace57675d130 100644 +--- a/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java ++++ b/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java +@@ -11,6 +11,27 @@ public final class ImprovedNoise { + public final double yo; + public final double zo; + ++ // Gale start - C2ME - optimize noise generation ++ private static final double[] FLAT_SIMPLEX_GRAD = new double[]{ ++ 1, 1, 0, 0, ++ -1, 1, 0, 0, ++ 1, -1, 0, 0, ++ -1, -1, 0, 0, ++ 1, 0, 1, 0, ++ -1, 0, 1, 0, ++ 1, 0, -1, 0, ++ -1, 0, -1, 0, ++ 0, 1, 1, 0, ++ 0, -1, 1, 0, ++ 0, 1, -1, 0, ++ 0, -1, -1, 0, ++ 1, 1, 0, 0, ++ 0, -1, 1, 0, ++ -1, 1, 0, 0, ++ 0, -1, -1, 0, ++ }; ++ // Gale end - C2ME - optimize noise generation ++ + public ImprovedNoise(RandomSource random) { + this.xo = random.nextDouble() * 256.0D; + this.yo = random.nextDouble() * 256.0D; +@@ -40,12 +61,14 @@ public final class ImprovedNoise { + double d = x + this.xo; + double e = y + this.yo; + double f = z + this.zo; +- int i = Mth.floor(d); +- int j = Mth.floor(e); +- int k = Mth.floor(f); +- double g = d - (double)i; +- double h = e - (double)j; +- double l = f - (double)k; ++ // Gale start - C2ME - optimize noise generation - optimize: remove frequent type conversions ++ double i = Math.floor(d); ++ double j = Math.floor(e); ++ double k = Math.floor(f); ++ double g = d - i; ++ double h = e - j; ++ double l = f - k; ++ // Gale end - C2ME - optimize noise generation - optimize: remove frequent type conversions + double o; + if (yScale != 0.0D) { + double m; +@@ -55,25 +78,27 @@ public final class ImprovedNoise { + m = h; + } + +- o = (double)Mth.floor(m / yScale + (double)1.0E-7F) * yScale; ++ o = Math.floor(m / yScale + (double)1.0E-7F) * yScale; // Gale - C2ME - optimize noise generation - optimize: remove frequent type conversions + } else { + o = 0.0D; + } + +- return this.sampleAndLerp(i, j, k, g, h - o, l, h); ++ return this.sampleAndLerp((int) i, (int) j, (int) k, g, h - o, l, h); // Gale - C2ME - optimize noise generation - optimize: remove frequent type conversions + } + + public double noiseWithDerivative(double x, double y, double z, double[] ds) { + double d = x + this.xo; + double e = y + this.yo; + double f = z + this.zo; +- int i = Mth.floor(d); +- int j = Mth.floor(e); +- int k = Mth.floor(f); +- double g = d - (double)i; +- double h = e - (double)j; +- double l = f - (double)k; +- return this.sampleWithDerivative(i, j, k, g, h, l, ds); ++ // Gale start - C2ME - optimize noise generation - optimize: remove frequent type conversions ++ double i = Math.floor(d); ++ double j = Math.floor(e); ++ double k = Math.floor(f); ++ double g = d - i; ++ double h = e - j; ++ double l = f - k; ++ return this.sampleWithDerivative((int) i, (int) j, (int) k, g, h, l, ds); ++ // Gale end - C2ME - optimize noise generation - optimize: remove frequent type conversions + } + + private static double gradDot(int hash, double x, double y, double z) { +@@ -85,24 +110,69 @@ public final class ImprovedNoise { + } + + private double sampleAndLerp(int sectionX, int sectionY, int sectionZ, double localX, double localY, double localZ, double fadeLocalY) { +- int i = this.p(sectionX); +- int j = this.p(sectionX + 1); +- int k = this.p(i + sectionY); +- int l = this.p(i + sectionY + 1); +- int m = this.p(j + sectionY); +- int n = this.p(j + sectionY + 1); +- double d = gradDot(this.p(k + sectionZ), localX, localY, localZ); +- double e = gradDot(this.p(m + sectionZ), localX - 1.0D, localY, localZ); +- double f = gradDot(this.p(l + sectionZ), localX, localY - 1.0D, localZ); +- double g = gradDot(this.p(n + sectionZ), localX - 1.0D, localY - 1.0D, localZ); +- double h = gradDot(this.p(k + sectionZ + 1), localX, localY, localZ - 1.0D); +- double o = gradDot(this.p(m + sectionZ + 1), localX - 1.0D, localY, localZ - 1.0D); +- double p = gradDot(this.p(l + sectionZ + 1), localX, localY - 1.0D, localZ - 1.0D); +- double q = gradDot(this.p(n + sectionZ + 1), localX - 1.0D, localY - 1.0D, localZ - 1.0D); +- double r = Mth.smoothstep(localX); +- double s = Mth.smoothstep(fadeLocalY); +- double t = Mth.smoothstep(localZ); +- return Mth.lerp3(r, s, t, d, e, f, g, h, o, p, q); ++ // Gale start - C2ME - optimize noise generation - inline math & small optimization: remove frequent type conversions and redundant ops ++ final int var0 = sectionX & 0xFF; ++ final int var1 = (sectionX + 1) & 0xFF; ++ final int var2 = this.p[var0] & 0xFF; ++ final int var3 = this.p[var1] & 0xFF; ++ final int var4 = (var2 + sectionY) & 0xFF; ++ final int var5 = (var3 + sectionY) & 0xFF; ++ final int var6 = (var2 + sectionY + 1) & 0xFF; ++ final int var7 = (var3 + sectionY + 1) & 0xFF; ++ final int var8 = this.p[var4] & 0xFF; ++ final int var9 = this.p[var5] & 0xFF; ++ final int var10 = this.p[var6] & 0xFF; ++ final int var11 = this.p[var7] & 0xFF; ++ ++ final int var12 = (var8 + sectionZ) & 0xFF; ++ final int var13 = (var9 + sectionZ) & 0xFF; ++ final int var14 = (var10 + sectionZ) & 0xFF; ++ final int var15 = (var11 + sectionZ) & 0xFF; ++ final int var16 = (var8 + sectionZ + 1) & 0xFF; ++ final int var17 = (var9 + sectionZ + 1) & 0xFF; ++ final int var18 = (var10 + sectionZ + 1) & 0xFF; ++ final int var19 = (var11 + sectionZ + 1) & 0xFF; ++ final int var20 = (this.p[var12] & 15) << 2; ++ final int var21 = (this.p[var13] & 15) << 2; ++ final int var22 = (this.p[var14] & 15) << 2; ++ final int var23 = (this.p[var15] & 15) << 2; ++ final int var24 = (this.p[var16] & 15) << 2; ++ final int var25 = (this.p[var17] & 15) << 2; ++ final int var26 = (this.p[var18] & 15) << 2; ++ final int var27 = (this.p[var19] & 15) << 2; ++ final double var60 = localX - 1.0; ++ final double var61 = localY - 1.0; ++ final double var62 = localZ - 1.0; ++ final double var87 = FLAT_SIMPLEX_GRAD[(var20) | 0] * localX + FLAT_SIMPLEX_GRAD[(var20) | 1] * localY + FLAT_SIMPLEX_GRAD[(var20) | 2] * localZ; ++ final double var88 = FLAT_SIMPLEX_GRAD[(var21) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var21) | 1] * localY + FLAT_SIMPLEX_GRAD[(var21) | 2] * localZ; ++ final double var89 = FLAT_SIMPLEX_GRAD[(var22) | 0] * localX + FLAT_SIMPLEX_GRAD[(var22) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var22) | 2] * localZ; ++ final double var90 = FLAT_SIMPLEX_GRAD[(var23) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var23) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var23) | 2] * localZ; ++ final double var91 = FLAT_SIMPLEX_GRAD[(var24) | 0] * localX + FLAT_SIMPLEX_GRAD[(var24) | 1] * localY + FLAT_SIMPLEX_GRAD[(var24) | 2] * var62; ++ final double var92 = FLAT_SIMPLEX_GRAD[(var25) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var25) | 1] * localY + FLAT_SIMPLEX_GRAD[(var25) | 2] * var62; ++ final double var93 = FLAT_SIMPLEX_GRAD[(var26) | 0] * localX + FLAT_SIMPLEX_GRAD[(var26) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var26) | 2] * var62; ++ final double var94 = FLAT_SIMPLEX_GRAD[(var27) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var27) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var27) | 2] * var62; ++ ++ final double var95 = localX * 6.0 - 15.0; ++ final double var96 = fadeLocalY * 6.0 - 15.0; ++ final double var97 = localZ * 6.0 - 15.0; ++ final double var98 = localX * var95 + 10.0; ++ final double var99 = fadeLocalY * var96 + 10.0; ++ final double var100 = localZ * var97 + 10.0; ++ final double var101 = localX * localX * localX * var98; ++ final double var102 = fadeLocalY * fadeLocalY * fadeLocalY * var99; ++ final double var103 = localZ * localZ * localZ * var100; ++ ++ final double var113 = var87 + var101 * (var88 - var87); ++ final double var114 = var93 + var101 * (var94 - var93); ++ final double var115 = var91 + var101 * (var92 - var91); ++ final double var116 = var89 + var101 * (var90 - var89); ++ final double var117 = var114 - var115; ++ final double var118 = var102 * (var116 - var113); ++ final double var119 = var102 * var117; ++ final double var120 = var113 + var118; ++ final double var121 = var115 + var119; ++ return var120 + (var103 * (var121 - var120)); ++ // Gale end - C2ME - optimize noise generation - inline math & small optimization: remove frequent type conversions and redundant ops + } + + private double sampleWithDerivative(int sectionX, int sectionY, int sectionZ, double localX, double localY, double localZ, double[] ds) { +diff --git a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java +index 97ef7288ea935f3d17c5b7a9eba642143c786c2b..6d084145f8529fa8b0439123f9a9812940cc62da 100644 +--- a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java ++++ b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java +@@ -26,6 +26,10 @@ public class PerlinNoise { + private final double lowestFreqValueFactor; + private final double lowestFreqInputFactor; + private final double maxValue; ++ // Gale start - C2ME - optimize noise generation ++ private final int octaveSamplersCount; ++ private final double [] amplitudesArray; ++ // Gale end - C2ME - optimize noise generation + + /** @deprecated */ + @Deprecated +@@ -131,6 +135,10 @@ public class PerlinNoise { + this.lowestFreqInputFactor = Math.pow(2.0D, (double)(-j)); + this.lowestFreqValueFactor = Math.pow(2.0D, (double)(i - 1)) / (Math.pow(2.0D, (double)i) - 1.0D); + this.maxValue = this.edgeValue(2.0D); ++ // Gale start - C2ME - optimize noise generation ++ this.octaveSamplersCount = this.noiseLevels.length; ++ this.amplitudesArray = this.amplitudes.toDoubleArray(); ++ // Gale end - C2ME - optimize noise generation + } + + protected double maxValue() { +@@ -142,7 +150,27 @@ public class PerlinNoise { + } + + public double getValue(double x, double y, double z) { +- return this.getValue(x, y, z, 0.0D, 0.0D, false); ++ // Gale start - C2ME - optimize noise generation - optimize for common cases ++ double d = 0.0; ++ double e = this.lowestFreqInputFactor; ++ double f = this.lowestFreqValueFactor; ++ ++ for(int i = 0; i < this.octaveSamplersCount; ++i) { ++ ImprovedNoise perlinNoiseSampler = this.noiseLevels[i]; ++ if (perlinNoiseSampler != null) { ++ @SuppressWarnings("deprecation") ++ double g = perlinNoiseSampler.noise( ++ wrap(x * e), wrap(y * e), wrap(z * e), 0.0, 0.0 ++ ); ++ d += this.amplitudesArray[i] * g * f; ++ } ++ ++ e *= 2.0; ++ f /= 2.0; ++ } ++ ++ return d; ++ // Gale end - C2ME - optimize noise generation - optimize for common cases + } + + /** @deprecated */ diff --git a/patches/server/0044-LinearPaper-Remove-all-locks-on-region-files.patch b/patches/server/0046-LinearPaper-Remove-all-locks-on-region-files.patch similarity index 100% rename from patches/server/0044-LinearPaper-Remove-all-locks-on-region-files.patch rename to patches/server/0046-LinearPaper-Remove-all-locks-on-region-files.patch diff --git a/patches/server/0045-Sparkly-Paper-Optimize-canSee-checks.patch b/patches/server/0047-Sparkly-Paper-Optimize-canSee-checks.patch similarity index 100% rename from patches/server/0045-Sparkly-Paper-Optimize-canSee-checks.patch rename to patches/server/0047-Sparkly-Paper-Optimize-canSee-checks.patch diff --git a/patches/server/0046-Purpur-use-alternative-keep-alive.patch b/patches/server/0048-Purpur-use-alternative-keep-alive.patch similarity index 100% rename from patches/server/0046-Purpur-use-alternative-keep-alive.patch rename to patches/server/0048-Purpur-use-alternative-keep-alive.patch diff --git a/patches/server/0047-Leaves-Protocol-Core.patch b/patches/server/0049-Leaves-Protocol-Core.patch similarity index 100% rename from patches/server/0047-Leaves-Protocol-Core.patch rename to patches/server/0049-Leaves-Protocol-Core.patch diff --git a/patches/server/0048-Leaves-Bladeren-Protocol.patch b/patches/server/0050-Leaves-Bladeren-Protocol.patch similarity index 100% rename from patches/server/0048-Leaves-Bladeren-Protocol.patch rename to patches/server/0050-Leaves-Bladeren-Protocol.patch diff --git a/patches/server/0049-Leaves-Fix-Bladeren-Protocol.patch b/patches/server/0051-Leaves-Fix-Bladeren-Protocol.patch similarity index 100% rename from patches/server/0049-Leaves-Fix-Bladeren-Protocol.patch rename to patches/server/0051-Leaves-Fix-Bladeren-Protocol.patch diff --git a/patches/server/0050-Leaves-carpet-protocol-support.patch b/patches/server/0052-Leaves-carpet-protocol-support.patch similarity index 100% rename from patches/server/0050-Leaves-carpet-protocol-support.patch rename to patches/server/0052-Leaves-carpet-protocol-support.patch diff --git a/patches/server/0051-Threaded-region-start-tick-and-finished-tick-event.patch b/patches/server/0053-Threaded-region-start-tick-and-finished-tick-event.patch similarity index 100% rename from patches/server/0051-Threaded-region-start-tick-and-finished-tick-event.patch rename to patches/server/0053-Threaded-region-start-tick-and-finished-tick-event.patch