Paper/CraftBukkit-Patches/0053-Orebfuscator.patch

From 0880b62865e0edb645d203f5189e37ae46293dd1 Mon Sep 17 00:00:00 2001
From: md_5 <md_5@live.com.au>
Date: Thu, 16 May 2013 18:51:05 +1000
Subject: [PATCH] Orebfuscator


diff --git a/src/main/java/net/minecraft/server/EntityFallingBlock.java b/src/main/java/net/minecraft/server/EntityFallingBlock.java
index 22dc42d..fd78677 100644
--- a/src/main/java/net/minecraft/server/EntityFallingBlock.java
+++ b/src/main/java/net/minecraft/server/EntityFallingBlock.java
@@ -60,6 +60,7 @@ public class EntityFallingBlock extends Entity {
                 blockposition = new BlockPosition(this);
                 if (this.world.getType(blockposition).getBlock() == block && !CraftEventFactory.callEntityChangeBlockEvent(this, blockposition.getX(), blockposition.getY(), blockposition.getZ(), Blocks.AIR, 0).isCancelled()) {
                     this.world.setAir(blockposition);
+                    world.spigotConfig.antiXrayInstance.updateNearbyBlocks(world, blockposition); // Spigot
                 } else if (!this.world.isStatic) {
                     this.die();
                     return;
@@ -84,6 +85,7 @@ public class EntityFallingBlock extends Entity {
                                 return;
                             }
                             this.world.setTypeAndData(blockposition, this.block, 3);
+                            world.spigotConfig.antiXrayInstance.updateNearbyBlocks(world, blockposition); // Spigot
                             // CraftBukkit end
                             if (block instanceof BlockFalling) {
                                 ((BlockFalling) block).a_(this.world, blockposition);
diff --git a/src/main/java/net/minecraft/server/Explosion.java b/src/main/java/net/minecraft/server/Explosion.java
index 5ce4985..735a7d4 100644
--- a/src/main/java/net/minecraft/server/Explosion.java
+++ b/src/main/java/net/minecraft/server/Explosion.java
@@ -195,6 +195,7 @@ public class Explosion {
                 blockposition = (BlockPosition) iterator.next();
                 Block block = this.world.getType(blockposition).getBlock();
 
+                world.spigotConfig.antiXrayInstance.updateNearbyBlocks(world, blockposition); // Spigot
                 if (flag) {
                     double d0 = (double) ((float) blockposition.getX() + this.world.random.nextFloat());
                     double d1 = (double) ((float) blockposition.getY() + this.world.random.nextFloat());
diff --git a/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java b/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
index e24d3ae..e106a1f 100644
--- a/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
+++ b/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
@@ -18,6 +18,7 @@ public class PacketPlayOutMapChunk implements Packet {
         this.b = chunk.locZ;
         this.d = flag;
         this.c = a(chunk, flag, !chunk.getWorld().worldProvider.o(), i);
+        chunk.world.spigotConfig.antiXrayInstance.obfuscateSync(chunk.locX, chunk.locZ, c.b, c.a, chunk.world);
     }
 
     public void a(PacketDataSerializer packetdataserializer) {
diff --git a/src/main/java/net/minecraft/server/PacketPlayOutMapChunkBulk.java b/src/main/java/net/minecraft/server/PacketPlayOutMapChunkBulk.java
index 8af5e1f..9df0d53 100644
--- a/src/main/java/net/minecraft/server/PacketPlayOutMapChunkBulk.java
+++ b/src/main/java/net/minecraft/server/PacketPlayOutMapChunkBulk.java
@@ -8,6 +8,7 @@ public class PacketPlayOutMapChunkBulk implements Packet {
     private int[] b;
     private ChunkMap[] c;
     private boolean d;
+    private World world; // Spigot
 
     public PacketPlayOutMapChunkBulk() {}
 
@@ -27,7 +28,8 @@ public class PacketPlayOutMapChunkBulk implements Packet {
             this.b[j] = chunk.locZ;
             this.c[j] = chunkmap;
         }
-
+        
+        world = ((Chunk) list.get(0)).getWorld(); // Spigot
     }
 
     public void a(PacketDataSerializer packetdataserializer) {
@@ -67,6 +69,7 @@ public class PacketPlayOutMapChunkBulk implements Packet {
         }
 
         for (i = 0; i < this.a.length; ++i) {
+            world.spigotConfig.antiXrayInstance.obfuscate(this.a[i], this.b[i], this.c[i].b, this.c[i].a, world); // Spigot
             packetdataserializer.writeBytes(this.c[i].a);
         }
 
diff --git a/src/main/java/net/minecraft/server/PlayerInteractManager.java b/src/main/java/net/minecraft/server/PlayerInteractManager.java
index e6145ac..34c22d2 100644
--- a/src/main/java/net/minecraft/server/PlayerInteractManager.java
+++ b/src/main/java/net/minecraft/server/PlayerInteractManager.java
@@ -197,6 +197,7 @@ public class PlayerInteractManager {
             }
 
         }
+        world.spigotConfig.antiXrayInstance.updateNearbyBlocks(world, blockposition); // Spigot
     }
 
     public void a(BlockPosition blockposition) {
diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java
index 7c058fc..d3ee73d 100644
--- a/src/main/java/net/minecraft/server/World.java
+++ b/src/main/java/net/minecraft/server/World.java
@@ -458,6 +458,7 @@ public abstract class World implements IBlockAccess {
         this.d(blockposition.up(), block);
         this.d(blockposition.north(), block);
         this.d(blockposition.south(), block);
+        spigotConfig.antiXrayInstance.updateNearbyBlocks(this, blockposition); // Spigot
     }
 
     public void a(BlockPosition blockposition, Block block, EnumDirection enumdirection) {
@@ -671,9 +672,16 @@ public abstract class World implements IBlockAccess {
         return this.worldProvider.p()[this.getLightLevel(blockposition)];
     }
 
-    public IBlockData getType(BlockPosition blockposition) {
+    // Spigot start
+    public IBlockData getType(BlockPosition blockposition)
+    {
+        return getType( blockposition, true );
+    }
+    
+    public IBlockData getType(BlockPosition blockposition, boolean useCaptured) {
         // CraftBukkit start - tree generation
-        if (captureTreeGeneration) {
+        if (captureTreeGeneration && useCaptured) {
+    // Spigot end
             Iterator<BlockState> it = capturedBlockStates.iterator();
             while (it.hasNext()) {
                 BlockState previous = it.next();
diff --git a/src/main/java/org/spigotmc/AntiXray.java b/src/main/java/org/spigotmc/AntiXray.java
new file mode 100644
index 0000000..6f28cd8
--- /dev/null
+++ b/src/main/java/org/spigotmc/AntiXray.java
@@ -0,0 +1,234 @@
+package org.spigotmc;
+
+import gnu.trove.set.TByteSet;
+import gnu.trove.set.hash.TByteHashSet;
+import net.minecraft.server.Block;
+import net.minecraft.server.BlockPosition;
+import net.minecraft.server.Blocks;
+import net.minecraft.server.World;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+
+public class AntiXray
+{
+
+    private static final CustomTimingsHandler update = new CustomTimingsHandler( "xray - update" );
+    private static final CustomTimingsHandler obfuscate = new CustomTimingsHandler( "xray - obfuscate" );
+    /*========================================================================*/
+    // Used to keep track of which blocks to obfuscate
+    private final boolean[] obfuscateBlocks = new boolean[ Short.MAX_VALUE ];
+    // Used to select a random replacement ore
+    private final byte[] replacementOres;
+
+    public AntiXray(SpigotWorldConfig config)
+    {
+        // Set all listed blocks as true to be obfuscated
+        for ( int id : ( config.engineMode == 1 ) ? config.hiddenBlocks : config.replaceBlocks )
+        {
+            obfuscateBlocks[id] = true;
+        }
+
+        // For every block
+        TByteSet blocks = new TByteHashSet();
+        for ( Integer i : config.hiddenBlocks )
+        {
+            Block block = Block.getById( i );
+            // Check it exists and is not a tile entity
+            if ( block != null && !block.isTileEntity() )
+            {
+                // Add it to the set of replacement blocks
+                blocks.add( (byte) (int) i );
+            }
+        }
+        // Bake it to a flat array of replacements
+        replacementOres = blocks.toArray();
+    }
+
+    /**
+     * Starts the timings handler, then updates all blocks within the set radius
+     * of the given coordinate, revealing them if they are hidden ores.
+     */
+    public void updateNearbyBlocks(World world, BlockPosition position)
+    {
+        if ( world.spigotConfig.antiXray )
+        {
+            update.startTiming();
+            updateNearbyBlocks( world, position, 2, false ); // 2 is the radius, we shouldn't change it as that would make it exponentially slower
+            update.stopTiming();
+        }
+    }
+
+    /**
+     * Starts the timings handler, and then removes all non exposed ores from
+     * the chunk buffer.
+     */
+    public void obfuscateSync(int chunkX, int chunkY, int bitmask, byte[] buffer, World world)
+    {
+        if ( world.spigotConfig.antiXray )
+        {
+            obfuscate.startTiming();
+            obfuscate( chunkX, chunkY, bitmask, buffer, world );
+            obfuscate.stopTiming();
+        }
+    }
+
+    /**
+     * Removes all non exposed ores from the chunk buffer.
+     */
+    public void obfuscate(int chunkX, int chunkY, int bitmask, byte[] buffer, World world)
+    {
+        // If the world is marked as obfuscated
+        if ( world.spigotConfig.antiXray )
+        {
+            // Initial radius to search around for air
+            int initialRadius = 1;
+            // Which block in the buffer we are looking at, anywhere from 0 to 16^4
+            int index = 0;
+            // The iterator marking which random ore we should use next
+            int randomOre = 0;
+
+            // Chunk corner X and Z blocks
+            int startX = chunkX << 4;
+            int startZ = chunkY << 4;
+
+            byte replaceWithTypeId;
+            switch ( world.getWorld().getEnvironment() )
+            {
+                case NETHER:
+                    replaceWithTypeId = (byte) CraftMagicNumbers.getId(Blocks.NETHERRACK);
+                    break;
+                case THE_END:
+                    replaceWithTypeId = (byte) CraftMagicNumbers.getId(Blocks.END_STONE);
+                    break;
+                default:
+                    replaceWithTypeId = (byte) CraftMagicNumbers.getId(Blocks.STONE);
+                    break;
+            }
+
+            // Chunks can have up to 16 sections
+            for ( int i = 0; i < 16; i++ )
+            {
+                // If the bitmask indicates this chunk is sent...
+                if ( ( bitmask & 1 << i ) != 0 )
+                {
+                    // Work through all blocks in the chunk, y,z,x
+                    for ( int y = 0; y < 16; y++ )
+                    {
+                        for ( int z = 0; z < 16; z++ )
+                        {
+                            for ( int x = 0; x < 16; x++ )
+                            {
+                                // For some reason we can get too far ahead of ourselves (concurrent modification on bulk chunks?) so if we do, just abort and move on
+                                if ( index >= buffer.length )
+                                {
+                                    index++;
+                                    continue;
+                                }
+                                // Grab the block ID in the buffer.
+                                // TODO: extended IDs are not yet supported
+                                int blockId = (buffer[index << 1] & 0xFF) 
+                                        | ((buffer[(index << 1) + 1] & 0xFF) << 8);
+                                blockId >>>= 4;
+                                // Check if the block should be obfuscated
+                                if ( obfuscateBlocks[blockId] )
+                                {
+                                    // The world isn't loaded, bail out
+                                    if ( !isLoaded( world, new BlockPosition( startX + x, ( i << 4 ) + y, startZ + z ), initialRadius ) )
+                                    {
+                                        index++;
+                                        continue;
+                                    }
+                                    // On the otherhand, if radius is 0, or the nearby blocks are all non air, we can obfuscate
+                                    if ( !hasTransparentBlockAdjacent( world, new BlockPosition( startX + x, ( i << 4 ) + y, startZ + z ), initialRadius ) )
+                                    {
+                                        int newId = blockId;
+                                        switch ( world.spigotConfig.engineMode )
+                                        {
+                                            case 1:
+                                                // Replace with replacement material
+                                                newId = replaceWithTypeId & 0xFF;
+                                                break;
+                                            case 2:
+                                                // Replace with random ore.
+                                                if ( randomOre >= replacementOres.length )
+                                                {
+                                                    randomOre = 0;
+                                                }
+                                                newId = replacementOres[randomOre++] & 0xFF;
+                                                break;
+                                        }
+                                        newId <<= 4;
+                                        buffer[index << 1] = (byte) (newId & 0xFF);
+                                        buffer[(index << 1) + 1] = (byte) ((newId >> 8) & 0xFF);
+                                    }
+                                }
+
+                                index++;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private void updateNearbyBlocks(World world, BlockPosition position, int radius, boolean updateSelf)
+    {
+        // If the block in question is loaded
+        if ( world.isLoaded( position ) )
+        {
+            // Get block id
+            Block block = world.getType(position).getBlock();
+
+            // See if it needs update
+            if ( updateSelf && obfuscateBlocks[Block.getId( block )] )
+            {
+                // Send the update
+                world.notify( position );
+            }
+
+            // Check other blocks for updates
+            if ( radius > 0 )
+            {
+                updateNearbyBlocks( world, position.east(), radius - 1, true );
+                updateNearbyBlocks( world, position.west(), radius - 1, true );
+                updateNearbyBlocks( world, position.up(), radius - 1, true );
+                updateNearbyBlocks( world, position.down(), radius - 1, true );
+                updateNearbyBlocks( world, position.south(), radius - 1, true );
+                updateNearbyBlocks( world, position.north(), radius - 1, true );
+            }
+        }
+    }
+
+    private static boolean isLoaded(World world, BlockPosition position, int radius)
+    {
+        return world.isLoaded( position )
+                && ( radius == 0 ||
+                ( isLoaded( world, position.east(), radius - 1 )
+                && isLoaded( world, position.west(), radius - 1 )
+                && isLoaded( world, position.up(), radius - 1 )
+                && isLoaded( world, position.down(), radius - 1 )
+                && isLoaded( world, position.south(), radius - 1 )
+                && isLoaded( world, position.north(), radius - 1 ) ) );
+    }
+
+    private static boolean hasTransparentBlockAdjacent(World world, BlockPosition position, int radius)
+    {
+        return !isSolidBlock(world.getType(position, false).getBlock()) /* isSolidBlock */
+                || ( radius > 0
+                && ( hasTransparentBlockAdjacent( world, position.east(), radius - 1 )
+                || hasTransparentBlockAdjacent( world, position.west(), radius - 1 )
+                || hasTransparentBlockAdjacent( world, position.up(), radius - 1 )
+                || hasTransparentBlockAdjacent( world, position.down(), radius - 1 )
+                || hasTransparentBlockAdjacent( world, position.south(), radius - 1 )
+                || hasTransparentBlockAdjacent( world, position.north(), radius - 1 ) ) );
+    }
+
+    private static boolean isSolidBlock(Block block) {
+        // Mob spawners are treated as solid blocks as far as the
+        // game is concerned for lighting and other tasks but for
+        // rendering they can be seen through therefor we special
+        // case them so that the antixray doesn't show the fake
+        // blocks around them.
+        return block.isOccluding() && block != Blocks.MOB_SPAWNER;
+    }
+}
diff --git a/src/main/java/org/spigotmc/SpigotWorldConfig.java b/src/main/java/org/spigotmc/SpigotWorldConfig.java
index 1814b4f..45b2aae 100644
--- a/src/main/java/org/spigotmc/SpigotWorldConfig.java
+++ b/src/main/java/org/spigotmc/SpigotWorldConfig.java
@@ -1,5 +1,6 @@
 package org.spigotmc;
 
+import java.util.Arrays;
 import java.util.List;
 import org.bukkit.Bukkit;
 import org.bukkit.configuration.file.YamlConfiguration;
@@ -212,4 +213,36 @@ public class SpigotWorldConfig
         arrowDespawnRate = getInt( "arrow-despawn-rate", 1200  );
         log( "Arrow Despawn Rate: " + arrowDespawnRate );
     }
+    
+    public boolean antiXray;
+    public int engineMode;
+    public List<Integer> hiddenBlocks;
+    public List<Integer> replaceBlocks;
+    public AntiXray antiXrayInstance;
+    private void antiXray()
+    {
+        antiXray = getBoolean( "anti-xray.enabled", true );
+        log( "Anti X-Ray: " + antiXray );
+
+        engineMode = getInt( "anti-xray.engine-mode", 1 );
+        log( "\tEngine Mode: " + engineMode );
+
+        if ( SpigotConfig.version < 5 )
+        {
+            set( "anti-xray.blocks", null );
+        }
+        hiddenBlocks = getList( "anti-xray.hide-blocks", Arrays.asList( new Integer[]
+        {
+            14, 15, 16, 21, 48, 49, 54, 56, 73, 74, 82, 129, 130
+        } ) );
+        log( "\tHidden Blocks: " + hiddenBlocks );
+
+        replaceBlocks = getList( "anti-xray.replace-blocks", Arrays.asList( new Integer[]
+        {
+            1, 5
+        } ) );
+        log( "\tReplace Blocks: " + replaceBlocks );
+
+        antiXrayInstance = new AntiXray( this );
+    }
 }
-- 
2.1.0