Merge pull request #1 from MinceraftMC/feat/anti-xray

Implement lightweight anti-xray support

Author: booky10

README.md

@@ -21,6 +21,7 @@ caching of chunk data.
 - Configurable limitations for chunk sending and chunk generation
 - Per-dimension configuration options
 - Support for integrated or dedicated fabric servers
+- Lightweight anti-xray support for extended chunks
 
 <details>
 <summary><strong>Example: Loading speed for a view distance of 127 chunks</strong></summary>
@@ -71,10 +72,18 @@ On the first start, this plugin will automatically create a configuration file.
         - `view-distance`: The maximum extended view distance for this dimension (default: `32`)
         - `cache-duration`: The cache duration for how long extended chunks should be kept in memory (default: `PT5M`,
           5 minutes)
+        - `anti-xray`:
+          - `enabled`: Whether anti-xray will be enabled or disabled in this world (default: `false`)
+          - `engine-mode`: Engine modes of anti-xray, either `HIDE`, `OBFUSCATE`, or `OBFUSCATE_LAYER` (default: `HIDE`)
+          - `hidden-blocks`: The list of blocks to hide/obfuscate (default: all ores and all base blocks of dimensions)
 
 Feel free to play around with the chunk generations and chunk sending limits for
 an optimal experience on your server setup.
 
+When using anti-xray, be aware that this plugin implements a lightweight version of anti-xray, which
+doesn't check if a block is exposed to air or not. This means that every engine-mode other than `HIDE`
+will probably not look very good.
+
 Make sure to adjust the cache duration based on what you use your server for;
 for e.g. static lobby servers, you can use a longer cache duration than for dynamic SMP servers.
 If the cache duration is too high, chunks will display outdated content after e.g. a rejoin.

common/src/main/java/dev/booky/betterview/common/antixray/AntiXrayProcessor.java

@@ -0,0 +1,31 @@
+package dev.booky.betterview.common.antixray;
+// Created by booky10 in BetterView (20:15 16.06.2025)
+
+import org.jspecify.annotations.NullMarked;
+
+import java.util.Arrays;
+
+// https://github.com/PaperMC/Paper/blob/ba7fb23ddd2376079951d1e22f9204d1ed691585/paper-server/src/main/java/io/papermc/paper/antixray/ChunkPacketBlockControllerAntiXray.java#L150-L168
+// licensed under the terms of the MIT license
+// the code has been adapted to our own structure, additionally all
+// returned arrays should be sorted
+@NullMarked
+@FunctionalInterface
+public interface ReplacementPresets {
+
+    static ReplacementPresets createStatic(int... presets) {
+        Arrays.sort(presets);
+        return __ -> presets;
+    }
+
+    static ReplacementPresets createStaticZeroSplit(int[] abovePresets, int[] belowPresets) {
+        Arrays.sort(abovePresets);
+        Arrays.sort(belowPresets);
+        return sectionY -> sectionY < 0 ? belowPresets : abovePresets;
+    }
+
+    /**
+     * @return a sorted array of preset blockstate ids
+     */
+    int[] getPresets(int sectionY);
+}

common/src/main/java/dev/booky/betterview/common/antixray/ReplacementPresets.java

@@ -0,0 +1,81 @@
+package dev.booky.betterview.common.antixray;
+// Created by booky10 in BetterView (19:50 16.06.2025)
+
+import org.jspecify.annotations.NullMarked;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+// see https://github.com/PaperMC/Paper/blob/ba7fb23ddd2376079951d1e22f9204d1ed691585/paper-server/src/main/java/io/papermc/paper/antixray/ChunkPacketBlockControllerAntiXray.java#L232-L272
+// licensed under the terms of the MIT license
+// other than adapting the code to our own structure, no modifications have been made to the actual logic
+@NullMarked
+@FunctionalInterface
+public interface ReplacementStrategy {
+
+    ReplacementStrategy STATIC_ZERO = () -> 0;
+
+    // Paper's engine-mode 1 (hide ores)
+    static ReplacementStrategy replaceStaticZero(int ignoredBlockCount) {
+        return STATIC_ZERO;
+    }
+
+    // Paper's engine-mode 2 (obfuscate)
+    static ReplacementStrategy replaceRandom(int blockCount) {
+        return new ReplacementStrategy() {
+            private int state;
+
+            {
+                while ((this.state = ThreadLocalRandom.current().nextInt()) == 0) ;
+            }
+
+            @Override
+            public int get() {
+                // https://en.wikipedia.org/wiki/Xorshift
+                this.state ^= this.state << 13;
+                this.state ^= this.state >>> 17;
+                this.state ^= this.state << 5;
+                // https://www.pcg-random.org/posts/bounded-rands.html
+                return (int) ((Integer.toUnsignedLong(this.state) * blockCount) >>> 32);
+            }
+        };
+    }
+
+    // Paper's engine-mode 3 (obfuscate layer)
+    static ReplacementStrategy replaceRandomLayered(int blockCount) {
+        return new ReplacementStrategy() {
+            private int state;
+            private int next;
+
+            {
+                while ((this.state = ThreadLocalRandom.current().nextInt()) == 0) ;
+            }
+
+            @Override
+            public void advance() {
+                // https://en.wikipedia.org/wiki/Xorshift
+                this.state ^= this.state << 13;
+                this.state ^= this.state >>> 17;
+                this.state ^= this.state << 5;
+                // https://www.pcg-random.org/posts/bounded-rands.html
+                this.next = (int) ((Integer.toUnsignedLong(this.state) * blockCount) >>> 32);
+            }
+
+            @Override
+            public int get() {
+                return this.next;
+            }
+        };
+    }
+
+    default void advance() {
+        // NO-OP
+    }
+
+    int get();
+
+    @FunctionalInterface
+    interface Ctor {
+
+        ReplacementStrategy construct(int blockCount);
+    }
+}

common/src/main/java/dev/booky/betterview/common/antixray/ReplacementStrategy.java

@@ -1,11 +1,14 @@
 package dev.booky.betterview.common.config;
 // Created by booky10 in BetterView (14:49 03.06.2025)
 
+import dev.booky.betterview.common.antixray.ReplacementStrategy;
+import net.kyori.adventure.key.Key;
 import org.jspecify.annotations.NullMarked;
 import org.spongepowered.configurate.objectmapping.ConfigSerializable;
 import org.spongepowered.configurate.objectmapping.meta.Comment;
 
 import java.time.Duration;
+import java.util.List;
 
 @NullMarked
 @ConfigSerializable
@@ -21,6 +24,8 @@ public class BvLevelConfig {
     private int viewDistance = 32;
     @Comment("The cache duration for all extended chunks, after which they will be re-build")
     private Duration cacheDuration = Duration.ofMinutes(5L);
+    @Comment("Configuration options for a lightweight anti-xray applied to extended chunks")
+    private AntiXrayConfig antiXray = new AntiXrayConfig();
 
     public boolean isEnabled() {
         return this.enabled;
@@ -41,4 +46,64 @@ public int getViewDistance() {
     public Duration getCacheDuration() {
         return this.cacheDuration;
     }
+
+    public AntiXrayConfig getAntiXray() {
+        return this.antiXray;
+    }
+
+    @ConfigSerializable
+    public static final class AntiXrayConfig {
+
+        @Comment("Whether or not anti-xray is enabled for extended chunks")
+        private boolean enabled = false;
+        @Comment("The anti-xray engine mode, recommended to be left at \"HIDE\" as this\n"
+                + "anti-xray doesn't check whether a block is exposed or not")
+        private EngineMode engineMode = EngineMode.HIDE;
+        @Comment("The blocks to hide or obfuscate")
+        private List<Key> hiddenBlocks = List.of(
+                Key.key("stone"), Key.key("deepslate"),
+                Key.key("netherrack"), Key.key("end_stone"),
+                Key.key("diamond_ore"), Key.key("deepslate_diamond_ore"),
+                Key.key("iron_ore"), Key.key("deepslate_iron_ore"),
+                Key.key("coal_ore"), Key.key("deepslate_coal_ore"),
+                Key.key("emerald_ore"), Key.key("deepslate_emerald_ore"),
+                Key.key("copper_ore"), Key.key("deepslate_copper_ore"),
+                Key.key("redstone_ore"), Key.key("deepslate_redstone_ore"),
+                Key.key("gold_ore"), Key.key("deepslate_gold_ore"),
+                Key.key("lapis_ore"), Key.key("deepslate_lapis_ore"),
+                Key.key("nether_gold_ore"), Key.key("nether_quartz_ore"),
+                Key.key("ancient_debris"), Key.key("raw_copper_block"),
+                Key.key("raw_iron_block")
+        );
+
+        public boolean isEnabled() {
+            return this.enabled;
+        }
+
+        public EngineMode getEngineMode() {
+            return this.engineMode;
+        }
+
+        public List<Key> getHiddenBlocks() {
+            return this.hiddenBlocks;
+        }
+
+        public enum EngineMode {
+
+            HIDE(ReplacementStrategy::replaceStaticZero),
+            OBFUSCATE(ReplacementStrategy::replaceRandom),
+            OBFUSCATE_LAYER(ReplacementStrategy::replaceRandomLayered),
+            ;
+
+            private final ReplacementStrategy.Ctor strategy;
+
+            EngineMode(ReplacementStrategy.Ctor strategy) {
+                this.strategy = strategy;
+            }
+
+            public ReplacementStrategy.Ctor getStrategy() {
+                return this.strategy;
+            }
+        }
+    }
 }

common/src/main/java/dev/booky/betterview/common/config/BvLevelConfig.java

@@ -0,0 +1,24 @@
+package dev.booky.betterview.common.util;
+// Created by booky10 in BetterView (21:10 16.06.2025)
+
+import org.jspecify.annotations.NullMarked;
+
+@NullMarked
+public final class MathUtil {
+
+    private MathUtil() {
+    }
+
+    public static int log2(int i) {
+        // https://stackoverflow.com/a/3305710
+        return 31 - Integer.numberOfLeadingZeros(i);
+    }
+
+    public static int ceilLog2(int i) {
+        // https://stackoverflow.com/a/22027270
+        boolean pow2 = i != 0 && (i & -i) == i;
+        // if the number is a power of two, don't add one; otherwise,
+        // we want to get to the ceiling!
+        return log2(i) + (pow2 ? 0 : 1);
+    }
+}

common/src/main/java/dev/booky/betterview/common/util/MathUtil.java

@@ -0,0 +1,92 @@
+package dev.booky.betterview.common.util;
+// Created by booky10 in BetterView (20:39 16.06.2025)
+
+import io.netty.buffer.ByteBuf;
+import org.jspecify.annotations.NullMarked;
+
+// https://github.com/PaperMC/Velocity/blob/44bc15db409226d39ca0330ac01bb1295da34424/proxy/src/main/java/com/velocitypowered/proxy/protocol/ProtocolUtils.java#L151-L234
+// licensed under the terms of the GPL
+// the only change made was to replace exception handling
+@NullMarked
+public final class VarIntUtil {
+
+    private static final int MAXIMUM_VARINT_SIZE = 5;
+
+    private VarIntUtil() {
+    }
+
+    /**
+     * Reads a Minecraft-style VarInt from the specified {@code buf}.
+     *
+     * @param buf the buffer to read from
+     * @return the decoded VarInt
+     */
+    public static int readVarInt(ByteBuf buf) {
+        int readable = buf.readableBytes();
+        if (readable == 0) {
+            // special case for empty buffer
+            throw new IllegalStateException("No bytes readable");
+        }
+
+        // we can read at least one byte, and this should be a common case
+        int k = buf.readByte();
+        if ((k & 0x80) != 128) {
+            return k;
+        }
+
+        // in case decoding one byte was not enough, use a loop to decode up to the next 4 bytes
+        int maxRead = Math.min(MAXIMUM_VARINT_SIZE, readable);
+        int i = k & 0x7F;
+        for (int j = 1; j < maxRead; j++) {
+            k = buf.readByte();
+            i |= (k & 0x7F) << j * 7;
+            if ((k & 0x80) != 128) {
+                return i;
+            }
+        }
+        throw new IllegalStateException("Too many bytes readable");
+    }
+
+    /**
+     * Writes a Minecraft-style VarInt to the specified {@code buf}.
+     *
+     * @param buf   the buffer to read from
+     * @param value the integer to write
+     */
+    public static void writeVarInt(ByteBuf buf, int value) {
+        // Peel the one and two byte count cases explicitly as they are the most common VarInt sizes
+        // that the proxy will write, to improve inlining.
+        if ((value & (0xFFFFFFFF << 7)) == 0) {
+            buf.writeByte(value);
+        } else if ((value & (0xFFFFFFFF << 14)) == 0) {
+            int w = (value & 0x7F | 0x80) << 8 | (value >>> 7);
+            buf.writeShort(w);
+        } else {
+            writeVarIntFull(buf, value);
+        }
+    }
+
+    private static void writeVarIntFull(ByteBuf buf, int value) {
+        // See https://steinborn.me/posts/performance/how-fast-can-you-write-a-varint/
+
+        // This essentially is an unrolled version of the "traditional" VarInt encoding.
+        if ((value & (0xFFFFFFFF << 7)) == 0) {
+            buf.writeByte(value);
+        } else if ((value & (0xFFFFFFFF << 14)) == 0) {
+            int w = (value & 0x7F | 0x80) << 8 | (value >>> 7);
+            buf.writeShort(w);
+        } else if ((value & (0xFFFFFFFF << 21)) == 0) {
+            int w = (value & 0x7F | 0x80) << 16 | ((value >>> 7) & 0x7F | 0x80) << 8 | (value >>> 14);
+            buf.writeMedium(w);
+        } else if ((value & (0xFFFFFFFF << 28)) == 0) {
+            int w = (value & 0x7F | 0x80) << 24 | (((value >>> 7) & 0x7F | 0x80) << 16)
+                    | ((value >>> 14) & 0x7F | 0x80) << 8 | (value >>> 21);
+            buf.writeInt(w);
+        } else {
+            int w = (value & 0x7F | 0x80) << 24 | ((value >>> 7) & 0x7F | 0x80) << 16
+                    | ((value >>> 14) & 0x7F | 0x80) << 8 | ((value >>> 21) & 0x7F | 0x80);
+            buf.writeInt(w);
+            buf.writeByte(value >>> 28);
+        }
+    }
+}