2020-05-06 09:48:49 +00:00
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
2019-06-26 04:50:57 +00:00
From: stonar96 <minecraft.stonar96@gmail.com>
Date: Mon, 20 Aug 2018 03:03:58 +0200
Subject: [PATCH] Anti-Xray
diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
2020-10-16 21:08:33 +00:00
index e7c73a4ddbb42aa52112147a60c8a761bfd3d07b..75c30889ec186dbae35159d9a4a38494fad0f6df 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
2020-05-06 08:35:20 +00:00
@@ -1,7 +1,9 @@
2019-06-26 04:50:57 +00:00
package com.destroystokyo.paper;
+import java.util.Arrays;
import java.util.List;
+import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray.EngineMode;
import org.bukkit.Bukkit;
import org.bukkit.configuration.file.YamlConfiguration;
import org.spigotmc.SpigotWorldConfig;
2020-10-16 21:08:33 +00:00
@@ -454,4 +456,33 @@ public class PaperWorldConfig {
2019-06-26 04:50:57 +00:00
private void maxAutoSaveChunksPerTick() {
maxAutoSaveChunksPerTick = getInt("max-auto-save-chunks-per-tick", 24);
}
+
+ public boolean antiXray;
+ public EngineMode engineMode;
+ public int maxChunkSectionIndex;
+ public int updateRadius;
2020-10-16 21:08:33 +00:00
+ public boolean lavaObscures;
2019-06-26 04:50:57 +00:00
+ public List<String> hiddenBlocks;
+ public List<String> replacementBlocks;
+ private void antiXray() {
+ antiXray = getBoolean("anti-xray.enabled", false);
+ engineMode = EngineMode.getById(getInt("anti-xray.engine-mode", EngineMode.HIDE.getId()));
+ engineMode = engineMode == null ? EngineMode.HIDE : engineMode;
+ maxChunkSectionIndex = getInt("anti-xray.max-chunk-section-index", 3);
+ maxChunkSectionIndex = maxChunkSectionIndex > 15 ? 15 : maxChunkSectionIndex;
+ updateRadius = getInt("anti-xray.update-radius", 2);
2020-10-16 21:08:33 +00:00
+ lavaObscures = getBoolean("anti-xray.lava-obscures", false);
2019-06-26 04:50:57 +00:00
+ hiddenBlocks = getList("anti-xray.hidden-blocks", Arrays.asList("gold_ore", "iron_ore", "coal_ore", "lapis_ore", "mossy_cobblestone", "obsidian", "chest", "diamond_ore", "redstone_ore", "clay", "emerald_ore", "ender_chest"));
+ replacementBlocks = getList("anti-xray.replacement-blocks", Arrays.asList("stone", "oak_planks"));
2019-07-01 21:53:51 +00:00
+ if (PaperConfig.version < 19) {
+ hiddenBlocks.remove("lit_redstone_ore");
+ int index = replacementBlocks.indexOf("planks");
+ if (index != -1) {
+ replacementBlocks.set(index, "oak_planks");
+ }
+ set("anti-xray.hidden-blocks", hiddenBlocks);
+ set("anti-xray.replacement-blocks", replacementBlocks);
+ }
2020-05-06 08:35:20 +00:00
+ log("Anti-Xray: " + (antiXray ? "enabled" : "disabled") + " / Engine Mode: " + engineMode.getDescription() + " / Up to " + ((maxChunkSectionIndex + 1) * 16) + " blocks / Update Radius: " + updateRadius);
2019-06-26 04:50:57 +00:00
+ }
}
diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockController.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockController.java
new file mode 100644
2020-05-06 09:48:49 +00:00
index 0000000000000000000000000000000000000000..df7e4183d8842f5be8ae9d0698f8fa90742ff43c
2019-06-26 04:50:57 +00:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockController.java
2020-05-06 08:35:20 +00:00
@@ -0,0 +1,40 @@
2019-06-26 04:50:57 +00:00
+package com.destroystokyo.paper.antixray;
+
+import net.minecraft.server.BlockPosition;
+import net.minecraft.server.Chunk;
+import net.minecraft.server.ChunkSection;
+import net.minecraft.server.EnumDirection;
+import net.minecraft.server.IBlockData;
+import net.minecraft.server.IChunkAccess;
+import net.minecraft.server.PacketPlayOutMapChunk;
+import net.minecraft.server.PlayerInteractManager;
+import net.minecraft.server.World;
+
+public class ChunkPacketBlockController {
+
+ public static final ChunkPacketBlockController NO_OPERATION_INSTANCE = new ChunkPacketBlockController();
+
+ protected ChunkPacketBlockController() {
+
+ }
+
2020-05-06 08:35:20 +00:00
+ public IBlockData[] getPredefinedBlockData(World world, IChunkAccess chunk, ChunkSection chunkSection, boolean initializeBlocks) {
2019-06-26 04:50:57 +00:00
+ return null;
+ }
+
2020-05-06 08:35:20 +00:00
+ public ChunkPacketInfo<IBlockData> getChunkPacketInfo(PacketPlayOutMapChunk packetPlayOutMapChunk, Chunk chunk, int chunkSectionSelector) {
2019-06-26 04:50:57 +00:00
+ return null;
+ }
+
2020-05-06 08:35:20 +00:00
+ public void modifyBlocks(PacketPlayOutMapChunk packetPlayOutMapChunk, ChunkPacketInfo<IBlockData> chunkPacketInfo) {
2019-06-26 04:50:57 +00:00
+ packetPlayOutMapChunk.setReady(true);
+ }
+
+ public void onBlockChange(World world, BlockPosition blockPosition, IBlockData newBlockData, IBlockData oldBlockData, int flag) {
+
+ }
+
+ public void onPlayerLeftClickBlock(PlayerInteractManager playerInteractManager, BlockPosition blockPosition, EnumDirection enumDirection) {
+
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java
new file mode 100644
2020-11-03 02:22:15 +00:00
index 0000000000000000000000000000000000000000..b879f1796912bb8467202e946ccf0c9270d1589d
2019-06-26 04:50:57 +00:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java
2020-10-16 21:08:33 +00:00
@@ -0,0 +1,605 @@
2019-06-26 04:50:57 +00:00
+package com.destroystokyo.paper.antixray;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
2020-06-09 08:12:20 +00:00
+import java.util.concurrent.Executor;
2020-08-07 02:26:01 +00:00
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.function.IntSupplier;
2019-06-26 04:50:57 +00:00
+
+import net.minecraft.server.*;
2019-07-01 21:36:31 +00:00
+import org.bukkit.Bukkit;
2019-06-26 04:50:57 +00:00
+import org.bukkit.World.Environment;
+
+import com.destroystokyo.paper.PaperWorldConfig;
+
2020-05-06 08:35:20 +00:00
+public final class ChunkPacketBlockControllerAntiXray extends ChunkPacketBlockController {
2019-06-26 04:50:57 +00:00
+
2020-06-09 08:12:20 +00:00
+ private final Executor executor;
2019-06-26 04:50:57 +00:00
+ private final EngineMode engineMode;
+ private final int maxChunkSectionIndex;
+ private final int updateRadius;
+ private final IBlockData[] predefinedBlockData;
+ private final IBlockData[] predefinedBlockDataStone;
+ private final IBlockData[] predefinedBlockDataNetherrack;
+ private final IBlockData[] predefinedBlockDataEndStone;
+ private final int[] predefinedBlockDataBitsGlobal;
+ private final int[] predefinedBlockDataBitsStoneGlobal;
+ private final int[] predefinedBlockDataBitsNetherrackGlobal;
+ private final int[] predefinedBlockDataBitsEndStoneGlobal;
+ private final boolean[] solidGlobal = new boolean[Block.REGISTRY_ID.size()];
+ private final boolean[] obfuscateGlobal = new boolean[Block.REGISTRY_ID.size()];
+ private final ChunkSection[] emptyNearbyChunkSections = {Chunk.EMPTY_CHUNK_SECTION, Chunk.EMPTY_CHUNK_SECTION, Chunk.EMPTY_CHUNK_SECTION, Chunk.EMPTY_CHUNK_SECTION};
+ private final int maxBlockYUpdatePosition;
+
2020-08-25 02:22:08 +00:00
+ public ChunkPacketBlockControllerAntiXray(World world, Executor executor) {
+ PaperWorldConfig paperWorldConfig = world.paperConfig;
2019-06-26 04:50:57 +00:00
+ engineMode = paperWorldConfig.engineMode;
+ maxChunkSectionIndex = paperWorldConfig.maxChunkSectionIndex;
+ updateRadius = paperWorldConfig.updateRadius;
+
2020-06-09 08:12:20 +00:00
+ this.executor = executor;
2019-06-26 04:50:57 +00:00
+
+ List<String> toObfuscate;
+
+ if (engineMode == EngineMode.HIDE) {
+ toObfuscate = paperWorldConfig.hiddenBlocks;
+ predefinedBlockData = null;
+ predefinedBlockDataStone = new IBlockData[] {Blocks.STONE.getBlockData()};
+ predefinedBlockDataNetherrack = new IBlockData[] {Blocks.NETHERRACK.getBlockData()};
+ predefinedBlockDataEndStone = new IBlockData[] {Blocks.END_STONE.getBlockData()};
+ predefinedBlockDataBitsGlobal = null;
+ predefinedBlockDataBitsStoneGlobal = new int[] {ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(Blocks.STONE.getBlockData())};
+ predefinedBlockDataBitsNetherrackGlobal = new int[] {ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(Blocks.NETHERRACK.getBlockData())};
+ predefinedBlockDataBitsEndStoneGlobal = new int[] {ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(Blocks.END_STONE.getBlockData())};
+ } else {
+ toObfuscate = new ArrayList<>(paperWorldConfig.replacementBlocks);
+ Set<IBlockData> predefinedBlockDataSet = new HashSet<IBlockData>();
+
+ for (String id : paperWorldConfig.hiddenBlocks) {
+ Block block = IRegistry.BLOCK.getOptional(new MinecraftKey(id)).orElse(null);
+
+ if (block != null && !block.isTileEntity()) {
+ toObfuscate.add(id);
+ predefinedBlockDataSet.add(block.getBlockData());
+ }
+ }
+
+ predefinedBlockData = predefinedBlockDataSet.size() == 0 ? new IBlockData[] {Blocks.DIAMOND_ORE.getBlockData()} : predefinedBlockDataSet.toArray(new IBlockData[0]);
+ predefinedBlockDataStone = null;
+ predefinedBlockDataNetherrack = null;
+ predefinedBlockDataEndStone = null;
+ predefinedBlockDataBitsGlobal = new int[predefinedBlockData.length];
+
+ for (int i = 0; i < predefinedBlockData.length; i++) {
+ predefinedBlockDataBitsGlobal[i] = ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(predefinedBlockData[i]);
+ }
+
+ predefinedBlockDataBitsStoneGlobal = null;
+ predefinedBlockDataBitsNetherrackGlobal = null;
+ predefinedBlockDataBitsEndStoneGlobal = null;
+ }
+
+ for (String id : toObfuscate) {
+ Block block = IRegistry.BLOCK.getOptional(new MinecraftKey(id)).orElse(null);
+
2020-08-25 02:22:08 +00:00
+ // Don't obfuscate air because air causes unnecessary block updates and causes block updates to fail in the void
+ if (block != null && !block.getBlockData().isAir()) {
2019-06-26 04:50:57 +00:00
+ obfuscateGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(block.getBlockData())] = true;
+ }
+ }
+
2020-08-25 02:22:08 +00:00
+ ChunkEmpty emptyChunk = new ChunkEmpty(world, new ChunkCoordIntPair(0, 0));
2019-06-26 04:50:57 +00:00
+ BlockPosition zeroPos = new BlockPosition(0, 0, 0);
+
+ for (int i = 0; i < solidGlobal.length; i++) {
+ IBlockData blockData = ChunkSection.GLOBAL_PALETTE.getObject(i);
+
+ if (blockData != null) {
2020-06-26 06:29:44 +00:00
+ solidGlobal[i] = blockData.isOccluding(emptyChunk, zeroPos)
2020-10-17 02:19:09 +00:00
+ && blockData.getBlock() != Blocks.SPAWNER && blockData.getBlock() != Blocks.BARRIER && blockData.getBlock() != Blocks.SHULKER_BOX && blockData.getBlock() != Blocks.SLIME_BLOCK || paperWorldConfig.lavaObscures && blockData == Blocks.LAVA.getBlockData();
2020-10-16 21:08:33 +00:00
+ // Comparing blockData == Blocks.LAVA.getBlockData() instead of blockData.getBlock() == Blocks.LAVA ensures that only "stationary lava" is used
2019-06-26 04:50:57 +00:00
+ // shulker box checks TE.
+ }
+ }
+
+ this.maxBlockYUpdatePosition = (maxChunkSectionIndex + 1) * 16 + updateRadius - 1;
+ }
+
2020-06-09 08:12:20 +00:00
+ private int getPredefinedBlockDataLength() {
+ return engineMode == EngineMode.HIDE ? 1 : predefinedBlockData.length;
2019-06-26 04:50:57 +00:00
+ }
+
+ @Override
2020-05-06 08:35:20 +00:00
+ public IBlockData[] getPredefinedBlockData(World world, IChunkAccess chunk, ChunkSection chunkSection, boolean initializeBlocks) {
+ // Return the block data which should be added to the data palettes so that they can be used for the obfuscation
2019-06-26 04:50:57 +00:00
+ if (chunkSection.getYPosition() >> 4 <= maxChunkSectionIndex) {
+ switch (engineMode) {
+ case HIDE:
2020-05-06 08:35:20 +00:00
+ switch (world.getWorld().getEnvironment()) {
+ case NETHER:
+ return predefinedBlockDataNetherrack;
+ case THE_END:
+ return predefinedBlockDataEndStone;
+ default:
+ return predefinedBlockDataStone;
2019-06-26 04:50:57 +00:00
+ }
+ default:
+ return predefinedBlockData;
+ }
+ }
+
+ return null;
+ }
+
+ @Override
2020-05-06 08:35:20 +00:00
+ public ChunkPacketInfoAntiXray getChunkPacketInfo(PacketPlayOutMapChunk packetPlayOutMapChunk, Chunk chunk, int chunkSectionSelector) {
2019-07-01 21:36:31 +00:00
+ // Return a new instance to collect data and objects in the right state while creating the chunk packet for thread safe access later
+ // Note: As of 1.14 this has to be moved later due to the chunk system.
+ ChunkPacketInfoAntiXray chunkPacketInfoAntiXray = new ChunkPacketInfoAntiXray(packetPlayOutMapChunk, chunk, chunkSectionSelector, this);
+ return chunkPacketInfoAntiXray;
+ }
+
+ @Override
2020-05-06 08:35:20 +00:00
+ public void modifyBlocks(PacketPlayOutMapChunk packetPlayOutMapChunk, ChunkPacketInfo<IBlockData> chunkPacketInfo) {
2019-07-01 21:36:31 +00:00
+ if (!Bukkit.isPrimaryThread()) {
+ // plugins?
+ MinecraftServer.getServer().scheduleOnMain(() -> {
2020-05-06 08:35:20 +00:00
+ this.modifyBlocks(packetPlayOutMapChunk, chunkPacketInfo);
2019-07-01 21:36:31 +00:00
+ });
+ return;
+ }
2020-05-06 08:35:20 +00:00
+
2019-07-01 21:36:31 +00:00
+ Chunk chunk = chunkPacketInfo.getChunk();
2020-05-06 08:35:20 +00:00
+ int x = chunk.getPos().x;
+ int z = chunk.getPos().z;
2019-07-01 21:36:31 +00:00
+ WorldServer world = (WorldServer)chunk.world;
2020-05-06 08:35:20 +00:00
+ ((ChunkPacketInfoAntiXray) chunkPacketInfo).setNearbyChunks(
+ (Chunk) world.getChunkIfLoadedImmediately(x - 1, z),
+ (Chunk) world.getChunkIfLoadedImmediately(x + 1, z),
+ (Chunk) world.getChunkIfLoadedImmediately(x, z - 1),
+ (Chunk) world.getChunkIfLoadedImmediately(x, z + 1));
2019-06-26 04:50:57 +00:00
+
2020-06-09 08:12:20 +00:00
+ executor.execute((ChunkPacketInfoAntiXray) chunkPacketInfo);
2019-06-26 04:50:57 +00:00
+ }
+
2020-06-09 08:12:20 +00:00
+ // Actually these fields should be variables inside the obfuscate method but in sync mode or with SingleThreadExecutor in async mode it's okay (even without ThreadLocal)
+ // If an ExecutorService with multiple threads is used, ThreadLocal must be used here
+ private final ThreadLocal<int[]> predefinedBlockDataBits = ThreadLocal.withInitial(() -> new int[getPredefinedBlockDataLength()]);
+ private static final ThreadLocal<boolean[]> solid = ThreadLocal.withInitial(() -> new boolean[Block.REGISTRY_ID.size()]);
+ private static final ThreadLocal<boolean[]> obfuscate = ThreadLocal.withInitial(() -> new boolean[Block.REGISTRY_ID.size()]);
2020-05-06 08:35:20 +00:00
+ // These boolean arrays represent chunk layers, true means don't obfuscate, false means obfuscate
2020-06-09 08:12:20 +00:00
+ private static final ThreadLocal<boolean[][]> current = ThreadLocal.withInitial(() -> new boolean[16][16]);
+ private static final ThreadLocal<boolean[][]> next = ThreadLocal.withInitial(() -> new boolean[16][16]);
+ private static final ThreadLocal<boolean[][]> nextNext = ThreadLocal.withInitial(() -> new boolean[16][16]);
2019-06-26 04:50:57 +00:00
+
+ public void obfuscate(ChunkPacketInfoAntiXray chunkPacketInfoAntiXray) {
2020-06-09 08:12:20 +00:00
+ int[] predefinedBlockDataBits = this.predefinedBlockDataBits.get();
+ boolean[] solid = this.solid.get();
+ boolean[] obfuscate = this.obfuscate.get();
+ boolean[][] current = this.current.get();
+ boolean[][] next = this.next.get();
+ boolean[][] nextNext = this.nextNext.get();
+ // dataBitsReader, dataBitsWriter and nearbyChunkSections could also be reused (with ThreadLocal if necessary) but it's not worth it
+ DataBitsReader dataBitsReader = new DataBitsReader();
+ DataBitsWriter dataBitsWriter = new DataBitsWriter();
+ ChunkSection[] nearbyChunkSections = new ChunkSection[4];
2020-05-06 08:35:20 +00:00
+ boolean[] solidTemp = null;
+ boolean[] obfuscateTemp = null;
+ dataBitsReader.setDataBits(chunkPacketInfoAntiXray.getData());
+ dataBitsWriter.setDataBits(chunkPacketInfoAntiXray.getData());
2020-08-07 02:26:01 +00:00
+ int numberOfBlocks = predefinedBlockDataBits.length;
+ // Keep the lambda expressions as simple as possible. They are used very frequently.
+ IntSupplier random = numberOfBlocks == 1 ? (() -> 0) : new IntSupplier() {
+ private int state;
+
+ {
+ while ((state = ThreadLocalRandom.current().nextInt()) == 0);
+ }
+
+ @Override
+ public int getAsInt() {
+ // https://en.wikipedia.org/wiki/Xorshift
+ state ^= state << 13;
+ state ^= state >>> 17;
+ state ^= state << 5;
+ // https://www.pcg-random.org/posts/bounded-rands.html
+ return (int) ((Integer.toUnsignedLong(state) * numberOfBlocks) >>> 32);
+ }
+ };
2020-05-06 08:35:20 +00:00
+
+ for (int chunkSectionIndex = 0; chunkSectionIndex <= maxChunkSectionIndex; chunkSectionIndex++) {
+ if (chunkPacketInfoAntiXray.isWritten(chunkSectionIndex) && chunkPacketInfoAntiXray.getPredefinedObjects(chunkSectionIndex) != null) {
+ int[] predefinedBlockDataBitsTemp;
+
+ if (chunkPacketInfoAntiXray.getDataPalette(chunkSectionIndex) == ChunkSection.GLOBAL_PALETTE) {
+ predefinedBlockDataBitsTemp = engineMode == EngineMode.HIDE ? chunkPacketInfoAntiXray.getChunk().world.getWorld().getEnvironment() == Environment.NETHER ? predefinedBlockDataBitsNetherrackGlobal : chunkPacketInfoAntiXray.getChunk().world.getWorld().getEnvironment() == Environment.THE_END ? predefinedBlockDataBitsEndStoneGlobal : predefinedBlockDataBitsStoneGlobal : predefinedBlockDataBitsGlobal;
+ } else {
2020-06-09 08:12:20 +00:00
+ predefinedBlockDataBitsTemp = predefinedBlockDataBits;
2019-06-26 04:50:57 +00:00
+
2020-05-06 08:35:20 +00:00
+ for (int i = 0; i < predefinedBlockDataBitsTemp.length; i++) {
+ predefinedBlockDataBitsTemp[i] = chunkPacketInfoAntiXray.getDataPalette(chunkSectionIndex).getOrCreateIdFor(chunkPacketInfoAntiXray.getPredefinedObjects(chunkSectionIndex)[i]);
2019-06-26 04:50:57 +00:00
+ }
2020-05-06 08:35:20 +00:00
+ }
2019-06-26 04:50:57 +00:00
+
2020-05-06 08:35:20 +00:00
+ dataBitsWriter.setIndex(chunkPacketInfoAntiXray.getDataBitsIndex(chunkSectionIndex));
+
+ // Check if the chunk section below was not obfuscated
+ if (chunkSectionIndex == 0 || !chunkPacketInfoAntiXray.isWritten(chunkSectionIndex - 1) || chunkPacketInfoAntiXray.getPredefinedObjects(chunkSectionIndex - 1) == null) {
+ // If so, initialize some stuff
+ dataBitsReader.setBitsPerObject(chunkPacketInfoAntiXray.getBitsPerObject(chunkSectionIndex));
+ dataBitsReader.setIndex(chunkPacketInfoAntiXray.getDataBitsIndex(chunkSectionIndex));
+ solidTemp = readDataPalette(chunkPacketInfoAntiXray.getDataPalette(chunkSectionIndex), solid, solidGlobal);
+ obfuscateTemp = readDataPalette(chunkPacketInfoAntiXray.getDataPalette(chunkSectionIndex), obfuscate, obfuscateGlobal);
+ // Read the blocks of the upper layer of the chunk section below if it exists
+ ChunkSection belowChunkSection = null;
+ boolean skipFirstLayer = chunkSectionIndex == 0 || (belowChunkSection = chunkPacketInfoAntiXray.getChunk().getSections()[chunkSectionIndex - 1]) == Chunk.EMPTY_CHUNK_SECTION;
+
+ for (int z = 0; z < 16; z++) {
+ for (int x = 0; x < 16; x++) {
+ current[z][x] = true;
+ next[z][x] = skipFirstLayer || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(belowChunkSection.getType(x, 15, z))];
2019-06-27 02:04:28 +00:00
+ }
+ }
+
2020-05-06 08:35:20 +00:00
+ // Abuse the obfuscateLayer method to read the blocks of the first layer of the current chunk section
+ dataBitsWriter.setBitsPerObject(0);
2020-08-07 02:26:01 +00:00
+ obfuscateLayer(-1, dataBitsReader, dataBitsWriter, solidTemp, obfuscateTemp, predefinedBlockDataBitsTemp, current, next, nextNext, emptyNearbyChunkSections, random);
2020-05-06 08:35:20 +00:00
+ }
2019-06-26 04:50:57 +00:00
+
2020-05-06 08:35:20 +00:00
+ dataBitsWriter.setBitsPerObject(chunkPacketInfoAntiXray.getBitsPerObject(chunkSectionIndex));
+ nearbyChunkSections[0] = chunkPacketInfoAntiXray.getNearbyChunks()[0] == null ? Chunk.EMPTY_CHUNK_SECTION : chunkPacketInfoAntiXray.getNearbyChunks()[0].getSections()[chunkSectionIndex];
+ nearbyChunkSections[1] = chunkPacketInfoAntiXray.getNearbyChunks()[1] == null ? Chunk.EMPTY_CHUNK_SECTION : chunkPacketInfoAntiXray.getNearbyChunks()[1].getSections()[chunkSectionIndex];
+ nearbyChunkSections[2] = chunkPacketInfoAntiXray.getNearbyChunks()[2] == null ? Chunk.EMPTY_CHUNK_SECTION : chunkPacketInfoAntiXray.getNearbyChunks()[2].getSections()[chunkSectionIndex];
+ nearbyChunkSections[3] = chunkPacketInfoAntiXray.getNearbyChunks()[3] == null ? Chunk.EMPTY_CHUNK_SECTION : chunkPacketInfoAntiXray.getNearbyChunks()[3].getSections()[chunkSectionIndex];
+
+ // Obfuscate all layers of the current chunk section except the upper one
+ for (int y = 0; y < 15; y++) {
+ boolean[][] temp = current;
+ current = next;
+ next = nextNext;
+ nextNext = temp;
2020-08-07 02:26:01 +00:00
+ obfuscateLayer(y, dataBitsReader, dataBitsWriter, solidTemp, obfuscateTemp, predefinedBlockDataBitsTemp, current, next, nextNext, nearbyChunkSections, random);
2020-05-06 08:35:20 +00:00
+ }
+
+ // Check if the chunk section above doesn't need obfuscation
+ if (chunkSectionIndex == maxChunkSectionIndex || !chunkPacketInfoAntiXray.isWritten(chunkSectionIndex + 1) || chunkPacketInfoAntiXray.getPredefinedObjects(chunkSectionIndex + 1) == null) {
+ // If so, obfuscate the upper layer of the current chunk section by reading blocks of the first layer from the chunk section above if it exists
+ ChunkSection aboveChunkSection;
+
+ if (chunkSectionIndex != 15 && (aboveChunkSection = chunkPacketInfoAntiXray.getChunk().getSections()[chunkSectionIndex + 1]) != Chunk.EMPTY_CHUNK_SECTION) {
2019-06-26 04:50:57 +00:00
+ boolean[][] temp = current;
+ current = next;
+ next = nextNext;
+ nextNext = temp;
+
2020-05-06 08:35:20 +00:00
+ for (int z = 0; z < 16; z++) {
+ for (int x = 0; x < 16; x++) {
+ if (!solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(aboveChunkSection.getType(x, 0, z))]) {
+ current[z][x] = true;
2019-06-26 04:50:57 +00:00
+ }
+ }
2019-06-27 02:04:28 +00:00
+ }
2019-06-28 15:05:52 +00:00
+
2020-05-06 08:35:20 +00:00
+ // There is nothing to read anymore
+ dataBitsReader.setBitsPerObject(0);
+ solid[0] = true;
2020-08-07 02:26:01 +00:00
+ obfuscateLayer(15, dataBitsReader, dataBitsWriter, solid, obfuscateTemp, predefinedBlockDataBitsTemp, current, next, nextNext, nearbyChunkSections, random);
2020-05-06 08:35:20 +00:00
+ }
2019-07-23 09:59:48 +00:00
+ } else {
2020-05-06 08:35:20 +00:00
+ // If not, initialize the reader and other stuff for the chunk section above to obfuscate the upper layer of the current chunk section
+ dataBitsReader.setBitsPerObject(chunkPacketInfoAntiXray.getBitsPerObject(chunkSectionIndex + 1));
+ dataBitsReader.setIndex(chunkPacketInfoAntiXray.getDataBitsIndex(chunkSectionIndex + 1));
+ solidTemp = readDataPalette(chunkPacketInfoAntiXray.getDataPalette(chunkSectionIndex + 1), solid, solidGlobal);
+ obfuscateTemp = readDataPalette(chunkPacketInfoAntiXray.getDataPalette(chunkSectionIndex + 1), obfuscate, obfuscateGlobal);
+ boolean[][] temp = current;
+ current = next;
+ next = nextNext;
+ nextNext = temp;
2020-08-07 02:26:01 +00:00
+ obfuscateLayer(15, dataBitsReader, dataBitsWriter, solidTemp, obfuscateTemp, predefinedBlockDataBitsTemp, current, next, nextNext, nearbyChunkSections, random);
2019-07-23 09:59:48 +00:00
+ }
2020-05-06 08:35:20 +00:00
+
+ dataBitsWriter.finish();
2019-06-28 15:05:52 +00:00
+ }
2019-06-27 02:04:28 +00:00
+ }
2020-05-06 08:35:20 +00:00
+
+ chunkPacketInfoAntiXray.getPacketPlayOutMapChunk().setReady(true);
2019-06-26 04:50:57 +00:00
+ }
+
2020-08-07 02:26:01 +00:00
+ private void obfuscateLayer(int y, DataBitsReader dataBitsReader, DataBitsWriter dataBitsWriter, boolean[] solid, boolean[] obfuscate, int[] predefinedBlockDataBits, boolean[][] current, boolean[][] next, boolean[][] nextNext, ChunkSection[] nearbyChunkSections, IntSupplier random) {
2020-05-06 08:35:20 +00:00
+ // First block of first line
2019-06-26 04:50:57 +00:00
+ int dataBits = dataBitsReader.read();
+
+ if (nextNext[0][0] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[0][1] = true;
+ next[1][0] = true;
+ } else {
+ if (nearbyChunkSections[2] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[2].getType(0, y, 15))] || nearbyChunkSections[0] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[0].getType(15, y, 0))] || current[0][0]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[0][0] = true;
+ }
+
2020-05-06 08:35:20 +00:00
+ // First line
2019-06-26 04:50:57 +00:00
+ for (int x = 1; x < 15; x++) {
+ dataBits = dataBitsReader.read();
+
+ if (nextNext[0][x] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[0][x - 1] = true;
+ next[0][x + 1] = true;
+ next[1][x] = true;
+ } else {
+ if (nearbyChunkSections[2] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[2].getType(x, y, 15))] || current[0][x]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[0][x] = true;
+ }
+ }
+
2020-05-06 08:35:20 +00:00
+ // Last block of first line
2019-06-26 04:50:57 +00:00
+ dataBits = dataBitsReader.read();
+
+ if (nextNext[0][15] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[0][14] = true;
+ next[1][15] = true;
+ } else {
+ if (nearbyChunkSections[2] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[2].getType(15, y, 15))] || nearbyChunkSections[1] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[1].getType(0, y, 0))] || current[0][15]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[0][15] = true;
+ }
+
2020-05-06 08:35:20 +00:00
+ // All inner lines
2019-06-26 04:50:57 +00:00
+ for (int z = 1; z < 15; z++) {
2020-05-06 08:35:20 +00:00
+ // First block
2019-06-26 04:50:57 +00:00
+ dataBits = dataBitsReader.read();
+
+ if (nextNext[z][0] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[z][1] = true;
+ next[z - 1][0] = true;
+ next[z + 1][0] = true;
+ } else {
+ if (nearbyChunkSections[0] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[0].getType(15, y, z))] || current[z][0]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[z][0] = true;
+ }
+
2020-05-06 08:35:20 +00:00
+ // All inner blocks
2019-06-26 04:50:57 +00:00
+ for (int x = 1; x < 15; x++) {
+ dataBits = dataBitsReader.read();
+
+ if (nextNext[z][x] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[z][x - 1] = true;
+ next[z][x + 1] = true;
+ next[z - 1][x] = true;
+ next[z + 1][x] = true;
+ } else {
+ if (current[z][x]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[z][x] = true;
+ }
+ }
+
2020-05-06 08:35:20 +00:00
+ // Last block
2019-06-26 04:50:57 +00:00
+ dataBits = dataBitsReader.read();
+
+ if (nextNext[z][15] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[z][14] = true;
+ next[z - 1][15] = true;
+ next[z + 1][15] = true;
+ } else {
+ if (nearbyChunkSections[1] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[1].getType(0, y, z))] || current[z][15]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[z][15] = true;
+ }
+ }
+
2020-05-06 08:35:20 +00:00
+ // First block of last line
2019-06-26 04:50:57 +00:00
+ dataBits = dataBitsReader.read();
+
+ if (nextNext[15][0] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[15][1] = true;
+ next[14][0] = true;
+ } else {
+ if (nearbyChunkSections[3] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[3].getType(0, y, 0))] || nearbyChunkSections[0] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[0].getType(15, y, 15))] || current[15][0]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[15][0] = true;
+ }
+
2020-05-06 08:35:20 +00:00
+ // Last line
2019-06-26 04:50:57 +00:00
+ for (int x = 1; x < 15; x++) {
+ dataBits = dataBitsReader.read();
+
+ if (nextNext[15][x] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[15][x - 1] = true;
+ next[15][x + 1] = true;
+ next[14][x] = true;
+ } else {
+ if (nearbyChunkSections[3] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[3].getType(x, y, 0))] || current[15][x]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[15][x] = true;
+ }
+ }
+
2020-05-06 08:35:20 +00:00
+ // Last block of last line
2019-06-26 04:50:57 +00:00
+ dataBits = dataBitsReader.read();
+
+ if (nextNext[15][15] = !solid[dataBits]) {
+ dataBitsWriter.skip();
+ next[15][14] = true;
+ next[14][15] = true;
+ } else {
+ if (nearbyChunkSections[3] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[3].getType(15, y, 0))] || nearbyChunkSections[1] == Chunk.EMPTY_CHUNK_SECTION || !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(nearbyChunkSections[1].getType(0, y, 15))] || current[15][15]) {
+ dataBitsWriter.skip();
+ } else {
2020-08-07 02:26:01 +00:00
+ dataBitsWriter.write(predefinedBlockDataBits[random.getAsInt()]);
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ if (!obfuscate[dataBits]) {
+ next[15][15] = true;
+ }
+ }
+
+ private boolean[] readDataPalette(DataPalette<IBlockData> dataPalette, boolean[] temp, boolean[] global) {
+ if (dataPalette == ChunkSection.GLOBAL_PALETTE) {
+ return global;
+ }
+
+ IBlockData blockData;
+
+ for (int i = 0; (blockData = dataPalette.getObject(i)) != null; i++) {
+ temp[i] = global[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(blockData)];
+ }
+
+ return temp;
+ }
+
+ @Override
+ public void onBlockChange(World world, BlockPosition blockPosition, IBlockData newBlockData, IBlockData oldBlockData, int flag) {
+ if (oldBlockData != null && solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(oldBlockData)] && !solidGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(newBlockData)] && blockPosition.getY() <= maxBlockYUpdatePosition) {
+ updateNearbyBlocks(world, blockPosition);
+ }
+ }
+
+ @Override
+ public void onPlayerLeftClickBlock(PlayerInteractManager playerInteractManager, BlockPosition blockPosition, EnumDirection enumDirection) {
+ if (blockPosition.getY() <= maxBlockYUpdatePosition) {
+ updateNearbyBlocks(playerInteractManager.world, blockPosition);
+ }
+ }
+
+ private void updateNearbyBlocks(World world, BlockPosition blockPosition) {
+ if (updateRadius >= 2) {
+ BlockPosition temp = blockPosition.west();
+ updateBlock(world, temp);
+ updateBlock(world, temp.west());
+ updateBlock(world, temp.down());
+ updateBlock(world, temp.up());
+ updateBlock(world, temp.north());
+ updateBlock(world, temp.south());
+ updateBlock(world, temp = blockPosition.east());
+ updateBlock(world, temp.east());
+ updateBlock(world, temp.down());
+ updateBlock(world, temp.up());
+ updateBlock(world, temp.north());
+ updateBlock(world, temp.south());
+ updateBlock(world, temp = blockPosition.down());
+ updateBlock(world, temp.down());
+ updateBlock(world, temp.north());
+ updateBlock(world, temp.south());
+ updateBlock(world, temp = blockPosition.up());
+ updateBlock(world, temp.up());
+ updateBlock(world, temp.north());
+ updateBlock(world, temp.south());
+ updateBlock(world, temp = blockPosition.north());
+ updateBlock(world, temp.north());
+ updateBlock(world, temp = blockPosition.south());
+ updateBlock(world, temp.south());
+ } else if (updateRadius == 1) {
+ updateBlock(world, blockPosition.west());
+ updateBlock(world, blockPosition.east());
+ updateBlock(world, blockPosition.down());
+ updateBlock(world, blockPosition.up());
+ updateBlock(world, blockPosition.north());
+ updateBlock(world, blockPosition.south());
+ } else {
2020-05-06 08:35:20 +00:00
+ // Do nothing if updateRadius <= 0 (test mode)
2019-06-26 04:50:57 +00:00
+ }
+ }
+
+ private void updateBlock(World world, BlockPosition blockPosition) {
+ IBlockData blockData = world.getTypeIfLoaded(blockPosition);
+
+ if (blockData != null && obfuscateGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(blockData)]) {
2020-05-06 08:35:20 +00:00
+ // world.notify(blockPosition, blockData, blockData, 3);
2019-06-26 04:50:57 +00:00
+ ((WorldServer)world).getChunkProvider().flagDirty(blockPosition); // We only need to re-send to client
+ }
+ }
+
+ public enum EngineMode {
+
+ HIDE(1, "hide ores"),
+ OBFUSCATE(2, "obfuscate");
+
+ private final int id;
+ private final String description;
+
+ EngineMode(int id, String description) {
+ this.id = id;
+ this.description = description;
+ }
+
+ public static EngineMode getById(int id) {
+ for (EngineMode engineMode : values()) {
+ if (engineMode.id == id) {
+ return engineMode;
+ }
+ }
+
+ return null;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfo.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfo.java
new file mode 100644
2020-05-06 09:48:49 +00:00
index 0000000000000000000000000000000000000000..41618994b463267e41a9eb312db682e497c68e1b
2019-06-26 04:50:57 +00:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfo.java
@@ -0,0 +1,81 @@
+package com.destroystokyo.paper.antixray;
+
+import net.minecraft.server.Chunk;
+import net.minecraft.server.DataPalette;
+import net.minecraft.server.PacketPlayOutMapChunk;
+
+public class ChunkPacketInfo<T> {
+
+ private final PacketPlayOutMapChunk packetPlayOutMapChunk;
+ private final Chunk chunk;
+ private final int chunkSectionSelector;
+ private byte[] data;
+ private final int[] bitsPerObject = new int[16];
+ private final Object[] dataPalettes = new Object[16];
+ private final int[] dataBitsIndexes = new int[16];
+ private final Object[][] predefinedObjects = new Object[16][];
+
+ public ChunkPacketInfo(PacketPlayOutMapChunk packetPlayOutMapChunk, Chunk chunk, int chunkSectionSelector) {
+ this.packetPlayOutMapChunk = packetPlayOutMapChunk;
+ this.chunk = chunk;
+ this.chunkSectionSelector = chunkSectionSelector;
+ }
+
+ public PacketPlayOutMapChunk getPacketPlayOutMapChunk() {
+ return packetPlayOutMapChunk;
+ }
+
+ public Chunk getChunk() {
+ return chunk;
+ }
+
+ public int getChunkSectionSelector() {
+ return chunkSectionSelector;
+ }
+
+ public byte[] getData() {
+ return data;
+ }
+
+ public void setData(byte[] data) {
+ this.data = data;
+ }
+
+ public int getBitsPerObject(int chunkSectionIndex) {
+ return bitsPerObject[chunkSectionIndex];
+ }
+
+ public void setBitsPerObject(int chunkSectionIndex, int bitsPerObject) {
+ this.bitsPerObject[chunkSectionIndex] = bitsPerObject;
+ }
+
+ @SuppressWarnings("unchecked")
+ public DataPalette<T> getDataPalette(int chunkSectionIndex) {
+ return (DataPalette<T>) dataPalettes[chunkSectionIndex];
+ }
+
+ public void setDataPalette(int chunkSectionIndex, DataPalette<T> dataPalette) {
+ dataPalettes[chunkSectionIndex] = dataPalette;
+ }
+
2020-05-06 08:35:20 +00:00
+ public int getDataBitsIndex(int chunkSectionIndex) {
2019-06-26 04:50:57 +00:00
+ return dataBitsIndexes[chunkSectionIndex];
+ }
+
+ public void setDataBitsIndex(int chunkSectionIndex, int dataBitsIndex) {
+ dataBitsIndexes[chunkSectionIndex] = dataBitsIndex;
+ }
+
+ @SuppressWarnings("unchecked")
+ public T[] getPredefinedObjects(int chunkSectionIndex) {
+ return (T[]) predefinedObjects[chunkSectionIndex];
+ }
+
+ public void setPredefinedObjects(int chunkSectionIndex, T[] predefinedObjects) {
+ this.predefinedObjects[chunkSectionIndex] = predefinedObjects;
+ }
+
+ public boolean isWritten(int chunkSectionIndex) {
+ return bitsPerObject[chunkSectionIndex] != 0;
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfoAntiXray.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfoAntiXray.java
new file mode 100644
2020-05-06 09:48:49 +00:00
index 0000000000000000000000000000000000000000..e61421d87a19bf2f6ce8836b48c445ffdb6772df
2019-06-26 04:50:57 +00:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfoAntiXray.java
2020-05-06 08:35:20 +00:00
@@ -0,0 +1,30 @@
2019-06-26 04:50:57 +00:00
+package com.destroystokyo.paper.antixray;
+
+import net.minecraft.server.Chunk;
+import net.minecraft.server.IBlockData;
+import net.minecraft.server.PacketPlayOutMapChunk;
+
2020-05-06 08:35:20 +00:00
+public final class ChunkPacketInfoAntiXray extends ChunkPacketInfo<IBlockData> implements Runnable {
2019-06-26 04:50:57 +00:00
+
+ private Chunk[] nearbyChunks;
+ private final ChunkPacketBlockControllerAntiXray chunkPacketBlockControllerAntiXray;
+
2019-06-27 02:04:28 +00:00
+ public ChunkPacketInfoAntiXray(PacketPlayOutMapChunk packetPlayOutMapChunk, Chunk chunk, int chunkSectionSelector,
2019-07-01 21:36:31 +00:00
+ ChunkPacketBlockControllerAntiXray chunkPacketBlockControllerAntiXray) {
2019-06-26 04:50:57 +00:00
+ super(packetPlayOutMapChunk, chunk, chunkSectionSelector);
+ this.chunkPacketBlockControllerAntiXray = chunkPacketBlockControllerAntiXray;
+ }
+
+ public Chunk[] getNearbyChunks() {
+ return nearbyChunks;
+ }
+
+ public void setNearbyChunks(Chunk... nearbyChunks) {
+ this.nearbyChunks = nearbyChunks;
+ }
+
+ @Override
+ public void run() {
+ chunkPacketBlockControllerAntiXray.obfuscate(this);
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/antixray/DataBitsReader.java b/src/main/java/com/destroystokyo/paper/antixray/DataBitsReader.java
new file mode 100644
2020-06-27 02:27:03 +00:00
index 0000000000000000000000000000000000000000..298ea423084dbcc1b61f991bcd82b8ae51bf0977
2019-06-26 04:50:57 +00:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/antixray/DataBitsReader.java
2020-06-27 02:27:03 +00:00
@@ -0,0 +1,51 @@
2019-06-26 04:50:57 +00:00
+package com.destroystokyo.paper.antixray;
+
2020-05-06 08:35:20 +00:00
+public final class DataBitsReader {
2019-06-26 04:50:57 +00:00
+
+ private byte[] dataBits;
+ private int bitsPerObject;
+ private int mask;
+ private int longInDataBitsIndex;
+ private int bitInLongIndex;
+ private long current;
+
+ public void setDataBits(byte[] dataBits) {
+ this.dataBits = dataBits;
+ }
+
+ public void setBitsPerObject(int bitsPerObject) {
+ this.bitsPerObject = bitsPerObject;
+ mask = (1 << bitsPerObject) - 1;
+ }
+
+ public void setIndex(int index) {
+ this.longInDataBitsIndex = index;
+ bitInLongIndex = 0;
+ init();
+ }
+
+ private void init() {
+ if (dataBits.length > longInDataBitsIndex + 7) {
+ current = ((((long) dataBits[longInDataBitsIndex]) << 56)
+ | (((long) dataBits[longInDataBitsIndex + 1] & 0xff) << 48)
+ | (((long) dataBits[longInDataBitsIndex + 2] & 0xff) << 40)
+ | (((long) dataBits[longInDataBitsIndex + 3] & 0xff) << 32)
+ | (((long) dataBits[longInDataBitsIndex + 4] & 0xff) << 24)
+ | (((long) dataBits[longInDataBitsIndex + 5] & 0xff) << 16)
+ | (((long) dataBits[longInDataBitsIndex + 6] & 0xff) << 8)
+ | (((long) dataBits[longInDataBitsIndex + 7] & 0xff)));
+ }
+ }
+
+ public int read() {
2020-06-27 02:27:03 +00:00
+ if (bitInLongIndex + bitsPerObject > 64) {
+ bitInLongIndex = 0;
2019-06-26 04:50:57 +00:00
+ longInDataBitsIndex += 8;
+ init();
+ }
+
2020-06-27 02:27:03 +00:00
+ int value = (int) (current >>> bitInLongIndex) & mask;
+ bitInLongIndex += bitsPerObject;
2019-06-26 04:50:57 +00:00
+ return value;
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/antixray/DataBitsWriter.java b/src/main/java/com/destroystokyo/paper/antixray/DataBitsWriter.java
new file mode 100644
2020-06-27 02:27:03 +00:00
index 0000000000000000000000000000000000000000..333763936897befda5bb6c077944d2667f922799
2019-06-26 04:50:57 +00:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/antixray/DataBitsWriter.java
2020-06-27 02:27:03 +00:00
@@ -0,0 +1,79 @@
2019-06-26 04:50:57 +00:00
+package com.destroystokyo.paper.antixray;
+
2020-05-06 08:35:20 +00:00
+public final class DataBitsWriter {
2019-06-26 04:50:57 +00:00
+
+ private byte[] dataBits;
+ private int bitsPerObject;
+ private long mask;
+ private int longInDataBitsIndex;
+ private int bitInLongIndex;
+ private long current;
+ private boolean dirty;
+
+ public void setDataBits(byte[] dataBits) {
+ this.dataBits = dataBits;
+ }
+
+ public void setBitsPerObject(int bitsPerObject) {
+ this.bitsPerObject = bitsPerObject;
+ mask = (1 << bitsPerObject) - 1;
+ }
+
+ public void setIndex(int index) {
+ this.longInDataBitsIndex = index;
+ bitInLongIndex = 0;
+ init();
+ }
+
+ private void init() {
+ if (dataBits.length > longInDataBitsIndex + 7) {
+ current = ((((long) dataBits[longInDataBitsIndex]) << 56)
+ | (((long) dataBits[longInDataBitsIndex + 1] & 0xff) << 48)
+ | (((long) dataBits[longInDataBitsIndex + 2] & 0xff) << 40)
+ | (((long) dataBits[longInDataBitsIndex + 3] & 0xff) << 32)
+ | (((long) dataBits[longInDataBitsIndex + 4] & 0xff) << 24)
+ | (((long) dataBits[longInDataBitsIndex + 5] & 0xff) << 16)
+ | (((long) dataBits[longInDataBitsIndex + 6] & 0xff) << 8)
+ | (((long) dataBits[longInDataBitsIndex + 7] & 0xff)));
+ }
+
+ dirty = false;
+ }
+
+ public void finish() {
+ if (dirty && dataBits.length > longInDataBitsIndex + 7) {
+ dataBits[longInDataBitsIndex] = (byte) (current >> 56 & 0xff);
+ dataBits[longInDataBitsIndex + 1] = (byte) (current >> 48 & 0xff);
+ dataBits[longInDataBitsIndex + 2] = (byte) (current >> 40 & 0xff);
+ dataBits[longInDataBitsIndex + 3] = (byte) (current >> 32 & 0xff);
+ dataBits[longInDataBitsIndex + 4] = (byte) (current >> 24 & 0xff);
+ dataBits[longInDataBitsIndex + 5] = (byte) (current >> 16 & 0xff);
+ dataBits[longInDataBitsIndex + 6] = (byte) (current >> 8 & 0xff);
+ dataBits[longInDataBitsIndex + 7] = (byte) (current & 0xff);
+ }
+ }
+
+ public void write(int value) {
2020-06-27 02:27:03 +00:00
+ if (bitInLongIndex + bitsPerObject > 64) {
2019-06-26 04:50:57 +00:00
+ finish();
2020-06-27 02:27:03 +00:00
+ bitInLongIndex = 0;
2019-06-26 04:50:57 +00:00
+ longInDataBitsIndex += 8;
+ init();
+ }
2020-06-27 02:27:03 +00:00
+
+ current = current & ~(mask << bitInLongIndex) | (value & mask) << bitInLongIndex;
+ dirty = true;
+ bitInLongIndex += bitsPerObject;
2019-06-26 04:50:57 +00:00
+ }
+
+ public void skip() {
+ bitInLongIndex += bitsPerObject;
+
2020-06-27 02:27:03 +00:00
+ if (bitInLongIndex > 64) {
2019-06-26 04:50:57 +00:00
+ finish();
2020-06-27 02:27:03 +00:00
+ bitInLongIndex = bitsPerObject;
2019-06-26 04:50:57 +00:00
+ longInDataBitsIndex += 8;
+ init();
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java
2020-10-17 10:39:45 +00:00
index 71efd1efab43d5aeabba2ad385016b616f4e4849..4ff3eff58fa8007eca7eec22ef53d23705a98ed9 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/Chunk.java
+++ b/src/main/java/net/minecraft/server/Chunk.java
2020-10-17 10:39:45 +00:00
@@ -426,7 +426,7 @@ public class Chunk implements IChunkAccess {
2019-06-26 04:50:57 +00:00
return null;
}
- chunksection = new ChunkSection(j >> 4 << 4);
2020-05-06 08:35:20 +00:00
+ chunksection = new ChunkSection(j >> 4 << 4, this, this.world, true); // Paper - Anti-Xray - Add parameters
2019-06-26 04:50:57 +00:00
this.sections[j >> 4] = chunksection;
}
2020-08-25 02:22:08 +00:00
diff --git a/src/main/java/net/minecraft/server/ChunkEmpty.java b/src/main/java/net/minecraft/server/ChunkEmpty.java
index ed22ff28ea6c0978ec0d9d1ecf7baa3f422ed677..d2286f1549de563332c3e4181b9ada30845b3725 100644
--- a/src/main/java/net/minecraft/server/ChunkEmpty.java
+++ b/src/main/java/net/minecraft/server/ChunkEmpty.java
@@ -12,7 +12,7 @@ public class ChunkEmpty extends Chunk {
});
public ChunkEmpty(World world, ChunkCoordIntPair chunkcoordintpair) {
- super(world, chunkcoordintpair, new BiomeStorage(world.r().b(IRegistry.ay), ChunkEmpty.b));
+ super(world, chunkcoordintpair, new BiomeStorage(MinecraftServer.getServer().getCustomRegistry().b(IRegistry.ay), ChunkEmpty.b)); // Paper - world isnt ready yet for anti xray use here, use server singleton for registry
}
// Paper start
2019-06-26 04:50:57 +00:00
diff --git a/src/main/java/net/minecraft/server/ChunkRegionLoader.java b/src/main/java/net/minecraft/server/ChunkRegionLoader.java
2020-11-03 02:22:15 +00:00
index 23664a8e7c6e642e601fd83c875e5be56826be74..2dc4f1b689d2a2af9ae42156d954eb5284297ec0 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/ChunkRegionLoader.java
+++ b/src/main/java/net/minecraft/server/ChunkRegionLoader.java
2020-06-25 23:38:24 +00:00
@@ -58,7 +58,7 @@ public class ChunkRegionLoader {
2019-06-26 04:50:57 +00:00
byte b0 = nbttagcompound2.getByte("Y");
if (nbttagcompound2.hasKeyOfType("Palette", 9) && nbttagcompound2.hasKeyOfType("BlockStates", 12)) {
- ChunkSection chunksection = new ChunkSection(b0 << 4);
2020-05-06 08:35:20 +00:00
+ ChunkSection chunksection = new ChunkSection(b0 << 4, null, worldserver, false); // Paper - Anti-Xray - Add parameters
2019-06-26 04:50:57 +00:00
chunksection.getBlocks().a(nbttagcompound2.getList("Palette", 10), nbttagcompound2.getLongArray("BlockStates"));
chunksection.recalcBlockCounts();
2020-10-17 10:39:45 +00:00
@@ -122,7 +122,7 @@ public class ChunkRegionLoader {
// CraftBukkit end
2019-06-26 04:50:57 +00:00
});
} else {
- ProtoChunk protochunk = new ProtoChunk(chunkcoordintpair, chunkconverter, achunksection, protochunkticklist, protochunkticklist1);
2020-05-06 08:35:20 +00:00
+ ProtoChunk protochunk = new ProtoChunk(chunkcoordintpair, chunkconverter, achunksection, protochunkticklist, protochunkticklist1, worldserver); // Paper - Anti-Xray - Add parameter
2019-06-26 04:50:57 +00:00
2019-12-12 16:20:43 +00:00
protochunk.a(biomestorage);
2019-06-26 04:50:57 +00:00
object = protochunk;
diff --git a/src/main/java/net/minecraft/server/ChunkSection.java b/src/main/java/net/minecraft/server/ChunkSection.java
2020-08-25 02:22:08 +00:00
index 5c7068cd93806d67c643ed6aabdfcab8888ed94e..90bb2f7ad9f82818d58de9be918f1299c6725070 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/ChunkSection.java
+++ b/src/main/java/net/minecraft/server/ChunkSection.java
2020-06-25 23:38:24 +00:00
@@ -1,6 +1,7 @@
2020-05-06 08:35:20 +00:00
package net.minecraft.server;
2020-06-25 23:38:24 +00:00
import java.util.function.Predicate;
2020-05-06 08:35:20 +00:00
+import com.destroystokyo.paper.antixray.ChunkPacketInfo; // Paper - Anti-Xray - Add chunk packet info
import javax.annotation.Nullable;
2019-06-26 04:50:57 +00:00
2020-05-06 08:35:20 +00:00
public class ChunkSection {
2020-06-25 23:38:24 +00:00
@@ -12,16 +13,22 @@ public class ChunkSection {
2019-06-26 04:50:57 +00:00
private short e;
2020-08-25 02:22:08 +00:00
final DataPaletteBlock<IBlockData> blockIds; // Paper - package-private
2019-06-26 04:50:57 +00:00
2020-05-06 08:35:20 +00:00
- public ChunkSection(int i) {
2019-06-26 04:50:57 +00:00
- this(i, (short) 0, (short) 0, (short) 0);
2020-05-06 08:35:20 +00:00
+ // Paper start - Anti-Xray - Add parameters
+ @Deprecated public ChunkSection(int i) { this(i, null, null, true); } // Notice for updates: Please make sure this constructor isn't used anywhere
+ public ChunkSection(int i, IChunkAccess chunk, World world, boolean initializeBlocks) {
2019-06-26 04:50:57 +00:00
+ this(i, (short) 0, (short) 0, (short) 0, chunk, world, initializeBlocks);
+ // Paper end
}
2020-05-06 08:35:20 +00:00
- public ChunkSection(int i, short short0, short short1, short short2) {
+ // Paper start - Anti-Xray - Add parameters
+ @Deprecated public ChunkSection(int i, short short0, short short1, short short2) { this(i, short0, short1, short2, null, null, true); } // Notice for updates: Please make sure this constructor isn't used anywhere
+ public ChunkSection(int i, short short0, short short1, short short2, IChunkAccess chunk, World world, boolean initializeBlocks) {
2019-06-26 04:50:57 +00:00
+ // Paper end
this.yPos = i;
this.nonEmptyBlockCount = short0;
this.tickingBlockCount = short1;
this.e = short2;
2020-06-25 23:38:24 +00:00
- this.blockIds = new DataPaletteBlock<>(ChunkSection.GLOBAL_PALETTE, Block.REGISTRY_ID, GameProfileSerializer::c, GameProfileSerializer::a, Blocks.AIR.getBlockData());
+ this.blockIds = new DataPaletteBlock<>(ChunkSection.GLOBAL_PALETTE, Block.REGISTRY_ID, GameProfileSerializer::c, GameProfileSerializer::a, Blocks.AIR.getBlockData(), world == null ? null : world.chunkPacketBlockController.getPredefinedBlockData(world, chunk, this, initializeBlocks), initializeBlocks); // Paper - Anti-Xray - Add predefined block data
2019-06-26 04:50:57 +00:00
}
2020-06-05 05:25:11 +00:00
public final IBlockData getType(int i, int j, int k) { // Paper
2020-06-25 23:38:24 +00:00
@@ -133,10 +140,14 @@ public class ChunkSection {
2020-05-06 08:35:20 +00:00
return this.blockIds;
}
- public void writeChunkSection(PacketDataSerializer packetDataSerializer) { this.b(packetDataSerializer); } // Paper - OBFHELPER
- public void b(PacketDataSerializer packetdataserializer) {
+ // Paper start - Anti-Xray - Add chunk packet info
2020-08-02 05:39:36 +00:00
+ @Deprecated public final void writeChunkSection(PacketDataSerializer packetDataSerializer) { this.b(packetDataSerializer); } // OBFHELPER // Notice for updates: Please make sure this method isn't used anywhere
+ @Deprecated public final void b(PacketDataSerializer packetdataserializer) { this.writeChunkSection(packetdataserializer, null); } // Notice for updates: Please make sure this method isn't used anywhere
+ public final void writeChunkSection(PacketDataSerializer packetDataSerializer, ChunkPacketInfo<IBlockData> chunkPacketInfo) { this.b(packetDataSerializer, chunkPacketInfo); } // OBFHELPER
2020-05-06 08:35:20 +00:00
+ public void b(PacketDataSerializer packetdataserializer, ChunkPacketInfo<IBlockData> chunkPacketInfo) {
+ // Paper end
packetdataserializer.writeShort(this.nonEmptyBlockCount);
- this.blockIds.b(packetdataserializer);
+ this.blockIds.writeDataPaletteBlock(packetdataserializer, chunkPacketInfo, this.yPos >> 4); // Paper - Anti-Xray - Add chunk packet info
}
public int j() {
2019-06-26 04:50:57 +00:00
diff --git a/src/main/java/net/minecraft/server/DataPaletteBlock.java b/src/main/java/net/minecraft/server/DataPaletteBlock.java
2020-08-02 05:39:36 +00:00
index f4c1b8d32b239c44e70d3fa6d094b74955f75339..ed77117630d54b7ad81f633110c7d2a7c59288e9 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/DataPaletteBlock.java
+++ b/src/main/java/net/minecraft/server/DataPaletteBlock.java
2020-06-25 23:38:24 +00:00
@@ -1,6 +1,7 @@
package net.minecraft.server;
2019-07-20 04:01:24 +00:00
import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
2020-05-06 08:35:20 +00:00
+import com.destroystokyo.paper.antixray.ChunkPacketInfo; // Paper - Anti-Xray - Add chunk packet info
2019-06-26 04:50:57 +00:00
import java.util.Arrays;
import java.util.Objects;
import java.util.concurrent.locks.ReentrantLock;
2020-06-25 23:38:24 +00:00
@@ -18,6 +19,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
2019-06-26 04:50:57 +00:00
private final Function<NBTTagCompound, T> e;
private final Function<T, NBTTagCompound> f;
private final T g;
+ private final T[] predefinedObjects; // Paper - Anti-Xray - Add predefined objects
2020-08-02 05:39:36 +00:00
protected DataBits a; public final DataBits getDataBits() { return this.a; } // Paper - OBFHELPER
2019-06-26 04:50:57 +00:00
private DataPalette<T> h; private DataPalette<T> getDataPalette() { return this.h; } // Paper - OBFHELPER
private int i; private int getBitsPerObject() { return this.i; } // Paper - OBFHELPER
2020-06-25 23:38:24 +00:00
@@ -42,14 +44,47 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
2020-05-30 00:36:42 +00:00
//this.j.unlock(); // Paper - disable this
2019-06-26 04:50:57 +00:00
}
2020-05-06 08:35:20 +00:00
- public DataPaletteBlock(DataPalette<T> datapalette, RegistryBlockID<T> registryblockid, Function<NBTTagCompound, T> function, Function<T, NBTTagCompound> function1, T t0) {
+ // Paper start - Anti-Xray - Add predefined objects
+ @Deprecated public DataPaletteBlock(DataPalette<T> datapalette, RegistryBlockID<T> registryblockid, Function<NBTTagCompound, T> function, Function<T, NBTTagCompound> function1, T t0) { this(datapalette, registryblockid, function, function1, t0, null, true); } // Notice for updates: Please make sure this constructor isn't used anywhere
2019-06-26 04:50:57 +00:00
+ public DataPaletteBlock(DataPalette<T> datapalette, RegistryBlockID<T> registryblockid, Function<NBTTagCompound, T> function, Function<T, NBTTagCompound> function1, T t0, T[] predefinedObjects, boolean initialize) {
2020-05-06 08:35:20 +00:00
+ // Paper end
2019-06-26 04:50:57 +00:00
this.b = datapalette;
this.d = registryblockid;
this.e = function;
this.f = function1;
this.g = t0;
- this.b(4);
+ // Paper start - Anti-Xray - Add predefined objects
+ this.predefinedObjects = predefinedObjects;
+
+ if (initialize) {
+ if (predefinedObjects == null) {
+ // Default
+ this.initialize(4);
+ } else {
+ // MathHelper.d() is trailingBits(roundCeilPow2(n)), alternatively; (int)ceil(log2(n)); however it's trash, use numberOfLeadingZeros instead
+ // Count the bits of the maximum array index to initialize a data palette with enough space from the beginning
+ // The length of the array is used because air is also added to the data palette from the beginning
+ // Start with at least 4
+ int maxIndex = predefinedObjects.length >> 4;
+ int bitCount = (32 - Integer.numberOfLeadingZeros(Math.max(16, maxIndex) - 1));
+
+ // Initialize with at least 15 free indixes
+ this.initialize((1 << bitCount) - predefinedObjects.length < 16 ? bitCount + 1 : bitCount);
+ this.addPredefinedObjects();
+ }
+ }
+ // Paper end
2020-05-06 08:35:20 +00:00
+ }
+
2019-06-26 04:50:57 +00:00
+ // Paper start - Anti-Xray - Add predefined objects
+ private void addPredefinedObjects() {
+ if (this.predefinedObjects != null && this.getDataPalette() != this.getDataPaletteGlobal()) {
+ for (int i = 0; i < this.predefinedObjects.length; i++) {
+ this.getDataPalette().getOrCreateIdFor(this.predefinedObjects[i]);
+ }
+ }
2020-05-06 08:35:20 +00:00
}
2019-06-26 04:50:57 +00:00
+ // Paper end
2020-05-06 08:35:20 +00:00
2019-06-26 04:50:57 +00:00
private static int b(int i, int j, int k) {
return j << 8 | k << 4 | i;
2020-06-25 23:38:24 +00:00
@@ -84,6 +119,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
2019-06-26 04:50:57 +00:00
int j;
+ this.addPredefinedObjects(); // Paper - Anti-Xray - Add predefined objects
for (j = 0; j < databits.b(); ++j) {
T t1 = datapalette.a(databits.a(j));
2020-06-25 23:38:24 +00:00
@@ -133,24 +169,38 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
2020-05-06 08:35:20 +00:00
return t0 == null ? this.g : t0;
}
2019-06-26 04:50:57 +00:00
2020-05-06 08:35:20 +00:00
- public void writeDataPaletteBlock(PacketDataSerializer packetDataSerializer) { this.b(packetDataSerializer); } // Paper - OBFHELPER
2020-05-30 00:36:42 +00:00
- public synchronized void b(PacketDataSerializer packetdataserializer) { // Paper - synchronize
2020-05-06 08:35:20 +00:00
+ // Paper start - Anti-Xray - Add chunk packet info
+ @Deprecated public void writeDataPaletteBlock(PacketDataSerializer packetDataSerializer) { this.b(packetDataSerializer); } // OBFHELPER // Notice for updates: Please make sure this method isn't used anywhere
+ @Deprecated public void b(PacketDataSerializer packetdataserializer) { this.writeDataPaletteBlock(packetdataserializer, null, 0); } // Notice for updates: Please make sure this method isn't used anywhere
+ public void writeDataPaletteBlock(PacketDataSerializer packetDataSerializer, ChunkPacketInfo<T> chunkPacketInfo, int chunkSectionIndex) { this.b(packetDataSerializer, chunkPacketInfo, chunkSectionIndex); } // OBFHELPER
2020-05-30 00:36:42 +00:00
+ public synchronized void b(PacketDataSerializer packetdataserializer, ChunkPacketInfo<T> chunkPacketInfo, int chunkSectionIndex) { // Paper - synchronize
2019-06-26 04:50:57 +00:00
+ // Paper end
this.a();
packetdataserializer.writeByte(this.i);
this.h.b(packetdataserializer);
+ // Paper start - Anti-Xray - Add chunk packet info
+ if (chunkPacketInfo != null) {
+ chunkPacketInfo.setBitsPerObject(chunkSectionIndex, this.getBitsPerObject());
+ chunkPacketInfo.setDataPalette(chunkSectionIndex, this.getDataPalette());
+ chunkPacketInfo.setDataBitsIndex(chunkSectionIndex, packetdataserializer.writerIndex() + PacketDataSerializer.countBytes(this.getDataBits().getDataBits().length));
+ chunkPacketInfo.setPredefinedObjects(chunkSectionIndex, this.predefinedObjects);
+ }
+ // Paper end
packetdataserializer.a(this.a.a());
this.b();
}
2020-05-30 00:36:42 +00:00
public synchronized void a(NBTTagList nbttaglist, long[] along) { // Paper - synchronize
2019-06-26 04:50:57 +00:00
this.a();
2020-06-25 23:38:24 +00:00
- int i = Math.max(4, MathHelper.e(nbttaglist.size()));
2019-06-26 04:50:57 +00:00
+ // Paper - Anti-Xray - TODO: Should this.predefinedObjects.length just be added here (faster) or should the contents be compared to calculate the size (less RAM)?
2020-06-25 23:38:24 +00:00
+ int i = Math.max(4, MathHelper.e(nbttaglist.size() + (this.predefinedObjects == null ? 0 : this.predefinedObjects.length))); // Paper - Anti-Xray - Calculate the size with predefined objects
2019-06-26 04:50:57 +00:00
- if (i != this.i) {
+ if (true || i != this.i) { // Paper - Anti-Xray - Not initialized yet
this.b(i);
}
this.h.a(nbttaglist);
+ this.addPredefinedObjects(); // Paper - Anti-Xray - Add predefined objects
int j = along.length * 64 / 4096;
if (this.h == this.b) {
diff --git a/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java b/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
2020-08-25 02:22:08 +00:00
index 5fae0ec8933cef2b87d2f465c8019af0af2e130d..5094a5d6fb3c1a84d6e8f6abe79e894c047d9cfa 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
+++ b/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
@@ -1,5 +1,6 @@
package net.minecraft.server;
2020-05-06 08:35:20 +00:00
+import com.destroystokyo.paper.antixray.ChunkPacketInfo; // Paper - Anti-Xray - Add chunk packet info
2019-06-26 04:50:57 +00:00
import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
2020-08-25 02:22:08 +00:00
@@ -21,7 +22,13 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
private List<NBTTagCompound> g;
2019-12-12 16:20:43 +00:00
private boolean h;
2019-06-26 04:50:57 +00:00
- public PacketPlayOutMapChunk() {}
2020-05-06 08:35:20 +00:00
+ // Paper start - Async-Anti-Xray - Set the ready flag to true
2020-06-25 23:38:24 +00:00
+ private volatile boolean ready; // Paper - Async-Anti-Xray - Ready flag for the network manager
2019-06-26 04:50:57 +00:00
+ public PacketPlayOutMapChunk() {
2020-05-06 08:35:20 +00:00
+ this.ready = true;
2019-06-26 04:50:57 +00:00
+ }
2020-05-06 08:35:20 +00:00
+ // Paper end
2020-08-25 02:22:08 +00:00
+
2019-06-26 04:50:57 +00:00
// Paper start
private final java.util.List<Packet> extraPackets = new java.util.ArrayList<>();
2020-08-25 02:22:08 +00:00
private static final int TE_LIMIT = Integer.getInteger("Paper.excessiveTELimit", 750);
@@ -32,6 +39,7 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
2019-06-26 04:50:57 +00:00
}
// Paper end
2020-08-25 02:22:08 +00:00
public PacketPlayOutMapChunk(Chunk chunk, int i) {
2020-05-06 08:35:20 +00:00
+ ChunkPacketInfo<IBlockData> chunkPacketInfo = chunk.world.chunkPacketBlockController.getChunkPacketInfo(this, chunk, i); // Paper - Anti-Xray - Add chunk packet info
2019-06-26 04:50:57 +00:00
ChunkCoordIntPair chunkcoordintpair = chunk.getPos();
this.a = chunkcoordintpair.x;
2020-08-25 02:22:08 +00:00
@@ -54,7 +62,12 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
2019-06-26 04:50:57 +00:00
}
2019-12-12 16:20:43 +00:00
this.f = new byte[this.a(chunk, i)];
2020-08-25 02:22:08 +00:00
- this.c = this.a(new PacketDataSerializer(this.j()), chunk, i);
2019-06-26 04:50:57 +00:00
+ // Paper start - Anti-Xray - Add chunk packet info
+ if (chunkPacketInfo != null) {
+ chunkPacketInfo.setData(this.getData());
+ }
2020-08-25 02:22:08 +00:00
+ this.c = this.writeChunk(new PacketDataSerializer(this.j()), chunk, i, chunkPacketInfo);
2019-06-26 04:50:57 +00:00
+ // Paper end
2019-12-12 16:20:43 +00:00
this.g = Lists.newArrayList();
2019-06-26 04:50:57 +00:00
iterator = chunk.getTileEntities().entrySet().iterator();
2020-05-02 03:18:33 +00:00
int totalTileEntities = 0; // Paper
2020-08-25 02:22:08 +00:00
@@ -81,8 +94,19 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
2019-12-12 18:45:00 +00:00
this.g.add(nbttagcompound);
2019-06-26 04:50:57 +00:00
}
}
2020-05-06 08:35:20 +00:00
+ chunk.world.chunkPacketBlockController.modifyBlocks(this, chunkPacketInfo); // Paper - Anti-Xray - Modify blocks
2019-12-12 18:45:00 +00:00
+ }
2019-06-26 04:50:57 +00:00
+ // Paper start - Async-Anti-Xray - Getter and Setter for the ready flag
2020-05-06 09:22:03 +00:00
+ @Override
2019-06-26 04:50:57 +00:00
+ public boolean isReady() {
+ return this.ready;
2020-05-06 09:22:03 +00:00
+ }
+
2019-06-26 04:50:57 +00:00
+ public void setReady(boolean ready) {
+ this.ready = ready;
2020-05-06 09:22:03 +00:00
}
2019-06-26 04:50:57 +00:00
+ // Paper end
2020-05-06 09:22:03 +00:00
2019-06-26 04:50:57 +00:00
@Override
public void a(PacketDataSerializer packetdataserializer) throws IOException {
2020-08-25 02:22:08 +00:00
@@ -148,8 +172,12 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
2020-05-06 08:35:20 +00:00
return bytebuf;
}
2019-06-26 04:50:57 +00:00
2020-05-06 08:35:20 +00:00
- public int writeChunk(PacketDataSerializer packetDataSerializer, Chunk chunk, int chunkSectionSelector) { return this.a(packetDataSerializer, chunk, chunkSectionSelector); } // Paper - OBFHELPER
- public int a(PacketDataSerializer packetdataserializer, Chunk chunk, int i) {
+ // Paper start - Anti-Xray - Add chunk packet info
+ @Deprecated public int writeChunk(PacketDataSerializer packetDataSerializer, Chunk chunk, int chunkSectionSelector) { return this.a(packetDataSerializer, chunk, chunkSectionSelector); } // OBFHELPER // Notice for updates: Please make sure this method isn't used anywhere
+ @Deprecated public int a(PacketDataSerializer packetdataserializer, Chunk chunk, int i) { return this.writeChunk(packetdataserializer, chunk, i, null); } // Notice for updates: Please make sure this method isn't used anywhere
+ public int writeChunk(PacketDataSerializer packetDataSerializer, Chunk chunk, int chunkSectionSelector, ChunkPacketInfo<IBlockData> chunkPacketInfo) { return this.a(packetDataSerializer, chunk, chunkSectionSelector, chunkPacketInfo); } // OBFHELPER
+ public int a(PacketDataSerializer packetdataserializer, Chunk chunk, int i, ChunkPacketInfo<IBlockData> chunkPacketInfo) {
2019-06-26 04:50:57 +00:00
+ // Paper end
int j = 0;
ChunkSection[] achunksection = chunk.getSections();
int k = 0;
2020-08-25 02:22:08 +00:00
@@ -159,7 +187,7 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
2019-06-26 04:50:57 +00:00
if (chunksection != Chunk.a && (!this.f() || !chunksection.c()) && (i & 1 << k) != 0) {
j |= 1 << k;
- chunksection.b(packetdataserializer);
2020-05-06 08:35:20 +00:00
+ chunksection.writeChunkSection(packetdataserializer, chunkPacketInfo); // Paper - Anti-Xray - Add chunk packet info
2019-06-26 04:50:57 +00:00
}
}
diff --git a/src/main/java/net/minecraft/server/PlayerChunkMap.java b/src/main/java/net/minecraft/server/PlayerChunkMap.java
2020-08-25 02:22:08 +00:00
index c4ed4d58f7b344626acb13baeb14288970a7bb90..8e79200b23f2dee612b0cbdcd6359a25dc2323cb 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/PlayerChunkMap.java
+++ b/src/main/java/net/minecraft/server/PlayerChunkMap.java
2020-08-25 02:22:08 +00:00
@@ -609,7 +609,7 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
2019-06-26 04:50:57 +00:00
}
2020-06-25 23:38:24 +00:00
this.g(chunkcoordintpair);
2019-06-26 04:50:57 +00:00
- return Either.left(new ProtoChunk(chunkcoordintpair, ChunkConverter.a));
2020-05-06 08:35:20 +00:00
+ return Either.left(new ProtoChunk(chunkcoordintpair, ChunkConverter.a, this.world)); // Paper - Anti-Xray - Add parameter
2019-06-26 04:50:57 +00:00
}, this.executor);
}
diff --git a/src/main/java/net/minecraft/server/PlayerInteractManager.java b/src/main/java/net/minecraft/server/PlayerInteractManager.java
2020-11-03 02:22:15 +00:00
index 3056468a7e70238228b91be0f103cfbe111fedb5..cdaeeb8b01f084ae7a91f9681850a737af8a74be 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/PlayerInteractManager.java
+++ b/src/main/java/net/minecraft/server/PlayerInteractManager.java
2020-06-25 23:38:24 +00:00
@@ -275,6 +275,8 @@ public class PlayerInteractManager {
2019-06-26 04:50:57 +00:00
}
}
+
+ this.world.chunkPacketBlockController.onPlayerLeftClickBlock(this, blockposition, enumdirection); // Paper - Anti-Xray
}
2019-12-12 16:20:43 +00:00
public void a(BlockPosition blockposition, PacketPlayInBlockDig.EnumPlayerDigType packetplayinblockdig_enumplayerdigtype, String s) {
2019-06-26 04:50:57 +00:00
diff --git a/src/main/java/net/minecraft/server/ProtoChunk.java b/src/main/java/net/minecraft/server/ProtoChunk.java
2020-08-25 02:22:08 +00:00
index 2bcd26ccccf4503241c6b77600ed6ce1d94ccfcc..912c5187a08e972fc9455aed33278387a83f03f2 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/ProtoChunk.java
+++ b/src/main/java/net/minecraft/server/ProtoChunk.java
2020-06-25 23:38:24 +00:00
@@ -46,16 +46,24 @@ public class ProtoChunk implements IChunkAccess {
2019-06-26 04:50:57 +00:00
private long s;
private final Map<WorldGenStage.Features, BitSet> t;
private volatile boolean u;
2020-05-06 08:35:20 +00:00
+ private final World world; // Paper - Anti-Xray - Add world
2019-06-26 04:50:57 +00:00
2020-05-06 08:35:20 +00:00
- public ProtoChunk(ChunkCoordIntPair chunkcoordintpair, ChunkConverter chunkconverter) {
+ // Paper start - Anti-Xray - Add world
+ @Deprecated public ProtoChunk(ChunkCoordIntPair chunkcoordintpair, ChunkConverter chunkconverter) { this(chunkcoordintpair, chunkconverter, null); } // Notice for updates: Please make sure this constructor isn't used anywhere
+ public ProtoChunk(ChunkCoordIntPair chunkcoordintpair, ChunkConverter chunkconverter, World world) {
2019-06-26 04:50:57 +00:00
+ // Paper end
this(chunkcoordintpair, chunkconverter, (ChunkSection[]) null, new ProtoChunkTickList<>((block) -> {
return block == null || block.getBlockData().isAir();
}, chunkcoordintpair), new ProtoChunkTickList<>((fluidtype) -> {
return fluidtype == null || fluidtype == FluidTypes.EMPTY;
- }, chunkcoordintpair));
2020-05-06 08:35:20 +00:00
+ }, chunkcoordintpair), world); // Paper - Anti-Xray - Add world
2019-06-26 04:50:57 +00:00
}
2020-05-06 08:35:20 +00:00
- public ProtoChunk(ChunkCoordIntPair chunkcoordintpair, ChunkConverter chunkconverter, @Nullable ChunkSection[] achunksection, ProtoChunkTickList<Block> protochunkticklist, ProtoChunkTickList<FluidType> protochunkticklist1) {
+ // Paper start - Anti-Xray - Add world
+ @Deprecated public ProtoChunk(ChunkCoordIntPair chunkcoordintpair, ChunkConverter chunkconverter, @Nullable ChunkSection[] achunksection, ProtoChunkTickList<Block> protochunkticklist, ProtoChunkTickList<FluidType> protochunkticklist1) { this(chunkcoordintpair, chunkconverter, achunksection, protochunkticklist, protochunkticklist1, null); } // Notice for updates: Please make sure this constructor isn't used anywhere
+ public ProtoChunk(ChunkCoordIntPair chunkcoordintpair, ChunkConverter chunkconverter, @Nullable ChunkSection[] achunksection, ProtoChunkTickList<Block> protochunkticklist, ProtoChunkTickList<FluidType> protochunkticklist1, World world) {
2019-06-26 04:50:57 +00:00
+ this.world = world;
+ // Paper end
this.f = Maps.newEnumMap(HeightMap.Type.class);
this.g = ChunkStatus.EMPTY;
this.h = Maps.newHashMap();
2020-06-25 23:38:24 +00:00
@@ -210,7 +218,7 @@ public class ProtoChunk implements IChunkAccess {
2019-06-26 04:50:57 +00:00
public ChunkSection a(int i) {
if (this.j[i] == Chunk.a) {
- this.j[i] = new ChunkSection(i << 4);
2020-05-06 08:35:20 +00:00
+ this.j[i] = new ChunkSection(i << 4, this, this.world, true); // Paper - Anti-Xray - Add parameters
2019-06-26 04:50:57 +00:00
}
return this.j[i];
2020-05-06 08:35:20 +00:00
diff --git a/src/main/java/net/minecraft/server/ProtoChunkExtension.java b/src/main/java/net/minecraft/server/ProtoChunkExtension.java
2020-11-03 02:22:15 +00:00
index 420bf7116def909d3dd7dc9a799723446ddf8f7f..300cbb8b01d94e7eb0cded0c8e118103c416d4b6 100644
2020-05-06 08:35:20 +00:00
--- a/src/main/java/net/minecraft/server/ProtoChunkExtension.java
+++ b/src/main/java/net/minecraft/server/ProtoChunkExtension.java
@@ -11,7 +11,7 @@ public class ProtoChunkExtension extends ProtoChunk {
private final Chunk a;
public ProtoChunkExtension(Chunk chunk) {
- super(chunk.getPos(), ChunkConverter.a);
+ super(chunk.getPos(), ChunkConverter.a, chunk.world); // Paper - Anti-Xray - Add parameter
this.a = chunk;
}
2019-06-27 02:04:28 +00:00
2019-06-26 04:50:57 +00:00
diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java
2020-11-03 02:22:15 +00:00
index 048cfcd32c774148f424b246b1f7048fd437afd8..e7ad9a926f58cc7e5d70229dd69f2f5b34603a39 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/net/minecraft/server/World.java
+++ b/src/main/java/net/minecraft/server/World.java
@@ -2,6 +2,8 @@ package net.minecraft.server;
import co.aikar.timings.Timing;
import co.aikar.timings.Timings;
+import com.destroystokyo.paper.antixray.ChunkPacketBlockController; // Paper - Anti-Xray
+import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray; // Paper - Anti-Xray
import com.destroystokyo.paper.event.server.ServerExceptionEvent;
import com.destroystokyo.paper.exception.ServerInternalException;
import com.google.common.base.MoreObjects;
2020-06-26 16:20:03 +00:00
@@ -84,6 +86,7 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
2019-06-26 04:50:57 +00:00
public final org.spigotmc.SpigotWorldConfig spigotConfig; // Spigot
public final com.destroystokyo.paper.PaperWorldConfig paperConfig; // Paper
+ public final ChunkPacketBlockController chunkPacketBlockController; // Paper - Anti-Xray
public final co.aikar.timings.WorldTimingsHandler timings; // Paper
public static BlockPosition lastPhysicsProblem; // Spigot
2020-08-25 02:22:08 +00:00
@@ -105,9 +108,10 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
return typeKey;
2020-06-09 08:12:20 +00:00
}
2020-08-25 02:22:08 +00:00
- protected World(WorldDataMutable worlddatamutable, ResourceKey<World> resourcekey, final DimensionManager dimensionmanager, Supplier<GameProfilerFiller> supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.World.Environment env) {
+ protected World(WorldDataMutable worlddatamutable, ResourceKey<World> resourcekey, final DimensionManager dimensionmanager, Supplier<GameProfilerFiller> supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.World.Environment env, java.util.concurrent.Executor executor) { // Paper
2020-06-25 23:38:24 +00:00
this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((WorldDataServer) worlddatamutable).getName()); // Spigot
this.paperConfig = new com.destroystokyo.paper.PaperWorldConfig((((WorldDataServer)worlddatamutable).getName()), this.spigotConfig); // Paper
2020-08-25 02:22:08 +00:00
+ this.chunkPacketBlockController = this.paperConfig.antiXray ? new ChunkPacketBlockControllerAntiXray(this, executor) : ChunkPacketBlockController.NO_OPERATION_INSTANCE; // Paper - Anti-Xray
2019-06-26 04:50:57 +00:00
this.generator = gen;
this.world = new CraftWorld((WorldServer) this, gen, env);
2020-06-25 23:38:24 +00:00
this.ticksPerAnimalSpawns = this.getServer().getTicksPerAnimalSpawns(); // CraftBukkit
2020-09-19 15:51:01 +00:00
@@ -372,6 +376,7 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
2019-06-26 04:50:57 +00:00
// CraftBukkit end
IBlockData iblockdata1 = chunk.setType(blockposition, iblockdata, (i & 64) != 0, (i & 1024) == 0); // CraftBukkit custom NO_PLACE flag
+ this.chunkPacketBlockController.onBlockChange(this, blockposition, iblockdata, iblockdata1, i); // Paper - Anti-Xray
if (iblockdata1 == null) {
2020-04-08 07:49:15 +00:00
// CraftBukkit start - remove blockstate if failed (or the same)
2020-06-09 08:12:20 +00:00
diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java
2020-11-03 02:22:15 +00:00
index 5a35395434ffdefd410573302a3d46cca9642a81..6b52f9b9adce975cdafaf12b2a1bea5ef1bbaaa4 100644
2020-06-09 08:12:20 +00:00
--- a/src/main/java/net/minecraft/server/WorldServer.java
+++ b/src/main/java/net/minecraft/server/WorldServer.java
2020-11-03 02:22:15 +00:00
@@ -100,7 +100,7 @@ public class WorldServer extends World implements GeneratorAccessSeed {
2020-06-09 08:12:20 +00:00
2020-06-25 23:38:24 +00:00
// Add env and gen to constructor, WorldData -> WorldDataServer
2020-08-25 02:22:08 +00:00
public WorldServer(MinecraftServer minecraftserver, Executor executor, Convertable.ConversionSession convertable_conversionsession, IWorldDataServer iworlddataserver, ResourceKey<World> resourcekey, DimensionManager dimensionmanager, WorldLoadListener worldloadlistener, ChunkGenerator chunkgenerator, boolean flag, long i, List<MobSpawner> list, boolean flag1, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen) {
- super(iworlddataserver, resourcekey, dimensionmanager, minecraftserver::getMethodProfiler, false, flag, i, gen, env);
+ super(iworlddataserver, resourcekey, dimensionmanager, minecraftserver::getMethodProfiler, false, flag, i, gen, env, executor); // Paper pass executor
2020-06-25 23:38:24 +00:00
this.pvpMode = minecraftserver.getPVP();
convertable = convertable_conversionsession;
uuid = WorldUUID.getUUID(convertable_conversionsession.folder.toFile());
2020-05-06 08:35:20 +00:00
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
2020-10-17 10:39:45 +00:00
index 4aeae5ef72c2d929c86b4f9575f2c162710f99f0..d40ef8353b2c025309144b4123d6a7dff04a9c62 100644
2020-05-06 08:35:20 +00:00
--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
2020-10-17 10:39:45 +00:00
@@ -42,7 +42,7 @@ public class CraftChunk implements Chunk {
2020-05-06 08:35:20 +00:00
private final WorldServer worldServer;
private final int x;
private final int z;
- private static final DataPaletteBlock<IBlockData> emptyBlockIDs = new ChunkSection(0).getBlocks();
+ private static final DataPaletteBlock<IBlockData> emptyBlockIDs = new ChunkSection(0, null, null, true).getBlocks(); // Paper - Anti-Xray - Add parameters
private static final byte[] emptyLight = new byte[2048];
public CraftChunk(net.minecraft.server.Chunk chunk) {
2020-10-17 10:39:45 +00:00
@@ -264,7 +264,7 @@ public class CraftChunk implements Chunk {
2020-05-06 08:35:20 +00:00
NBTTagCompound data = new NBTTagCompound();
cs[i].getBlocks().a(data, "Palette", "BlockStates");
2020-06-25 23:38:24 +00:00
- DataPaletteBlock blockids = new DataPaletteBlock<>(ChunkSection.GLOBAL_PALETTE, net.minecraft.server.Block.REGISTRY_ID, GameProfileSerializer::c, GameProfileSerializer::a, Blocks.AIR.getBlockData()); // TODO: snapshot whole ChunkSection
+ DataPaletteBlock blockids = new DataPaletteBlock<>(ChunkSection.GLOBAL_PALETTE, net.minecraft.server.Block.REGISTRY_ID, GameProfileSerializer::c, GameProfileSerializer::a, Blocks.AIR.getBlockData(), null, false); // TODO: snapshot whole ChunkSection // Paper - Anti-Xray - Add no predefined block data and don't initialize because it's done in the line below internally
2020-05-06 08:35:20 +00:00
blockids.a(data.getList("Palette", CraftMagicNumbers.NBT.TAG_COMPOUND), data.getLongArray("BlockStates"));
sectionBlockIDs[i] = blockids;
2019-06-26 04:50:57 +00:00
diff --git a/src/main/java/org/bukkit/craftbukkit/generator/CraftChunkData.java b/src/main/java/org/bukkit/craftbukkit/generator/CraftChunkData.java
2020-05-06 09:48:49 +00:00
index 8191e7c34899e204b8afbb2fd11d235e8ef8db99..bb18740ebdf4a14ced9944efa82103b350b32ba5 100644
2019-06-26 04:50:57 +00:00
--- a/src/main/java/org/bukkit/craftbukkit/generator/CraftChunkData.java
+++ b/src/main/java/org/bukkit/craftbukkit/generator/CraftChunkData.java
@@ -21,9 +21,11 @@ public final class CraftChunkData implements ChunkGenerator.ChunkData {
private final int maxHeight;
private final ChunkSection[] sections;
private Set<BlockPosition> tiles;
2020-05-06 08:35:20 +00:00
+ private World world; // Paper - Anti-Xray - Add world
2019-06-26 04:50:57 +00:00
public CraftChunkData(World world) {
this(world.getMaxHeight());
2020-05-06 08:35:20 +00:00
+ this.world = world; // Paper - Anti-Xray - Add world
2019-06-26 04:50:57 +00:00
}
/* pp for tests */ CraftChunkData(int maxHeight) {
@@ -157,7 +159,7 @@ public final class CraftChunkData implements ChunkGenerator.ChunkData {
private ChunkSection getChunkSection(int y, boolean create) {
ChunkSection section = sections[y >> 4];
if (create && section == null) {
2020-02-25 18:57:15 +00:00
- sections[y >> 4] = section = new ChunkSection(y >> 4 << 4);
2020-05-06 08:35:20 +00:00
+ sections[y >> 4] = section = new ChunkSection(y >> 4 << 4, null, world instanceof org.bukkit.craftbukkit.CraftWorld ? ((org.bukkit.craftbukkit.CraftWorld) world).getHandle() : null, true); // Paper - Anti-Xray - Add parameters
2019-06-26 04:50:57 +00:00
}
return section;
}
