GamePacket.java

package com.osroyale.net.packet;
 
import com.osroyale.net.codec.ByteModification;
import com.osroyale.net.codec.ByteOrder;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.DefaultByteBufHolder;

 
public class GamePacket extends DefaultByteBufHolder {

    private final int opcode;

    private final PacketType header;

    private final ByteBuf payload;

    private final int size;

    public GamePacket(final int opcode, final PacketType header, final ByteBuf payload) {
        super(payload);
 
        this.opcode = opcode;
        this.header = header;       
        this.payload = payload;
        this.size = payload.readableBytes();
    }

    public int getSize() {
        return size;
    }

    public int getOpcode() {
        return opcode;
    }
    
    public PacketType getHeader() {
        return header;      
    }
    
    public ByteBuf getPayload() {
        return payload;
    }
    
    public int readByte() {
        return payload.readByte();
    }

    public int readByte(boolean signed) {
        return readByte(signed, ByteModification.NONE);
    }

    public int readByte(ByteModification mod) {
        return readByte(true, mod);
    }

    public int readByte(boolean signed, ByteModification mod) {
        int value = payload.readByte();
        switch (mod) {
        case ADD:
            value = value - 128;
            break;
 
        case SUB:
            value = 128 - value;
            break;
 
        case NEG:
            value = -value;
            break;
 
        case NONE:
            break;
 
        }
        return signed ? value : value & 0xFF;
    }

    public int readShort() {
        return payload.readShort();
    }

    public int readShort(boolean signed) {
        return readShort(signed, ByteOrder.BE, ByteModification.NONE);
    }

    public int readShort(ByteOrder order) {
        return readShort(true, order, ByteModification.NONE);
    }

    public int readShort(boolean signed, ByteOrder order) {
        return readShort(signed, order, ByteModification.NONE);
    }

    public int readShort(ByteOrder order, ByteModification mod) {
        return readShort(true, order, mod);
    }

    public int readShort(ByteModification mod) {
        return readShort(true, ByteOrder.BE, mod);
    }

    public int readShort(boolean signed, ByteModification mod) {
        return readShort(signed, ByteOrder.BE, mod);
    }

    public int readShort(boolean signed, ByteOrder order, ByteModification mod) {
        int value = 0;
        switch (order) {
        case BE:
            value |= readByte(false) << 8;
            value |= readByte(false, mod);
            break;
 
        case IME:
            throw new UnsupportedOperationException("Inverse-middle-endian short is impossible!");
 
        case ME:
            throw new UnsupportedOperationException("Middle-endian short " + "is impossible!");
 
        case LE:
            value |= readByte(false, mod);
            value |= readByte(false) << 8;
            break;
        }
        return signed ? value : value & 0xFFFF;
    }

    public int readInt() {
        return readInt(true, ByteOrder.BE, ByteModification.NONE);
    }

    public int readInt(boolean signed) {
        return readInt(signed, ByteOrder.BE, ByteModification.NONE);
    }

    public int readInt(ByteModification mod) {
        return readInt(true, ByteOrder.BE, mod);
    }

    public int readInt(boolean signed, ByteModification mod) {
        return readInt(signed, ByteOrder.BE, mod);
    }

    public int readInt(boolean signed, ByteOrder order) {
        return readInt(signed, order, ByteModification.NONE);
    }

    public int readInt(boolean signed, ByteOrder order, ByteModification mod) {
        long value = 0;
        switch (order) {
        case BE:
            value |= readByte(false) << 24;
            value |= readByte(false) << 16;
            value |= readByte(false) << 8;
            value |= readByte(false, mod);
            break;
 
        case ME:
            value |= readByte(false) << 8;
            value |= readByte(false, mod);
            value |= readByte(false) << 24;
            value |= readByte(false) << 16;
            break;
        case IME:
            value |= readByte(false) << 16;
            value |= readByte(false) << 24;
            value |= readByte(false, mod);
            value |= readByte(false) << 8;
            break;
 
        case LE:
            value |= readByte(false, mod);
            value |= readByte(false) << 8;
            value |= readByte(false) << 16;
            value |= readByte(false) << 24;
            break;
 
        }
        return (int) (signed ? value : value & 0xFFFFFFFFL);
    }

    public long readLong() {
        return readLong(true, ByteOrder.BE, ByteModification.NONE);
    }

    public long readLong(boolean signed) {
        return readLong(signed, ByteOrder.BE, ByteModification.NONE);
    }

    public long readLong(ByteModification mod) {
        return readLong(true, ByteOrder.BE, mod);
    }

    public long readLong(boolean signed, ByteModification mod) {
        return readLong(signed, ByteOrder.BE, mod);
    }

    public long readLong(boolean signed, ByteOrder order) {
        return readLong(signed, order, ByteModification.NONE);
    }

    public long readLong(boolean signed, ByteOrder order, ByteModification mod) {
        long value = 0;
        switch (order) {
        case BE:
            value |= (long) readByte(false) << 56L;
            value |= (long) readByte(false) << 48L;
            value |= (long) readByte(false) << 40L;
            value |= (long) readByte(false) << 32L;
            value |= (long) readByte(false) << 24L;
            value |= (long) readByte(false) << 16L;
            value |= (long) readByte(false) << 8L;
            value |= readByte(false, mod);
            break;
 
        case ME:
        case IME:
            throw new UnsupportedOperationException("Middle and " + "inverse-middle value types not supported!");
 
        case LE:
            value |= readByte(false, mod);
            value |= (long) readByte(false) << 8L;
            value |= (long) readByte(false) << 16L;
            value |= (long) readByte(false) << 24L;
            value |= (long) readByte(false) << 32L;
            value |= (long) readByte(false) << 40L;
            value |= (long) readByte(false) << 48L;
            value |= (long) readByte(false) << 56L;
            break;
 
        }
        return signed ? value : value & 0xFFFFFFFFL;
    }

    public byte[] readBytes(int amount) {
        return readBytes(amount, ByteModification.NONE);
    }

    public byte[] readBytes(int amount, ByteModification mod) {
        byte[] data = new byte[amount];
        for (int i = 0; i < amount; i++) {
            data[i] = (byte) readByte(mod);
        }
        return data;
    }

    public byte[] readBytesReverse(int amount) {
        return readBytesReverse(amount, ByteModification.NONE);
    }

    public byte[] readBytesReverse(int amount, ByteModification mod) {
        byte[] data = new byte[amount];
 
        int dataPosition = 0;
 
        for (int index = payload.readerIndex() + amount - 1; index >= payload.readerIndex(); index--) {
            int value = payload.getByte(index);
 
            switch (mod) {
 
            case ADD:
                value -= 128;
                break;
 
            case NEG:
                value = -value;
                break;
 
            case SUB:
                value = 128 - value;
                break;
 
            case NONE:
                break;
 
            }
            data[dataPosition++] = (byte) value;
        }
        return data;
    }

    public String getRS2String() {
        final StringBuilder bldr = new StringBuilder();
        byte b;
        while (payload.isReadable() && (b = payload.readByte()) != 10) {
            bldr.append((char) b);
        }
        return bldr.toString();
    }
 
    @Override
    public String toString() {
        return String.format("[opcode=%d], [type=%s], [size= %d]", opcode, header.name(), size);
    }
 
}