diff --git a/paper-server/patches/features/0001-Add-PaperHooks.patch b/paper-server/patches/features/0001-Add-PaperHooks.patch new file mode 100644 index 0000000000..db8dd7f311 --- /dev/null +++ b/paper-server/patches/features/0001-Add-PaperHooks.patch @@ -0,0 +1,252 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Spottedleaf +Date: Mon, 16 Dec 2024 09:03:35 -0800 +Subject: [PATCH] Add PaperHooks + + +diff --git a/ca/spottedleaf/moonrise/paper/PaperHooks.java b/ca/spottedleaf/moonrise/paper/PaperHooks.java +new file mode 100644 +index 0000000000000000000000000000000000000000..834c5ce238c7adb0164a6282582d709348ef96cc +--- /dev/null ++++ b/ca/spottedleaf/moonrise/paper/PaperHooks.java +@@ -0,0 +1,240 @@ ++package ca.spottedleaf.moonrise.paper; ++ ++import ca.spottedleaf.moonrise.common.PlatformHooks; ++import com.mojang.datafixers.DSL; ++import com.mojang.datafixers.DataFixer; ++import com.mojang.serialization.Dynamic; ++import java.util.Collection; ++import net.minecraft.core.BlockPos; ++import net.minecraft.nbt.CompoundTag; ++import net.minecraft.nbt.NbtOps; ++import net.minecraft.server.level.ChunkHolder; ++import net.minecraft.server.level.GenerationChunkHolder; ++import net.minecraft.server.level.ServerLevel; ++import net.minecraft.server.level.ServerPlayer; ++import net.minecraft.world.entity.Entity; ++import net.minecraft.world.entity.boss.EnderDragonPart; ++import net.minecraft.world.level.BlockGetter; ++import net.minecraft.world.level.ChunkPos; ++import net.minecraft.world.level.Level; ++import net.minecraft.world.level.block.state.BlockState; ++import net.minecraft.world.level.chunk.ChunkAccess; ++import net.minecraft.world.level.chunk.LevelChunk; ++import net.minecraft.world.level.chunk.ProtoChunk; ++import net.minecraft.world.level.chunk.storage.SerializableChunkData; ++import net.minecraft.world.level.entity.EntityTypeTest; ++import net.minecraft.world.phys.AABB; ++import java.util.List; ++import java.util.function.Predicate; ++ ++public final class PaperHooks implements PlatformHooks { ++ ++ @Override ++ public String getBrand() { ++ return "Paper"; ++ } ++ ++ @Override ++ public int getLightEmission(final BlockState blockState, final BlockGetter world, final BlockPos pos) { ++ return blockState.getLightEmission(); ++ } ++ ++ @Override ++ public Predicate maybeHasLightEmission() { ++ return (final BlockState state) -> { ++ return state.getLightEmission() != 0; ++ }; ++ } ++ ++ @Override ++ public boolean hasCurrentlyLoadingChunk() { ++ return false; ++ } ++ ++ @Override ++ public LevelChunk getCurrentlyLoadingChunk(final GenerationChunkHolder holder) { ++ return null; ++ } ++ ++ @Override ++ public void setCurrentlyLoading(final GenerationChunkHolder holder, final LevelChunk levelChunk) { ++ ++ } ++ ++ @Override ++ public void chunkFullStatusComplete(final LevelChunk newChunk, final ProtoChunk original) { ++ ++ } ++ ++ @Override ++ public boolean allowAsyncTicketUpdates() { ++ return true; ++ } ++ ++ @Override ++ public void onChunkHolderTicketChange(final ServerLevel world, final ChunkHolder holder, final int oldLevel, final int newLevel) { ++ ++ } ++ ++ @Override ++ public void chunkUnloadFromWorld(final LevelChunk chunk) { ++ ++ } ++ ++ @Override ++ public void chunkSyncSave(final ServerLevel world, final ChunkAccess chunk, final SerializableChunkData data) { ++ ++ } ++ ++ @Override ++ public void onChunkWatch(final ServerLevel world, final LevelChunk chunk, final ServerPlayer player) { ++ ++ } ++ ++ @Override ++ public void onChunkUnWatch(final ServerLevel world, final ChunkPos chunk, final ServerPlayer player) { ++ ++ } ++ ++ @Override ++ public void addToGetEntities(final Level world, final Entity entity, final AABB boundingBox, final Predicate predicate, final List into) { ++ final Collection parts = world.dragonParts(); ++ if (parts.isEmpty()) { ++ return; ++ } ++ ++ for (final EnderDragonPart part : parts) { ++ if (part != entity && part.getBoundingBox().intersects(boundingBox) && (predicate == null || predicate.test(part))) { ++ into.add(part); ++ } ++ } ++ } ++ ++ @Override ++ public void addToGetEntities(final Level world, final EntityTypeTest entityTypeTest, final AABB boundingBox, final Predicate predicate, final List into, final int maxCount) { ++ if (into.size() >= maxCount) { ++ // fix neoforge issue: do not add if list is already full ++ return; ++ } ++ ++ final Collection parts = world.dragonParts(); ++ if (parts.isEmpty()) { ++ return; ++ } ++ for (final EnderDragonPart part : parts) { ++ if (!part.getBoundingBox().intersects(boundingBox)) { ++ continue; ++ } ++ final T casted = (T)entityTypeTest.tryCast(part); ++ if (casted != null && (predicate == null || predicate.test(casted))) { ++ into.add(casted); ++ if (into.size() >= maxCount) { ++ break; ++ } ++ } ++ } ++ } ++ ++ @Override ++ public void entityMove(final Entity entity, final long oldSection, final long newSection) { ++ ++ } ++ ++ @Override ++ public boolean screenEntity(final ServerLevel world, final Entity entity, final boolean fromDisk, final boolean event) { ++ return true; ++ } ++ ++ @Override ++ public boolean configFixMC224294() { ++ return true; ++ } ++ ++ @Override ++ public boolean configAutoConfigSendDistance() { ++ return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.autoConfigSendDistance; ++ } ++ ++ @Override ++ public double configPlayerMaxLoadRate() { ++ return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkLoadRate; ++ } ++ ++ @Override ++ public double configPlayerMaxGenRate() { ++ return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkGenerateRate; ++ } ++ ++ @Override ++ public double configPlayerMaxSendRate() { ++ return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkSendRate; ++ } ++ ++ @Override ++ public int configPlayerMaxConcurrentLoads() { ++ return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.playerMaxConcurrentChunkLoads; ++ } ++ ++ @Override ++ public int configPlayerMaxConcurrentGens() { ++ return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.playerMaxConcurrentChunkGenerates; ++ } ++ ++ @Override ++ public long configAutoSaveInterval(final ServerLevel world) { ++ return world.paperConfig().chunks.autoSaveInterval.value(); ++ } ++ ++ @Override ++ public int configMaxAutoSavePerTick(final ServerLevel world) { ++ return world.paperConfig().chunks.maxAutoSaveChunksPerTick; ++ } ++ ++ @Override ++ public boolean configFixMC159283() { ++ return true; ++ } ++ ++ @Override ++ public boolean forceNoSave(final ChunkAccess chunk) { ++ return chunk instanceof LevelChunk levelChunk && levelChunk.mustNotSave; ++ } ++ ++ @Override ++ public CompoundTag convertNBT(final DSL.TypeReference type, final DataFixer dataFixer, final CompoundTag nbt, ++ final int fromVersion, final int toVersion) { ++ return (CompoundTag)dataFixer.update( ++ type, new Dynamic<>(NbtOps.INSTANCE, nbt), fromVersion, toVersion ++ ).getValue(); ++ } ++ ++ @Override ++ public boolean hasMainChunkLoadHook() { ++ return false; ++ } ++ ++ @Override ++ public void mainChunkLoad(final ChunkAccess chunk, final SerializableChunkData chunkData) { ++ ++ } ++ ++ @Override ++ public List modifySavedEntities(final ServerLevel world, final int chunkX, final int chunkZ, final List entities) { ++ return entities; ++ } ++ ++ @Override ++ public void unloadEntity(final Entity entity) { ++ entity.setRemoved(Entity.RemovalReason.UNLOADED_TO_CHUNK, org.bukkit.event.entity.EntityRemoveEvent.Cause.UNLOAD); ++ } ++ ++ @Override ++ public void postLoadProtoChunk(final ServerLevel world, final ProtoChunk chunk) { ++ net.minecraft.world.level.chunk.status.ChunkStatusTasks.postLoadProtoChunk(world, chunk.getEntities()); ++ } ++ ++ @Override ++ public int modifyEntityTrackingRange(final Entity entity, final int currentRange) { ++ return org.spigotmc.TrackingRange.getEntityTrackingRange(entity, currentRange); ++ } ++} diff --git a/paper-server/patches/features/0001-Optimize-isInWorldBounds-and-getBlockState-for-inlin.patch b/paper-server/patches/features/0002-Optimize-isInWorldBounds-and-getBlockState-for-inlin.patch similarity index 100% rename from paper-server/patches/features/0001-Optimize-isInWorldBounds-and-getBlockState-for-inlin.patch rename to paper-server/patches/features/0002-Optimize-isInWorldBounds-and-getBlockState-for-inlin.patch diff --git a/paper-server/patches/features/0002-Improve-Maps-in-item-frames-performance-and-bug-fixe.patch b/paper-server/patches/features/0003-Improve-Maps-in-item-frames-performance-and-bug-fixe.patch similarity index 100% rename from paper-server/patches/features/0002-Improve-Maps-in-item-frames-performance-and-bug-fixe.patch rename to paper-server/patches/features/0003-Improve-Maps-in-item-frames-performance-and-bug-fixe.patch diff --git a/paper-server/patches/features/0003-Optimize-Network-Manager-and-add-advanced-packet-sup.patch b/paper-server/patches/features/0004-Optimize-Network-Manager-and-add-advanced-packet-sup.patch similarity index 100% rename from paper-server/patches/features/0003-Optimize-Network-Manager-and-add-advanced-packet-sup.patch rename to paper-server/patches/features/0004-Optimize-Network-Manager-and-add-advanced-packet-sup.patch diff --git a/paper-server/patches/features/0004-Allow-Saving-of-Oversized-Chunks.patch b/paper-server/patches/features/0005-Allow-Saving-of-Oversized-Chunks.patch similarity index 100% rename from paper-server/patches/features/0004-Allow-Saving-of-Oversized-Chunks.patch rename to paper-server/patches/features/0005-Allow-Saving-of-Oversized-Chunks.patch diff --git a/paper-server/patches/features/0005-Entity-Activation-Range-2.0.patch b/paper-server/patches/features/0006-Entity-Activation-Range-2.0.patch similarity index 100% rename from paper-server/patches/features/0005-Entity-Activation-Range-2.0.patch rename to paper-server/patches/features/0006-Entity-Activation-Range-2.0.patch diff --git a/paper-server/patches/features/0006-Anti-Xray.patch b/paper-server/patches/features/0007-Anti-Xray.patch similarity index 100% rename from paper-server/patches/features/0006-Anti-Xray.patch rename to paper-server/patches/features/0007-Anti-Xray.patch diff --git a/paper-server/patches/features/0007-Use-Velocity-compression-and-cipher-natives.patch b/paper-server/patches/features/0008-Use-Velocity-compression-and-cipher-natives.patch similarity index 100% rename from paper-server/patches/features/0007-Use-Velocity-compression-and-cipher-natives.patch rename to paper-server/patches/features/0008-Use-Velocity-compression-and-cipher-natives.patch diff --git a/paper-server/patches/features/0008-Optimize-Collision-to-not-load-chunks.patch b/paper-server/patches/features/0009-Optimize-Collision-to-not-load-chunks.patch similarity index 100% rename from paper-server/patches/features/0008-Optimize-Collision-to-not-load-chunks.patch rename to paper-server/patches/features/0009-Optimize-Collision-to-not-load-chunks.patch diff --git a/paper-server/patches/features/0009-Optimize-GoalSelector-Goal.Flag-Set-operations.patch b/paper-server/patches/features/0010-Optimize-GoalSelector-Goal.Flag-Set-operations.patch similarity index 100% rename from paper-server/patches/features/0009-Optimize-GoalSelector-Goal.Flag-Set-operations.patch rename to paper-server/patches/features/0010-Optimize-GoalSelector-Goal.Flag-Set-operations.patch diff --git a/paper-server/patches/features/0010-Optimize-Voxel-Shape-Merging.patch b/paper-server/patches/features/0011-Optimize-Voxel-Shape-Merging.patch similarity index 100% rename from paper-server/patches/features/0010-Optimize-Voxel-Shape-Merging.patch rename to paper-server/patches/features/0011-Optimize-Voxel-Shape-Merging.patch diff --git a/paper-server/patches/features/0011-Fix-entity-type-tags-suggestions-in-selectors.patch b/paper-server/patches/features/0012-Fix-entity-type-tags-suggestions-in-selectors.patch similarity index 100% rename from paper-server/patches/features/0011-Fix-entity-type-tags-suggestions-in-selectors.patch rename to paper-server/patches/features/0012-Fix-entity-type-tags-suggestions-in-selectors.patch diff --git a/paper-server/patches/features/0012-Handle-Oversized-block-entities-in-chunks.patch b/paper-server/patches/features/0013-Handle-Oversized-block-entities-in-chunks.patch similarity index 97% rename from paper-server/patches/features/0012-Handle-Oversized-block-entities-in-chunks.patch rename to paper-server/patches/features/0013-Handle-Oversized-block-entities-in-chunks.patch index 3d61143e0e..3ae9000bc3 100644 --- a/paper-server/patches/features/0012-Handle-Oversized-block-entities-in-chunks.patch +++ b/paper-server/patches/features/0013-Handle-Oversized-block-entities-in-chunks.patch @@ -47,7 +47,7 @@ index 3aea76690bc3e35758d3bf274777130af17d8a0f..9e321ef1c3d5803519b243685f4ee598 } } diff --git a/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java b/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java -index d2d21fe8d7275b01454e09be252d7dd7710cdc2d..5eef540242413df3ed136aa8837866a94cc285b3 100644 +index 5699bc15eba92e22433a20cb8326b59f2ebd3036..8578d1f78ddd1bb75f3230f04bfaa35af9f5f822 100644 --- a/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java +++ b/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java @@ -84,4 +84,11 @@ public class ClientboundLevelChunkWithLightPacket implements Packet MapType createEmptyMap(); + +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/types/Types.java b/src/main/java/ca/spottedleaf/dataconverter/types/Types.java +diff --git a/ca/spottedleaf/dataconverter/types/Types.java b/ca/spottedleaf/dataconverter/types/Types.java new file mode 100644 index 0000000000000000000000000000000000000000..2ab9e3b579f20c9a189518496c522155630a36c4 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/types/Types.java ++++ b/ca/spottedleaf/dataconverter/types/Types.java @@ -0,0 +1,15 @@ +package ca.spottedleaf.dataconverter.types; + @@ -27402,11 +27402,11 @@ index 0000000000000000000000000000000000000000..2ab9e3b579f20c9a189518496c522155 + // why does this exist + public static final TypeUtil JSON_COMPRESSED = new JsonTypeCompressedUtil(); +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonListType.java b/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonListType.java +diff --git a/ca/spottedleaf/dataconverter/types/json/JsonListType.java b/ca/spottedleaf/dataconverter/types/json/JsonListType.java new file mode 100644 index 0000000000000000000000000000000000000000..f6f57cb3a215876976b5eecae810b8b20925f2e2 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonListType.java ++++ b/ca/spottedleaf/dataconverter/types/json/JsonListType.java @@ -0,0 +1,415 @@ +package ca.spottedleaf.dataconverter.types.json; + @@ -27823,11 +27823,11 @@ index 0000000000000000000000000000000000000000..f6f57cb3a215876976b5eecae810b8b2 + throw new UnsupportedOperationException(); + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonMapType.java b/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonMapType.java +diff --git a/ca/spottedleaf/dataconverter/types/json/JsonMapType.java b/ca/spottedleaf/dataconverter/types/json/JsonMapType.java new file mode 100644 index 0000000000000000000000000000000000000000..b6ad4623894454675f4be52ecdb4655d6623b385 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonMapType.java ++++ b/ca/spottedleaf/dataconverter/types/json/JsonMapType.java @@ -0,0 +1,474 @@ +package ca.spottedleaf.dataconverter.types.json; + @@ -28303,11 +28303,11 @@ index 0000000000000000000000000000000000000000..b6ad4623894454675f4be52ecdb4655d + this.map.addProperty(key, val); + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonTypeCompressedUtil.java b/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonTypeCompressedUtil.java +diff --git a/ca/spottedleaf/dataconverter/types/json/JsonTypeCompressedUtil.java b/ca/spottedleaf/dataconverter/types/json/JsonTypeCompressedUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..9c3093b66b847b5248bde923243fce78842bf67f --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonTypeCompressedUtil.java ++++ b/ca/spottedleaf/dataconverter/types/json/JsonTypeCompressedUtil.java @@ -0,0 +1,18 @@ +package ca.spottedleaf.dataconverter.types.json; + @@ -28327,11 +28327,11 @@ index 0000000000000000000000000000000000000000..9c3093b66b847b5248bde923243fce78 + return new JsonMapType(true); + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonTypeUtil.java b/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonTypeUtil.java +diff --git a/ca/spottedleaf/dataconverter/types/json/JsonTypeUtil.java b/ca/spottedleaf/dataconverter/types/json/JsonTypeUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..9410ae68395a09c7710bdbb2ccc6acf6633cad23 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/types/json/JsonTypeUtil.java ++++ b/ca/spottedleaf/dataconverter/types/json/JsonTypeUtil.java @@ -0,0 +1,81 @@ +package ca.spottedleaf.dataconverter.types.json; + @@ -28414,11 +28414,11 @@ index 0000000000000000000000000000000000000000..9410ae68395a09c7710bdbb2ccc6acf6 + return ret; + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTListType.java b/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTListType.java +diff --git a/ca/spottedleaf/dataconverter/types/nbt/NBTListType.java b/ca/spottedleaf/dataconverter/types/nbt/NBTListType.java new file mode 100644 index 0000000000000000000000000000000000000000..bf4e9ea17222cfa8f7cee9e46775302c9c2e6328 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTListType.java ++++ b/ca/spottedleaf/dataconverter/types/nbt/NBTListType.java @@ -0,0 +1,440 @@ +package ca.spottedleaf.dataconverter.types.nbt; + @@ -28860,11 +28860,11 @@ index 0000000000000000000000000000000000000000..bf4e9ea17222cfa8f7cee9e46775302c + this.list.add(index, StringTag.valueOf(string)); + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTMapType.java b/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTMapType.java +diff --git a/ca/spottedleaf/dataconverter/types/nbt/NBTMapType.java b/ca/spottedleaf/dataconverter/types/nbt/NBTMapType.java new file mode 100644 index 0000000000000000000000000000000000000000..01b6796c6ac168a82f41cf4fddbd32a1c8a86484 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTMapType.java ++++ b/ca/spottedleaf/dataconverter/types/nbt/NBTMapType.java @@ -0,0 +1,454 @@ +package ca.spottedleaf.dataconverter.types.nbt; + @@ -29320,11 +29320,11 @@ index 0000000000000000000000000000000000000000..01b6796c6ac168a82f41cf4fddbd32a1 + this.map.putString(key, val); + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTTypeUtil.java b/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTTypeUtil.java +diff --git a/ca/spottedleaf/dataconverter/types/nbt/NBTTypeUtil.java b/ca/spottedleaf/dataconverter/types/nbt/NBTTypeUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..62c0f4073aff301bf5b3187e0d4446fd8d0ac475 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/types/nbt/NBTTypeUtil.java ++++ b/ca/spottedleaf/dataconverter/types/nbt/NBTTypeUtil.java @@ -0,0 +1,18 @@ +package ca.spottedleaf.dataconverter.types.nbt; + @@ -29344,11 +29344,11 @@ index 0000000000000000000000000000000000000000..62c0f4073aff301bf5b3187e0d4446fd + return new NBTMapType(); + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/util/CommandArgumentUpgrader.java b/src/main/java/ca/spottedleaf/dataconverter/util/CommandArgumentUpgrader.java +diff --git a/ca/spottedleaf/dataconverter/util/CommandArgumentUpgrader.java b/ca/spottedleaf/dataconverter/util/CommandArgumentUpgrader.java new file mode 100644 index 0000000000000000000000000000000000000000..40da70d5cf584a9730f9fe81c355cf8513fba475 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/util/CommandArgumentUpgrader.java ++++ b/ca/spottedleaf/dataconverter/util/CommandArgumentUpgrader.java @@ -0,0 +1,592 @@ +package ca.spottedleaf.dataconverter.util; + @@ -29942,11 +29942,11 @@ index 0000000000000000000000000000000000000000..40da70d5cf584a9730f9fe81c355cf85 + ); + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/util/Int2IntArraySortedMap.java b/src/main/java/ca/spottedleaf/dataconverter/util/Int2IntArraySortedMap.java +diff --git a/ca/spottedleaf/dataconverter/util/Int2IntArraySortedMap.java b/ca/spottedleaf/dataconverter/util/Int2IntArraySortedMap.java new file mode 100644 index 0000000000000000000000000000000000000000..6596de3d9ebae583c252aa061f0cfdf8778ea1a5 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/util/Int2IntArraySortedMap.java ++++ b/ca/spottedleaf/dataconverter/util/Int2IntArraySortedMap.java @@ -0,0 +1,77 @@ +package ca.spottedleaf.dataconverter.util; + @@ -30025,11 +30025,11 @@ index 0000000000000000000000000000000000000000..6596de3d9ebae583c252aa061f0cfdf8 + return this.val[index]; + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/util/Int2ObjectArraySortedMap.java b/src/main/java/ca/spottedleaf/dataconverter/util/Int2ObjectArraySortedMap.java +diff --git a/ca/spottedleaf/dataconverter/util/Int2ObjectArraySortedMap.java b/ca/spottedleaf/dataconverter/util/Int2ObjectArraySortedMap.java new file mode 100644 index 0000000000000000000000000000000000000000..de9d632489609136c712a9adaee941fd38fad440 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/util/Int2ObjectArraySortedMap.java ++++ b/ca/spottedleaf/dataconverter/util/Int2ObjectArraySortedMap.java @@ -0,0 +1,74 @@ +package ca.spottedleaf.dataconverter.util; + @@ -30105,11 +30105,11 @@ index 0000000000000000000000000000000000000000..de9d632489609136c712a9adaee941fd + return this.val[index]; + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/util/IntegerUtil.java b/src/main/java/ca/spottedleaf/dataconverter/util/IntegerUtil.java +diff --git a/ca/spottedleaf/dataconverter/util/IntegerUtil.java b/ca/spottedleaf/dataconverter/util/IntegerUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..4bbf38c812feeb30d2aa5f3fcf482bfcbed79d05 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/util/IntegerUtil.java ++++ b/ca/spottedleaf/dataconverter/util/IntegerUtil.java @@ -0,0 +1,239 @@ +package ca.spottedleaf.dataconverter.util; + @@ -30350,11 +30350,11 @@ index 0000000000000000000000000000000000000000..4bbf38c812feeb30d2aa5f3fcf482bfc + throw new RuntimeException(); + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/util/Long2IntArraySortedMap.java b/src/main/java/ca/spottedleaf/dataconverter/util/Long2IntArraySortedMap.java +diff --git a/ca/spottedleaf/dataconverter/util/Long2IntArraySortedMap.java b/ca/spottedleaf/dataconverter/util/Long2IntArraySortedMap.java new file mode 100644 index 0000000000000000000000000000000000000000..94705bb141b550589faa9a0408402d8636c61907 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/util/Long2IntArraySortedMap.java ++++ b/ca/spottedleaf/dataconverter/util/Long2IntArraySortedMap.java @@ -0,0 +1,76 @@ +package ca.spottedleaf.dataconverter.util; + @@ -30432,11 +30432,11 @@ index 0000000000000000000000000000000000000000..94705bb141b550589faa9a0408402d86 + return this.val[index]; + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/util/Long2ObjectArraySortedMap.java b/src/main/java/ca/spottedleaf/dataconverter/util/Long2ObjectArraySortedMap.java +diff --git a/ca/spottedleaf/dataconverter/util/Long2ObjectArraySortedMap.java b/ca/spottedleaf/dataconverter/util/Long2ObjectArraySortedMap.java new file mode 100644 index 0000000000000000000000000000000000000000..6f634c8825589a23f46ad7b54354475c9a95bd1b --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/util/Long2ObjectArraySortedMap.java ++++ b/ca/spottedleaf/dataconverter/util/Long2ObjectArraySortedMap.java @@ -0,0 +1,76 @@ +package ca.spottedleaf.dataconverter.util; + @@ -30514,11 +30514,11 @@ index 0000000000000000000000000000000000000000..6f634c8825589a23f46ad7b54354475c + return this.val[index]; + } +} -diff --git a/src/main/java/ca/spottedleaf/dataconverter/util/NamespaceUtil.java b/src/main/java/ca/spottedleaf/dataconverter/util/NamespaceUtil.java +diff --git a/ca/spottedleaf/dataconverter/util/NamespaceUtil.java b/ca/spottedleaf/dataconverter/util/NamespaceUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..5a6536377c9c1e1753e930ff2a6bb98ea57055c7 --- /dev/null -+++ b/src/main/java/ca/spottedleaf/dataconverter/util/NamespaceUtil.java ++++ b/ca/spottedleaf/dataconverter/util/NamespaceUtil.java @@ -0,0 +1,39 @@ +package ca.spottedleaf.dataconverter.util; + @@ -30559,10 +30559,10 @@ index 0000000000000000000000000000000000000000..5a6536377c9c1e1753e930ff2a6bb98e + return correct.equals(value) ? null : correct; + } +} -diff --git a/src/main/java/ca/spottedleaf/moonrise/paper/PaperHooks.java b/src/main/java/ca/spottedleaf/moonrise/paper/PaperHooks.java +diff --git a/ca/spottedleaf/moonrise/paper/PaperHooks.java b/ca/spottedleaf/moonrise/paper/PaperHooks.java index 834c5ce238c7adb0164a6282582d709348ef96cc..11cfe9cc29666ce3a6a40281069fb9eb4fa0ded2 100644 ---- a/src/main/java/ca/spottedleaf/moonrise/paper/PaperHooks.java -+++ b/src/main/java/ca/spottedleaf/moonrise/paper/PaperHooks.java +--- a/ca/spottedleaf/moonrise/paper/PaperHooks.java ++++ b/ca/spottedleaf/moonrise/paper/PaperHooks.java @@ -203,6 +203,43 @@ public final class PaperHooks implements PlatformHooks { @Override public CompoundTag convertNBT(final DSL.TypeReference type, final DataFixer dataFixer, final CompoundTag nbt, @@ -30607,68 +30607,68 @@ index 834c5ce238c7adb0164a6282582d709348ef96cc..11cfe9cc29666ce3a6a40281069fb9eb return (CompoundTag)dataFixer.update( type, new Dynamic<>(NbtOps.INSTANCE, nbt), fromVersion, toVersion ).getValue(); -diff --git a/src/main/java/net/minecraft/data/structures/StructureUpdater.java b/src/main/java/net/minecraft/data/structures/StructureUpdater.java -index 96aea6d8cb68dd033c31cbde9d73ee490f320501..c51d71dd24cd28c22cda83cc3128c414ebd71a54 100644 ---- a/src/main/java/net/minecraft/data/structures/StructureUpdater.java -+++ b/src/main/java/net/minecraft/data/structures/StructureUpdater.java +diff --git a/net/minecraft/data/structures/StructureUpdater.java b/net/minecraft/data/structures/StructureUpdater.java +index 1110ca4075a1bbaa46b66686435dab91b275c945..c2218630c3074c8b3f82364e37503b12bd0a0d74 100644 +--- a/net/minecraft/data/structures/StructureUpdater.java ++++ b/net/minecraft/data/structures/StructureUpdater.java @@ -27,7 +27,7 @@ public class StructureUpdater implements SnbtToNbt.Filter { - LOGGER.warn("SNBT Too old, do not forget to update: {} < {}: {}", i, 4173, name); + LOGGER.warn("SNBT Too old, do not forget to update: {} < {}: {}", dataVersion, 4173, structureLocationPath); } -- CompoundTag compoundTag = DataFixTypes.STRUCTURE.updateToCurrentVersion(DataFixers.getDataFixer(), nbt, i); -+ CompoundTag compoundTag = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.STRUCTURE, nbt, i, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper +- CompoundTag compoundTag = DataFixTypes.STRUCTURE.updateToCurrentVersion(DataFixers.getDataFixer(), tag, dataVersion); ++ CompoundTag compoundTag = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.STRUCTURE, tag, dataVersion, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper structureTemplate.load(BuiltInRegistries.BLOCK, compoundTag); return structureTemplate.save(new CompoundTag()); } -diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index ccbd76a7d1a3c29759aec86c5780cab6d244915d..807d05097f7313361eadb600187421d25e294413 100644 ---- a/src/main/java/net/minecraft/server/MinecraftServer.java -+++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -331,6 +331,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop pluginsBlockingSleep = new java.util.HashSet<>(); // Paper - API to allow/disallow tick sleeping - public static S spin(Function serverFactory) { + public static S spin(Function threadFunction) { + ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.init(); // Paper - rewrite data converter system - AtomicReference atomicreference = new AtomicReference(); - Thread thread = new Thread(() -> { - ((MinecraftServer) atomicreference.get()).runServer(); -diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java -index 7d5e2e6e96ea9017334dddade54a9dcb37518642..092f7b6bba4e1291f76c2c09155f33803e93eb04 100644 ---- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java -+++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java -@@ -86,7 +86,7 @@ public class ChunkStorage implements AutoCloseable { + AtomicReference atomicReference = new AtomicReference<>(); + Thread thread = new ca.spottedleaf.moonrise.common.util.TickThread(() -> atomicReference.get().runServer(), "Server thread"); + thread.setUncaughtExceptionHandler((thread1, exception) -> LOGGER.error("Uncaught exception in server thread", exception)); +diff --git a/net/minecraft/world/level/chunk/storage/ChunkStorage.java b/net/minecraft/world/level/chunk/storage/ChunkStorage.java +index 1b931e68634e72c3465a99aa29aa53009163046b..80bc7ad9ad076968d06279dedd845d5946cf2501 100644 +--- a/net/minecraft/world/level/chunk/storage/ChunkStorage.java ++++ b/net/minecraft/world/level/chunk/storage/ChunkStorage.java +@@ -85,7 +85,7 @@ public class ChunkStorage implements AutoCloseable { } else { try { // CraftBukkit start -- if (i < 1466) { -+ if (false && i < 1466) { // Paper - no longer needed, data converter system / DFU handles it now - CompoundTag level = nbttagcompound.getCompound("Level"); +- if (version < 1466) { ++ if (false && version < 1466) { // Paper - no longer needed, data converter system / DFU handles it now + CompoundTag level = chunkData.getCompound("Level"); if (level.getBoolean("TerrainPopulated") && !level.getBoolean("LightPopulated")) { - ServerChunkCache cps = (generatoraccess == null) ? null : ((ServerLevel) generatoraccess).getChunkSource(); -@@ -98,7 +98,7 @@ public class ChunkStorage implements AutoCloseable { + net.minecraft.server.level.ServerChunkCache cps = (generatoraccess == null) ? null : ((net.minecraft.server.level.ServerLevel) generatoraccess).getChunkSource(); +@@ -96,7 +96,7 @@ public class ChunkStorage implements AutoCloseable { + } // CraftBukkit end - - if (i < 1493) { -- nbttagcompound = DataFixTypes.CHUNK.update(this.fixerUpper, nbttagcompound, i, 1493); -+ nbttagcompound = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.CHUNK, nbttagcompound, i, 1493); // Paper - replace chunk converter - if (nbttagcompound.getCompound("Level").getBoolean("hasLegacyStructureData")) { - LegacyStructureDataHandler persistentstructurelegacy = this.getLegacyStructureHandler(resourcekey, supplier); - -@@ -116,7 +116,7 @@ public class ChunkStorage implements AutoCloseable { + if (version < 1493) { +- chunkData = DataFixTypes.CHUNK.update(this.fixerUpper, chunkData, version, 1493); ++ chunkData = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.CHUNK, chunkData, version, 1493); // Paper - replace chunk converter + if (chunkData.getCompound("Level").getBoolean("hasLegacyStructureData")) { + LegacyStructureDataHandler legacyStructureHandler = this.getLegacyStructureHandler(levelKey, storage); + chunkData = legacyStructureHandler.updateFromLegacy(chunkData); +@@ -113,7 +113,7 @@ public class ChunkStorage implements AutoCloseable { // Spigot end - ChunkStorage.injectDatafixingContext(nbttagcompound, resourcekey, optional); -- nbttagcompound = DataFixTypes.CHUNK.updateToCurrentVersion(this.fixerUpper, nbttagcompound, Math.max(1493, i)); -+ nbttagcompound = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.CHUNK, nbttagcompound, Math.max(1493, i), SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper - replace chunk converter + injectDatafixingContext(chunkData, levelKey, chunkGeneratorKey); +- chunkData = DataFixTypes.CHUNK.updateToCurrentVersion(this.fixerUpper, chunkData, Math.max(1493, version)); ++ chunkData = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.CHUNK, chunkData, Math.max(1493, version), SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper - replace chunk converter // Spigot start if (stopBelowZero) { - nbttagcompound.putString("Status", net.minecraft.core.registries.BuiltInRegistries.CHUNK_STATUS.getKey(ChunkStatus.SPAWN).toString()); -diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/SimpleRegionStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/SimpleRegionStorage.java -index e0e843f4f69013379ed70cb63d9b4f72163b828b..578d270d5b7efb9ac8f5dde539170f6021e2b786 100644 ---- a/src/main/java/net/minecraft/world/level/chunk/storage/SimpleRegionStorage.java -+++ b/src/main/java/net/minecraft/world/level/chunk/storage/SimpleRegionStorage.java + chunkData.putString("Status", net.minecraft.core.registries.BuiltInRegistries.CHUNK_STATUS.getKey(net.minecraft.world.level.chunk.status.ChunkStatus.SPAWN).toString()); +diff --git a/net/minecraft/world/level/chunk/storage/SimpleRegionStorage.java b/net/minecraft/world/level/chunk/storage/SimpleRegionStorage.java +index 6be673172548c1382c7402ec4e1ec6ef51f702d3..41ddaceb7485626b1f2ee258c2142eb3114c106e 100644 +--- a/net/minecraft/world/level/chunk/storage/SimpleRegionStorage.java ++++ b/net/minecraft/world/level/chunk/storage/SimpleRegionStorage.java @@ -32,13 +32,30 @@ public class SimpleRegionStorage implements AutoCloseable { - return this.worker.store(pos, nbt); + return this.worker.store(chunkPos, data); } + // Paper start - rewrite data conversion system @@ -30683,122 +30683,73 @@ index e0e843f4f69013379ed70cb63d9b4f72163b828b..578d270d5b7efb9ac8f5dde539170f60 + } + // Paper end - rewrite data conversion system + - public CompoundTag upgradeChunkTag(CompoundTag nbt, int oldVersion) { -- int i = NbtUtils.getDataVersion(nbt, oldVersion); -- return this.dataFixType.updateToCurrentVersion(this.fixerUpper, nbt, i); + public CompoundTag upgradeChunkTag(CompoundTag tag, int version) { +- int dataVersion = NbtUtils.getDataVersion(tag, version); +- return this.dataFixType.updateToCurrentVersion(this.fixerUpper, tag, dataVersion); + // Paper start - rewrite data conversion system -+ final int dataVer = NbtUtils.getDataVersion(nbt, oldVersion); -+ return ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(this.getDataConverterType(), nbt, dataVer, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); ++ final int dataVer = NbtUtils.getDataVersion(tag, version); ++ return ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(this.getDataConverterType(), tag, dataVer, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); + // Paper end - rewrite data conversion system } - public Dynamic upgradeChunkTag(Dynamic nbt, int oldVersion) { -- return this.dataFixType.updateToCurrentVersion(this.fixerUpper, nbt, oldVersion); + public Dynamic upgradeChunkTag(Dynamic tag, int version) { +- return this.dataFixType.updateToCurrentVersion(this.fixerUpper, tag, version); + // Paper start - rewrite data conversion system -+ final CompoundTag converted = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(this.getDataConverterType(), (CompoundTag)nbt.getValue(), oldVersion, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); -+ return new Dynamic<>(net.minecraft.nbt.NbtOps.INSTANCE, converted); ++ final CompoundTag converted = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(this.getDataConverterType(), (CompoundTag)tag.getValue(), version, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); ++ return new Dynamic<>(tag.getOps(), converted); + // Paper end - rewrite data conversion system } - public CompletableFuture synchronize(boolean sync) { -diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/StructureCheck.java b/src/main/java/net/minecraft/world/level/levelgen/structure/StructureCheck.java -index 5f354b333a39b873915bedd57b647355ae5bdf56..c3586281c9594769593a6027ea0a78f7c76c0262 100644 ---- a/src/main/java/net/minecraft/world/level/levelgen/structure/StructureCheck.java -+++ b/src/main/java/net/minecraft/world/level/levelgen/structure/StructureCheck.java + public CompletableFuture synchronize(boolean flushStorage) { +diff --git a/net/minecraft/world/level/levelgen/structure/StructureCheck.java b/net/minecraft/world/level/levelgen/structure/StructureCheck.java +index b348d06b261b23eef02c7b14b3010669de9a1b7e..06b54c0bec4031689d5c2da5cfea4ef28dbd16bc 100644 +--- a/net/minecraft/world/level/levelgen/structure/StructureCheck.java ++++ b/net/minecraft/world/level/levelgen/structure/StructureCheck.java @@ -151,7 +151,7 @@ public class StructureCheck { - CompoundTag compoundTag2; + CompoundTag compoundTag1; try { -- compoundTag2 = DataFixTypes.CHUNK.updateToCurrentVersion(this.fixerUpper, compoundTag, i); -+ compoundTag2 = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.CHUNK, compoundTag, i, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper - replace chunk converter +- compoundTag1 = DataFixTypes.CHUNK.updateToCurrentVersion(this.fixerUpper, compoundTag, version); ++ compoundTag1 = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.CHUNK, compoundTag, version, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper - replace chunk converter } catch (Exception var12) { - LOGGER.warn("Failed to partially datafix chunk {}", pos, var12); + LOGGER.warn("Failed to partially datafix chunk {}", chunkPos, var12); return StructureCheckResult.CHUNK_LOAD_NEEDED; -diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplateManager.java b/src/main/java/net/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplateManager.java -index 05a76f9d18638f10218161450470f07524b723ac..3ab22c384bb8a7772d389977a61d0e28975fdb79 100644 ---- a/src/main/java/net/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplateManager.java -+++ b/src/main/java/net/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplateManager.java +diff --git a/net/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplateManager.java b/net/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplateManager.java +index 408ba448c2f127e27e30bfcc6f35f0bdcf86d298..80533af16a59e9ad7e38d1c37b213529a4ecf5b8 100644 +--- a/net/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplateManager.java ++++ b/net/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplateManager.java @@ -245,7 +245,7 @@ public class StructureTemplateManager { public StructureTemplate readStructure(CompoundTag nbt) { StructureTemplate structureTemplate = new StructureTemplate(); - int i = NbtUtils.getDataVersion(nbt, 500); -- structureTemplate.load(this.blockLookup, DataFixTypes.STRUCTURE.updateToCurrentVersion(this.fixerUpper, nbt, i)); -+ structureTemplate.load(this.blockLookup, ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.STRUCTURE, nbt, i, SharedConstants.getCurrentVersion().getDataVersion().getVersion())); // Paper + int dataVersion = NbtUtils.getDataVersion(nbt, 500); +- structureTemplate.load(this.blockLookup, DataFixTypes.STRUCTURE.updateToCurrentVersion(this.fixerUpper, nbt, dataVersion)); ++ structureTemplate.load(this.blockLookup, ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.STRUCTURE, nbt, dataVersion, SharedConstants.getCurrentVersion().getDataVersion().getVersion())); // Paper - rewrite data conversion system return structureTemplate; } -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 79397b3c76e4b9d2ee03dfa16c2daf4f71ae8b4d..cdca5ae69991cc068bfbc0686b5defb3604a5440 100644 ---- a/src/main/java/net/minecraft/world/level/storage/LevelStorageSource.java -+++ b/src/main/java/net/minecraft/world/level/storage/LevelStorageSource.java -@@ -277,12 +277,21 @@ public class LevelStorageSource { - static Dynamic readLevelDataTagFixed(Path path, DataFixer dataFixer) throws IOException { - CompoundTag nbttagcompound = LevelStorageSource.readLevelDataTagRaw(path); - CompoundTag nbttagcompound1 = nbttagcompound.getCompound("Data"); -- int i = NbtUtils.getDataVersion(nbttagcompound1, -1); -+ int i = NbtUtils.getDataVersion(nbttagcompound1, -1); final int version = i; // Paper - obfuscation helpers - Dynamic dynamic = DataFixTypes.LEVEL.updateToCurrentVersion(dataFixer, new Dynamic(NbtOps.INSTANCE, nbttagcompound1), i); - -+ // Paper start - replace data conversion system - dynamic = dynamic.update("Player", (dynamic1) -> { -- return DataFixTypes.PLAYER.updateToCurrentVersion(dataFixer, dynamic1, i); -+ return new Dynamic<>( -+ NbtOps.INSTANCE, -+ ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag( -+ ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.PLAYER, -+ (net.minecraft.nbt.CompoundTag)dynamic1.getValue(), -+ version, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion() -+ ) -+ ); - }); -+ // Paper end - replace data conversion system - dynamic = dynamic.update("WorldGenSettings", (dynamic1) -> { - return DataFixTypes.WORLD_GEN_SETTINGS.updateToCurrentVersion(dataFixer, dynamic1, i); - }); -diff --git a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java -index b54a3741cd3ba615c83c98985cb4b3c4c586ed7a..b148cf247acdd36f856d0495cde4cc5ad32b5a2f 100644 ---- a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java -+++ b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java -@@ -137,7 +137,7 @@ public class PlayerDataStorage { - }).map((nbttagcompound) -> { - int i = NbtUtils.getDataVersion(nbttagcompound, -1); - -- nbttagcompound = DataFixTypes.PLAYER.updateToCurrentVersion(this.fixerUpper, nbttagcompound, i); -+ nbttagcompound = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.PLAYER, nbttagcompound, i, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper - rewrite data conversion system - // entityhuman.load(nbttagcompound); // CraftBukkit - handled above - return nbttagcompound; - }); -diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java -index 0e8f4710c0ce05e8cd42cbbc9fedc05bf8585a19..15892c7769caa15f3d52a1ee2147cf9615aa0e25 100644 ---- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java -+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java -@@ -523,7 +523,7 @@ public final class CraftMagicNumbers implements UnsafeValues { - - net.minecraft.nbt.CompoundTag compound = deserializeNbtFromBytes(data); - final int dataVersion = compound.getInt("DataVersion"); -- compound = (net.minecraft.nbt.CompoundTag) MinecraftServer.getServer().fixerUpper.update(References.ITEM_STACK, new Dynamic<>(NbtOps.INSTANCE, compound), dataVersion, this.getDataVersion()).getValue(); -+ compound = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.ITEM_STACK, compound, dataVersion, this.getDataVersion()); // Paper - replace data conversion system - return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.parse(MinecraftServer.getServer().registryAccess(), compound).orElseThrow()); +diff --git a/net/minecraft/world/level/storage/LevelStorageSource.java b/net/minecraft/world/level/storage/LevelStorageSource.java +index ed6ea17e9cf3498591f2acd232a48107564b774b..117e8a155937ed5312d544b6de748206c255c84f 100644 +--- a/net/minecraft/world/level/storage/LevelStorageSource.java ++++ b/net/minecraft/world/level/storage/LevelStorageSource.java +@@ -227,7 +227,7 @@ public class LevelStorageSource { + CompoundTag compound = levelDataTagRaw.getCompound("Data"); + int dataVersion = NbtUtils.getDataVersion(compound, -1); + Dynamic dynamic = DataFixTypes.LEVEL.updateToCurrentVersion(dataFixer, new Dynamic<>(NbtOps.INSTANCE, compound), dataVersion); +- dynamic = dynamic.update("Player", dynamic1 -> DataFixTypes.PLAYER.updateToCurrentVersion(dataFixer, dynamic1, dataVersion)); ++ dynamic = dynamic.update("Player", dynamic1 -> new Dynamic(dynamic1.getOps(), ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.PLAYER, (net.minecraft.nbt.CompoundTag)dynamic1.getValue(), dataVersion, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()))); // Paper - replace data conversion system + return dynamic.update("WorldGenSettings", dynamic1 -> DataFixTypes.WORLD_GEN_SETTINGS.updateToCurrentVersion(dataFixer, dynamic1, dataVersion)); } -@@ -552,7 +552,10 @@ public final class CraftMagicNumbers implements UnsafeValues { +diff --git a/net/minecraft/world/level/storage/PlayerDataStorage.java b/net/minecraft/world/level/storage/PlayerDataStorage.java +index 6ac8f16500e44069b84d862d5f0e5c5cbc07387e..5682f6d601cbf8a7eb0d76eafd52095435252579 100644 +--- a/net/minecraft/world/level/storage/PlayerDataStorage.java ++++ b/net/minecraft/world/level/storage/PlayerDataStorage.java +@@ -115,7 +115,7 @@ public class PlayerDataStorage { - final int dataVersion = data.get("DataVersion").getAsInt(); - final int currentVersion = org.bukkit.craftbukkit.util.CraftMagicNumbers.INSTANCE.getDataVersion(); -- data = (com.google.gson.JsonObject) MinecraftServer.getServer().fixerUpper.update(References.ITEM_STACK, new Dynamic<>(com.mojang.serialization.JsonOps.INSTANCE, data), dataVersion, currentVersion).getValue(); -+ data = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertJson( -+ ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.ITEM_STACK, -+ data, false, dataVersion, currentVersion -+ ); - com.mojang.serialization.DynamicOps ops = MinecraftServer.getServer().registryAccess().createSerializationContext(com.mojang.serialization.JsonOps.INSTANCE); - return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.CODEC.parse(ops, data).getOrThrow(IllegalArgumentException::new)); - } -@@ -574,7 +577,7 @@ public final class CraftMagicNumbers implements UnsafeValues { - - net.minecraft.nbt.CompoundTag compound = deserializeNbtFromBytes(data); - int dataVersion = compound.getInt("DataVersion"); -- compound = (net.minecraft.nbt.CompoundTag) MinecraftServer.getServer().fixerUpper.update(References.ENTITY, new Dynamic<>(NbtOps.INSTANCE, compound), dataVersion, this.getDataVersion()).getValue(); -+ compound = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.ENTITY, compound, dataVersion, this.getDataVersion()); - if (!preserveUUID) { - // Generate a new UUID so we don't have to worry about deserializing the same entity twice - compound.remove("UUID"); + return optional.or(() -> this.load(name, uuid, ".dat_old")).map(compoundTag -> { // CraftBukkit + int dataVersion = NbtUtils.getDataVersion(compoundTag, -1); +- compoundTag = DataFixTypes.PLAYER.updateToCurrentVersion(this.fixerUpper, compoundTag, dataVersion); ++ compoundTag = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.PLAYER, compoundTag, dataVersion, net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper - rewrite data conversion system + // player.load(compoundTag); // CraftBukkit - handled above + return compoundTag; + }); diff --git a/paper-server/src/main/java/ca/spottedleaf/moonrise/paper/PaperHooks.java b/paper-server/src/main/java/ca/spottedleaf/moonrise/paper/PaperHooks.java deleted file mode 100644 index 834c5ce238..0000000000 --- a/paper-server/src/main/java/ca/spottedleaf/moonrise/paper/PaperHooks.java +++ /dev/null @@ -1,240 +0,0 @@ -package ca.spottedleaf.moonrise.paper; - -import ca.spottedleaf.moonrise.common.PlatformHooks; -import com.mojang.datafixers.DSL; -import com.mojang.datafixers.DataFixer; -import com.mojang.serialization.Dynamic; -import java.util.Collection; -import net.minecraft.core.BlockPos; -import net.minecraft.nbt.CompoundTag; -import net.minecraft.nbt.NbtOps; -import net.minecraft.server.level.ChunkHolder; -import net.minecraft.server.level.GenerationChunkHolder; -import net.minecraft.server.level.ServerLevel; -import net.minecraft.server.level.ServerPlayer; -import net.minecraft.world.entity.Entity; -import net.minecraft.world.entity.boss.EnderDragonPart; -import net.minecraft.world.level.BlockGetter; -import net.minecraft.world.level.ChunkPos; -import net.minecraft.world.level.Level; -import net.minecraft.world.level.block.state.BlockState; -import net.minecraft.world.level.chunk.ChunkAccess; -import net.minecraft.world.level.chunk.LevelChunk; -import net.minecraft.world.level.chunk.ProtoChunk; -import net.minecraft.world.level.chunk.storage.SerializableChunkData; -import net.minecraft.world.level.entity.EntityTypeTest; -import net.minecraft.world.phys.AABB; -import java.util.List; -import java.util.function.Predicate; - -public final class PaperHooks implements PlatformHooks { - - @Override - public String getBrand() { - return "Paper"; - } - - @Override - public int getLightEmission(final BlockState blockState, final BlockGetter world, final BlockPos pos) { - return blockState.getLightEmission(); - } - - @Override - public Predicate maybeHasLightEmission() { - return (final BlockState state) -> { - return state.getLightEmission() != 0; - }; - } - - @Override - public boolean hasCurrentlyLoadingChunk() { - return false; - } - - @Override - public LevelChunk getCurrentlyLoadingChunk(final GenerationChunkHolder holder) { - return null; - } - - @Override - public void setCurrentlyLoading(final GenerationChunkHolder holder, final LevelChunk levelChunk) { - - } - - @Override - public void chunkFullStatusComplete(final LevelChunk newChunk, final ProtoChunk original) { - - } - - @Override - public boolean allowAsyncTicketUpdates() { - return true; - } - - @Override - public void onChunkHolderTicketChange(final ServerLevel world, final ChunkHolder holder, final int oldLevel, final int newLevel) { - - } - - @Override - public void chunkUnloadFromWorld(final LevelChunk chunk) { - - } - - @Override - public void chunkSyncSave(final ServerLevel world, final ChunkAccess chunk, final SerializableChunkData data) { - - } - - @Override - public void onChunkWatch(final ServerLevel world, final LevelChunk chunk, final ServerPlayer player) { - - } - - @Override - public void onChunkUnWatch(final ServerLevel world, final ChunkPos chunk, final ServerPlayer player) { - - } - - @Override - public void addToGetEntities(final Level world, final Entity entity, final AABB boundingBox, final Predicate predicate, final List into) { - final Collection parts = world.dragonParts(); - if (parts.isEmpty()) { - return; - } - - for (final EnderDragonPart part : parts) { - if (part != entity && part.getBoundingBox().intersects(boundingBox) && (predicate == null || predicate.test(part))) { - into.add(part); - } - } - } - - @Override - public void addToGetEntities(final Level world, final EntityTypeTest entityTypeTest, final AABB boundingBox, final Predicate predicate, final List into, final int maxCount) { - if (into.size() >= maxCount) { - // fix neoforge issue: do not add if list is already full - return; - } - - final Collection parts = world.dragonParts(); - if (parts.isEmpty()) { - return; - } - for (final EnderDragonPart part : parts) { - if (!part.getBoundingBox().intersects(boundingBox)) { - continue; - } - final T casted = (T)entityTypeTest.tryCast(part); - if (casted != null && (predicate == null || predicate.test(casted))) { - into.add(casted); - if (into.size() >= maxCount) { - break; - } - } - } - } - - @Override - public void entityMove(final Entity entity, final long oldSection, final long newSection) { - - } - - @Override - public boolean screenEntity(final ServerLevel world, final Entity entity, final boolean fromDisk, final boolean event) { - return true; - } - - @Override - public boolean configFixMC224294() { - return true; - } - - @Override - public boolean configAutoConfigSendDistance() { - return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.autoConfigSendDistance; - } - - @Override - public double configPlayerMaxLoadRate() { - return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkLoadRate; - } - - @Override - public double configPlayerMaxGenRate() { - return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkGenerateRate; - } - - @Override - public double configPlayerMaxSendRate() { - return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkSendRate; - } - - @Override - public int configPlayerMaxConcurrentLoads() { - return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.playerMaxConcurrentChunkLoads; - } - - @Override - public int configPlayerMaxConcurrentGens() { - return io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.playerMaxConcurrentChunkGenerates; - } - - @Override - public long configAutoSaveInterval(final ServerLevel world) { - return world.paperConfig().chunks.autoSaveInterval.value(); - } - - @Override - public int configMaxAutoSavePerTick(final ServerLevel world) { - return world.paperConfig().chunks.maxAutoSaveChunksPerTick; - } - - @Override - public boolean configFixMC159283() { - return true; - } - - @Override - public boolean forceNoSave(final ChunkAccess chunk) { - return chunk instanceof LevelChunk levelChunk && levelChunk.mustNotSave; - } - - @Override - public CompoundTag convertNBT(final DSL.TypeReference type, final DataFixer dataFixer, final CompoundTag nbt, - final int fromVersion, final int toVersion) { - return (CompoundTag)dataFixer.update( - type, new Dynamic<>(NbtOps.INSTANCE, nbt), fromVersion, toVersion - ).getValue(); - } - - @Override - public boolean hasMainChunkLoadHook() { - return false; - } - - @Override - public void mainChunkLoad(final ChunkAccess chunk, final SerializableChunkData chunkData) { - - } - - @Override - public List modifySavedEntities(final ServerLevel world, final int chunkX, final int chunkZ, final List entities) { - return entities; - } - - @Override - public void unloadEntity(final Entity entity) { - entity.setRemoved(Entity.RemovalReason.UNLOADED_TO_CHUNK, org.bukkit.event.entity.EntityRemoveEvent.Cause.UNLOAD); - } - - @Override - public void postLoadProtoChunk(final ServerLevel world, final ProtoChunk chunk) { - net.minecraft.world.level.chunk.status.ChunkStatusTasks.postLoadProtoChunk(world, chunk.getEntities()); - } - - @Override - public int modifyEntityTrackingRange(final Entity entity, final int currentRange) { - return org.spigotmc.TrackingRange.getEntityTrackingRange(entity, currentRange); - } -} diff --git a/paper-server/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/paper-server/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java index 0e8f4710c0..b6665e1875 100644 --- a/paper-server/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +++ b/paper-server/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java @@ -523,7 +523,7 @@ public final class CraftMagicNumbers implements UnsafeValues { net.minecraft.nbt.CompoundTag compound = deserializeNbtFromBytes(data); final int dataVersion = compound.getInt("DataVersion"); - compound = (net.minecraft.nbt.CompoundTag) MinecraftServer.getServer().fixerUpper.update(References.ITEM_STACK, new Dynamic<>(NbtOps.INSTANCE, compound), dataVersion, this.getDataVersion()).getValue(); + compound = ca.spottedleaf.moonrise.common.PlatformHooks.get().convertNBT(References.ITEM_STACK, MinecraftServer.getServer().fixerUpper, compound, dataVersion, this.getDataVersion()); // Paper - possibly use dataconverter return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.parse(MinecraftServer.getServer().registryAccess(), compound).orElseThrow()); } @@ -574,7 +574,7 @@ public final class CraftMagicNumbers implements UnsafeValues { net.minecraft.nbt.CompoundTag compound = deserializeNbtFromBytes(data); int dataVersion = compound.getInt("DataVersion"); - compound = (net.minecraft.nbt.CompoundTag) MinecraftServer.getServer().fixerUpper.update(References.ENTITY, new Dynamic<>(NbtOps.INSTANCE, compound), dataVersion, this.getDataVersion()).getValue(); + compound = ca.spottedleaf.moonrise.common.PlatformHooks.get().convertNBT(References.ENTITY, MinecraftServer.getServer().fixerUpper, compound, dataVersion, this.getDataVersion()); // Paper - possibly use dataconverter if (!preserveUUID) { // Generate a new UUID so we don't have to worry about deserializing the same entity twice compound.remove("UUID");