PacketCustomBlockChunkOverride.java

/*
 * This file is part of Spoutcraft.
 *
 * Copyright (c) 2011 SpoutcraftDev <http://spoutcraft.org/>
 * Spoutcraft is licensed under the GNU Lesser General Public License.
 *
 * Spoutcraft is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Spoutcraft is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.spoutcraft.client.packet;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.zip.DataFormatException;
import java.util.zip.Deflater;
import java.util.zip.Inflater;

import org.apache.commons.io.output.ByteArrayOutputStream;

import net.minecraft.src.EnumSkyBlock;
import net.minecraft.src.World;

import org.spoutcraft.api.Spoutcraft;
import org.spoutcraft.api.io.SpoutInputStream;
import org.spoutcraft.api.io.SpoutOutputStream;
import org.spoutcraft.api.material.CustomBlock;
import org.spoutcraft.api.material.MaterialData;
import org.spoutcraft.client.SpoutClient;
import org.spoutcraft.client.packet.LightingThread.LightingData;

public class PacketCustomBlockChunkOverride implements CompressablePacket {
	private static LightingThread thread;
	private int chunkX;
	private int chunkZ;
	private boolean hasData = false;
	private byte[] data;
	private boolean compressed = true;

	public PacketCustomBlockChunkOverride() {
	}

	public PacketCustomBlockChunkOverride(int x, int z) {
		chunkX = x;
		chunkZ = z;
		compressed = false;
	}

	public void readData(SpoutInputStream input) throws IOException {
		chunkX = input.readInt();
		chunkZ = input.readInt();
		hasData = input.readBoolean();
		if (hasData) {
			int size = input.readInt();
			data = new byte[size];
			input.read(data);
		}
	}

	public void writeData(SpoutOutputStream output) throws IOException {
		output.writeInt(chunkX);
		output.writeInt(chunkZ);
		output.writeBoolean(hasData);
		if (hasData) {
			output.writeInt(data.length);
			output.write(data);
		}
	}

	public void run(int playerId) {
		if (hasData) {
			if (!SpoutClient.getInstance().getRawWorld().chunkProvider.chunkExists(chunkX, chunkZ)) {
				return;
			}

			if (thread == null) {
				thread = new LightingThread();
				thread.start();
			}

			ByteBuffer buffer = ByteBuffer.allocate(data.length);
			buffer.put(data);
			short[] customIds = new short[16*16*256];
			byte[] customData = new byte[16*16*256];
			for (int i = 0; i < customIds.length; i++) {
				customIds[i] = buffer.getShort(i * 3);
				customData[i] = buffer.get((i * 3) + 2);
			}
			Spoutcraft.getChunk(SpoutClient.getInstance().getRawWorld(), chunkX, chunkZ).setCustomBlockIds(customIds);
			Spoutcraft.getChunk(SpoutClient.getInstance().getRawWorld(), chunkX, chunkZ).setCustomBlockData(customData);
			thread.queue.add(new LightingData(chunkX, chunkZ, customIds));
		}
	}

	public void failure(int playerId) {
	}

	public PacketType getPacketType() {
		return PacketType.PacketCustomBlockChunkOverride;
	}

	public int getVersion() {
		return 2;
	}

	public void compress() {
		if (!compressed && hasData) {
			if (data != null) {
				Deflater deflater = new Deflater();
				deflater.setInput(data);
				deflater.setLevel(Deflater.BEST_COMPRESSION);
				deflater.finish();
				ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
				byte[] buffer = new byte[1024];
				while (!deflater.finished()) {
					int bytesCompressed = deflater.deflate(buffer);
					bos.write(buffer, 0, bytesCompressed);
				}
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				data = bos.toByteArray();
			}
			compressed = true;
		}
	}

	public void decompress() {
		if (compressed && hasData) {
			Inflater decompressor = new Inflater();
			decompressor.setInput(data);

			ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);

			byte[] buf = new byte[1024];
			while (!decompressor.finished()) {
				try {
					int count = decompressor.inflate(buf);
					bos.write(buf, 0, count);
				} catch (DataFormatException e) {
				}
			}
			try {
				bos.close();
			} catch (IOException e) {
			}

			data = bos.toByteArray();
		}
	}

	public boolean isCompressed() {
		return compressed;
	}
}

class LightingThread extends Thread {
	final LinkedBlockingDeque<LightingData> queue = new LinkedBlockingDeque<LightingData>();
	final int[] lightingBlockList = new int[32768 * 4];
	LightingThread() {
		super("Lighting Thread");
		setDaemon(true);
	}

	@Override
	public void run() {
		while (!this.isInterrupted()) {
			try {
				LightingData data = queue.take();
				World world = SpoutClient.getHandle().theWorld;
				if (world != null && world.chunkProvider.chunkExists(data.cx, data.cz)) {
					for (int i = 0; i < data.ids.length; i++) {
						CustomBlock cb = MaterialData.getCustomBlock(data.ids[i]);
						if (cb != null && cb.getLightLevel() != 0) {
							int bx = (i >> 12) & 0xF;
							int by = i & 0xFF;
							int bz = (i >> 8) & 0xF;
							world.updateLightByType(lightingBlockList, EnumSkyBlock.Sky, data.cx * 16 + bx, by, data.cz * 16 + bz);
							world.updateLightByType(lightingBlockList, EnumSkyBlock.Block, data.cx * 16 + bx, by, data.cz * 16 + bz);
						}
					}
				}
			} catch (InterruptedException e) {
				return;
			}
		}
	}

	static class LightingData{
		final int cx, cz;
		final short[] ids;
		LightingData(int cx, int cz, short[] ids) {
			this.cx = cx;
			this.cz = cz;
			this.ids = ids;
		}
	}
}