add anti x-ray

Author: Mapacheee

src/main/java/me/mapacheee/extendedhorizons/shared/config/MainConfig.java

@@ -47,7 +47,16 @@ public record FakeChunksConfig(
                                 @Setting("use-compression") boolean useCompression,
                                 @Setting("cache-cleanup-interval") int cacheCleanupInterval,
                                 @Setting("enable-memory-cache") boolean enableMemoryCache,
-                                @Setting("max-memory-cache-size") int maxMemoryCacheSize) {
+                                @Setting("max-memory-cache-size") int maxMemoryCacheSize,
+                                @Setting("anti-xray") AntiXrayConfig antiXray) {
+
+                        @ConfigSerializable
+                        public record AntiXrayConfig(
+                                        boolean enabled,
+                                        @Setting("hide-ores") boolean hideOres,
+                                        @Setting("add-fake-ores") boolean addFakeOres,
+                                        @Setting("fake-ore-density") double fakeOreDensity) {
+                        }
                 }
 
                 @ConfigSerializable

src/main/java/me/mapacheee/extendedhorizons/viewdistance/service/ChunkAntiXray.java

@@ -0,0 +1,102 @@
+package me.mapacheee.extendedhorizons.viewdistance.service;
+
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraft.world.level.chunk.PalettedContainer;
+
+import java.util.Random;
+
+/**
+ * Anti-Xray utility for obfuscating chunks
+ * Replaces valuable ores with stone/deepslate and adds fake ores
+ * 
+ */
+public class ChunkAntiXray {
+
+    private static final BlockState STONE = Blocks.STONE.defaultBlockState();
+    private static final BlockState DEEPSLATE = Blocks.DEEPSLATE.defaultBlockState();
+
+    private static final Block[] VALUABLE_ORES = {
+            Blocks.DIAMOND_ORE, Blocks.DEEPSLATE_DIAMOND_ORE,
+            Blocks.EMERALD_ORE, Blocks.DEEPSLATE_EMERALD_ORE,
+            Blocks.GOLD_ORE, Blocks.DEEPSLATE_GOLD_ORE,
+            Blocks.IRON_ORE, Blocks.DEEPSLATE_IRON_ORE,
+            Blocks.LAPIS_ORE, Blocks.DEEPSLATE_LAPIS_ORE,
+            Blocks.REDSTONE_ORE, Blocks.DEEPSLATE_REDSTONE_ORE,
+            Blocks.ANCIENT_DEBRIS,
+            Blocks.COPPER_ORE, Blocks.DEEPSLATE_COPPER_ORE
+    };
+
+    private static final BlockState[] FAKE_ORES = {
+            Blocks.DIAMOND_ORE.defaultBlockState(),
+            Blocks.DEEPSLATE_DIAMOND_ORE.defaultBlockState(),
+            Blocks.GOLD_ORE.defaultBlockState(),
+            Blocks.DEEPSLATE_GOLD_ORE.defaultBlockState(),
+            Blocks.IRON_ORE.defaultBlockState()
+    };
+
+    /**
+     * Obfuscates a chunk by hiding real ores and adding fake ones
+     */
+    public static void obfuscateChunk(LevelChunk chunk, boolean hideOres, boolean addFakeOres, double fakeOreDensity) {
+        Random random = new Random(chunk.getPos().toLong());
+        LevelChunkSection[] sections = chunk.getSections();
+
+        for (int sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {
+            LevelChunkSection section = sections[sectionIndex];
+            if (section == null || section.hasOnlyAir()) {
+                continue;
+            }
+
+            int sectionY = chunk.getMinSectionY() + sectionIndex;
+            int baseY = sectionY * 16;
+
+            PalettedContainer<BlockState> blocks = section.getStates();
+
+            for (int x = 0; x < 16; x++) {
+                for (int y = 0; y < 16; y++) {
+                    for (int z = 0; z < 16; z++) {
+                        BlockState state = blocks.get(x, y, z);
+                        if (state == null)
+                            continue;
+
+                        Block block = state.getBlock();
+                        int worldY = baseY + y;
+
+                        if (hideOres && isValuableOre(block)) {
+                            BlockState replacement = worldY < 0 ? DEEPSLATE : STONE;
+                            blocks.set(x, y, z, replacement);
+                        } else if (addFakeOres && random.nextDouble() < fakeOreDensity) {
+                            if (block == Blocks.STONE || block == Blocks.DEEPSLATE) {
+                                BlockState fakeOre = getFakeOre(random, worldY);
+                                blocks.set(x, y, z, fakeOre);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static boolean isValuableOre(Block block) {
+        for (Block ore : VALUABLE_ORES) {
+            if (block == ore) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static BlockState getFakeOre(Random random, int y) {
+        if (y < 0) {
+            return random.nextBoolean()
+                    ? Blocks.DEEPSLATE_DIAMOND_ORE.defaultBlockState()
+                    : Blocks.DEEPSLATE_GOLD_ORE.defaultBlockState();
+        } else {
+            return FAKE_ORES[random.nextInt(FAKE_ORES.length)];
+        }
+    }
+}

src/main/java/me/mapacheee/extendedhorizons/viewdistance/service/FakeChunkService.java

@@ -766,7 +766,8 @@ private boolean shouldClearQueue(Queue<Long> queue, int playerChunkX, int player
      * Attempts to get a chunk from the servers memory cache or our own cache
      */
     private LevelChunk getChunkFromMemoryCache(World world, int chunkX, int chunkZ) {
-        if (!configService.get().performance().fakeChunks().enableMemoryCache()) {
+        boolean antiXrayEnabled = configService.get().performance().fakeChunks().antiXray().enabled();
+        if (!configService.get().performance().fakeChunks().enableMemoryCache() || antiXrayEnabled) {
             return null;
         }
 
@@ -865,6 +866,22 @@ private void generateChunkAndSend(Player player, World world, int chunkX, int ch
      * Packets are created here in async thread and queued for sending
      */
     private void sendChunkPacket(Player player, LevelChunk nmsChunk, long key, Set<Long> sentTracker) {
+        if (configService.get().performance().fakeChunks().antiXray().enabled()) {
+            try {
+                nmsChunk = cloneChunkForObfuscation(nmsChunk);
+
+                boolean hideOres = configService.get().performance().fakeChunks().antiXray().hideOres();
+                boolean addFakeOres = configService.get().performance().fakeChunks().antiXray().addFakeOres();
+                double density = configService.get().performance().fakeChunks().antiXray().fakeOreDensity();
+
+                ChunkAntiXray.obfuscateChunk(nmsChunk, hideOres, addFakeOres, density);
+            } catch (Exception e) {
+                if (DEBUG) {
+                    logger.warn("[EH] Failed to obfuscate chunk: {}", e.getMessage());
+                }
+            }
+        }
+
         net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket packet = null;
         try {
             net.minecraft.world.level.lighting.LevelLightEngine lightEngine = nmsChunk.getLevel().getLightEngine();
@@ -903,6 +920,17 @@ private void sendChunkPacket(Player player, LevelChunk nmsChunk, long key, Set<L
         }
     }
 
+    /**
+     * Placeholder for chunk cloning (not needed - memory cache is disabled when
+     * anti-xray is active)
+     */
+    private LevelChunk cloneChunkForObfuscation(LevelChunk original) {
+        // No cloning needed: memory cache is automatically disabled when anti-xray is
+        // enabled
+        // This prevents cached chunks from being permanently obfuscated
+        return original;
+    }
+
     /**
      * Sends a Column directly to the player using PacketEvents
      * Returns true if successful, false if Column is null or invalid

src/main/resources/config.yml

@@ -64,6 +64,20 @@ performance:
     # Maximum chunks to cache in memory (1000 = ~40-80MB depending on chunk complexity)
     # Increase for more players in same area, decrease for dispersed players or low RAM
     max-memory-cache-size: 1000
+    
+    # Anti-X-Ray for fake chunks
+
+    # Enable this feature will affect the speed to load fake chunks
+    # Enable this only if its necessary
+    anti-xray:
+      # Enable anti-xray obfuscation for fake chunks
+      enabled: false
+      # Replace valuable ores with stone/deepslate
+      hide-ores: true
+      # Add fake ores to confuse x-ray users
+      add-fake-ores: true
+      # Density of fake ores (0.0-1.0, higher = more fakes)
+      fake-ore-density: 0.15
 
   occlusion-culling:
     enabled: true