Thread: Netty Issue?

Edit:

Originally Posted by relex lawl

Well managed to fix some things, but still end up with this:

Error: T2 - 81,73,249 - 3,0,0 - -128,31,-4,

Spoiler for new PlayerUpdating:

Code:

package org.niobe.world.util;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.niobe.model.Appearance.Gender;
import org.niobe.model.Attributes.Attribute;
import org.niobe.model.UpdateFlag.Flag;
import org.niobe.model.container.ItemContainer;
import org.niobe.model.container.impl.Equipment;
import org.niobe.model.definitions.ItemDefinition;
import org.niobe.model.Appearance;
import org.niobe.model.MovementQueue;
import org.niobe.net.packet.Packet.Type;
import org.niobe.net.packet.Packet;
import org.niobe.net.packet.PacketBuilder;
import org.niobe.util.NameUtils;
import org.niobe.world.Player;

public class PlayerUpdating {
	
	private List<Player> localPlayers = new LinkedList<Player>();
	
	public PlayerUpdating update() {
		if (player.getAttributes().containsKey(Attribute.CHANGING_REGION)) {
			player.getPacketSender().sendMapRegion();
		}
		PacketBuilder update = new PacketBuilder();
		PacketBuilder packet = new PacketBuilder(81, Type.SHORT);
		packet.initializeBitAccess();
		updateMovement(packet).appendUpdates(update, player, false, true);
		packet.writeBits(8, localPlayers.size());
		for (Iterator<Player> playerIterator = localPlayers.iterator(); playerIterator.hasNext();) {
			Player otherPlayer = (Player) playerIterator.next();
			if (player.getRegion().getArea().getPlayers().contains(otherPlayer) && !otherPlayer.getAttributes().containsKey(Attribute.TELEPORTING)) {
				updateOtherPlayerMovement(packet, otherPlayer);
				if (otherPlayer.getUpdateFlag().isUpdateRequired()) {
					appendUpdates(update, otherPlayer, false, false);
				}
			} else {
				localPlayers.remove(otherPlayer);
				playerIterator.remove();
				packet.writeBits(1, 1).writeBits(2, 3);
			}
		}
		for (Iterator<Player> playerIterator = player.getRegion().getArea().getPlayers().iterator(); playerIterator.hasNext();) {
			Player otherPlayer = (Player) playerIterator.next();
			if (localPlayers.size() >= 255)
				break;
			if (otherPlayer == player || localPlayers.contains(otherPlayer))
				continue;
			localPlayers.add(otherPlayer);
			addPlayer(otherPlayer, packet);
			appendUpdates(update, otherPlayer, false, false);
		}
		if (!update.isEmpty()) {
			packet.writeBits(11, 2047);
			packet.finalizeBitAccess();
			packet.writeBuffer(update.toPacket().getBuffer());
		} else {
			packet.finalizeBitAccess();
		}
		player.write(packet.toPacket());
		return this;
	}
	
	public PlayerUpdating addPlayer(Player otherPlayer, PacketBuilder builder) {
		builder.writeBits(11, otherPlayer.getIndex());
		builder.writeBits(1, 1);
		builder.writeBits(1, 1);
		builder.writeBits(5, otherPlayer.getPosition().getY() - player.getPosition().getY());
		builder.writeBits(5, otherPlayer.getPosition().getX() - player.getPosition().getX());
		return this;
	}
	
	private PlayerUpdating appendUpdates(PacketBuilder builder, Player player, boolean updateAppearance, boolean noChat) {
		if (!player.getUpdateFlag().isUpdateRequired() && !updateAppearance)
			return this;
		int mask = 0;

		if (player.getUpdateFlag().flagged(Flag.APPEARANCE) || updateAppearance) {
			mask |= 0x10;
		}

		if (player.getUpdateFlag().flagged(Flag.CHAT) && !noChat) {
			mask |= 0x80;
		}

		if (mask >= 0x100) {
			mask |= 0x40;
			builder.writeByte(mask & 0xFF);
			builder.writeByte(mask >> 8);
		} else {
			builder.writeByte(mask);
		}

		if (player.getUpdateFlag().flagged(Flag.APPEARANCE) || updateAppearance) {
			updateAppearance(builder, player);
		}

		if (player.getUpdateFlag().flagged(Flag.CHAT) && !noChat) {
			updateChat(builder, player);
		}
		return this;
	}
	
	private PlayerUpdating updateMovement(PacketBuilder builder) {
		if (player.getAttributes().containsKey(Attribute.TELEPORTING) || player.getAttributes().containsKey(Attribute.CHANGING_REGION)) {
			builder.writeBits(1, 1);
			builder.writeBits(2, 3);
			builder.writeBits(2, player.getPosition().getZ());
			builder.writeBits(1, player.getTeleportTarget() != null ? 1 : 0);
			builder.writeBits(1, player.getUpdateFlag().isUpdateRequired() ? 1 : 0);
			builder.writeBits(7, player.getPosition().getLocalY());
			builder.writeBits(7, player.getPosition().getLocalX());
		} else {
			if (!player.getMovementQueue().updateRequired()) {
				if (player.getUpdateFlag().isUpdateRequired()) {
					builder.writeBits(1, 1);
					builder.writeBits(2, 0);
				} else {
					builder.writeBits(1, 0);
				}
			} else {
				if (player.getMovementQueue().getDirections()[MovementQueue.RUNNING_DIRECTION] == -1) {
					builder.writeBits(1, 1);
					builder.writeBits(2, 1);
					builder.writeBits(3, player.getMovementQueue().getDirections()[MovementQueue.WALKING_DIRECTION]);
					builder.writeBits(1, player.getUpdateFlag().isUpdateRequired() ? 1 : 0);
				} else {
					builder.writeBits(1, 1);
					builder.writeBits(2, 2);
					builder.writeBits(3, player.getMovementQueue().getDirections()[MovementQueue.WALKING_DIRECTION]);
					builder.writeBits(3, player.getMovementQueue().getDirections()[MovementQueue.RUNNING_DIRECTION]);
					builder.writeBits(1, player.getUpdateFlag().isUpdateRequired() ? 1 : 0);
				}
			}
		}
		return this;
	}
	
	private PlayerUpdating updateChat(PacketBuilder builder, Player otherPlayer) {
		int effects = ((otherPlayer.getPlayerUpdating().chatColor & 0xff) << 8) + (otherPlayer.getPlayerUpdating().chatEffect & 0xff);
		builder.writeLEShort(effects);
		builder.writeByte(/*player.getRights().ordinal()*/0);
		builder.writeByteC((byte) otherPlayer.getPlayerUpdating().chat.length);
		builder.writeBytes(otherPlayer.getPlayerUpdating().chat);
		return this;
	}
	
	private PlayerUpdating updateAppearance(PacketBuilder builder, Player otherPlayer) {
		Appearance appearance = otherPlayer.getAppearance();
		ItemContainer equipment = otherPlayer.getEquipment();
		
		PacketBuilder properties = new PacketBuilder();
		
		properties.writeByte((byte) appearance.getGender().getId());
		properties.writeByte((byte) appearance.getHeadIcon().getId());
		properties.writeByte((byte) appearance.getSkullHint().getId());
		
		int[] equip = new int[equipment.getCapacity()];
		for (int i = 0; i < equipment.getCapacity(); i++) {
			equip[i] = equipment.getItems()[i].getId();
		}

		if (equip[Equipment.HAT_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.HAT_SLOT]);
		} else {
			properties.writeByte(0);
		}

		if (equip[Equipment.CAPE_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.CAPE_SLOT]);
		} else {
			properties.writeByte(0);
		}

		if (equip[Equipment.AMULET_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.AMULET_SLOT]);
		} else {
			properties.writeByte(0);
		}

		if (equip[Equipment.WEAPON_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.WEAPON_SLOT]);
		} else {
			properties.writeByte(0);
		}

		if (equip[Equipment.BODY_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.BODY_SLOT]);
		} else {
			properties.writeShort(0x100 + appearance.getLook()[Appearance.CHEST]);
		}

		if (equip[Equipment.SHIELD_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.SHIELD_SLOT]);
		} else {
			properties.writeByte(0);
		}

		if (ItemDefinition.forId(equip[Equipment.BODY_SLOT]).isFullBody()) {
			properties.writeByte(0);
		} else {
			properties.writeShort(0x100 + appearance.getLook()[Appearance.ARMS]);
		}

		if (equip[Equipment.LEGS_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.LEGS_SLOT]);
		} else {
			properties.writeShort(0x100 + appearance.getLook()[Appearance.LEGS]);
		}

		if (ItemDefinition.forId(equip[Equipment.HAT_SLOT]).isFullHelm()) {
			properties.writeByte(0);
		} else {
			properties.writeShort(0x100 + appearance.getLook()[Appearance.HEAD]);
		}

		if (equip[Equipment.HANDS_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.HANDS_SLOT]);
		} else {
			properties.writeShort(0x100 + appearance.getLook()[Appearance.HANDS]);
		}

		if (equip[Equipment.FEET_SLOT] > -1) {
			properties.writeShort(0x200 + equip[Equipment.FEET_SLOT]);
		} else {
			properties.writeShort(0x100 + appearance.getLook()[Appearance.FEET]);
		}
		
		if (appearance.getLook()[Appearance.BEARD] <= 0 || appearance.getGender().equals(Gender.FEMALE)) {
			properties.writeByte(0);
		} else {
			properties.writeShort(0x100 + appearance.getLook()[Appearance.BEARD]);
		}
		
		properties.writeByte(appearance.getLook()[Appearance.HAIR_COLOUR]);
		properties.writeByte(appearance.getLook()[Appearance.TORSO_COLOUR]);
		properties.writeByte(appearance.getLook()[Appearance.LEG_COLOUR]);
		properties.writeByte(appearance.getLook()[Appearance.FEET_COLOUR]);
		properties.writeByte(appearance.getLook()[Appearance.SKIN_COLOUR]);
		
		properties.writeShort(0x328); // TODO: standAnimIndex
		properties.writeShort(0x337); // TODO: standTurnAnimIndex
		properties.writeShort(0x333); // TODO: walkAnimIndex
		properties.writeShort(0x334); // TODO: turn180AnimIndex
		properties.writeShort(0x335); // TODO: turn90CWAnimIndex
		properties.writeShort(0x336); // TODO: turn90CCWAnimIndex
		properties.writeShort(0x338); // TODO: runAnimIndex
		
		properties.writeLong(NameUtils.nameToLong(player.getUsername()));
		
		properties.writeByte(otherPlayer.getSkills().getCombatLevel());
		properties.writeShort(otherPlayer.getSkills().getTotalLevel());
		
		Packet packet = properties.toPacket();
		
		builder.writeByteC((byte) packet.getLength());
		builder.writeBuffer(packet.getBuffer());
		return this;
	}
	
	private PlayerUpdating updateOtherPlayerMovement(PacketBuilder packetBuilder, Player otherPlayer) {
		if (!otherPlayer.getMovementQueue().updateRequired()) {
			if (otherPlayer.getUpdateFlag().isUpdateRequired()) {
				packetBuilder.writeBits(1, 1);
				packetBuilder.writeBits(2, 0);
			} else {
				packetBuilder.writeBits(1, 0);
			}
		} else if (otherPlayer.getMovementQueue().getDirections()[MovementQueue.RUNNING_DIRECTION] == -1) {
			packetBuilder.writeBits(1, 1);
			packetBuilder.writeBits(2, 1);
			packetBuilder.writeBits(3, otherPlayer.getMovementQueue().getDirections()[MovementQueue.WALKING_DIRECTION]);
			packetBuilder.writeBits(1, otherPlayer.getUpdateFlag().isUpdateRequired() ? 1 : 0);
		} else {
			packetBuilder.writeBits(1, 1);
			packetBuilder.writeBits(2, 2);
			packetBuilder.writeBits(3, otherPlayer.getMovementQueue().getDirections()[MovementQueue.WALKING_DIRECTION]); // Walking
			packetBuilder.writeBits(3, otherPlayer.getMovementQueue().getDirections()[MovementQueue.RUNNING_DIRECTION]); // Running
			packetBuilder.writeBits(1, otherPlayer.getUpdateFlag().isUpdateRequired() ? 1 : 0);
		}
		return this;
	}
	
	public PlayerUpdating resetFlags() {
		chat = new byte[256];
		chatColor = chatEffect = 0;
		player.getUpdateFlag().set(Flag.NONE);
		player.getMovementQueue().setDirections(-1, -1);
		return this;
	}

	public PlayerUpdating(Player player) {
		this.player = player;
	}
	
	private Player player;
	
	private byte[] chat = new byte[256];
	
	private int chatColor = 0, chatEffect = 0;
}

I've never been able to make a framework with netty...I always end up getting stuck on login, never wants to successfully show the map region, I honestly do not know what's wrong....It just gets stuck at loading - please wait. I mean it should work:

Nov 26, 2012 5:32:57 PM org.niobe.Server main
INFO: Launching Niobe, please be patient while configurations are being loaded...
Loading npc definitions...
Loaded 11257 npc definitions in 1495ms
Loading object definitions...
Loaded 20461 object definitions in 2221ms
Loading item definitions...
Loaded 20694 item definitions in 1310ms
Loading shop definitions...
Loaded 2 shop definitions in 3ms.
Nov 26, 2012 5:33:03 PM org.niobe.Server main
INFO: Port 43594 has been binded.
sending raw packet with size: 256
sending raw packet with size: 256
Registered player: Dddd
sending finalized Packet - [opcode, size] : [249, 256]
sending finalized Packet - [opcode, size] : [73, 256]
sending map region for position: Position values: [x, y, z] - [3222, 3222, 0].
setting session's player
received packet message: Packet - [opcode, size] : [3, 1] <-- This is from me clicking outside the client.

This is the message received method from my ChanneHandler (extends SimpleChannelHandler)

Spoiler for messageReceived:

Code:

@Override
	public void messageReceived(ChannelHandlerContext context, MessageEvent event) {
		if (event.getMessage() instanceof Player) {
			Player player = (Player) event.getMessage();
			session.setPlayer(player);
			System.out.println("setting session's player");
		} else if (event.getMessage() instanceof Packet) {
			if (session.getPlayer() != null) {
				Packet packet = (Packet) event.getMessage();
				PacketExecutor.parse(session.getPlayer(), packet);
				System.out.println("received packet message: " + packet.toString());
			}
		} else {
			System.out.println("received unhandled message: " + event.getMessage().toString());
		}
	}

Spoiler for sendLogin:

Code:

public PacketSender sendLogin() {
		player.write(new PacketBuilder(249).writeByteA((byte) 1).writeLEShortA(player.getIndex()).toPacket());

		sendMapRegion();	
		
		/*sendSidebarInterface(0, 2423); // attack tab
		sendSidebarInterface(1, 3917); // skills tab
		sendSidebarInterface(2, 638); // quest tab
		sendSidebarInterface(3, 3213); // backpack tab
		sendSidebarInterface(4, 1644); // items wearing tab
		sendSidebarInterface(5, 5608); // pray tab
		sendSidebarInterface(6, 1151); // magic tab
		sendSidebarInterface(7, -1); // clan chat
		sendSidebarInterface(8, 5065); // friend
		sendSidebarInterface(9, 5715); // ignore
		sendSidebarInterface(10, 2449); // logout tab
		sendSidebarInterface(11, 904); // wrench tab
		sendSidebarInterface(12, 147); // run tab
		sendSidebarInterface(13, -1); // harp tab
		
		sendInteractionOption("Attack", 2, false);
		sendInteractionOption("Follow", 3, false);
		sendInteractionOption("Trade With", 4, false);*/
		
		//sendMessage("Welcome to RuneScape.");
		return this;
	}

Spoiler for PacketEncoder extends OneToOneEncoder:

Code:

@Override
	protected Object encode(ChannelHandlerContext context, Channel channel, Object message) throws Exception {
		Packet packet = (Packet) message;
		if (packet.getOpcode() == -1) {
			System.out.println("sending raw packet with size: " + packet.getLength());
			return packet.getBuffer();
		}
		int opcode = packet.getOpcode();
		Type type = packet.getType();
		int length = packet.getLength();
		/*
		 * Encrypts the packet's opcode.
		 */
		opcode += algorithm.getNextValue();
		
		int totalLength = length + 1;
		switch (type) {
		case BYTE:
			totalLength += 1;
			break;
		case SHORT:
			totalLength += 2;
			break;
		}
		ChannelBuffer buffer = ChannelBuffers.buffer(totalLength);
		buffer.writeByte(opcode);
		switch (type) {
		case BYTE:
			buffer.writeByte(length);
			break;
		case SHORT:
			buffer.writeShort(length);
			break;
		}
		System.out.println("sending finalized " + packet.toString());
		buffer.writeBytes(packet.getBuffer());
		return buffer;
	}

Those are the 3 methods that should be causing the problem, but I still don't get it, also these:

Spoiler for sendMapRegion:

Code:

public PacketSender sendMapRegion() {
		player.setLastKnownRegion(player.getPosition());
		player.write(new PacketBuilder(73).writeShortA(player.getPosition().getRegionX() + 6).writeShort(player.getPosition().getRegionY() + 6).toPacket());
		player.getAttributes().remove("changing_region");
		System.out.println("sending map region for position: " + player.getPosition().toString());
		return this;
	}

Spoiler for Packet:

Code:

package org.niobe.net.packet;

import org.jboss.netty.buffer.ChannelBuffer;

public class Packet {
	
	public Packet(int opcode, Type type, ChannelBuffer buffer) {
		this.opcode = opcode;
		this.type = type;
		this.buffer = buffer;
	}
	
	private final int opcode;
	
	public int getOpcode() {
		return opcode;
	}
	
	private Type type;
	
	public Type getType() {
		return type;
	}
	
	private ChannelBuffer buffer;
	
	public ChannelBuffer getBuffer() {
		return buffer;
	}
	
	public int getLength() {
		return buffer.capacity();
	}
	
	public byte readByte() {
		return buffer.readByte();
	}
	
	public byte readByteA() {
		return (byte) (readByte() - 128);
	}
	
	public byte readByteC() {
		return (byte) (-readByte());
	}
	
	public byte readByteS() {
		return (byte) (128 - readByte());
	}
	
	public Packet readBytes(byte[] bytes) {
		buffer.readBytes(bytes);
		return this;
	}
	
	public Packet readReversedBytes(byte[] bytes, int offset, int length) {
		for (int i = (offset + length - 1); i >= offset; i--)
			bytes[i] = readByte();
		return this;
	}
	
	public Packet readReversedBytesA(byte[] bytes, int offset, int length) {
		for (int i = (offset + length - 1); i >= offset; i--)
			bytes[i] = readByteA();
		return this;
	}
	
	public Packet readBytes(byte[] bytes, int offset, int length) {
		for (int i = 0; i < length; i++)
			bytes[offset + i] = readByte();
		return this;
	}
	
	public int readUnsignedByte() {
		return readByte() & 0xff;
	}
	
	public short readShort() {
		return buffer.readShort();
	}
	
	public short readShortA() {
		int value = ((readByte() & 0xFF) << 8) | (readByte() - 128 & 0xFF);
		return (short) (value > 32767 ? value - 0x10000 : value);
	}
	
	public short readLEShort() {
		int value = (readByte() & 0xFF) | (readByte() & 0xFF) << 8;
		return (short) (value > 32767 ? value - 0x10000 : value);
	}
	
	public short readLEShortA() {
		int value = (readByte() - 128 & 0xFF) | (readByte() & 0xFF) << 8;
		return (short) (value > 32767 ? value - 0x10000 : value);
	}
	
	public int readUnsignedShort() {
		int valuealue = 0;
		valuealue |= readUnsignedByte() << 8;
		valuealue |= readUnsignedByte();
		return valuealue;
	}
	
	public int readUnsignedShortA() {
		int value = 0;
		value |= readUnsignedByte() << 8;
		value |= (readByte() - 128) & 0xff;
		return value;
	}
	
	public int readInt() {
		return buffer.readInt();
	}
	
	public int readSingleInt() {
		byte firstByte = readByte(), secondByte = readByte(), thirdByte = readByte(), fourthByte = readByte();
		return ((thirdByte << 24) & 0xFF) | ((fourthByte << 16) & 0xFF) | ((firstByte << 8) & 0xFF) | (secondByte & 0xFF);
	}
	
	public int readDuoInt() {
		int firstByte = readByte() & 0xFF, secondByte = readByte() & 0xFF, thirdByte = readByte() & 0xFF, fourthByte = readByte() & 0xFF;
		return ((secondByte << 24) & 0xFF) | ((firstByte << 16) & 0xFF) | ((fourthByte << 8) & 0xFF) | (thirdByte & 0xFF);
	}
	
	public int readTriInt() {
		return ((readByte() << 16) & 0xFF) | ((readByte() << 8) & 0xFF) | (readByte() & 0xFF);
	}
	
	public long readLong() {
		return buffer.readLong();
	}
	
	public String readString() {
		StringBuilder builder = new StringBuilder();
		byte value;
		while (buffer.readable() && (value = buffer.readByte()) != 10) {
			builder.append((char) value);
		}
		return builder.toString();
	}
	
	public int readSmart() {
		return buffer.getByte(buffer.readerIndex()) < 128 ? readByte() & 0xFF : (readShort() & 0xFFFF) - 32768;
	}

	public int readSignedSmart() {
		return buffer.getByte(buffer.readerIndex()) < 128 ? (readByte() & 0xFF) - 64 : (readShort() & 0xFFFF) - 49152;
	}
	
	@Override
	public String toString() {
		return "Packet - [opcode, size] : [" + getOpcode() + ", " + getLength() + "]";
	}
	
	public enum Type {
		FIXED,
		BYTE,
		SHORT;
	}
}

Spoiler for PacketBuilder:

Code:

package org.niobe.net.packet;

import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.niobe.net.packet.Packet.Type;

public class PacketBuilder {
	
	public PacketBuilder(int opcode, Type type) {
		this.opcode = opcode;
		this.type = type;
	}
	
	public PacketBuilder(int opcode) {
		this(opcode, Type.FIXED);
	}
	
	public PacketBuilder() {
		this(-1);
	}
	
	private final int opcode;
	
	private final Type type;
	
	private int bitPosition;
	
	private final ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
	
	public boolean isEmpty() {
		return buffer.writerIndex() == 0;
	}
	
	public PacketBuilder writeByte(byte value) {
		buffer.writeByte(value);
		return this;
	}
	
	public PacketBuilder writeByte(int value) {
		writeByte((byte) value);
		return this;
	}
	
	public PacketBuilder writeByteA(byte value) {
		writeByte((byte) (value + 128));
		return this;
	}
	
	public PacketBuilder writeByteC(byte value) {
		writeByte((byte) (-value));
		return this;
	}
	
	public PacketBuilder writeByteS(byte value) {
		writeByte((byte) (128 - value));
		return this;
	}
	
	public PacketBuilder writeBytes(byte[] bytes) {
		buffer.writeBytes(bytes);
		return this;
	}
	
	public PacketBuilder writeBytes(byte[] bytes, int offset, int length) {
		writeBytes(bytes, offset, length);
		return this;
	}
	
	public PacketBuilder writeBytes(int value, int amount) {
		for (; amount > 0; amount--) {
			buffer.writeByte((byte) value);
		}
		return this;
	}
	
	public PacketBuilder writeReversedBytes(byte[] bytes, int offset, int length) {
		for (int i = (offset + length - 1); i >= offset; i--)
			writeByte(bytes[i]);
		return this;
	}
	
	public PacketBuilder putReverseA(final byte[] bytes, final int offset, final int length) {
		for (int i = (offset + length - 1); i >= offset; i--)
			writeByteA(bytes[i]);
		return this;
	}
	
	public PacketBuilder writeShort(int value) {
		buffer.writeShort((short) value);
		return this;
	}
	
	public PacketBuilder writeInt(int value) {
		buffer.writeInt(value);
		return this;
	}
	
	public PacketBuilder writeSingleInt(int value) {
		writeByte((byte) (value >> 8)).writeByte((byte) value).writeByte((byte) (value >> 24)).writeByte((byte) (value >> 16));
		return this;
	}
	
	public PacketBuilder writeDuoInt(int value) {
		writeByte((byte) (value >> 16)).writeByte((byte) (value >> 24)).writeByte((byte) value).writeByte((byte) (value >> 8));
		return this;
	}
	
	public PacketBuilder writeTriInt(int value) {
		writeByte((byte) (value >> 16)).writeByte((byte) (value >> 8)).writeByte((byte) value);
		return this;
	}
	
	public PacketBuilder writeLEInt(int value) {
		writeByte((byte) (value)).writeByte((byte) (value >> 8)).writeByte((byte) (value >> 16)).writeByte((byte) (value >> 24));
		return this;
	}
	
	public PacketBuilder writeLong(long value) {
		buffer.writeLong(value);
		return this;
	}
	
	public PacketBuilder writeString(String string) {
		buffer.writeBytes(string.getBytes());
		writeByte((byte) 10);
		return this;
	}
	
	public PacketBuilder writeShortA(int value) {
		writeByte((byte) (value >> 8)).writeByte((byte) (value + 128));
		return this;
	}
	
	public PacketBuilder writeLEShort(int value) {
		writeByte((byte) (value)).writeByte((byte) (value >> 8));
		return this;
	}
	
	public PacketBuilder writeLEShortA(int value) {
		writeByte((byte) (value + 128)).writeByte((byte) (value >> 8));
		return this;
	}
	
	public PacketBuilder writeSmart(int value) {
		if (value < 128)
			writeByte((byte)value);
		else
			writeShort((value + 32768));
		return this;
	}
	
	public PacketBuilder writeSignedSmart(int value) {
		if (value < 128)
			writeByte((byte) (value + 64));
		else
			writeShort((value + 49152));
		return this;
	}
	
	public PacketBuilder writeBuffer(ChannelBuffer buffer) {
		buffer.writeBytes(buffer);
		return this;
	}
	
	public PacketBuilder initializeBitAccess() {
		bitPosition = buffer.writerIndex() * 8;
		return this;
	}
	
	public PacketBuilder finalizeBitAccess() {
		buffer.writerIndex((bitPosition + 7) / 8);
		return this;
	}
	
	public PacketBuilder writeBits(int numBits, final int value) {
		if (!buffer.hasArray())
			throw new UnsupportedOperationException("The ChannelBuffer implementation must support array() for bit usage.");

		final int bytes = (int) Math.ceil(numBits / 8D) + 1;
		buffer.ensureWritableBytes((bitPosition + 7) / 8 + bytes);

		final byte[] buffer = this.buffer.array();

		int bytePos = bitPosition >> 3;
		int bitOffset = 8 - (bitPosition & 7);
		bitPosition += numBits;

		for (; numBits > bitOffset; bitOffset = 8) {
			buffer[bytePos] &= ~BIT_MASK[bitOffset];
			buffer[bytePos++] |= (value >> (numBits - bitOffset)) & BIT_MASK[bitOffset];
			numBits -= bitOffset;
		}
		if (numBits == bitOffset) {
			buffer[bytePos] &= ~BIT_MASK[bitOffset];
			buffer[bytePos] |= value & BIT_MASK[bitOffset];
		} else {
			buffer[bytePos] &= ~(BIT_MASK[numBits] << (bitOffset - numBits));
			buffer[bytePos] |= (value & BIT_MASK[numBits]) << (bitOffset - numBits);
		}
		return this;
	}
	
	public Packet toPacket() {
		return new Packet(opcode, type, buffer);
	}

	public static final int[] BIT_MASK = new int[32];
	
	static {
		for (int i = 0; i < BIT_MASK.length; i++) {
			BIT_MASK[i] = (1 << i) - 1;
		}
	}
}