func (this *packetClientLoginEncryptRequestCodec17) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetClientLoginEncryptRequest := new(PacketClientLoginEncryptRequest)
packetClientLoginEncryptRequest.ServerId, err = packet.ReadString(reader, util)
if err != nil {
return
}
publicKeyLength, err := packet.ReadUint16(reader, util)
if err != nil {
return
}
packetClientLoginEncryptRequest.PublicKey = make([]byte, publicKeyLength)
_, err = reader.Read(packetClientLoginEncryptRequest.PublicKey)
if err != nil {
return
}
verifyTokenLength, err := packet.ReadUint16(reader, util)
if err != nil {
return
}
packetClientLoginEncryptRequest.VerifyToken = make([]byte, verifyTokenLength)
_, err = reader.Read(packetClientLoginEncryptRequest.VerifyToken)
if err != nil {
return
}
decode = packetClientLoginEncryptRequest
return
}
func (this *PacketClientLoginEncryptRequestCodec) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetClientLoginEncryptRequest := &PacketClientLoginEncryptRequest{}
packetClientLoginEncryptRequest.ServerId, err = packet.ReadString(reader, util)
if err != nil {
return
}
publicKeySize, err := packet.ReadUint16(reader, util)
if err != nil {
return
}
packetClientLoginEncryptRequest.PublicKey = make([]byte, publicKeySize)
_, err = reader.Read(packetClientLoginEncryptRequest.PublicKey)
if err != nil {
return
}
verifyTokenSize, err := packet.ReadUint16(reader, util)
if err != nil {
return
}
packetClientLoginEncryptRequest.VerifyToken = make([]byte, verifyTokenSize)
_, err = reader.Read(packetClientLoginEncryptRequest.VerifyToken)
if err != nil {
return
}
return packetClientLoginEncryptRequest, nil
}
func (this *requestAsProxyCodec) Decode(reader io.Reader, util []byte) (request Request, err error) {
requestAsProxy := new(RequestAsProxy)
requestAsProxy.Address, err = packet.ReadString(reader, util)
if err != nil {
return
}
requestAsProxy.Port, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
requestAsProxy.Motd, err = packet.ReadString(reader, util)
if err != nil {
return
}
requestAsProxy.Version, err = packet.ReadString(reader, util)
if err != nil {
return
}
requestAsProxy.MaxPlayers, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
request = requestAsProxy
return
}
func (this *requestMessageCodec) Decode(reader io.Reader) (request Request, err error) {
requestMessage := new(RequestMessage)
recipientsSize, err := packet.ReadUint16(reader)
if err != nil {
return
}
requestMessage.Recipients = make([]string, recipientsSize)
var i uint16
for i = 0; i < recipientsSize; i++ {
requestMessage.Recipients[i], err = packet.ReadString(reader)
if err != nil {
return
}
}
requestMessage.Channel, err = packet.ReadString(reader)
if err != nil {
return
}
messageSize, err := packet.ReadUint16(reader)
if err != nil {
return
}
requestMessage.Message = make([]byte, messageSize)
_, err = reader.Read(requestMessage.Message)
if err != nil {
return
}
request = requestMessage
return
}
func (this *ResultGetPlayersCodec) Decode(reader io.Reader, util []byte) (result Result, err error) {
resultGetPlayers := &ResultGetPlayers{}
resultGetPlayers.List, err = packet.ReadBool(reader, util)
if err != nil {
return
}
resultGetPlayers.CurrentPlayers, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
resultGetPlayers.MaximumPlayers, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
if resultGetPlayers.List {
resultGetPlayers.Players = make([]string, resultGetPlayers.CurrentPlayers)
var i uint16
for i = 0; i < resultGetPlayers.CurrentPlayers; i++ {
if err != nil {
return
}
resultGetPlayers.Players[i], err = packet.ReadString(reader, util)
}
}
return resultGetPlayers, nil
}
func (this *resultGetPlayersCodec) Decode(reader io.Reader) (result Result, err error) {
resultGetPlayers := new(ResultGetPlayers)
resultGetPlayers.List, err = packet.ReadBool(reader)
if err != nil {
return
}
resultGetPlayers.CurrentPlayers, err = packet.ReadUint16(reader)
if err != nil {
return
}
resultGetPlayers.MaxPlayers, err = packet.ReadUint16(reader)
if err != nil {
return
}
if resultGetPlayers.List {
resultGetPlayers.Players = make([]string, resultGetPlayers.CurrentPlayers)
var i uint16
for i = 0; i < resultGetPlayers.CurrentPlayers; i++ {
if err != nil {
return
}
resultGetPlayers.Players[i], err = packet.ReadString(reader)
}
}
result = resultGetPlayers
return
}
func (this *packetServerEventCodec) Decode(reader io.Reader) (decode packet.Packet, err error) {
packetServerEvent := new(PacketServerEvent)
packetServerEvent.Add, err = packet.ReadBool(reader)
if err != nil {
return
}
packetServerEvent.Server, err = packet.ReadString(reader)
if err != nil {
return
}
if packetServerEvent.Add {
packetServerEvent.SecurityKey, err = packet.ReadString(reader)
if err != nil {
return
}
packetServerEvent.Address, err = packet.ReadString(reader)
if err != nil {
return
}
packetServerEvent.Port, err = packet.ReadUint16(reader)
if err != nil {
return
}
}
decode = packetServerEvent
return
}
func (this *PacketServerEventCodec) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetServerEvent := &PacketServerEvent{}
packetServerEvent.Add, err = packet.ReadBool(reader, util)
if err != nil {
return
}
packetServerEvent.Server, err = packet.ReadString(reader, util)
if err != nil {
return
}
if packetServerEvent.Add {
packetServerEvent.SecurityKey, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetServerEvent.Address, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetServerEvent.Port, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
}
return packetServerEvent, nil
}
func (this *RequestAsServerCodec) Decode(reader io.Reader, util []byte) (request Request, err error) {
requestAsServer := &RequestAsServer{}
requestAsServer.Address, err = packet.ReadString(reader, util)
if err != nil {
return
}
requestAsServer.Port, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
return requestAsServer, nil
}
func (this *PacketServerLoginEncryptResponseCodec) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetServerLoginEncryptResponse := &PacketServerLoginEncryptResponse{}
sharedSecretSize, err := packet.ReadUint16(reader, util)
if err != nil {
return
}
packetServerLoginEncryptResponse.SharedSecret = make([]byte, sharedSecretSize)
_, err = reader.Read(packetServerLoginEncryptResponse.SharedSecret)
if err != nil {
return
}
verifyTokenSize, err := packet.ReadUint16(reader, util)
if err != nil {
return
}
packetServerLoginEncryptResponse.VerifyToken = make([]byte, verifyTokenSize)
_, err = reader.Read(packetServerLoginEncryptResponse.VerifyToken)
if err != nil {
return
}
return packetServerLoginEncryptResponse, nil
}
func (this *requestAsServerCodec) Decode(reader io.Reader) (request Request, err error) {
requestAsServer := new(RequestAsServer)
requestAsServer.Address, err = packet.ReadString(reader)
if err != nil {
return
}
requestAsServer.Port, err = packet.ReadUint16(reader)
if err != nil {
return
}
request = requestAsServer
return
}
func (this *packetServerLoginEncryptResponseCodec17) Decode(reader io.Reader) (decode packet.Packet, err error) {
packetServerLoginEncryptResponse := new(PacketServerLoginEncryptResponse)
sharedSecretLength, err := packet.ReadUint16(reader)
if err != nil {
return
}
packetServerLoginEncryptResponse.SharedSecret = make([]byte, sharedSecretLength)
_, err = reader.Read(packetServerLoginEncryptResponse.SharedSecret)
if err != nil {
return
}
verifyTokenLength, err := packet.ReadUint16(reader)
if err != nil {
return
}
packetServerLoginEncryptResponse.VerifyToken = make([]byte, verifyTokenLength)
_, err = reader.Read(packetServerLoginEncryptResponse.VerifyToken)
if err != nil {
return
}
decode = packetServerLoginEncryptResponse
return
}
func (this *packetResultCodec) Decode(reader io.Reader) (decode packet.Packet, err error) {
if this.Sequencer == nil {
err = errors.New("No sequencer to decode PacketResult")
return
}
packetResult := new(PacketResult)
packetResult.SequenceId, err = packet.ReadInt32(reader)
if err != nil {
return
}
packetResult.StatusCode, err = packet.ReadUint8(reader)
if err != nil {
return
}
if packetResult.StatusCode == STATUS_SUCCESS {
var payloadSize uint16
payloadSize, err = packet.ReadUint16(reader)
if err != nil {
return
}
payload := make([]byte, payloadSize)
_, err = reader.Read(payload)
if err != nil {
return
}
buffer := bytes.NewBuffer(payload)
requestId := this.Sequencer.RequestIdBySequenceId(packetResult.SequenceId)
if requestId < 0 {
err = errors.New(fmt.Sprintf("Decode, Request Id is below zero: %d", requestId))
return
}
if int(requestId) >= len(requestCodecs) {
err = errors.New(fmt.Sprintf("Decode, Request Id is above maximum: %d", requestId))
return
}
codec := resultCodecs[requestId]
if codec == nil {
err = errors.New(fmt.Sprintf("Decode, Request Id does not have a codec: %d", requestId))
return
}
packetResult.Result, err = codec.Decode(buffer)
if err != nil {
return
}
}
decode = packetResult
return
}
func (this *packetClientTeamsCodec17) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetClientTeams := new(PacketClientTeams)
packetClientTeams.Name, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetClientTeams.Action, err = packet.ReadInt8(reader, util)
if err != nil {
return
}
if packetClientTeams.Action == 0 || packetClientTeams.Action == 2 {
packetClientTeams.DisplayName, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetClientTeams.Prefix, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetClientTeams.Suffix, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetClientTeams.FriendlyFire, err = packet.ReadInt8(reader, util)
if err != nil {
return
}
}
if packetClientTeams.Action == 0 || packetClientTeams.Action == 3 || packetClientTeams.Action == 4 {
var playersLength uint16
playersLength, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
packetClientTeams.Players = make([]string, playersLength)
var i uint16
for i = 0; i < playersLength; i++ {
packetClientTeams.Players[i], err = packet.ReadString(reader, util)
if err != nil {
return
}
}
}
decode = packetClientTeams
return
}
func (this *PacketClientTeamsCodec) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetClientTeams := &PacketClientTeams{}
packetClientTeams.Name, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetClientTeams.Action, err = packet.ReadInt8(reader, util)
if err != nil {
return
}
if packetClientTeams.Action == 0 || packetClientTeams.Action == 2 {
packetClientTeams.DisplayName, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetClientTeams.Prefix, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetClientTeams.Suffix, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetClientTeams.FriendlyFire, err = packet.ReadInt8(reader, util)
if err != nil {
return
}
}
if packetClientTeams.Action == 0 || packetClientTeams.Action == 3 || packetClientTeams.Action == 4 {
var playersSize uint16
playersSize, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
packetClientTeams.Players = make([]string, playersSize)
var i uint16
for i = 0; i < playersSize; i++ {
packetClientTeams.Players[i], err = packet.ReadString(reader, util)
if err != nil {
return
}
}
}
return packetClientTeams, nil
}
func (this *packetServerPluginMessageCodec17) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetServerPluginMessage := new(PacketServerPluginMessage)
packetServerPluginMessage.Channel, err = packet.ReadString(reader, util)
if err != nil {
return
}
dataLength, err := packet.ReadUint16(reader, util)
if err != nil {
return
}
packetServerPluginMessage.Data = make([]byte, dataLength)
_, err = reader.Read(packetServerPluginMessage.Data)
if err != nil {
return
}
decode = packetServerPluginMessage
return
}
func (this *ResultGetDetailsCodec) Decode(reader io.Reader, util []byte) (result Result, err error) {
resultGetDetails := &ResultGetDetails{}
resultGetDetails.Ip, err = packet.ReadString(reader, util)
if err != nil {
return
}
resultGetDetails.Port, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
resultGetDetails.Motd, err = packet.ReadString(reader, util)
if err != nil {
return
}
resultGetDetails.Version, err = packet.ReadString(reader, util)
if err != nil {
return
}
return resultGetDetails, nil
}
func (this *PacketServerHandshakeCodec) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetServerHandshake := &PacketServerHandshake{}
packetServerHandshake.ProtocolVersion, err = packet.ReadVarInt(reader, util)
if err != nil {
return
}
packetServerHandshake.ServerAddress, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetServerHandshake.ServerPort, err = packet.ReadUint16(reader, util)
if err != nil {
return
}
packetServerHandshake.State, err = packet.ReadVarInt(reader, util)
if err != nil {
return
}
return packetServerHandshake, nil
}
func (this *packetServerHandshakeCodec) Decode(reader io.Reader) (decode packet.Packet, err error) {
packetServerHandshake := new(PacketServerHandshake)
packetServerHandshake.ProtocolVersion, err = packet.ReadVarInt(reader)
if err != nil {
return
}
packetServerHandshake.ServerAddress, err = packet.ReadString(reader)
if err != nil {
return
}
packetServerHandshake.ServerPort, err = packet.ReadUint16(reader)
if err != nil {
return
}
packetServerHandshake.State, err = packet.ReadVarInt(reader)
if err != nil {
return
}
decode = packetServerHandshake
return
}
func (this *resultGetDetailsCodec) Decode(reader io.Reader) (result Result, err error) {
resultGetDetails := new(ResultGetDetails)
resultGetDetails.Ip, err = packet.ReadString(reader)
if err != nil {
return
}
resultGetDetails.Port, err = packet.ReadUint16(reader)
if err != nil {
return
}
resultGetDetails.Motd, err = packet.ReadString(reader)
if err != nil {
return
}
resultGetDetails.Version, err = packet.ReadString(reader)
if err != nil {
return
}
result = resultGetDetails
return
}
func (this *PacketMessageEventCodec) Decode(reader io.Reader, util []byte) (decode packet.Packet, err error) {
packetMessageEvent := &PacketMessageEvent{}
packetMessageEvent.Sender, err = packet.ReadString(reader, util)
if err != nil {
return
}
packetMessageEvent.Channel, err = packet.ReadString(reader, util)
if err != nil {
return
}
payloadSize, err := packet.ReadUint16(reader, util)
if err != nil {
return
}
packetMessageEvent.Payload = make([]byte, payloadSize)
_, err = reader.Read(packetMessageEvent.Payload)
if err != nil {
return
}
return packetMessageEvent, nil
}
func (this *packetRequestCodec) Decode(reader io.Reader) (decode packet.Packet, err error) {
packetRequest := new(PacketRequest)
packetRequest.SequenceId, err = packet.ReadInt32(reader)
if err != nil {
return
}
requestId, err := packet.ReadUint8(reader)
if err != nil {
return
}
if requestId < 0 {
err = errors.New(fmt.Sprintf("Decode, Request Id is below zero: %d", requestId))
return
}
if int(requestId) >= len(requestCodecs) {
err = errors.New(fmt.Sprintf("Decode, Request Id is above maximum: %d", requestId))
return
}
payloadSize, err := packet.ReadUint16(reader)
if err != nil {
return
}
payload := make([]byte, payloadSize)
_, err = reader.Read(payload)
if err != nil {
return
}
buffer := bytes.NewBuffer(payload)
codec := requestCodecs[requestId]
if codec == nil {
err = errors.New(fmt.Sprintf("Decode, Request Id does not have a codec: %d", requestId))
return
}
packetRequest.Request, err = codec.Decode(buffer)
if err != nil {
return
}
decode = packetRequest
return
}
func (this *packetMessageEventCodec) Decode(reader io.Reader) (decode packet.Packet, err error) {
packetMessageEvent := new(PacketMessageEvent)
packetMessageEvent.Sender, err = packet.ReadString(reader)
if err != nil {
return
}
packetMessageEvent.Channel, err = packet.ReadString(reader)
if err != nil {
return
}
payloadSize, err := packet.ReadUint16(reader)
if err != nil {
return
}
packetMessageEvent.Payload = make([]byte, payloadSize)
_, err = reader.Read(packetMessageEvent.Payload)
if err != nil {
return
}
decode = packetMessageEvent
return
}