Massive refactoring + fix

src/lishid/orebfuscator/chunkscrambler/ChunkScramblerWorldListener.java

@@ -0,0 +1,18 @@
+package lishid.orebfuscator.chunkscrambler;
+
+import lishid.orebfuscator.Orebfuscator;
+
+import org.bukkit.World;
+import org.bukkit.event.world.WorldInitEvent;
+import org.bukkit.event.world.WorldListener;
+
+public class ChunkScramblerWorldListener extends WorldListener{
+	
+	public ChunkScramblerWorldListener() { }
+	
+	public void onWorldInit(WorldInitEvent e)
+	{
+		World world = e.getWorld();
+		Orebfuscator.ReplaceWorldChunkManager(world);
+	}
+}

src/lishid/orebfuscator/chunkscrambler/ScrambledBiomeDecorator.java

@@ -0,0 +1,46 @@
+package lishid.orebfuscator.chunkscrambler;
+
+import java.lang.reflect.Field;
+import java.util.Random;
+
+import lishid.orebfuscator.utils.OrebfuscatorConfig;
+
+import net.minecraft.server.*;
+
+public class ScrambledBiomeDecorator extends BiomeDecorator{
+
+	public ScrambledBiomeDecorator(BiomeBase biome, BiomeDecorator old)
+	{
+		super(biome);
+		this.y = getInt("y", old, y);
+		this.z = getInt("z", old, z);
+		this.A = getInt("A", old, A);
+		this.B = getInt("B", old, B);
+		this.C = getInt("C", old, C);
+		this.D = getInt("D", old, D);
+		this.E = getInt("E", old, E);
+		this.F = getInt("F", old, F);
+		this.G = getInt("G", old, G);
+		this.H = getInt("H", old, H);
+		this.I = getInt("I", old, I);
+		this.J = getInt("J", old, J);
+		this.K = old.K;
+	}
+	
+	private int getInt(String field, BiomeDecorator old, int def)
+	{
+		try {
+			Field f = BiomeDecorator.class.getDeclaredField(field);
+	    	f.setAccessible(true);
+	    	return f.getInt(old);
+		} catch (Exception e) { e.printStackTrace(); }
+		return def;
+	}
+	
+	@Override
+	public void a(World world, Random random, int x, int z)
+	{
+		long newSeed = (OrebfuscatorConfig.getSeed() / 2) + (random.nextLong() / 2);
+		super.a(world, new Random(newSeed), x, z);
+	}
+}

src/lishid/orebfuscator/chunkscrambler/ScrambledWorldChunkManager.java

@@ -0,0 +1,19 @@
+package lishid.orebfuscator.chunkscrambler;
+
+import net.minecraft.server.*;
+
+public class ScrambledWorldChunkManager extends WorldChunkManager {
+	public WorldChunkManager instance;
+	public ScrambledWorldChunkManager(World world)
+	{
+		super(world);
+	}
+	
+	@Override
+	public BiomeBase getBiome(int x, int z)
+	{
+		BiomeBase biome = super.getBiome(x, z);
+		biome.G = new ScrambledBiomeDecorator(biome, biome.G);
+		return biome;
+	}
+}

src/lishid/orebfuscator/hook/NetServerHandlerProxy.java

@@ -0,0 +1,189 @@
+package lishid.orebfuscator.hook;
+
+import net.minecraft.server.*;
+
+import java.util.logging.Logger;
+
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+
+public class NetServerHandlerProxy extends NetServerHandler implements ICommandListener {
+
+    public static Logger a;
+    public NetworkManager networkManager;
+    public boolean disconnected = false;
+    public EntityPlayer player;
+    public NetServerHandler nshInstance;
+
+    public NetServerHandlerProxy(MinecraftServer minecraftserver, NetServerHandler instance) {
+        super(minecraftserver, instance.networkManager, instance.player);
+        this.nshInstance = instance;
+        this.init();
+    }
+
+    public NetServerHandlerProxy(MinecraftServer minecraftserver, NetworkManager networkmanager, EntityPlayer entityplayer) {
+        super(minecraftserver, networkmanager, entityplayer);
+        this.nshInstance = new NetServerHandler(minecraftserver, networkmanager, entityplayer);
+        this.init();
+    }
+
+    private void init(){
+        a = Logger.getLogger("Minecraft");
+        networkManager = nshInstance.networkManager;
+        disconnected = nshInstance.disconnected;
+        player = nshInstance.player;
+    }
+
+    @Override
+    public CraftPlayer getPlayer() {
+        return nshInstance.getPlayer();
+    }
+
+    @Override
+    public void a() {
+        nshInstance.a();
+    }
+
+    @Override
+    public void disconnect(String s) {
+        nshInstance.disconnect(s);
+        this.disconnected = nshInstance.disconnected;
+    }
+
+    @Override
+    public void a(Packet10Flying packet10flying) {
+        nshInstance.a(packet10flying);
+    }
+
+    @Override
+    public void a(double d0, double d1, double d2, float f, float f1) {
+        nshInstance.a(d0, d1, d2, f, f1);
+    }
+
+    @Override
+    public void teleport(Location dest) {
+        nshInstance.teleport(dest);
+    }
+
+    @Override
+    public void a(Packet14BlockDig packet14blockdig) {
+        nshInstance.a(packet14blockdig);
+    }
+
+    @Override
+    public void a(Packet15Place packet15place) {
+        nshInstance.a(packet15place);
+    }
+
+    @Override
+    public void a(String s, Object[] aobject) {
+        nshInstance.a(s, aobject);
+        disconnected = nshInstance.disconnected;
+    }
+
+    @Override
+    public void a(Packet packet) {
+        nshInstance.a(packet);
+    }
+
+    @Override
+    public void sendPacket(Packet packet) {
+        nshInstance.sendPacket(packet);
+    }
+
+    @Override
+    public void a(Packet16BlockItemSwitch packet16blockitemswitch) {
+        nshInstance.a(packet16blockitemswitch);
+    }
+
+    @Override
+    public void a(Packet3Chat packet3chat) {
+        nshInstance.a(packet3chat);
+    }
+
+    @Override
+    public boolean chat(String s) {
+        return nshInstance.chat(s);
+    }
+
+    @Override
+    public void a(Packet18ArmAnimation packet18armanimation) {
+        nshInstance.a(packet18armanimation);
+    }
+
+    @Override
+    public void a(Packet19EntityAction packet19entityaction) {
+        nshInstance.a(packet19entityaction);
+    }
+
+    @Override
+    public void a(Packet255KickDisconnect packet255kickdisconnect) {
+        nshInstance.a(packet255kickdisconnect);
+    }
+
+    @Override
+    public int lowPriorityCount() {
+        return nshInstance.lowPriorityCount();
+    }
+
+    @Override
+    public void sendMessage(String s) {
+        nshInstance.sendMessage(s);
+    }
+
+    @Override
+    public String getName() {
+        return nshInstance.getName();
+    }
+
+    @Override
+    public void a(Packet7UseEntity packet7useentity) {
+        nshInstance.a(packet7useentity);
+    }
+
+    @Override
+    public void a(Packet9Respawn packet9respawn) {
+    	nshInstance.a(packet9respawn);
+        player = nshInstance.player;
+    }
+
+    @Override
+    public void a(Packet101CloseWindow packet101closewindow) {
+        nshInstance.a(packet101closewindow);
+    }
+
+    @Override
+    public void a(Packet102WindowClick packet102windowclick) {
+        nshInstance.a(packet102windowclick);
+    }
+
+    @Override
+    public void a(Packet107SetCreativeSlot packet107setcreativeslot) {
+        nshInstance.a(packet107setcreativeslot);
+    }
+
+    @Override
+    public void a(Packet108ButtonClick packet108buttonclick) {
+    	nshInstance.a(packet108buttonclick);
+    }
+
+    @Override
+    public void a(Packet106Transaction packet106transaction) {
+        nshInstance.a(packet106transaction);
+    }
+
+    @Override
+    public void a(Packet130UpdateSign packet130updatesign) {
+        nshInstance.a(packet130updatesign);
+    }
+
+    @Override
+    public void a(Packet0KeepAlive packet0keepalive) {
+        nshInstance.a(packet0keepalive);
+    }
+
+    @Override
+    public boolean c() {
+        return nshInstance.c();
+    }
+}

src/lishid/orebfuscator/hook/OrebfuscatorNetServerHandler.java

@@ -0,0 +1,28 @@
+package lishid.orebfuscator.hook;
+
+import lishid.orebfuscator.threading.OrebfuscatorThreadCalculation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.NetServerHandler;
+import net.minecraft.server.Packet;
+import net.minecraft.server.Packet51MapChunk;
+
+public class OrebfuscatorNetServerHandler extends NetServerHandlerProxy {
+	
+	public OrebfuscatorNetServerHandler(MinecraftServer minecraftserver, NetServerHandler instance) {
+		super(minecraftserver, instance);
+	}
+
+	@Override
+    public void sendPacket(Packet packet) {
+        if (packet instanceof Packet51MapChunk)
+        {
+        	//Obfuscate packet
+			OrebfuscatorThreadCalculation.SyncThreads();
+    		OrebfuscatorThreadCalculation.Queue((Packet51MapChunk)packet, this.getPlayer());
+        }
+        else
+        {
+        	super.sendPacket(packet);
+        }
+    }
+}

src/lishid/orebfuscator/hook/SpoutLoader.java

@@ -0,0 +1,34 @@
+package lishid.orebfuscator.hook;
+
+import lishid.orebfuscator.utils.Calculations;
+import net.minecraft.server.Packet51MapChunk;
+
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+import org.getspout.spout.packet.standard.MCCraftPacket;
+import org.getspout.spoutapi.SpoutManager;
+import org.getspout.spoutapi.packet.listener.PacketListener;
+import org.getspout.spoutapi.packet.standard.MCPacket;
+
+public class SpoutLoader {
+	
+	public static void InitializeSpout()
+	{
+		//Add spout listeners
+		SpoutManager.getPacketManager().addListenerUncompressedChunk(new PacketListener(){
+			
+			//Processing a chunk packet
+			public boolean checkPacket(Player player, MCPacket mcpacket)
+			{
+				if ((player == null) || (mcpacket == null) || (player.getWorld() == null)) return true;
+				
+				//Process the chunk
+				if(((MCCraftPacket)mcpacket).getPacket() instanceof Packet51MapChunk)
+				{
+					Calculations.Obfuscate((Packet51MapChunk)((MCCraftPacket)mcpacket).getPacket(), (CraftPlayer)player, false, false);
+				}
+				return true;
+			}
+		});
+	}
+}

src/lishid/orebfuscator/threading/OrebfuscatorThreadCalculation.java

@@ -0,0 +1,92 @@
+package lishid.orebfuscator.threading;
+
+import java.util.ArrayList;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import lishid.orebfuscator.Orebfuscator;
+import lishid.orebfuscator.utils.Calculations;
+import lishid.orebfuscator.utils.ObfuscatedPlayerPacket;
+import lishid.orebfuscator.utils.OrebfuscatorConfig;
+
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import net.minecraft.server.Packet51MapChunk;
+
+public class OrebfuscatorThreadCalculation extends Thread implements Runnable
+{
+	private static final Object syncObj = new Object();
+	private static final int QUEUE_CAPACITY = 1024 * 10;
+	private static ArrayList<OrebfuscatorThreadCalculation> threads = new ArrayList<OrebfuscatorThreadCalculation>();
+	private static final LinkedBlockingDeque<ObfuscatedPlayerPacket> queue = new LinkedBlockingDeque<ObfuscatedPlayerPacket>(QUEUE_CAPACITY);
+	
+	public static int getThreads()
+	{
+		return threads.size();
+	}
+	
+	public static boolean CheckThreads()
+	{
+		return threads.size() == OrebfuscatorConfig.getProcessingThreads();
+	}
+	
+	public static void SyncThreads()
+	{
+		synchronized(syncObj)
+		{
+			int extra = threads.size() - OrebfuscatorConfig.getProcessingThreads();
+			if (extra > 0)
+			{
+				for(int i = extra; i > 0; i--)
+				{
+					threads.get(i - 1).kill.set(true);
+					threads.remove(i - 1);
+				}
+			}
+			else if (extra < 0)
+			{
+				extra = -extra;
+				for(int i = 0; i < extra; i++)
+				{
+					OrebfuscatorThreadCalculation thread = new OrebfuscatorThreadCalculation();
+					thread.setName("Orebfuscator Calculation Thread");
+					thread.start();
+					threads.add(thread);
+				}
+			}
+		}
+	}
+	
+	public static void Queue(Packet51MapChunk packet, CraftPlayer player)
+	{
+		while(true)
+		{
+			try {
+				queue.put(new ObfuscatedPlayerPacket(player, packet));
+				return;
+			}
+			catch (Exception e) { Orebfuscator.log(e); }
+		}
+	}
+
+	private AtomicBoolean kill = new AtomicBoolean(false);
+	
+	public void run() {
+		while (!this.isInterrupted() && !kill.get()) {
+			try {
+				//Take a package from the queue
+				ObfuscatedPlayerPacket packet = queue.take();
+				
+				try {
+					//Try to obfuscate and send the packet
+					Calculations.Obfuscate(packet.packet, packet.player, true, true);
+				}
+				catch (Exception e)
+				{
+					Orebfuscator.log(e);
+		    		//If we run into problems, just send the packet.
+					packet.player.getHandle().netServerHandler.sendPacket(packet.packet);
+				}
+			} catch (Exception e) { Orebfuscator.log(e); }
+		}
+	}
+}

src/lishid/orebfuscator/threading/OrebfuscatorThreadUpdate.java

@@ -0,0 +1,70 @@
+package lishid.orebfuscator.threading;
+
+import java.util.concurrent.LinkedBlockingDeque;
+
+import lishid.orebfuscator.Orebfuscator;
+import lishid.orebfuscator.utils.Calculations;
+import lishid.orebfuscator.utils.OrebfuscatorConfig;
+
+import org.bukkit.block.Block;
+
+public class OrebfuscatorThreadUpdate extends Thread implements Runnable
+{
+	//Global
+	private static final int QUEUE_CAPACITY = 1024 * 10;
+	private static final LinkedBlockingDeque<Block> queue = new LinkedBlockingDeque<Block>(QUEUE_CAPACITY);
+	private static OrebfuscatorThreadUpdate thread;
+
+	public static void Queue(Block block)
+	{
+		//Removed: 
+		//!OrebfuscatorConfig.Enabled() || 
+		
+		//Dont do anything if the block is transparent
+        if (OrebfuscatorConfig.isTransparent((byte)block.getTypeId()))
+        {
+        	return;
+        }
+        
+        if(!OrebfuscatorConfig.getUpdateThread())
+        {
+	        Calculations.UpdateBlocksNearby(block);
+	        return;
+        }
+        
+		if(thread == null || thread.isInterrupted())
+		{
+			thread = new OrebfuscatorThreadUpdate();
+			thread.setName("Orebfuscator Update Thread");
+			thread.start();
+		}
+		while(true)
+		{
+			try {
+				//Queue block for later processing
+				queue.put(block);
+				return;
+			}
+			catch (Exception e) { Orebfuscator.log(e); }
+		}
+	}
+	
+	public void run() {
+		while (!this.isInterrupted()) {
+			try {
+				//Remove the first block from the queue
+				Block block = queue.take();
+				//Send updates on the block change
+		        Calculations.UpdateBlocksNearby(block);
+		        
+		        //Exit if config changed to not using this thread.
+		        if(!OrebfuscatorConfig.getUpdateThread() && queue.size() <= 0)
+		        {
+		        	thread = null;
+		        	return;
+		        }
+			}
+			catch (Exception e) { Orebfuscator.log(e); }
+		}
+	}
+}