import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
public void serialize( PacketBuffer buffer ) {
    buffer.writeSignedVarInt( 0 );

    buffer.writeUnsignedVarInt( this.ingredients.length );
    for ( ItemStack ingredient : this.ingredients ) {
        Packet.writeItemStack( ingredient, buffer );
    }

    buffer.writeUnsignedVarInt( this.outcome.length );
    for ( ItemStack itemStack : this.outcome ) {
        Packet.writeItemStack( itemStack, buffer );
    }

    buffer.writeUUID( this.getUUID() );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
/**
 * Deserialize a transaction action
 *
 * @param buffer Data from the packet
 */
public void deserialize( PacketBuffer buffer ) {
    this.sourceType = buffer.readUnsignedVarInt();

    switch ( this.sourceType ) {
        case SOURCE_CONTAINER:
        case SOURCE_WTF_IS_DIS:
            this.windowId = buffer.readSignedVarInt();
            break;
        case SOURCE_WORLD:
            this.unknown = buffer.readUnsignedVarInt();
            break;
        case SOURCE_CREATIVE:
            break;
        default:
            LOGGER.warn( "Unknown source type: " + this.sourceType );
    }

    this.slot = buffer.readUnsignedVarInt();
    this.oldItem = readItemStack( buffer );
    this.newItem = readItemStack( buffer );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
public void writeGamerules( Map<Gamerule, Object> gamerules, PacketBuffer buffer ) {
	if ( gamerules == null ) {
		buffer.writeUnsignedVarInt( 0 );
		return;
	}

	buffer.writeUnsignedVarInt( gamerules.size() );
	gamerules.forEach( new BiConsumer<Gamerule, Object>() {
		@Override
		public void accept( Gamerule gamerule, Object value ) {
			buffer.writeString( gamerule.getNbtName().toLowerCase() );

			if ( gamerule.getValueType() == Boolean.class ) {
				buffer.writeByte( (byte) 1 );
				buffer.writeBoolean( (Boolean) value );
			} else if ( gamerule.getValueType() == Integer.class ) {
				buffer.writeByte( (byte) 2 );
				buffer.writeUnsignedVarInt( (Integer) value );
			} else if ( gamerule.getValueType() == Float.class ) {
				buffer.writeByte( (byte) 3 );
				buffer.writeLFloat( (Float) value );
			}
		}
	} );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
public static void dumpPacketbuffer( PacketBuffer buffer ) {
    StringBuilder lineBuilder = new StringBuilder();
    StringBuilder stringRepBuilder = new StringBuilder();
    while ( buffer.getRemaining() > 0 ) {
        for ( int i = 0; i < 64 && buffer.getRemaining() > 0; ++i ) {
            byte b = buffer.readByte();
            String hex = Integer.toHexString( ( (int) b ) & 0xFF );
            if ( hex.length() < 2 ) {
                hex = "0" + hex;
            }

            stringRepBuilder.append( (char) (b & 0xFF) );
            lineBuilder.append( hex );
            if ( i + 1 < 64 && buffer.getRemaining() > 0 ) {
                lineBuilder.append( " " );
            }
        }

        lineBuilder.append( " " ).append( stringRepBuilder );
        LOGGER.info( lineBuilder.toString() );
        lineBuilder = new StringBuilder();
        stringRepBuilder = new StringBuilder();
    }

    buffer.resetPosition();
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
public void deserialize( PacketBuffer buffer ) {
    // We only need the runtime id
    buffer.readSignedVarLong();
    this.runtimeEntityId = buffer.readUnsignedVarLong();

    // ignore gamemode
    this.gamemode = buffer.readSignedVarInt();

    this.spawnX = buffer.readLFloat();
    this.spawnY = buffer.readLFloat();
    this.spawnZ = buffer.readLFloat();
    this.spawnYaw = buffer.readLFloat();
    this.spawnPitch = buffer.readLFloat();

    buffer.readSignedVarInt();
    buffer.readSignedVarInt();
    buffer.readSignedVarInt();
    buffer.readSignedVarInt();

    this.difficulty = buffer.readSignedVarInt();
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
private void sendQueue() {
    if ( !this.packetQueue.isEmpty() ) {
        List<PacketBuffer> buffers = new ArrayList<>();
        this.packetQueue.drainTo( buffers );
        this.postProcessWorker.sendPackets( buffers );
    }

    if ( this.disconnect != null ) {
        this.connection.disconnect( this.disconnect );

        if ( this.pendingDownStream != null ) {
            this.pendingDownStream.disconnect( this.disconnect );
            this.pendingDownStream = null;
        }

        if ( this.currentDownStream != null ) {
            this.currentDownStream.disconnect( this.disconnect );
            this.currentDownStream = null;
        }
    }
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
public void addPacket( String from, String to, byte packetId, PacketBuffer buffer ) {
    /*StringBuilder builder = new StringBuilder( "[PKT] " ).append( from ).append( " -> " ).append( to );
    builder.append( " 0x" ).append( Integer.toHexString( packetId & 0xFF ) ).append( ": " );

    if ( buffer.getRemaining() > 64 ) {
        builder.append( "TRUNCATED " );
    }

    int showAmount = buffer.getRemaining();
    if ( showAmount > 64 ) {
        showAmount = 64;
    }

    int oldPosition = buffer.getPosition();
    for ( int i = 0; i < showAmount; i++ ) {
        byte b = buffer.readByte();
        builder.append( "0x" ).append( Integer.toHexString( b & 0xFF ) ).append( " " );
    }

    buffer.setPosition( oldPosition );
    addLine( builder.toString() );*/
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
private void handleBatchPacket(Client client, ByteBuf buf) {
    // Encrypted?
    byte[] input = new byte[buf.readableBytes()];
    buf.readBytes(input);

    if (client.getProtocolEncryption() != null) {
        input = client.getProtocolEncryption().decryptInputFromClient(input);
        if (input == null) {
            disconnectClient(client, "Invalid checksum");
            return;
        }
    }

    byte[] payload = ByteBufUtils.inflate(input);

    PacketBuffer buffer = new PacketBuffer(payload, 0);
    while (buffer.getRemaining() > 0) {
        int packetLength = buffer.readUnsignedVarInt();

        byte[] payloadData = new byte[packetLength];
        buffer.readBytes(payloadData);

        ByteBuf pktBuffer = ByteBufAllocator.DEFAULT.buffer(payloadData.length);
        pktBuffer.writeBytes(payloadData);

        pktBuffer.markReaderIndex();

        handleSocketData(client, pktBuffer);

        if (pktBuffer.readableBytes() > 0) {
            pktBuffer.resetReaderIndex();
            log.warn("Did not read packet ID 0x{} to completion", Integer.toHexString(pktBuffer.readByte()));
        }
    }
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
public void serialize( PacketBuffer buffer ) {
    // The type of this recipe is defined after the input metadata
    buffer.writeSignedVarInt( this.input.getData() == 0 ? 2 : 3 );

    // We need to custom write items
    buffer.writeSignedVarInt( ( (io.gomint.server.inventory.item.ItemStack) this.input ).getMaterial() );
    if ( this.input.getData() != 0 ) buffer.writeSignedVarInt( this.input.getData() );

    Packet.writeItemStack( this.outcome, buffer );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
public void serialize( PacketBuffer buffer ) {
    buffer.writeByte( this.type.getSoundId() );
    buffer.writeLFloat( this.position.getX() );
    buffer.writeLFloat( this.position.getY() );
    buffer.writeLFloat( this.position.getZ() );
    buffer.writeSignedVarInt( this.extraData );
    buffer.writeSignedVarInt( this.pitch );
    buffer.writeBoolean( this.unknownBool );
    buffer.writeBoolean( this.disableRelativeVolume );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
void serialize( PacketBuffer buffer, int index ) {
    super.serialize( buffer, index );
    buffer.writeSignedVarInt( this.x );
    buffer.writeSignedVarInt( this.y );
    buffer.writeSignedVarInt( this.z );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
/**
 * Write a array of integers to the buffer
 *
 * @param integers which should be written to the buffer
 * @param buffer   which should be written to
 */
void writeIntList( int[] integers, PacketBuffer buffer ) {
    if ( integers == null || integers.length == 0 ) {
        buffer.writeUnsignedVarInt( 0 );
        return;
    }

    buffer.writeUnsignedVarInt( integers.length );

    for ( Integer integer : integers ) {
        buffer.writeSignedVarInt( integer );
    }
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
/**
 * Serializes this metadata container into the specified buffer.
 *
 * @param buffer The buffer to serialize this metadata container into
 */
public void serialize( PacketBuffer buffer ) {
    buffer.writeUnsignedVarInt( this.entries.size() );
    this.entries.forEach( new ByteObjConsumer<MetadataValue>() {
        @Override
        public void accept( byte id, MetadataValue metadataValue ) {
            metadataValue.serialize( buffer, id );
        }
    } );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
public void serialize( PacketBuffer buffer ) {
    buffer.writeUnsignedVarLong( this.entityId );
    writeItemStack( this.helmet, buffer );
    writeItemStack( this.chestplate, buffer );
    writeItemStack( this.leggings, buffer );
    writeItemStack( this.boots, buffer );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
/**
 * Sends the given packet to the player.
 *
 * @param reliability     The reliability to send the packet with
 * @param orderingChannel The ordering channel to send the packet on
 * @param packet          The packet to send to the player
 */
public void send( PacketReliability reliability, int orderingChannel, Packet packet ) {
    if ( !( packet instanceof PacketBatch ) ) {
        this.postProcessWorker.getQueuedPacketBatches().add( new Packet[]{ packet } );
    } else {
        PacketBuffer buffer = new PacketBuffer( 64 );
        buffer.writeByte( packet.getId() );
        packet.serialize( buffer );

        this.connection.send( reliability, orderingChannel, buffer.getBuffer(), 0, buffer.getPosition() );
    }
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
public void serialize( PacketBuffer buffer ) {
    buffer.writeUUID( this.uuid );
    buffer.writeString( this.name );
    buffer.writeSignedVarLong( this.entityId );
    buffer.writeUnsignedVarLong( this.runtimeEntityId );

    buffer.writeLFloat( this.x );
    buffer.writeLFloat( this.y );
    buffer.writeLFloat( this.z );

    buffer.writeLFloat( this.velocityX );
    buffer.writeLFloat( this.velocityY );
    buffer.writeLFloat( this.velocityZ );

    buffer.writeLFloat( this.pitch );
    buffer.writeLFloat( this.headYaw );
    buffer.writeLFloat( this.yaw );

    writeItemStack( this.itemInHand, buffer );
    this.metadataContainer.serialize( buffer );

    buffer.writeUnsignedVarInt( this.flags );
    buffer.writeUnsignedVarInt( this.commandPermission );
    buffer.writeUnsignedVarInt( this.flags2 );
    buffer.writeUnsignedVarInt( this.playerPermission );
    buffer.writeUnsignedVarInt( this.customFlags );

    buffer.writeLLong( this.entityId );

    writeEntityLinks( this.links, buffer );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
public void serialize( PacketBuffer buffer ) {
    buffer.writeByte( this.status.getId() );
    buffer.writeLShort( (short) this.info.size() );
    for ( Map.Entry<String, String> entry : this.info.entrySet() ) {
        buffer.writeString( entry.getKey() );
        buffer.writeString( entry.getValue() );
    }
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
public void writeEntityLinks( List<EntityLink> links, PacketBuffer buffer ) {
    if ( links == null ) {
        buffer.writeUnsignedVarInt( 0 );
    } else {
        buffer.writeUnsignedVarInt( links.size() );
        for ( EntityLink link : links ) {
            buffer.writeUnsignedVarLong( link.getFrom() );
            buffer.writeUnsignedVarLong( link.getTo() );
            buffer.writeByte( link.getUnknown1() );
            buffer.writeByte( link.getUnknown2() );
        }
    }
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
public static ItemStack readItemStack( PacketBuffer buffer ) {
	int id = buffer.readSignedVarInt();
	if ( id == 0 ) {
		return new ItemStack( Material.AIR, (short) 0, 0, null );
	}

	int temp = buffer.readSignedVarInt();
	byte amount = (byte) ( temp & 0xFF );
	short data = (short) ( temp >> 8 );

	NBTTagCompound nbt = null;
	short extraLen = buffer.readLShort();
	if ( extraLen > 0 ) {
		ByteArrayInputStream bin = new ByteArrayInputStream( buffer.getBuffer(), buffer.getPosition(), extraLen );
		try {
			nbt = NBTTagCompound.readFrom( bin, false, ByteOrder.LITTLE_ENDIAN );
		} catch ( IOException e ) {
			e.printStackTrace();
		}

		buffer.skip( extraLen );
	}

	// They implemented additional data for item stacks aside from nbt
	int countPlacedOn = buffer.readSignedVarInt();
	for ( int i = 0; i < countPlacedOn; i++ ) {
		buffer.readString();    // TODO: Implement proper support once we know the string values
	}

	int countCanBreak = buffer.readSignedVarInt();
	for ( int i = 0; i < countCanBreak; i++ ) {
		buffer.readString();    // TODO: Implement proper support once we know the string values
	}

	return new ItemStack( EnumConnectors.MATERIAL_CONNECTOR.revert( MaterialMagicNumbers.valueOfWithId( id ) ), data, amount, nbt );
}
 

import io.gomint.jraknet.PacketBuffer; //导入依赖的package包/类
@Override
void serialize( PacketBuffer buffer, int index ) {
    super.serialize( buffer, index );
    buffer.writeLFloat( this.value.getX() );
    buffer.writeLFloat( this.value.getY() );
    buffer.writeLFloat( this.value.getZ() );
}