OpenCode
eb83786f9a
- VisitNameAndData: return any instead of named struct when mergeCompareTo resolves $compareTo, fixing field type mismatches for switch/container types - ContainerCompareTo: traverse anon/bitfield fields for compareTo resolution, fixes entityMetadata 'field not found' errors - Array.Count: change from string to any to handle numeric count values - ArrayEncoder: fix nil check to correctly write length prefix for arrays - ArrayDecoder: use fmt.Sprint for safe Count conversion
10966 lines
281 KiB
Go
10966 lines
281 KiB
Go
// Code generated by strom. DO NOT EDIT.
|
|
// source: minecraft-data/pc/1.12.2/protocol.json (sha256:21c57208db654a5e14a34cb696570080df179c5c642e53b16120399eee9232be)
|
|
// version: v0.6.6-0.20260805154326-fa70ea36c6f5+dirty (go1.26.2)
|
|
package v1_12_2
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"io"
|
|
"github.com/admin-else/strom/mc/proto_base"
|
|
"github.com/admin-else/strom/mc/nbt"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type ByteArray struct {
|
|
Val []byte
|
|
}
|
|
|
|
func (ret *ByteArray) Decode(r io.ReadSeeker) (err error) {
|
|
var lByteArray int32
|
|
lByteArray, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = io.ReadAll(io.LimitReader(r, int64(lByteArray)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ByteArray) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadata struct {
|
|
Val map[byte]struct {
|
|
Anon struct {
|
|
Key uint8
|
|
Type int8
|
|
}
|
|
Value any
|
|
}
|
|
}
|
|
|
|
func (ret *EntityMetadata) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Val = make(map[uint8]struct {
|
|
Anon struct {
|
|
Key uint8
|
|
Type int8
|
|
}
|
|
Value any
|
|
})
|
|
var id uint8
|
|
for {
|
|
err = binary.Read(r, binary.BigEndian, &id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if id == 255 {
|
|
break
|
|
}
|
|
_, err = r.Seek(-1, io.SeekCurrent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var entry struct {
|
|
Anon struct {
|
|
Key uint8
|
|
Type int8
|
|
}
|
|
Value any
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &entry.Anon.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &entry.Anon.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch entry.Anon.Type {
|
|
case 0:
|
|
var EntityMetadataInnerValue0Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue0Tmp
|
|
case 1:
|
|
var EntityMetadataInnerValue1Tmp int32
|
|
EntityMetadataInnerValue1Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue1Tmp
|
|
case 10:
|
|
var EntityMetadataInnerValue10Tmp int32
|
|
EntityMetadataInnerValue10Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue10Tmp
|
|
case 11:
|
|
var EntityMetadataInnerValue11Tmp *uuid.UUID
|
|
var EntityMetadataInnerValue11TmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue11TmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataInnerValue11TmpPresent {
|
|
var EntityMetadataInnerValue11TmpPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, EntityMetadataInnerValue11TmpPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataInnerValue11Tmp = &EntityMetadataInnerValue11TmpPresentValue
|
|
}
|
|
entry.Value = EntityMetadataInnerValue11Tmp
|
|
case 12:
|
|
var EntityMetadataInnerValue12Tmp int32
|
|
EntityMetadataInnerValue12Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue12Tmp
|
|
case 13:
|
|
var EntityMetadataInnerValue13Tmp nbt.Tag
|
|
err = EntityMetadataInnerValue13Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue13Tmp
|
|
case 2:
|
|
var EntityMetadataInnerValue2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue2Tmp
|
|
case 3:
|
|
var EntityMetadataInnerValue3Tmp string
|
|
EntityMetadataInnerValue3Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue3Tmp
|
|
case 4:
|
|
var EntityMetadataInnerValue4Tmp string
|
|
EntityMetadataInnerValue4Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue4Tmp
|
|
case 5:
|
|
var EntityMetadataInnerValue5Tmp Slot
|
|
err = EntityMetadataInnerValue5Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue5Tmp
|
|
case 6:
|
|
var EntityMetadataInnerValue6Tmp bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue6Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue6Tmp
|
|
case 7:
|
|
var EntityMetadataInnerValue7Tmp struct {
|
|
Pitch float32
|
|
Yaw float32
|
|
Roll float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue7Tmp.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue7Tmp.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue7Tmp.Roll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue7Tmp
|
|
case 8:
|
|
var EntityMetadataInnerValue8Tmp Position
|
|
err = EntityMetadataInnerValue8Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue8Tmp
|
|
case 9:
|
|
var EntityMetadataInnerValue9Tmp *Position
|
|
var EntityMetadataInnerValue9TmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue9TmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataInnerValue9TmpPresent {
|
|
var EntityMetadataInnerValue9TmpPresentValue Position
|
|
err = EntityMetadataInnerValue9TmpPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataInnerValue9Tmp = &EntityMetadataInnerValue9TmpPresentValue
|
|
}
|
|
entry.Value = EntityMetadataInnerValue9Tmp
|
|
}
|
|
ret.Val[id] = entry
|
|
}
|
|
return
|
|
}
|
|
func (ret *EntityMetadata) Encode(w io.Writer) (err error) {
|
|
for _, v := range ret.Val {
|
|
err = binary.Write(w, binary.BigEndian, v.Anon.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, v.Anon.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch v.Anon.Type {
|
|
case 0:
|
|
EntityMetadataValue, ok := v.Value.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
EntityMetadataValue, ok := v.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 10:
|
|
EntityMetadataValue, ok := v.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 11:
|
|
EntityMetadataValue, ok := v.Value.(*uuid.UUID)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataValue != nil {
|
|
_, err = w.Write((*EntityMetadataValue)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 12:
|
|
EntityMetadataValue, ok := v.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 13:
|
|
EntityMetadataValue, ok := v.Value.(nbt.Tag)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataValueEncTmp := EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
EntityMetadataValue, ok := v.Value.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
EntityMetadataValue, ok := v.Value.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
EntityMetadataValue, ok := v.Value.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 5:
|
|
EntityMetadataValue, ok := v.Value.(Slot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataValueEncTmp := EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 6:
|
|
EntityMetadataValue, ok := v.Value.(bool)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 7:
|
|
EntityMetadataValue, ok := v.Value.(struct {
|
|
Pitch float32
|
|
Yaw float32
|
|
Roll float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Roll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 8:
|
|
EntityMetadataValue, ok := v.Value.(Position)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataValueEncTmp := EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 9:
|
|
EntityMetadataValue, ok := v.Value.(*Position)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataValue != nil {
|
|
EntityMetadataValueEncTmp := *EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, uint8(255))
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadataItem struct {
|
|
Val any
|
|
}
|
|
|
|
func (ret *EntityMetadataItem) Decode(r io.ReadSeeker) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret *EntityMetadataItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type Position struct {
|
|
X int32
|
|
Y int16
|
|
Z int32
|
|
}
|
|
|
|
func (ret *Position) Decode(r io.ReadSeeker) (err error) {
|
|
var PositionPacked uint64
|
|
err = binary.Read(r, binary.BigEndian, &PositionPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = int32(PositionPacked << 0 >> 38)
|
|
if ret.X >= 1<<25 {
|
|
ret.X -= 1 << 26
|
|
}
|
|
ret.Y = int16(PositionPacked << 26 >> 52)
|
|
if ret.Y >= 1<<11 {
|
|
ret.Y -= 1 << 12
|
|
}
|
|
ret.Z = int32(PositionPacked << 38 >> 38)
|
|
if ret.Z >= 1<<25 {
|
|
ret.Z -= 1 << 26
|
|
}
|
|
return
|
|
}
|
|
func (ret *Position) Encode(w io.Writer) (err error) {
|
|
var PositionPacked uint64
|
|
PositionPacked |= (uint64(ret.Z) & 0x3FFFFFF) << 0x0
|
|
PositionPacked |= (uint64(ret.Y) & 0xFFF) << 0x1A
|
|
PositionPacked |= (uint64(ret.X) & 0x3FFFFFF) << 0x26
|
|
err = binary.Write(w, binary.BigEndian, PositionPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Slot struct {
|
|
BlockId int16
|
|
Anon any
|
|
}
|
|
|
|
func (ret *Slot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.BlockId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.BlockId {
|
|
case -1:
|
|
var SlotAnon1Tmp struct {
|
|
}
|
|
ret.Anon = SlotAnon1Tmp
|
|
default:
|
|
var SlotAnonTmp struct {
|
|
ItemCount int8
|
|
ItemDamage int16
|
|
NbtData nbt.Tag
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &SlotAnonTmp.ItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &SlotAnonTmp.ItemDamage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = SlotAnonTmp.NbtData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = SlotAnonTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *Slot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.BlockId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.BlockId {
|
|
case -1:
|
|
_, ok := ret.Anon.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Anon.(struct {
|
|
ItemCount int8
|
|
ItemDamage int16
|
|
NbtData nbt.Tag
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Anon.(struct {
|
|
ItemCount int8
|
|
ItemDamage int16
|
|
NbtData nbt.Tag
|
|
}).ItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Anon.(struct {
|
|
ItemCount int8
|
|
ItemDamage int16
|
|
NbtData nbt.Tag
|
|
}).ItemDamage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
SlotAnonNbtDataEncTmp := ret.Anon.(struct {
|
|
ItemCount int8
|
|
ItemDamage int16
|
|
NbtData nbt.Tag
|
|
}).NbtData
|
|
err = SlotAnonNbtDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type Vec3i16 struct {
|
|
X int16
|
|
Y int16
|
|
Z int16
|
|
}
|
|
|
|
func (ret *Vec3i16) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *Vec3i16) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var HandshakingToClientPacketNameMap = map[int32]string{}
|
|
|
|
func (ret *HandshakingToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var HandshakingToClientPacketNameKey int32
|
|
HandshakingToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(HandshakingToClientPacketNameMap, HandshakingToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var HandshakingToClientPacketNameReverseMap = map[string]int32{}
|
|
|
|
func (ret *HandshakingToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vHandshakingToClientPacketName int32
|
|
vHandshakingToClientPacketName, err = proto_base.ErroringIndex(HandshakingToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vHandshakingToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var HandshakingToServerPacketNameMap = map[int32]string{0x00: "set_protocol", 0xfe: "legacy_server_list_ping"}
|
|
|
|
func (ret *HandshakingToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var HandshakingToServerPacketNameKey int32
|
|
HandshakingToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(HandshakingToServerPacketNameMap, HandshakingToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "legacy_server_list_ping":
|
|
var HandshakingToServerPacketParamsLegacyServerListPingTmp HandshakingToServerPacketLegacyServerListPing
|
|
err = HandshakingToServerPacketParamsLegacyServerListPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = HandshakingToServerPacketParamsLegacyServerListPingTmp
|
|
case "set_protocol":
|
|
var HandshakingToServerPacketParamsSetProtocolTmp HandshakingToServerPacketSetProtocol
|
|
err = HandshakingToServerPacketParamsSetProtocolTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = HandshakingToServerPacketParamsSetProtocolTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var HandshakingToServerPacketNameReverseMap = map[string]int32{"set_protocol": 0x00, "legacy_server_list_ping": 0xfe}
|
|
|
|
func (ret *HandshakingToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vHandshakingToServerPacketName int32
|
|
vHandshakingToServerPacketName, err = proto_base.ErroringIndex(HandshakingToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vHandshakingToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "legacy_server_list_ping":
|
|
HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketLegacyServerListPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
HandshakingToServerPacketParamsEncTmp := HandshakingToServerPacketParams
|
|
err = HandshakingToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_protocol":
|
|
HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketSetProtocol)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
HandshakingToServerPacketParamsEncTmp := HandshakingToServerPacketParams
|
|
err = HandshakingToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketLegacyServerListPing struct {
|
|
Payload uint8
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketLegacyServerListPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Payload)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketLegacyServerListPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Payload)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketSetProtocol struct {
|
|
ProtocolVersion int32
|
|
ServerHost string
|
|
ServerPort uint16
|
|
NextState int32
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketSetProtocol) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ProtocolVersion, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ServerHost, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ServerPort)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NextState, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketSetProtocol) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ProtocolVersion)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.ServerHost)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ServerPort)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.NextState)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var LoginToClientPacketNameMap = map[int32]string{0x00: "disconnect", 0x01: "encryption_begin", 0x02: "success", 0x03: "compress"}
|
|
|
|
func (ret *LoginToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var LoginToClientPacketNameKey int32
|
|
LoginToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(LoginToClientPacketNameMap, LoginToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "compress":
|
|
var LoginToClientPacketParamsCompressTmp LoginToClientPacketCompress
|
|
err = LoginToClientPacketParamsCompressTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsCompressTmp
|
|
case "disconnect":
|
|
var LoginToClientPacketParamsDisconnectTmp LoginToClientPacketDisconnect
|
|
err = LoginToClientPacketParamsDisconnectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsDisconnectTmp
|
|
case "encryption_begin":
|
|
var LoginToClientPacketParamsEncryptionBeginTmp LoginToClientPacketEncryptionBegin
|
|
err = LoginToClientPacketParamsEncryptionBeginTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsEncryptionBeginTmp
|
|
case "success":
|
|
var LoginToClientPacketParamsSuccessTmp LoginToClientPacketSuccess
|
|
err = LoginToClientPacketParamsSuccessTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsSuccessTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var LoginToClientPacketNameReverseMap = map[string]int32{"disconnect": 0x00, "encryption_begin": 0x01, "success": 0x02, "compress": 0x03}
|
|
|
|
func (ret *LoginToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vLoginToClientPacketName int32
|
|
vLoginToClientPacketName, err = proto_base.ErroringIndex(LoginToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vLoginToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "compress":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCompress)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "disconnect":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "encryption_begin":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketEncryptionBegin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "success":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketSuccess)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCompress struct {
|
|
Threshold int32
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCompress) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Threshold, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCompress) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Threshold)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketDisconnect struct {
|
|
Reason string
|
|
}
|
|
|
|
func (ret *LoginToClientPacketDisconnect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Reason, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketDisconnect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketEncryptionBegin struct {
|
|
ServerId string
|
|
PublicKey []byte
|
|
VerifyToken []byte
|
|
}
|
|
|
|
func (ret *LoginToClientPacketEncryptionBegin) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ServerId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToClientPacketEncryptionBeginPublicKey int32
|
|
lLoginToClientPacketEncryptionBeginPublicKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PublicKey, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginPublicKey)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToClientPacketEncryptionBeginVerifyToken int32
|
|
lLoginToClientPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginVerifyToken)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketEncryptionBegin) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.ServerId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.PublicKey)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.PublicKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.VerifyToken)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketSuccess struct {
|
|
Uuid string
|
|
Username string
|
|
}
|
|
|
|
func (ret *LoginToClientPacketSuccess) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Uuid, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Username, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketSuccess) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Uuid)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Username)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var LoginToServerPacketNameMap = map[int32]string{0x00: "login_start", 0x01: "encryption_begin"}
|
|
|
|
func (ret *LoginToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var LoginToServerPacketNameKey int32
|
|
LoginToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(LoginToServerPacketNameMap, LoginToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "encryption_begin":
|
|
var LoginToServerPacketParamsEncryptionBeginTmp LoginToServerPacketEncryptionBegin
|
|
err = LoginToServerPacketParamsEncryptionBeginTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsEncryptionBeginTmp
|
|
case "login_start":
|
|
var LoginToServerPacketParamsLoginStartTmp LoginToServerPacketLoginStart
|
|
err = LoginToServerPacketParamsLoginStartTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsLoginStartTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var LoginToServerPacketNameReverseMap = map[string]int32{"login_start": 0x00, "encryption_begin": 0x01}
|
|
|
|
func (ret *LoginToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vLoginToServerPacketName int32
|
|
vLoginToServerPacketName, err = proto_base.ErroringIndex(LoginToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vLoginToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "encryption_begin":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketEncryptionBegin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
|
|
err = LoginToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_start":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
|
|
err = LoginToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketEncryptionBegin struct {
|
|
SharedSecret []byte
|
|
VerifyToken []byte
|
|
}
|
|
|
|
func (ret *LoginToServerPacketEncryptionBegin) Decode(r io.ReadSeeker) (err error) {
|
|
var lLoginToServerPacketEncryptionBeginSharedSecret int32
|
|
lLoginToServerPacketEncryptionBeginSharedSecret, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SharedSecret, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginSharedSecret)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToServerPacketEncryptionBeginVerifyToken int32
|
|
lLoginToServerPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginVerifyToken)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketEncryptionBegin) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.SharedSecret)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.SharedSecret)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.VerifyToken)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketLoginStart struct {
|
|
Username string
|
|
}
|
|
|
|
func (ret *LoginToServerPacketLoginStart) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Username, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketLoginStart) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Username)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var PlayToClientPacketNameMap = map[int32]string{0x00: "spawn_entity", 0x01: "spawn_entity_experience_orb", 0x02: "spawn_entity_weather", 0x03: "spawn_entity_living", 0x04: "spawn_entity_painting", 0x05: "named_entity_spawn", 0x06: "animation", 0x07: "statistics", 0x08: "block_break_animation", 0x09: "tile_entity_data", 0x0a: "block_action", 0x0b: "block_change", 0x0c: "boss_bar", 0x0d: "difficulty", 0x0e: "tab_complete", 0x0f: "chat", 0x10: "multi_block_change", 0x11: "transaction", 0x12: "close_window", 0x13: "open_window", 0x14: "window_items", 0x15: "craft_progress_bar", 0x16: "set_slot", 0x17: "set_cooldown", 0x18: "custom_payload", 0x19: "named_sound_effect", 0x1a: "kick_disconnect", 0x1b: "entity_status", 0x1c: "explosion", 0x1d: "unload_chunk", 0x1e: "game_state_change", 0x1f: "keep_alive", 0x20: "map_chunk", 0x21: "world_event", 0x22: "world_particles", 0x23: "login", 0x24: "map", 0x25: "entity", 0x26: "rel_entity_move", 0x27: "entity_move_look", 0x28: "entity_look", 0x29: "vehicle_move", 0x2a: "open_sign_entity", 0x2b: "craft_recipe_response", 0x2c: "abilities", 0x2d: "combat_event", 0x2e: "player_info", 0x2f: "position", 0x30: "bed", 0x31: "unlock_recipes", 0x32: "entity_destroy", 0x33: "remove_entity_effect", 0x34: "resource_pack_send", 0x35: "respawn", 0x36: "entity_head_rotation", 0x37: "select_advancement_tab", 0x38: "world_border", 0x39: "camera", 0x3a: "held_item_slot", 0x3b: "scoreboard_display_objective", 0x3c: "entity_metadata", 0x3d: "attach_entity", 0x3e: "entity_velocity", 0x3f: "entity_equipment", 0x40: "experience", 0x41: "update_health", 0x42: "scoreboard_objective", 0x43: "set_passengers", 0x44: "teams", 0x45: "scoreboard_score", 0x46: "spawn_position", 0x47: "update_time", 0x48: "title", 0x49: "sound_effect", 0x4a: "playerlist_header", 0x4b: "collect", 0x4c: "entity_teleport", 0x4d: "advancements", 0x4e: "entity_update_attributes", 0x4f: "entity_effect"}
|
|
|
|
func (ret *PlayToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketNameKey int32
|
|
PlayToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(PlayToClientPacketNameMap, PlayToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
var PlayToClientPacketParamsAbilitiesTmp PlayToClientPacketAbilities
|
|
err = PlayToClientPacketParamsAbilitiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAbilitiesTmp
|
|
case "advancements":
|
|
var PlayToClientPacketParamsAdvancementsTmp PlayToClientPacketAdvancements
|
|
err = PlayToClientPacketParamsAdvancementsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAdvancementsTmp
|
|
case "animation":
|
|
var PlayToClientPacketParamsAnimationTmp PlayToClientPacketAnimation
|
|
err = PlayToClientPacketParamsAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAnimationTmp
|
|
case "attach_entity":
|
|
var PlayToClientPacketParamsAttachEntityTmp PlayToClientPacketAttachEntity
|
|
err = PlayToClientPacketParamsAttachEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAttachEntityTmp
|
|
case "bed":
|
|
var PlayToClientPacketParamsBedTmp PlayToClientPacketBed
|
|
err = PlayToClientPacketParamsBedTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBedTmp
|
|
case "block_action":
|
|
var PlayToClientPacketParamsBlockActionTmp PlayToClientPacketBlockAction
|
|
err = PlayToClientPacketParamsBlockActionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockActionTmp
|
|
case "block_break_animation":
|
|
var PlayToClientPacketParamsBlockBreakAnimationTmp PlayToClientPacketBlockBreakAnimation
|
|
err = PlayToClientPacketParamsBlockBreakAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockBreakAnimationTmp
|
|
case "block_change":
|
|
var PlayToClientPacketParamsBlockChangeTmp PlayToClientPacketBlockChange
|
|
err = PlayToClientPacketParamsBlockChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockChangeTmp
|
|
case "boss_bar":
|
|
var PlayToClientPacketParamsBossBarTmp PlayToClientPacketBossBar
|
|
err = PlayToClientPacketParamsBossBarTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBossBarTmp
|
|
case "camera":
|
|
var PlayToClientPacketParamsCameraTmp PlayToClientPacketCamera
|
|
err = PlayToClientPacketParamsCameraTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCameraTmp
|
|
case "chat":
|
|
var PlayToClientPacketParamsChatTmp PlayToClientPacketChat
|
|
err = PlayToClientPacketParamsChatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsChatTmp
|
|
case "close_window":
|
|
var PlayToClientPacketParamsCloseWindowTmp PlayToClientPacketCloseWindow
|
|
err = PlayToClientPacketParamsCloseWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCloseWindowTmp
|
|
case "collect":
|
|
var PlayToClientPacketParamsCollectTmp PlayToClientPacketCollect
|
|
err = PlayToClientPacketParamsCollectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCollectTmp
|
|
case "combat_event":
|
|
var PlayToClientPacketParamsCombatEventTmp PlayToClientPacketCombatEvent
|
|
err = PlayToClientPacketParamsCombatEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCombatEventTmp
|
|
case "craft_progress_bar":
|
|
var PlayToClientPacketParamsCraftProgressBarTmp PlayToClientPacketCraftProgressBar
|
|
err = PlayToClientPacketParamsCraftProgressBarTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCraftProgressBarTmp
|
|
case "craft_recipe_response":
|
|
var PlayToClientPacketParamsCraftRecipeResponseTmp PlayToClientPacketCraftRecipeResponse
|
|
err = PlayToClientPacketParamsCraftRecipeResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCraftRecipeResponseTmp
|
|
case "custom_payload":
|
|
var PlayToClientPacketParamsCustomPayloadTmp PlayToClientPacketCustomPayload
|
|
err = PlayToClientPacketParamsCustomPayloadTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCustomPayloadTmp
|
|
case "difficulty":
|
|
var PlayToClientPacketParamsDifficultyTmp PlayToClientPacketDifficulty
|
|
err = PlayToClientPacketParamsDifficultyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDifficultyTmp
|
|
case "entity":
|
|
var PlayToClientPacketParamsEntityTmp PlayToClientPacketEntity
|
|
err = PlayToClientPacketParamsEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityTmp
|
|
case "entity_destroy":
|
|
var PlayToClientPacketParamsEntityDestroyTmp PlayToClientPacketEntityDestroy
|
|
err = PlayToClientPacketParamsEntityDestroyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityDestroyTmp
|
|
case "entity_effect":
|
|
var PlayToClientPacketParamsEntityEffectTmp PlayToClientPacketEntityEffect
|
|
err = PlayToClientPacketParamsEntityEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityEffectTmp
|
|
case "entity_equipment":
|
|
var PlayToClientPacketParamsEntityEquipmentTmp PlayToClientPacketEntityEquipment
|
|
err = PlayToClientPacketParamsEntityEquipmentTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityEquipmentTmp
|
|
case "entity_head_rotation":
|
|
var PlayToClientPacketParamsEntityHeadRotationTmp PlayToClientPacketEntityHeadRotation
|
|
err = PlayToClientPacketParamsEntityHeadRotationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityHeadRotationTmp
|
|
case "entity_look":
|
|
var PlayToClientPacketParamsEntityLookTmp PlayToClientPacketEntityLook
|
|
err = PlayToClientPacketParamsEntityLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityLookTmp
|
|
case "entity_metadata":
|
|
var PlayToClientPacketParamsEntityMetadataTmp PlayToClientPacketEntityMetadata
|
|
err = PlayToClientPacketParamsEntityMetadataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityMetadataTmp
|
|
case "entity_move_look":
|
|
var PlayToClientPacketParamsEntityMoveLookTmp PlayToClientPacketEntityMoveLook
|
|
err = PlayToClientPacketParamsEntityMoveLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityMoveLookTmp
|
|
case "entity_status":
|
|
var PlayToClientPacketParamsEntityStatusTmp PlayToClientPacketEntityStatus
|
|
err = PlayToClientPacketParamsEntityStatusTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityStatusTmp
|
|
case "entity_teleport":
|
|
var PlayToClientPacketParamsEntityTeleportTmp PlayToClientPacketEntityTeleport
|
|
err = PlayToClientPacketParamsEntityTeleportTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityTeleportTmp
|
|
case "entity_update_attributes":
|
|
var PlayToClientPacketParamsEntityUpdateAttributesTmp PlayToClientPacketEntityUpdateAttributes
|
|
err = PlayToClientPacketParamsEntityUpdateAttributesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityUpdateAttributesTmp
|
|
case "entity_velocity":
|
|
var PlayToClientPacketParamsEntityVelocityTmp PlayToClientPacketEntityVelocity
|
|
err = PlayToClientPacketParamsEntityVelocityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityVelocityTmp
|
|
case "experience":
|
|
var PlayToClientPacketParamsExperienceTmp PlayToClientPacketExperience
|
|
err = PlayToClientPacketParamsExperienceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsExperienceTmp
|
|
case "explosion":
|
|
var PlayToClientPacketParamsExplosionTmp PlayToClientPacketExplosion
|
|
err = PlayToClientPacketParamsExplosionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsExplosionTmp
|
|
case "game_state_change":
|
|
var PlayToClientPacketParamsGameStateChangeTmp PlayToClientPacketGameStateChange
|
|
err = PlayToClientPacketParamsGameStateChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsGameStateChangeTmp
|
|
case "held_item_slot":
|
|
var PlayToClientPacketParamsHeldItemSlotTmp PlayToClientPacketHeldItemSlot
|
|
err = PlayToClientPacketParamsHeldItemSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsHeldItemSlotTmp
|
|
case "keep_alive":
|
|
var PlayToClientPacketParamsKeepAliveTmp PlayToClientPacketKeepAlive
|
|
err = PlayToClientPacketParamsKeepAliveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsKeepAliveTmp
|
|
case "kick_disconnect":
|
|
var PlayToClientPacketParamsKickDisconnectTmp PlayToClientPacketKickDisconnect
|
|
err = PlayToClientPacketParamsKickDisconnectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsKickDisconnectTmp
|
|
case "login":
|
|
var PlayToClientPacketParamsLoginTmp PlayToClientPacketLogin
|
|
err = PlayToClientPacketParamsLoginTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsLoginTmp
|
|
case "map":
|
|
var PlayToClientPacketParamsMapTmp PlayToClientPacketMap
|
|
err = PlayToClientPacketParamsMapTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMapTmp
|
|
case "map_chunk":
|
|
var PlayToClientPacketParamsMapChunkTmp PlayToClientPacketMapChunk
|
|
err = PlayToClientPacketParamsMapChunkTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMapChunkTmp
|
|
case "multi_block_change":
|
|
var PlayToClientPacketParamsMultiBlockChangeTmp PlayToClientPacketMultiBlockChange
|
|
err = PlayToClientPacketParamsMultiBlockChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMultiBlockChangeTmp
|
|
case "named_entity_spawn":
|
|
var PlayToClientPacketParamsNamedEntitySpawnTmp PlayToClientPacketNamedEntitySpawn
|
|
err = PlayToClientPacketParamsNamedEntitySpawnTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsNamedEntitySpawnTmp
|
|
case "named_sound_effect":
|
|
var PlayToClientPacketParamsNamedSoundEffectTmp PlayToClientPacketNamedSoundEffect
|
|
err = PlayToClientPacketParamsNamedSoundEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsNamedSoundEffectTmp
|
|
case "open_sign_entity":
|
|
var PlayToClientPacketParamsOpenSignEntityTmp PlayToClientPacketOpenSignEntity
|
|
err = PlayToClientPacketParamsOpenSignEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenSignEntityTmp
|
|
case "open_window":
|
|
var PlayToClientPacketParamsOpenWindowTmp PlayToClientPacketOpenWindow
|
|
err = PlayToClientPacketParamsOpenWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenWindowTmp
|
|
case "player_info":
|
|
var PlayToClientPacketParamsPlayerInfoTmp PlayToClientPacketPlayerInfo
|
|
err = PlayToClientPacketParamsPlayerInfoTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPlayerInfoTmp
|
|
case "playerlist_header":
|
|
var PlayToClientPacketParamsPlayerlistHeaderTmp PlayToClientPacketPlayerlistHeader
|
|
err = PlayToClientPacketParamsPlayerlistHeaderTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPlayerlistHeaderTmp
|
|
case "position":
|
|
var PlayToClientPacketParamsPositionTmp PlayToClientPacketPosition
|
|
err = PlayToClientPacketParamsPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPositionTmp
|
|
case "rel_entity_move":
|
|
var PlayToClientPacketParamsRelEntityMoveTmp PlayToClientPacketRelEntityMove
|
|
err = PlayToClientPacketParamsRelEntityMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRelEntityMoveTmp
|
|
case "remove_entity_effect":
|
|
var PlayToClientPacketParamsRemoveEntityEffectTmp PlayToClientPacketRemoveEntityEffect
|
|
err = PlayToClientPacketParamsRemoveEntityEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRemoveEntityEffectTmp
|
|
case "resource_pack_send":
|
|
var PlayToClientPacketParamsResourcePackSendTmp PlayToClientPacketResourcePackSend
|
|
err = PlayToClientPacketParamsResourcePackSendTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsResourcePackSendTmp
|
|
case "respawn":
|
|
var PlayToClientPacketParamsRespawnTmp PlayToClientPacketRespawn
|
|
err = PlayToClientPacketParamsRespawnTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRespawnTmp
|
|
case "scoreboard_display_objective":
|
|
var PlayToClientPacketParamsScoreboardDisplayObjectiveTmp PlayToClientPacketScoreboardDisplayObjective
|
|
err = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp
|
|
case "scoreboard_objective":
|
|
var PlayToClientPacketParamsScoreboardObjectiveTmp PlayToClientPacketScoreboardObjective
|
|
err = PlayToClientPacketParamsScoreboardObjectiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardObjectiveTmp
|
|
case "scoreboard_score":
|
|
var PlayToClientPacketParamsScoreboardScoreTmp PlayToClientPacketScoreboardScore
|
|
err = PlayToClientPacketParamsScoreboardScoreTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardScoreTmp
|
|
case "select_advancement_tab":
|
|
var PlayToClientPacketParamsSelectAdvancementTabTmp PlayToClientPacketSelectAdvancementTab
|
|
err = PlayToClientPacketParamsSelectAdvancementTabTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSelectAdvancementTabTmp
|
|
case "set_cooldown":
|
|
var PlayToClientPacketParamsSetCooldownTmp PlayToClientPacketSetCooldown
|
|
err = PlayToClientPacketParamsSetCooldownTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetCooldownTmp
|
|
case "set_passengers":
|
|
var PlayToClientPacketParamsSetPassengersTmp PlayToClientPacketSetPassengers
|
|
err = PlayToClientPacketParamsSetPassengersTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetPassengersTmp
|
|
case "set_slot":
|
|
var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot
|
|
err = PlayToClientPacketParamsSetSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetSlotTmp
|
|
case "sound_effect":
|
|
var PlayToClientPacketParamsSoundEffectTmp PlayToClientPacketSoundEffect
|
|
err = PlayToClientPacketParamsSoundEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSoundEffectTmp
|
|
case "spawn_entity":
|
|
var PlayToClientPacketParamsSpawnEntityTmp PlayToClientPacketSpawnEntity
|
|
err = PlayToClientPacketParamsSpawnEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityTmp
|
|
case "spawn_entity_experience_orb":
|
|
var PlayToClientPacketParamsSpawnEntityExperienceOrbTmp PlayToClientPacketSpawnEntityExperienceOrb
|
|
err = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp
|
|
case "spawn_entity_living":
|
|
var PlayToClientPacketParamsSpawnEntityLivingTmp PlayToClientPacketSpawnEntityLiving
|
|
err = PlayToClientPacketParamsSpawnEntityLivingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityLivingTmp
|
|
case "spawn_entity_painting":
|
|
var PlayToClientPacketParamsSpawnEntityPaintingTmp PlayToClientPacketSpawnEntityPainting
|
|
err = PlayToClientPacketParamsSpawnEntityPaintingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityPaintingTmp
|
|
case "spawn_entity_weather":
|
|
var PlayToClientPacketParamsSpawnEntityWeatherTmp PlayToClientPacketSpawnEntityWeather
|
|
err = PlayToClientPacketParamsSpawnEntityWeatherTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityWeatherTmp
|
|
case "spawn_position":
|
|
var PlayToClientPacketParamsSpawnPositionTmp PlayToClientPacketSpawnPosition
|
|
err = PlayToClientPacketParamsSpawnPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnPositionTmp
|
|
case "statistics":
|
|
var PlayToClientPacketParamsStatisticsTmp PlayToClientPacketStatistics
|
|
err = PlayToClientPacketParamsStatisticsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsStatisticsTmp
|
|
case "tab_complete":
|
|
var PlayToClientPacketParamsTabCompleteTmp PlayToClientPacketTabComplete
|
|
err = PlayToClientPacketParamsTabCompleteTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTabCompleteTmp
|
|
case "teams":
|
|
var PlayToClientPacketParamsTeamsTmp PlayToClientPacketTeams
|
|
err = PlayToClientPacketParamsTeamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTeamsTmp
|
|
case "tile_entity_data":
|
|
var PlayToClientPacketParamsTileEntityDataTmp PlayToClientPacketTileEntityData
|
|
err = PlayToClientPacketParamsTileEntityDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTileEntityDataTmp
|
|
case "title":
|
|
var PlayToClientPacketParamsTitleTmp PlayToClientPacketTitle
|
|
err = PlayToClientPacketParamsTitleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTitleTmp
|
|
case "transaction":
|
|
var PlayToClientPacketParamsTransactionTmp PlayToClientPacketTransaction
|
|
err = PlayToClientPacketParamsTransactionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTransactionTmp
|
|
case "unload_chunk":
|
|
var PlayToClientPacketParamsUnloadChunkTmp PlayToClientPacketUnloadChunk
|
|
err = PlayToClientPacketParamsUnloadChunkTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUnloadChunkTmp
|
|
case "unlock_recipes":
|
|
var PlayToClientPacketParamsUnlockRecipesTmp PlayToClientPacketUnlockRecipes
|
|
err = PlayToClientPacketParamsUnlockRecipesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUnlockRecipesTmp
|
|
case "update_health":
|
|
var PlayToClientPacketParamsUpdateHealthTmp PlayToClientPacketUpdateHealth
|
|
err = PlayToClientPacketParamsUpdateHealthTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateHealthTmp
|
|
case "update_time":
|
|
var PlayToClientPacketParamsUpdateTimeTmp PlayToClientPacketUpdateTime
|
|
err = PlayToClientPacketParamsUpdateTimeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateTimeTmp
|
|
case "vehicle_move":
|
|
var PlayToClientPacketParamsVehicleMoveTmp PlayToClientPacketVehicleMove
|
|
err = PlayToClientPacketParamsVehicleMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsVehicleMoveTmp
|
|
case "window_items":
|
|
var PlayToClientPacketParamsWindowItemsTmp PlayToClientPacketWindowItems
|
|
err = PlayToClientPacketParamsWindowItemsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWindowItemsTmp
|
|
case "world_border":
|
|
var PlayToClientPacketParamsWorldBorderTmp PlayToClientPacketWorldBorder
|
|
err = PlayToClientPacketParamsWorldBorderTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldBorderTmp
|
|
case "world_event":
|
|
var PlayToClientPacketParamsWorldEventTmp PlayToClientPacketWorldEvent
|
|
err = PlayToClientPacketParamsWorldEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldEventTmp
|
|
case "world_particles":
|
|
var PlayToClientPacketParamsWorldParticlesTmp PlayToClientPacketWorldParticles
|
|
err = PlayToClientPacketParamsWorldParticlesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldParticlesTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketNameReverseMap = map[string]int32{"spawn_entity": 0x00, "spawn_entity_experience_orb": 0x01, "spawn_entity_weather": 0x02, "spawn_entity_living": 0x03, "spawn_entity_painting": 0x04, "named_entity_spawn": 0x05, "animation": 0x06, "statistics": 0x07, "block_break_animation": 0x08, "tile_entity_data": 0x09, "block_action": 0x0a, "block_change": 0x0b, "boss_bar": 0x0c, "difficulty": 0x0d, "tab_complete": 0x0e, "chat": 0x0f, "multi_block_change": 0x10, "transaction": 0x11, "close_window": 0x12, "open_window": 0x13, "window_items": 0x14, "craft_progress_bar": 0x15, "set_slot": 0x16, "set_cooldown": 0x17, "custom_payload": 0x18, "named_sound_effect": 0x19, "kick_disconnect": 0x1a, "entity_status": 0x1b, "explosion": 0x1c, "unload_chunk": 0x1d, "game_state_change": 0x1e, "keep_alive": 0x1f, "map_chunk": 0x20, "world_event": 0x21, "world_particles": 0x22, "login": 0x23, "map": 0x24, "entity": 0x25, "rel_entity_move": 0x26, "entity_move_look": 0x27, "entity_look": 0x28, "vehicle_move": 0x29, "open_sign_entity": 0x2a, "craft_recipe_response": 0x2b, "abilities": 0x2c, "combat_event": 0x2d, "player_info": 0x2e, "position": 0x2f, "bed": 0x30, "unlock_recipes": 0x31, "entity_destroy": 0x32, "remove_entity_effect": 0x33, "resource_pack_send": 0x34, "respawn": 0x35, "entity_head_rotation": 0x36, "select_advancement_tab": 0x37, "world_border": 0x38, "camera": 0x39, "held_item_slot": 0x3a, "scoreboard_display_objective": 0x3b, "entity_metadata": 0x3c, "attach_entity": 0x3d, "entity_velocity": 0x3e, "entity_equipment": 0x3f, "experience": 0x40, "update_health": 0x41, "scoreboard_objective": 0x42, "set_passengers": 0x43, "teams": 0x44, "scoreboard_score": 0x45, "spawn_position": 0x46, "update_time": 0x47, "title": 0x48, "sound_effect": 0x49, "playerlist_header": 0x4a, "collect": 0x4b, "entity_teleport": 0x4c, "advancements": 0x4d, "entity_update_attributes": 0x4e, "entity_effect": 0x4f}
|
|
|
|
func (ret *PlayToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientPacketName int32
|
|
vPlayToClientPacketName, err = proto_base.ErroringIndex(PlayToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAbilities)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "advancements":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAdvancements)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "attach_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAttachEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "bed":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBed)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_action":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_break_animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockBreakAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "boss_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBossBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "camera":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCamera)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "close_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCloseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "collect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCollect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "combat_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCombatEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_progress_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftProgressBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_recipe_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftRecipeResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "difficulty":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDifficulty)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_destroy":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityDestroy)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_equipment":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEquipment)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_head_rotation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityHeadRotation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_look":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_metadata":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMetadata)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_move_look":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMoveLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_status":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityStatus)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_teleport":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityTeleport)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_update_attributes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityUpdateAttributes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_velocity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityVelocity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "experience":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExperience)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "explosion":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExplosion)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "game_state_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameStateChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "held_item_slot":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHeldItemSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "kick_disconnect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKickDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketLogin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "map":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMap)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "map_chunk":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunk)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "multi_block_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMultiBlockChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "named_entity_spawn":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNamedEntitySpawn)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "named_sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNamedSoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_sign_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenSignEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_info":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerInfo)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "playerlist_header":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerlistHeader)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "rel_entity_move":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRelEntityMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_entity_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRemoveEntityEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "resource_pack_send":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResourcePackSend)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "respawn":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRespawn)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_display_objective":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardDisplayObjective)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_objective":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardObjective)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_score":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardScore)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_advancement_tab":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSelectAdvancementTab)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_cooldown":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCooldown)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_passengers":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPassengers)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_slot":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_experience_orb":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityExperienceOrb)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_living":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityLiving)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_painting":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityPainting)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_weather":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityWeather)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "statistics":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStatistics)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tab_complete":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTabComplete)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "teams":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTeams)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tile_entity_data":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTileEntityData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "title":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTitle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "transaction":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTransaction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "unload_chunk":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnloadChunk)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "unlock_recipes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnlockRecipes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_health":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateHealth)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_time":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateTime)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vehicle_move":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketVehicleMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "window_items":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWindowItems)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorder)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_particles":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldParticles)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAbilities struct {
|
|
Flags int8
|
|
FlyingSpeed float32
|
|
WalkingSpeed float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAbilities) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAbilities) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAdvancements struct {
|
|
Reset bool
|
|
AdvancementMapping []struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title string
|
|
Description string
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Criteria []struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}
|
|
Requirements [][]string
|
|
}
|
|
}
|
|
Identifiers []string
|
|
ProgressMapping []struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAdvancements) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Reset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketAdvancementsAdvancementMapping int32
|
|
lPlayToClientPacketAdvancementsAdvancementMapping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AdvancementMapping = []struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title string
|
|
Description string
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Criteria []struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}
|
|
Requirements [][]string
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMapping {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElement struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title string
|
|
Description string
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Criteria []struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}
|
|
Requirements [][]string
|
|
}
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.ParentId = &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue struct {
|
|
Title string
|
|
Description string
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Title, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Description, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Icon.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.FrameType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked uint32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Unused = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked << 0 >> 3
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Hidden = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<29>>31 == 1
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.ShowToast = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<30>>31 == 1
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<31>>31 == 1
|
|
switch PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture {
|
|
case true:
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp
|
|
default:
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp struct {
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.XCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.YCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.DisplayData = &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue
|
|
}
|
|
var lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria int32
|
|
lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria = []struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria, PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement)
|
|
}
|
|
var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements int32
|
|
lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = [][]string{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement []string
|
|
var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement int32
|
|
lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = []string{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = append(PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement)
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement)
|
|
}
|
|
ret.AdvancementMapping = append(ret.AdvancementMapping, PlayToClientPacketAdvancementsAdvancementMappingElement)
|
|
}
|
|
var lPlayToClientPacketAdvancementsIdentifiers int32
|
|
lPlayToClientPacketAdvancementsIdentifiers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Identifiers = []string{}
|
|
for range lPlayToClientPacketAdvancementsIdentifiers {
|
|
var PlayToClientPacketAdvancementsIdentifiersElement string
|
|
PlayToClientPacketAdvancementsIdentifiersElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Identifiers = append(ret.Identifiers, PlayToClientPacketAdvancementsIdentifiersElement)
|
|
}
|
|
var lPlayToClientPacketAdvancementsProgressMapping int32
|
|
lPlayToClientPacketAdvancementsProgressMapping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ProgressMapping = []struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsProgressMapping {
|
|
var PlayToClientPacketAdvancementsProgressMappingElement struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketAdvancementsProgressMappingElementValue int32
|
|
lPlayToClientPacketAdvancementsProgressMappingElementValue, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Value = []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsProgressMappingElementValue {
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElement struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionIdentifier, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent {
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionProgress = &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Value = append(PlayToClientPacketAdvancementsProgressMappingElement.Value, PlayToClientPacketAdvancementsProgressMappingElementValueElement)
|
|
}
|
|
ret.ProgressMapping = append(ret.ProgressMapping, PlayToClientPacketAdvancementsProgressMappingElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAdvancements) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Reset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMapping := range len(ret.AdvancementMapping) {
|
|
err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil {
|
|
err = proto_base.EncodeString(w, *ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil {
|
|
err = proto_base.EncodeString(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Title)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Description)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataIconEncTmp := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Icon
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataIconEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).FrameType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked uint32
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture) & 0x1) << 0x0
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.ShowToast) & 0x1) << 0x1
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Hidden) & 0x1) << 0x2
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Unused) & 0x1FFFFFFF) << 0x3
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture {
|
|
case true:
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).XCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).YCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueCriteria := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria) {
|
|
err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueCriteria].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements])))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements]) {
|
|
err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements][iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Identifiers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsIdentifiers := range len(ret.Identifiers) {
|
|
err = proto_base.EncodeString(w, ret.Identifiers[iPlayToClientPacketAdvancementsIdentifiers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsProgressMapping := range len(ret.ProgressMapping) {
|
|
err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsProgressMappingInnerValue := range len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value) {
|
|
err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionIdentifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil {
|
|
err = binary.Write(w, binary.BigEndian, *ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAnimation struct {
|
|
EntityId int32
|
|
Animation uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Animation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Animation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAttachEntity struct {
|
|
EntityId int32
|
|
VehicleId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAttachEntity) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VehicleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAttachEntity) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VehicleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBed struct {
|
|
EntityId int32
|
|
Location Position
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBed) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBed) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketBedLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBedLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockAction struct {
|
|
Location Position
|
|
Byte1 uint8
|
|
Byte2 uint8
|
|
BlockId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockAction) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Byte1)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Byte2)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockAction) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketBlockActionLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockActionLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Byte1)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Byte2)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.BlockId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockBreakAnimation struct {
|
|
EntityId int32
|
|
Location Position
|
|
DestroyStage int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockBreakAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DestroyStage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockBreakAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketBlockBreakAnimationLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockBreakAnimationLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DestroyStage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockChange struct {
|
|
Location Position
|
|
Type int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockChange) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockChange) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketBlockChangeLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockChangeLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBossBar struct {
|
|
EntityUUID uuid.UUID
|
|
Action int32
|
|
Title any
|
|
Health any
|
|
Color any
|
|
Dividers any
|
|
Flags any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBossBar) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarTitle0Tmp string
|
|
PlayToClientPacketBossBarTitle0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitle0Tmp
|
|
case 3:
|
|
var PlayToClientPacketBossBarTitle3Tmp string
|
|
PlayToClientPacketBossBarTitle3Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitle3Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarTitleTmp struct {
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitleTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarHealth0Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealth0Tmp
|
|
case 2:
|
|
var PlayToClientPacketBossBarHealth2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealth2Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarHealthTmp struct {
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealthTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarColor0Tmp int32
|
|
PlayToClientPacketBossBarColor0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColor0Tmp
|
|
case 4:
|
|
var PlayToClientPacketBossBarColor4Tmp int32
|
|
PlayToClientPacketBossBarColor4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColor4Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarColorTmp struct {
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColorTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarDividers0Tmp int32
|
|
PlayToClientPacketBossBarDividers0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividers0Tmp
|
|
case 4:
|
|
var PlayToClientPacketBossBarDividers4Tmp int32
|
|
PlayToClientPacketBossBarDividers4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividers4Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarDividersTmp struct {
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividersTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarFlags0Tmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlags0Tmp
|
|
case 5:
|
|
var PlayToClientPacketBossBarFlags5Tmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags5Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlags5Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarFlagsTmp struct {
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlagsTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBossBar) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarTitle, ok := ret.Title.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketBossBarTitle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketBossBarTitle, ok := ret.Title.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketBossBarTitle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Title.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Health.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Color.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Dividers.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 5:
|
|
PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Flags.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCamera struct {
|
|
CameraId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCamera) Decode(r io.ReadSeeker) (err error) {
|
|
ret.CameraId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCamera) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.CameraId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChat struct {
|
|
Message string
|
|
Position int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketChat) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Message, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Position)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketChat) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Message)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Position)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCloseWindow struct {
|
|
WindowId uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCloseWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCloseWindow) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCollect struct {
|
|
CollectedEntityId int32
|
|
CollectorEntityId int32
|
|
PickupItemCount int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCollect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.CollectedEntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollectorEntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PickupItemCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCollect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.CollectedEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.CollectorEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.PickupItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCombatEvent struct {
|
|
Event int32
|
|
Duration any
|
|
PlayerId any
|
|
EntityId any
|
|
Message any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCombatEvent) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Event, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Event {
|
|
case 1:
|
|
var PlayToClientPacketCombatEventDuration1Tmp int32
|
|
PlayToClientPacketCombatEventDuration1Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Duration = PlayToClientPacketCombatEventDuration1Tmp
|
|
default:
|
|
var PlayToClientPacketCombatEventDurationTmp struct {
|
|
}
|
|
ret.Duration = PlayToClientPacketCombatEventDurationTmp
|
|
}
|
|
switch ret.Event {
|
|
case 2:
|
|
var PlayToClientPacketCombatEventPlayerId2Tmp int32
|
|
PlayToClientPacketCombatEventPlayerId2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PlayerId = PlayToClientPacketCombatEventPlayerId2Tmp
|
|
default:
|
|
var PlayToClientPacketCombatEventPlayerIdTmp struct {
|
|
}
|
|
ret.PlayerId = PlayToClientPacketCombatEventPlayerIdTmp
|
|
}
|
|
switch ret.Event {
|
|
case 1:
|
|
var PlayToClientPacketCombatEventEntityId1Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCombatEventEntityId1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketCombatEventEntityId1Tmp
|
|
case 2:
|
|
var PlayToClientPacketCombatEventEntityId2Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCombatEventEntityId2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketCombatEventEntityId2Tmp
|
|
default:
|
|
var PlayToClientPacketCombatEventEntityIdTmp struct {
|
|
}
|
|
ret.EntityId = PlayToClientPacketCombatEventEntityIdTmp
|
|
}
|
|
switch ret.Event {
|
|
case 2:
|
|
var PlayToClientPacketCombatEventMessage2Tmp string
|
|
PlayToClientPacketCombatEventMessage2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Message = PlayToClientPacketCombatEventMessage2Tmp
|
|
default:
|
|
var PlayToClientPacketCombatEventMessageTmp struct {
|
|
}
|
|
ret.Message = PlayToClientPacketCombatEventMessageTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCombatEvent) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Event)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Event {
|
|
case 1:
|
|
PlayToClientPacketCombatEventDuration, ok := ret.Duration.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketCombatEventDuration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Duration.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Event {
|
|
case 2:
|
|
PlayToClientPacketCombatEventPlayerId, ok := ret.PlayerId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketCombatEventPlayerId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.PlayerId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Event {
|
|
case 1:
|
|
PlayToClientPacketCombatEventEntityId, ok := ret.EntityId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketCombatEventEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketCombatEventEntityId, ok := ret.EntityId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketCombatEventEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Event {
|
|
case 2:
|
|
PlayToClientPacketCombatEventMessage, ok := ret.Message.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketCombatEventMessage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Message.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCraftProgressBar struct {
|
|
WindowId uint8
|
|
Property int16
|
|
Value int16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCraftProgressBar) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Property)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCraftProgressBar) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Property)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCraftRecipeResponse struct {
|
|
WindowId int8
|
|
Recipe int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCraftRecipeResponse) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipe, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCraftRecipeResponse) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Recipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCustomPayload) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketCustomPayloadDataEncTmp := ret.Data
|
|
err = PlayToClientPacketCustomPayloadDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDifficulty struct {
|
|
Difficulty uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDifficulty) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketDifficulty) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntity struct {
|
|
EntityId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityDestroy struct {
|
|
EntityIds []int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityDestroy) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketEntityDestroyEntityIds int32
|
|
lPlayToClientPacketEntityDestroyEntityIds, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityIds = []int32{}
|
|
for range lPlayToClientPacketEntityDestroyEntityIds {
|
|
var PlayToClientPacketEntityDestroyEntityIdsElement int32
|
|
PlayToClientPacketEntityDestroyEntityIdsElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityIds = append(ret.EntityIds, PlayToClientPacketEntityDestroyEntityIdsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityDestroy) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.EntityIds)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityDestroyEntityIds := range len(ret.EntityIds) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityIds[iPlayToClientPacketEntityDestroyEntityIds])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityEffect struct {
|
|
EntityId int32
|
|
EffectId int8
|
|
Amplifier int8
|
|
Duration int32
|
|
HideParticles int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Amplifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Duration, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HideParticles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Amplifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Duration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HideParticles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityEquipment struct {
|
|
EntityId int32
|
|
Slot int32
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityEquipment) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Slot, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityEquipmentItemEncTmp := ret.Item
|
|
err = PlayToClientPacketEntityEquipmentItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityHeadRotation struct {
|
|
EntityId int32
|
|
HeadYaw int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityHeadRotation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HeadYaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityHeadRotation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HeadYaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityLook struct {
|
|
EntityId int32
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityLook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityLook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityMetadata struct {
|
|
EntityId int32
|
|
Metadata EntityMetadata
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityMetadata) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Metadata.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityMetadata) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityMetadataMetadataEncTmp := ret.Metadata
|
|
err = PlayToClientPacketEntityMetadataMetadataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityMoveLook struct {
|
|
EntityId int32
|
|
DX int16
|
|
DY int16
|
|
DZ int16
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityMoveLook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityMoveLook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityStatus struct {
|
|
EntityId int32
|
|
EntityStatus int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityStatus) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityStatus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityStatus) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityStatus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityTeleport struct {
|
|
EntityId int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityTeleport) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityTeleport) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityUpdateAttributes struct {
|
|
EntityId int32
|
|
Properties []struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityUpdateAttributes) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketEntityUpdateAttributesProperties int32
|
|
err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketEntityUpdateAttributesProperties)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Properties = []struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketEntityUpdateAttributesProperties {
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElement struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElement.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers int32
|
|
lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}{}
|
|
for range lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers {
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
_, err = io.ReadFull(r, PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Amount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Operation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = append(PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers, PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement)
|
|
}
|
|
ret.Properties = append(ret.Properties, PlayToClientPacketEntityUpdateAttributesPropertiesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityUpdateAttributes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, int32(len(ret.Properties)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityUpdateAttributesProperties := range len(ret.Properties) {
|
|
err = proto_base.EncodeString(w, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers := range len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers) {
|
|
_, err = w.Write(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Amount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Operation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityVelocity struct {
|
|
EntityId int32
|
|
Velocity Vec3i16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityVelocity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Velocity.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityVelocity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityVelocityVelocityEncTmp := ret.Velocity
|
|
err = PlayToClientPacketEntityVelocityVelocityEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketExperience struct {
|
|
ExperienceBar float32
|
|
Level int32
|
|
TotalExperience int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketExperience) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ExperienceBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Level, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TotalExperience, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketExperience) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ExperienceBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Level)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.TotalExperience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketExplosion struct {
|
|
X float32
|
|
Y float32
|
|
Z float32
|
|
Radius float32
|
|
AffectedBlockOffsets []struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}
|
|
PlayerMotionX float32
|
|
PlayerMotionY float32
|
|
PlayerMotionZ float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketExplosion) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Radius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketExplosionAffectedBlockOffsets int32
|
|
err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketExplosionAffectedBlockOffsets)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AffectedBlockOffsets = []struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}{}
|
|
for range lPlayToClientPacketExplosionAffectedBlockOffsets {
|
|
var PlayToClientPacketExplosionAffectedBlockOffsetsElement struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AffectedBlockOffsets = append(ret.AffectedBlockOffsets, PlayToClientPacketExplosionAffectedBlockOffsetsElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketExplosion) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Radius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, int32(len(ret.AffectedBlockOffsets)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketExplosionAffectedBlockOffsets := range len(ret.AffectedBlockOffsets) {
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketGameStateChange struct {
|
|
Reason uint8
|
|
GameMode float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketGameStateChange) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.GameMode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketGameStateChange) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.GameMode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketHeldItemSlot struct {
|
|
Slot int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketHeldItemSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketKeepAlive) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketKickDisconnect struct {
|
|
Reason string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketKickDisconnect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Reason, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketKickDisconnect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketLogin struct {
|
|
EntityId int32
|
|
GameMode uint8
|
|
Dimension int32
|
|
Difficulty uint8
|
|
MaxPlayers uint8
|
|
LevelType string
|
|
ReducedDebugInfo bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketLogin) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.GameMode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Dimension)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.MaxPlayers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.LevelType, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ReducedDebugInfo)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketLogin) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.GameMode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Dimension)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.MaxPlayers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.LevelType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ReducedDebugInfo)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMap struct {
|
|
ItemDamage int32
|
|
Scale int8
|
|
TrackingPosition bool
|
|
Icons []struct {
|
|
DirectionAndType int8
|
|
X int8
|
|
Z int8
|
|
}
|
|
Columns int8
|
|
Rows any
|
|
X any
|
|
Y any
|
|
Data any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMap) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ItemDamage, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.TrackingPosition)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapIcons int32
|
|
lPlayToClientPacketMapIcons, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Icons = []struct {
|
|
DirectionAndType int8
|
|
X int8
|
|
Z int8
|
|
}{}
|
|
for range lPlayToClientPacketMapIcons {
|
|
var PlayToClientPacketMapIconsElement struct {
|
|
DirectionAndType int8
|
|
X int8
|
|
Z int8
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.DirectionAndType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Icons = append(ret.Icons, PlayToClientPacketMapIconsElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Columns)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapRows0Tmp struct {
|
|
}
|
|
ret.Rows = PlayToClientPacketMapRows0Tmp
|
|
default:
|
|
var PlayToClientPacketMapRowsTmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapRowsTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rows = PlayToClientPacketMapRowsTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapX0Tmp struct {
|
|
}
|
|
ret.X = PlayToClientPacketMapX0Tmp
|
|
default:
|
|
var PlayToClientPacketMapXTmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapXTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketMapXTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapY0Tmp struct {
|
|
}
|
|
ret.Y = PlayToClientPacketMapY0Tmp
|
|
default:
|
|
var PlayToClientPacketMapYTmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapYTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToClientPacketMapYTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapData0Tmp struct {
|
|
}
|
|
ret.Data = PlayToClientPacketMapData0Tmp
|
|
default:
|
|
var PlayToClientPacketMapDataTmp []byte
|
|
var lPlayToClientPacketMapData int32
|
|
lPlayToClientPacketMapData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapDataTmp, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientPacketMapDataTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketMap) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ItemDamage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.TrackingPosition)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Icons)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapIcons := range len(ret.Icons) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Icons[iPlayToClientPacketMapIcons].DirectionAndType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Icons[iPlayToClientPacketMapIcons].X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Icons[iPlayToClientPacketMapIcons].Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Columns)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Rows.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Rows.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Rows.(int8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.X.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.X.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X.(int8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Y.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Y.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y.(int8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data.([]byte)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Data.([]byte))))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.Data.([]byte))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMapChunk struct {
|
|
X int32
|
|
Z int32
|
|
GroundUp bool
|
|
BitMap int32
|
|
ChunkData []byte
|
|
BlockEntities []nbt.Tag
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMapChunk) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.GroundUp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BitMap, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapChunkChunkData int32
|
|
lPlayToClientPacketMapChunkChunkData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkData, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapChunkChunkData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapChunkBlockEntities int32
|
|
lPlayToClientPacketMapChunkBlockEntities, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockEntities = []nbt.Tag{}
|
|
for range lPlayToClientPacketMapChunkBlockEntities {
|
|
var PlayToClientPacketMapChunkBlockEntitiesElement nbt.Tag
|
|
err = PlayToClientPacketMapChunkBlockEntitiesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockEntities = append(ret.BlockEntities, PlayToClientPacketMapChunkBlockEntitiesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketMapChunk) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.GroundUp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.BitMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ChunkData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.ChunkData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockEntities)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkBlockEntities := range len(ret.BlockEntities) {
|
|
PlayToClientPacketMapChunkBlockEntitiesInnerEncTmp := ret.BlockEntities[iPlayToClientPacketMapChunkBlockEntities]
|
|
err = PlayToClientPacketMapChunkBlockEntitiesInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMultiBlockChange struct {
|
|
ChunkX int32
|
|
ChunkZ int32
|
|
Records []struct {
|
|
HorizontalPos uint8
|
|
Y uint8
|
|
BlockId int32
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMultiBlockChange) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMultiBlockChangeRecords int32
|
|
lPlayToClientPacketMultiBlockChangeRecords, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Records = []struct {
|
|
HorizontalPos uint8
|
|
Y uint8
|
|
BlockId int32
|
|
}{}
|
|
for range lPlayToClientPacketMultiBlockChangeRecords {
|
|
var PlayToClientPacketMultiBlockChangeRecordsElement struct {
|
|
HorizontalPos uint8
|
|
Y uint8
|
|
BlockId int32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeRecordsElement.HorizontalPos)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeRecordsElement.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMultiBlockChangeRecordsElement.BlockId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Records)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].HorizontalPos)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].BlockId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketNamedEntitySpawn struct {
|
|
EntityId int32
|
|
PlayerUUID uuid.UUID
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw int8
|
|
Pitch int8
|
|
Metadata EntityMetadata
|
|
}
|
|
|
|
func (ret *PlayToClientPacketNamedEntitySpawn) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.PlayerUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Metadata.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketNamedEntitySpawn) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.PlayerUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketNamedEntitySpawnMetadataEncTmp := ret.Metadata
|
|
err = PlayToClientPacketNamedEntitySpawnMetadataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketNamedSoundEffect struct {
|
|
SoundName string
|
|
SoundCategory int32
|
|
X int32
|
|
Y int32
|
|
Z int32
|
|
Volume float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketNamedSoundEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.SoundName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SoundCategory, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketNamedSoundEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.SoundName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SoundCategory)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenSignEntity struct {
|
|
Location Position
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenSignEntity) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenSignEntity) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketOpenSignEntityLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketOpenSignEntityLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenWindow struct {
|
|
WindowId uint8
|
|
InventoryType string
|
|
WindowTitle string
|
|
SlotCount uint8
|
|
EntityId any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.InventoryType, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WindowTitle, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SlotCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.InventoryType {
|
|
case "EntityHorse":
|
|
var PlayToClientPacketOpenWindowEntityIdEntityHorseTmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketOpenWindowEntityIdEntityHorseTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketOpenWindowEntityIdEntityHorseTmp
|
|
default:
|
|
var PlayToClientPacketOpenWindowEntityIdTmp struct {
|
|
}
|
|
ret.EntityId = PlayToClientPacketOpenWindowEntityIdTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenWindow) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.InventoryType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.WindowTitle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SlotCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.InventoryType {
|
|
case "EntityHorse":
|
|
PlayToClientPacketOpenWindowEntityId, ok := ret.EntityId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketOpenWindowEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerInfo struct {
|
|
Action string
|
|
Data []struct {
|
|
Uuid uuid.UUID
|
|
Anon any
|
|
}
|
|
}
|
|
|
|
var PlayToClientPacketPlayerInfoActionMap = map[int32]string{0: "add_player", 1: "update_game_mode", 2: "update_latency", 3: "update_display_name", 4: "remove_player"}
|
|
|
|
func (ret *PlayToClientPacketPlayerInfo) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketPlayerInfoActionKey int32
|
|
PlayToClientPacketPlayerInfoActionKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.ErroringIndex(PlayToClientPacketPlayerInfoActionMap, PlayToClientPacketPlayerInfoActionKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketPlayerInfoData int32
|
|
lPlayToClientPacketPlayerInfoData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = []struct {
|
|
Uuid uuid.UUID
|
|
Anon any
|
|
}{}
|
|
for range lPlayToClientPacketPlayerInfoData {
|
|
var PlayToClientPacketPlayerInfoDataElement struct {
|
|
Uuid uuid.UUID
|
|
Anon any
|
|
}
|
|
_, err = io.ReadFull(r, PlayToClientPacketPlayerInfoDataElement.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case "add_player":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp struct {
|
|
Name string
|
|
Properties []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
Gamemode int32
|
|
Ping int32
|
|
DisplayName *string
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties int32
|
|
lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties = []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}{}
|
|
for range lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties {
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Value, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent {
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue string
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Signature = &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties = append(PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties, PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement)
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Gamemode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Ping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent {
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue string
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.DisplayName = &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp
|
|
case "remove_player":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonRemovePlayerTmp struct {
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonRemovePlayerTmp
|
|
case "update_display_name":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp struct {
|
|
DisplayName *string
|
|
}
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent {
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue string
|
|
PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp.DisplayName = &PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp
|
|
case "update_game_mode":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp struct {
|
|
Gamemode int32
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp.Gamemode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp
|
|
case "update_latency":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp struct {
|
|
Ping int32
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp.Ping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp
|
|
}
|
|
ret.Data = append(ret.Data, PlayToClientPacketPlayerInfoDataElement)
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketPlayerInfoActionReverseMap = map[string]int32{"add_player": 0, "update_game_mode": 1, "update_latency": 2, "update_display_name": 3, "remove_player": 4}
|
|
|
|
func (ret *PlayToClientPacketPlayerInfo) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientPacketPlayerInfoAction int32
|
|
vPlayToClientPacketPlayerInfoAction, err = proto_base.ErroringIndex(PlayToClientPacketPlayerInfoActionReverseMap, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToClientPacketPlayerInfoAction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Data)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketPlayerInfoData := range len(ret.Data) {
|
|
_, err = w.Write(ret.Data[iPlayToClientPacketPlayerInfoData].Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case "add_player":
|
|
PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
Name string
|
|
Properties []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
Gamemode int32
|
|
Ping int32
|
|
DisplayName *string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketPlayerInfoDataInnerAnon.Properties)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketPlayerInfoDataInnerAnonProperties := range len(PlayToClientPacketPlayerInfoDataInnerAnon.Properties) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature != nil {
|
|
err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Gamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Ping)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil {
|
|
err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "remove_player":
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "update_display_name":
|
|
PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
DisplayName *string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil {
|
|
err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "update_game_mode":
|
|
PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
Gamemode int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Gamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_latency":
|
|
PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
Ping int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Ping)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerlistHeader struct {
|
|
Header string
|
|
Footer string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPlayerlistHeader) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Header, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Footer, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPlayerlistHeader) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Header)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Footer)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPosition struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
Flags int8
|
|
TeleportId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPosition) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TeleportId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPosition) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.TeleportId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRelEntityMove struct {
|
|
EntityId int32
|
|
DX int16
|
|
DY int16
|
|
DZ int16
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketRelEntityMove) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketRelEntityMove) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRemoveEntityEffect struct {
|
|
EntityId int32
|
|
EffectId int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketRemoveEntityEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketRemoveEntityEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketResourcePackSend struct {
|
|
Url string
|
|
Hash string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketResourcePackSend) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketResourcePackSend) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRespawn struct {
|
|
Dimension int32
|
|
Difficulty uint8
|
|
Gamemode uint8
|
|
LevelType string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketRespawn) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Dimension)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Gamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.LevelType, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketRespawn) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Dimension)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Gamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.LevelType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardDisplayObjective struct {
|
|
Position int8
|
|
Name string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketScoreboardDisplayObjective) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Position)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketScoreboardDisplayObjective) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Position)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardObjective struct {
|
|
Name string
|
|
Action int8
|
|
DisplayText any
|
|
Type any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketScoreboardObjective) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveDisplayText0Tmp string
|
|
PlayToClientPacketScoreboardObjectiveDisplayText0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveDisplayText2Tmp string
|
|
PlayToClientPacketScoreboardObjectiveDisplayText2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveDisplayTextTmp struct {
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayTextTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveType0Tmp string
|
|
PlayToClientPacketScoreboardObjectiveType0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveType0Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveType2Tmp string
|
|
PlayToClientPacketScoreboardObjectiveType2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveType2Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveTypeTmp struct {
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveTypeTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketScoreboardObjective) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketScoreboardObjectiveDisplayText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketScoreboardObjectiveDisplayText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.DisplayText.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketScoreboardObjectiveType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketScoreboardObjectiveType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Type.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardScore struct {
|
|
ItemName string
|
|
Action int32
|
|
ScoreName string
|
|
Value any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketScoreboardScore) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ItemName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ScoreName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
var PlayToClientPacketScoreboardScoreValue1Tmp struct {
|
|
}
|
|
ret.Value = PlayToClientPacketScoreboardScoreValue1Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardScoreValueTmp int32
|
|
PlayToClientPacketScoreboardScoreValueTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = PlayToClientPacketScoreboardScoreValueTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketScoreboardScore) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.ItemName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.ScoreName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
_, ok := ret.Value.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Value.(int32))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSelectAdvancementTab struct {
|
|
Id *string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSelectAdvancementTab) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketSelectAdvancementTabIdPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketSelectAdvancementTabIdPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketSelectAdvancementTabIdPresent {
|
|
var PlayToClientPacketSelectAdvancementTabIdPresentValue string
|
|
PlayToClientPacketSelectAdvancementTabIdPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Id = &PlayToClientPacketSelectAdvancementTabIdPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSelectAdvancementTab) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Id != nil {
|
|
err = proto_base.EncodeString(w, *ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetCooldown struct {
|
|
ItemID int32
|
|
CooldownTicks int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetCooldown) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ItemID, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CooldownTicks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetCooldown) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ItemID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.CooldownTicks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetPassengers struct {
|
|
EntityId int32
|
|
Passengers []int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetPassengers) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketSetPassengersPassengers int32
|
|
lPlayToClientPacketSetPassengersPassengers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Passengers = []int32{}
|
|
for range lPlayToClientPacketSetPassengersPassengers {
|
|
var PlayToClientPacketSetPassengersPassengersElement int32
|
|
PlayToClientPacketSetPassengersPassengersElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Passengers = append(ret.Passengers, PlayToClientPacketSetPassengersPassengersElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetPassengers) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Passengers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketSetPassengersPassengers := range len(ret.Passengers) {
|
|
err = proto_base.EncodeVarInt(w, ret.Passengers[iPlayToClientPacketSetPassengersPassengers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetSlot struct {
|
|
WindowId int8
|
|
Slot int16
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSetSlotItemEncTmp := ret.Item
|
|
err = PlayToClientPacketSetSlotItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSoundEffect struct {
|
|
SoundId int32
|
|
SoundCategory int32
|
|
X int32
|
|
Y int32
|
|
Z int32
|
|
Volume float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSoundEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.SoundId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SoundCategory, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSoundEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.SoundId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SoundCategory)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntity struct {
|
|
EntityId int32
|
|
ObjectUUID uuid.UUID
|
|
Type int8
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Pitch int8
|
|
Yaw int8
|
|
ObjectData int32
|
|
Velocity Vec3i16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.ObjectUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ObjectData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Velocity.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.ObjectUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ObjectData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityVelocityEncTmp := ret.Velocity
|
|
err = PlayToClientPacketSpawnEntityVelocityEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityExperienceOrb struct {
|
|
EntityId int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Count int16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityExperienceOrb) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Count)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityExperienceOrb) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Count)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityLiving struct {
|
|
EntityId int32
|
|
EntityUUID uuid.UUID
|
|
Type int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw int8
|
|
Pitch int8
|
|
HeadPitch int8
|
|
Velocity Vec3i16
|
|
Metadata EntityMetadata
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityLiving) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HeadPitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Velocity.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Metadata.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityLiving) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HeadPitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityLivingVelocityEncTmp := ret.Velocity
|
|
err = PlayToClientPacketSpawnEntityLivingVelocityEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityLivingMetadataEncTmp := ret.Metadata
|
|
err = PlayToClientPacketSpawnEntityLivingMetadataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityPainting struct {
|
|
EntityId int32
|
|
EntityUUID uuid.UUID
|
|
Title string
|
|
Location Position
|
|
Direction uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityPainting) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityPainting) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Title)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityPaintingLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketSpawnEntityPaintingLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityWeather struct {
|
|
EntityId int32
|
|
Type int8
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityWeather) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityWeather) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnPosition struct {
|
|
Location Position
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnPosition) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnPosition) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketSpawnPositionLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketSpawnPositionLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStatistics struct {
|
|
Entries []struct {
|
|
Name string
|
|
Value int32
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketStatistics) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketStatisticsEntries int32
|
|
lPlayToClientPacketStatisticsEntries, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = []struct {
|
|
Name string
|
|
Value int32
|
|
}{}
|
|
for range lPlayToClientPacketStatisticsEntries {
|
|
var PlayToClientPacketStatisticsEntriesElement struct {
|
|
Name string
|
|
Value int32
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.Value, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = append(ret.Entries, PlayToClientPacketStatisticsEntriesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketStatistics) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketStatisticsEntries := range len(ret.Entries) {
|
|
err = proto_base.EncodeString(w, ret.Entries[iPlayToClientPacketStatisticsEntries].Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTabComplete struct {
|
|
Matches []string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketTabCompleteMatches int32
|
|
lPlayToClientPacketTabCompleteMatches, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Matches = []string{}
|
|
for range lPlayToClientPacketTabCompleteMatches {
|
|
var PlayToClientPacketTabCompleteMatchesElement string
|
|
PlayToClientPacketTabCompleteMatchesElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Matches = append(ret.Matches, PlayToClientPacketTabCompleteMatchesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTabComplete) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Matches)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTabCompleteMatches := range len(ret.Matches) {
|
|
err = proto_base.EncodeString(w, ret.Matches[iPlayToClientPacketTabCompleteMatches])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTeams struct {
|
|
Team string
|
|
Mode int8
|
|
Name any
|
|
Prefix any
|
|
Suffix any
|
|
FriendlyFire any
|
|
NameTagVisibility any
|
|
CollisionRule any
|
|
Color any
|
|
Players any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTeams) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Team, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsName0Tmp string
|
|
PlayToClientPacketTeamsName0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsName0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsName2Tmp string
|
|
PlayToClientPacketTeamsName2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsName2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsNameTmp struct {
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsNameTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsPrefix0Tmp string
|
|
PlayToClientPacketTeamsPrefix0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefix0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsPrefix2Tmp string
|
|
PlayToClientPacketTeamsPrefix2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefix2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsPrefixTmp struct {
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefixTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsSuffix0Tmp string
|
|
PlayToClientPacketTeamsSuffix0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffix0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsSuffix2Tmp string
|
|
PlayToClientPacketTeamsSuffix2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffix2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsSuffixTmp struct {
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffixTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsFriendlyFire0Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsFriendlyFire0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFire0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsFriendlyFire2Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsFriendlyFire2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFire2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsFriendlyFireTmp struct {
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFireTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsNameTagVisibility0Tmp string
|
|
PlayToClientPacketTeamsNameTagVisibility0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibility0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsNameTagVisibility2Tmp string
|
|
PlayToClientPacketTeamsNameTagVisibility2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibility2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsNameTagVisibilityTmp struct {
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibilityTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsCollisionRule0Tmp string
|
|
PlayToClientPacketTeamsCollisionRule0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRule0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsCollisionRule2Tmp string
|
|
PlayToClientPacketTeamsCollisionRule2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRule2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsCollisionRuleTmp struct {
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRuleTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsColor0Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsColor0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketTeamsColor0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsColor2Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsColor2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketTeamsColor2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsColorTmp struct {
|
|
}
|
|
ret.Color = PlayToClientPacketTeamsColorTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsPlayers0Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers0Tmp int32
|
|
lPlayToClientPacketTeamsPlayers0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers0Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers0Tmp {
|
|
var PlayToClientPacketTeamsPlayers0TmpElement string
|
|
PlayToClientPacketTeamsPlayers0TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers0Tmp = append(PlayToClientPacketTeamsPlayers0Tmp, PlayToClientPacketTeamsPlayers0TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers0Tmp
|
|
case 3:
|
|
var PlayToClientPacketTeamsPlayers3Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers3Tmp int32
|
|
lPlayToClientPacketTeamsPlayers3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers3Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers3Tmp {
|
|
var PlayToClientPacketTeamsPlayers3TmpElement string
|
|
PlayToClientPacketTeamsPlayers3TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers3Tmp = append(PlayToClientPacketTeamsPlayers3Tmp, PlayToClientPacketTeamsPlayers3TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers3Tmp
|
|
case 4:
|
|
var PlayToClientPacketTeamsPlayers4Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers4Tmp int32
|
|
lPlayToClientPacketTeamsPlayers4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers4Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers4Tmp {
|
|
var PlayToClientPacketTeamsPlayers4TmpElement string
|
|
PlayToClientPacketTeamsPlayers4TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers4Tmp = append(PlayToClientPacketTeamsPlayers4Tmp, PlayToClientPacketTeamsPlayers4TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers4Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsPlayersTmp struct {
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayersTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTeams) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Team)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsName, ok := ret.Name.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsName, ok := ret.Name.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Name.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsPrefix, ok := ret.Prefix.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPrefix)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsPrefix, ok := ret.Prefix.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPrefix)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Prefix.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsSuffix, ok := ret.Suffix.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsSuffix)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsSuffix, ok := ret.Suffix.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsSuffix)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Suffix.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsFriendlyFire, ok := ret.FriendlyFire.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsFriendlyFire)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsFriendlyFire, ok := ret.FriendlyFire.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsFriendlyFire)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.FriendlyFire.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsNameTagVisibility, ok := ret.NameTagVisibility.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsNameTagVisibility)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsNameTagVisibility, ok := ret.NameTagVisibility.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsNameTagVisibility)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.NameTagVisibility.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsCollisionRule, ok := ret.CollisionRule.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsCollisionRule)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsCollisionRule, ok := ret.CollisionRule.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsCollisionRule)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.CollisionRule.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsColor, ok := ret.Color.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsColor)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsColor, ok := ret.Color.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsColor)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Color.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 3:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 4:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Players.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTileEntityData struct {
|
|
Location Position
|
|
Action uint8
|
|
NbtData nbt.Tag
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTileEntityData) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NbtData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTileEntityData) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketTileEntityDataLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketTileEntityDataLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTileEntityDataNbtDataEncTmp := ret.NbtData
|
|
err = PlayToClientPacketTileEntityDataNbtDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTitle struct {
|
|
Action int32
|
|
Text any
|
|
FadeIn any
|
|
Stay any
|
|
FadeOut any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTitle) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketTitleText0Tmp string
|
|
PlayToClientPacketTitleText0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text = PlayToClientPacketTitleText0Tmp
|
|
case 1:
|
|
var PlayToClientPacketTitleText1Tmp string
|
|
PlayToClientPacketTitleText1Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text = PlayToClientPacketTitleText1Tmp
|
|
case 2:
|
|
var PlayToClientPacketTitleText2Tmp string
|
|
PlayToClientPacketTitleText2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text = PlayToClientPacketTitleText2Tmp
|
|
default:
|
|
var PlayToClientPacketTitleTextTmp struct {
|
|
}
|
|
ret.Text = PlayToClientPacketTitleTextTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketTitleFadeIn3Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleFadeIn3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FadeIn = PlayToClientPacketTitleFadeIn3Tmp
|
|
default:
|
|
var PlayToClientPacketTitleFadeInTmp struct {
|
|
}
|
|
ret.FadeIn = PlayToClientPacketTitleFadeInTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketTitleStay3Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleStay3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Stay = PlayToClientPacketTitleStay3Tmp
|
|
default:
|
|
var PlayToClientPacketTitleStayTmp struct {
|
|
}
|
|
ret.Stay = PlayToClientPacketTitleStayTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketTitleFadeOut3Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleFadeOut3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FadeOut = PlayToClientPacketTitleFadeOut3Tmp
|
|
default:
|
|
var PlayToClientPacketTitleFadeOutTmp struct {
|
|
}
|
|
ret.FadeOut = PlayToClientPacketTitleFadeOutTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTitle) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketTitleText, ok := ret.Text.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTitleText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
PlayToClientPacketTitleText, ok := ret.Text.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTitleText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTitleText, ok := ret.Text.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTitleText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Text.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketTitleFadeIn, ok := ret.FadeIn.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleFadeIn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.FadeIn.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketTitleStay, ok := ret.Stay.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleStay)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Stay.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketTitleFadeOut, ok := ret.FadeOut.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleFadeOut)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.FadeOut.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTransaction struct {
|
|
WindowId int8
|
|
Action int16
|
|
Accepted bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTransaction) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Accepted)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTransaction) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Accepted)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUnloadChunk struct {
|
|
ChunkX int32
|
|
ChunkZ int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUnloadChunk) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUnloadChunk) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUnlockRecipes struct {
|
|
Action int32
|
|
CraftingBookOpen bool
|
|
FilteringCraftable bool
|
|
Recipes1 []int32
|
|
Recipes2 any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUnlockRecipes) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FilteringCraftable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketUnlockRecipesRecipes1 int32
|
|
lPlayToClientPacketUnlockRecipesRecipes1, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes1 = []int32{}
|
|
for range lPlayToClientPacketUnlockRecipesRecipes1 {
|
|
var PlayToClientPacketUnlockRecipesRecipes1Element int32
|
|
PlayToClientPacketUnlockRecipesRecipes1Element, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes1 = append(ret.Recipes1, PlayToClientPacketUnlockRecipesRecipes1Element)
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketUnlockRecipesRecipes20Tmp []int32
|
|
var lPlayToClientPacketUnlockRecipesRecipes20Tmp int32
|
|
lPlayToClientPacketUnlockRecipesRecipes20Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUnlockRecipesRecipes20Tmp = []int32{}
|
|
for range lPlayToClientPacketUnlockRecipesRecipes20Tmp {
|
|
var PlayToClientPacketUnlockRecipesRecipes20TmpElement int32
|
|
PlayToClientPacketUnlockRecipesRecipes20TmpElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUnlockRecipesRecipes20Tmp = append(PlayToClientPacketUnlockRecipesRecipes20Tmp, PlayToClientPacketUnlockRecipesRecipes20TmpElement)
|
|
}
|
|
ret.Recipes2 = PlayToClientPacketUnlockRecipesRecipes20Tmp
|
|
default:
|
|
var PlayToClientPacketUnlockRecipesRecipes2Tmp struct {
|
|
}
|
|
ret.Recipes2 = PlayToClientPacketUnlockRecipesRecipes2Tmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUnlockRecipes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilteringCraftable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes1)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUnlockRecipesRecipes1 := range len(ret.Recipes1) {
|
|
err = proto_base.EncodeVarInt(w, ret.Recipes1[iPlayToClientPacketUnlockRecipesRecipes1])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketUnlockRecipesRecipes2, ok := ret.Recipes2.([]int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketUnlockRecipesRecipes2)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUnlockRecipesRecipes2 := range len(PlayToClientPacketUnlockRecipesRecipes2) {
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketUnlockRecipesRecipes2[iPlayToClientPacketUnlockRecipesRecipes2])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Recipes2.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateHealth struct {
|
|
Health float32
|
|
Food int32
|
|
FoodSaturation float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateHealth) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Health)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Food, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FoodSaturation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateHealth) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Health)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Food)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FoodSaturation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateTime struct {
|
|
Age int64
|
|
Time int64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateTime) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Age)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateTime) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Age)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketVehicleMove struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketVehicleMove) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketVehicleMove) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWindowItems struct {
|
|
WindowId uint8
|
|
Items []Slot
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWindowItems) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketWindowItemsItems int16
|
|
err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketWindowItemsItems)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Items = []Slot{}
|
|
for range lPlayToClientPacketWindowItemsItems {
|
|
var PlayToClientPacketWindowItemsItemsElement Slot
|
|
err = PlayToClientPacketWindowItemsItemsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Items = append(ret.Items, PlayToClientPacketWindowItemsItemsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWindowItems) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, int16(len(ret.Items)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketWindowItemsItems := range len(ret.Items) {
|
|
PlayToClientPacketWindowItemsItemsInnerEncTmp := ret.Items[iPlayToClientPacketWindowItemsItems]
|
|
err = PlayToClientPacketWindowItemsItemsInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorder struct {
|
|
Action int32
|
|
Radius any
|
|
X any
|
|
Z any
|
|
OldRadius any
|
|
NewRadius any
|
|
Speed any
|
|
PortalBoundary any
|
|
WarningTime any
|
|
WarningBlocks any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldBorder) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketWorldBorderRadius0Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderRadius0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Radius = PlayToClientPacketWorldBorderRadius0Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderRadiusTmp struct {
|
|
}
|
|
ret.Radius = PlayToClientPacketWorldBorderRadiusTmp
|
|
}
|
|
switch ret.Action {
|
|
case 2:
|
|
var PlayToClientPacketWorldBorderX2Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderX2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketWorldBorderX2Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderX3Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderX3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketWorldBorderX3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderXTmp struct {
|
|
}
|
|
ret.X = PlayToClientPacketWorldBorderXTmp
|
|
}
|
|
switch ret.Action {
|
|
case 2:
|
|
var PlayToClientPacketWorldBorderZ2Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderZ2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToClientPacketWorldBorderZ2Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderZ3Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderZ3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToClientPacketWorldBorderZ3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderZTmp struct {
|
|
}
|
|
ret.Z = PlayToClientPacketWorldBorderZTmp
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
var PlayToClientPacketWorldBorderOldRadius1Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderOldRadius1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.OldRadius = PlayToClientPacketWorldBorderOldRadius1Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderOldRadius3Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderOldRadius3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.OldRadius = PlayToClientPacketWorldBorderOldRadius3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderOldRadiusTmp struct {
|
|
}
|
|
ret.OldRadius = PlayToClientPacketWorldBorderOldRadiusTmp
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
var PlayToClientPacketWorldBorderNewRadius1Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderNewRadius1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NewRadius = PlayToClientPacketWorldBorderNewRadius1Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderNewRadius3Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderNewRadius3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NewRadius = PlayToClientPacketWorldBorderNewRadius3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderNewRadiusTmp struct {
|
|
}
|
|
ret.NewRadius = PlayToClientPacketWorldBorderNewRadiusTmp
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
var PlayToClientPacketWorldBorderSpeed1Tmp int64
|
|
PlayToClientPacketWorldBorderSpeed1Tmp, err = proto_base.DecodeVarLong(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Speed = PlayToClientPacketWorldBorderSpeed1Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderSpeed3Tmp int64
|
|
PlayToClientPacketWorldBorderSpeed3Tmp, err = proto_base.DecodeVarLong(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Speed = PlayToClientPacketWorldBorderSpeed3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderSpeedTmp struct {
|
|
}
|
|
ret.Speed = PlayToClientPacketWorldBorderSpeedTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderPortalBoundary3Tmp int32
|
|
PlayToClientPacketWorldBorderPortalBoundary3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PortalBoundary = PlayToClientPacketWorldBorderPortalBoundary3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderPortalBoundaryTmp struct {
|
|
}
|
|
ret.PortalBoundary = PlayToClientPacketWorldBorderPortalBoundaryTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderWarningTime3Tmp int32
|
|
PlayToClientPacketWorldBorderWarningTime3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningTime = PlayToClientPacketWorldBorderWarningTime3Tmp
|
|
case 4:
|
|
var PlayToClientPacketWorldBorderWarningTime4Tmp int32
|
|
PlayToClientPacketWorldBorderWarningTime4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningTime = PlayToClientPacketWorldBorderWarningTime4Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderWarningTimeTmp struct {
|
|
}
|
|
ret.WarningTime = PlayToClientPacketWorldBorderWarningTimeTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderWarningBlocks3Tmp int32
|
|
PlayToClientPacketWorldBorderWarningBlocks3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocks3Tmp
|
|
case 5:
|
|
var PlayToClientPacketWorldBorderWarningBlocks5Tmp int32
|
|
PlayToClientPacketWorldBorderWarningBlocks5Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocks5Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderWarningBlocksTmp struct {
|
|
}
|
|
ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocksTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldBorder) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketWorldBorderRadius, ok := ret.Radius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Radius.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 2:
|
|
PlayToClientPacketWorldBorderX, ok := ret.X.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderX, ok := ret.X.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.X.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 2:
|
|
PlayToClientPacketWorldBorderZ, ok := ret.Z.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderZ, ok := ret.Z.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Z.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
PlayToClientPacketWorldBorderOldRadius, ok := ret.OldRadius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderOldRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderOldRadius, ok := ret.OldRadius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderOldRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.OldRadius.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
PlayToClientPacketWorldBorderNewRadius, ok := ret.NewRadius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderNewRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderNewRadius, ok := ret.NewRadius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderNewRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.NewRadius.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
PlayToClientPacketWorldBorderSpeed, ok := ret.Speed.(int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarLong(w, PlayToClientPacketWorldBorderSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderSpeed, ok := ret.Speed.(int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarLong(w, PlayToClientPacketWorldBorderSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Speed.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketWorldBorderPortalBoundary, ok := ret.PortalBoundary.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderPortalBoundary)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.PortalBoundary.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketWorldBorderWarningTime, ok := ret.WarningTime.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketWorldBorderWarningTime, ok := ret.WarningTime.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.WarningTime.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketWorldBorderWarningBlocks, ok := ret.WarningBlocks.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningBlocks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 5:
|
|
PlayToClientPacketWorldBorderWarningBlocks, ok := ret.WarningBlocks.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningBlocks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.WarningBlocks.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldEvent struct {
|
|
EffectId int32
|
|
Location Position
|
|
Data int32
|
|
Global bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldEvent) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Data)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Global)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldEvent) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketWorldEventLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketWorldEventLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Data)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Global)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldParticles struct {
|
|
ParticleId int32
|
|
LongDistance bool
|
|
X float32
|
|
Y float32
|
|
Z float32
|
|
OffsetX float32
|
|
OffsetY float32
|
|
OffsetZ float32
|
|
ParticleData float32
|
|
Particles int32
|
|
Data any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldParticles) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ParticleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.LongDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Particles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.ParticleId {
|
|
case 36:
|
|
var PlayToClientPacketWorldParticlesData36Tmp []int32
|
|
var lPlayToClientPacketWorldParticlesData36Tmp int32
|
|
lPlayToClientPacketWorldParticlesData36Tmp = 2
|
|
PlayToClientPacketWorldParticlesData36Tmp = []int32{}
|
|
for range lPlayToClientPacketWorldParticlesData36Tmp {
|
|
var PlayToClientPacketWorldParticlesData36TmpElement int32
|
|
PlayToClientPacketWorldParticlesData36TmpElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketWorldParticlesData36Tmp = append(PlayToClientPacketWorldParticlesData36Tmp, PlayToClientPacketWorldParticlesData36TmpElement)
|
|
}
|
|
ret.Data = PlayToClientPacketWorldParticlesData36Tmp
|
|
case 37:
|
|
var PlayToClientPacketWorldParticlesData37Tmp []int32
|
|
var lPlayToClientPacketWorldParticlesData37Tmp int32
|
|
lPlayToClientPacketWorldParticlesData37Tmp = 1
|
|
PlayToClientPacketWorldParticlesData37Tmp = []int32{}
|
|
for range lPlayToClientPacketWorldParticlesData37Tmp {
|
|
var PlayToClientPacketWorldParticlesData37TmpElement int32
|
|
PlayToClientPacketWorldParticlesData37TmpElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketWorldParticlesData37Tmp = append(PlayToClientPacketWorldParticlesData37Tmp, PlayToClientPacketWorldParticlesData37TmpElement)
|
|
}
|
|
ret.Data = PlayToClientPacketWorldParticlesData37Tmp
|
|
case 38:
|
|
var PlayToClientPacketWorldParticlesData38Tmp []int32
|
|
var lPlayToClientPacketWorldParticlesData38Tmp int32
|
|
lPlayToClientPacketWorldParticlesData38Tmp = 1
|
|
PlayToClientPacketWorldParticlesData38Tmp = []int32{}
|
|
for range lPlayToClientPacketWorldParticlesData38Tmp {
|
|
var PlayToClientPacketWorldParticlesData38TmpElement int32
|
|
PlayToClientPacketWorldParticlesData38TmpElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketWorldParticlesData38Tmp = append(PlayToClientPacketWorldParticlesData38Tmp, PlayToClientPacketWorldParticlesData38TmpElement)
|
|
}
|
|
ret.Data = PlayToClientPacketWorldParticlesData38Tmp
|
|
default:
|
|
var PlayToClientPacketWorldParticlesDataTmp struct {
|
|
}
|
|
ret.Data = PlayToClientPacketWorldParticlesDataTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldParticles) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ParticleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.LongDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Particles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.ParticleId {
|
|
case 36:
|
|
PlayToClientPacketWorldParticlesData, ok := ret.Data.([]int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
for iPlayToClientPacketWorldParticlesData := range len(PlayToClientPacketWorldParticlesData) {
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData[iPlayToClientPacketWorldParticlesData])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 37:
|
|
PlayToClientPacketWorldParticlesData, ok := ret.Data.([]int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
for iPlayToClientPacketWorldParticlesData := range len(PlayToClientPacketWorldParticlesData) {
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData[iPlayToClientPacketWorldParticlesData])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 38:
|
|
PlayToClientPacketWorldParticlesData, ok := ret.Data.([]int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
for iPlayToClientPacketWorldParticlesData := range len(PlayToClientPacketWorldParticlesData) {
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData[iPlayToClientPacketWorldParticlesData])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var PlayToServerPacketNameMap = map[int32]string{0x00: "teleport_confirm", 0x01: "tab_complete", 0x02: "chat", 0x03: "client_command", 0x04: "settings", 0x05: "transaction", 0x06: "enchant_item", 0x07: "window_click", 0x08: "close_window", 0x09: "custom_payload", 0x0a: "use_entity", 0x0b: "keep_alive", 0x0c: "flying", 0x0d: "position", 0x0e: "position_look", 0x0f: "look", 0x10: "vehicle_move", 0x11: "steer_boat", 0x12: "craft_recipe_request", 0x13: "abilities", 0x14: "block_dig", 0x15: "entity_action", 0x16: "steer_vehicle", 0x17: "crafting_book_data", 0x18: "resource_pack_receive", 0x19: "advancement_tab", 0x1a: "held_item_slot", 0x1b: "set_creative_slot", 0x1c: "update_sign", 0x1d: "arm_animation", 0x1e: "spectate", 0x1f: "block_place", 0x20: "use_item"}
|
|
|
|
func (ret *PlayToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToServerPacketNameKey int32
|
|
PlayToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(PlayToServerPacketNameMap, PlayToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
var PlayToServerPacketParamsAbilitiesTmp PlayToServerPacketAbilities
|
|
err = PlayToServerPacketParamsAbilitiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsAbilitiesTmp
|
|
case "advancement_tab":
|
|
var PlayToServerPacketParamsAdvancementTabTmp PlayToServerPacketAdvancementTab
|
|
err = PlayToServerPacketParamsAdvancementTabTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsAdvancementTabTmp
|
|
case "arm_animation":
|
|
var PlayToServerPacketParamsArmAnimationTmp PlayToServerPacketArmAnimation
|
|
err = PlayToServerPacketParamsArmAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsArmAnimationTmp
|
|
case "block_dig":
|
|
var PlayToServerPacketParamsBlockDigTmp PlayToServerPacketBlockDig
|
|
err = PlayToServerPacketParamsBlockDigTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsBlockDigTmp
|
|
case "block_place":
|
|
var PlayToServerPacketParamsBlockPlaceTmp PlayToServerPacketBlockPlace
|
|
err = PlayToServerPacketParamsBlockPlaceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsBlockPlaceTmp
|
|
case "chat":
|
|
var PlayToServerPacketParamsChatTmp PlayToServerPacketChat
|
|
err = PlayToServerPacketParamsChatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsChatTmp
|
|
case "client_command":
|
|
var PlayToServerPacketParamsClientCommandTmp PlayToServerPacketClientCommand
|
|
err = PlayToServerPacketParamsClientCommandTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsClientCommandTmp
|
|
case "close_window":
|
|
var PlayToServerPacketParamsCloseWindowTmp PlayToServerPacketCloseWindow
|
|
err = PlayToServerPacketParamsCloseWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCloseWindowTmp
|
|
case "craft_recipe_request":
|
|
var PlayToServerPacketParamsCraftRecipeRequestTmp PlayToServerPacketCraftRecipeRequest
|
|
err = PlayToServerPacketParamsCraftRecipeRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCraftRecipeRequestTmp
|
|
case "crafting_book_data":
|
|
var PlayToServerPacketParamsCraftingBookDataTmp PlayToServerPacketCraftingBookData
|
|
err = PlayToServerPacketParamsCraftingBookDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCraftingBookDataTmp
|
|
case "custom_payload":
|
|
var PlayToServerPacketParamsCustomPayloadTmp PlayToServerPacketCustomPayload
|
|
err = PlayToServerPacketParamsCustomPayloadTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCustomPayloadTmp
|
|
case "enchant_item":
|
|
var PlayToServerPacketParamsEnchantItemTmp PlayToServerPacketEnchantItem
|
|
err = PlayToServerPacketParamsEnchantItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsEnchantItemTmp
|
|
case "entity_action":
|
|
var PlayToServerPacketParamsEntityActionTmp PlayToServerPacketEntityAction
|
|
err = PlayToServerPacketParamsEntityActionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsEntityActionTmp
|
|
case "flying":
|
|
var PlayToServerPacketParamsFlyingTmp PlayToServerPacketFlying
|
|
err = PlayToServerPacketParamsFlyingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsFlyingTmp
|
|
case "held_item_slot":
|
|
var PlayToServerPacketParamsHeldItemSlotTmp PlayToServerPacketHeldItemSlot
|
|
err = PlayToServerPacketParamsHeldItemSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsHeldItemSlotTmp
|
|
case "keep_alive":
|
|
var PlayToServerPacketParamsKeepAliveTmp PlayToServerPacketKeepAlive
|
|
err = PlayToServerPacketParamsKeepAliveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsKeepAliveTmp
|
|
case "look":
|
|
var PlayToServerPacketParamsLookTmp PlayToServerPacketLook
|
|
err = PlayToServerPacketParamsLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsLookTmp
|
|
case "position":
|
|
var PlayToServerPacketParamsPositionTmp PlayToServerPacketPosition
|
|
err = PlayToServerPacketParamsPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsPositionTmp
|
|
case "position_look":
|
|
var PlayToServerPacketParamsPositionLookTmp PlayToServerPacketPositionLook
|
|
err = PlayToServerPacketParamsPositionLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsPositionLookTmp
|
|
case "resource_pack_receive":
|
|
var PlayToServerPacketParamsResourcePackReceiveTmp PlayToServerPacketResourcePackReceive
|
|
err = PlayToServerPacketParamsResourcePackReceiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsResourcePackReceiveTmp
|
|
case "set_creative_slot":
|
|
var PlayToServerPacketParamsSetCreativeSlotTmp PlayToServerPacketSetCreativeSlot
|
|
err = PlayToServerPacketParamsSetCreativeSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSetCreativeSlotTmp
|
|
case "settings":
|
|
var PlayToServerPacketParamsSettingsTmp PlayToServerPacketSettings
|
|
err = PlayToServerPacketParamsSettingsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSettingsTmp
|
|
case "spectate":
|
|
var PlayToServerPacketParamsSpectateTmp PlayToServerPacketSpectate
|
|
err = PlayToServerPacketParamsSpectateTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSpectateTmp
|
|
case "steer_boat":
|
|
var PlayToServerPacketParamsSteerBoatTmp PlayToServerPacketSteerBoat
|
|
err = PlayToServerPacketParamsSteerBoatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSteerBoatTmp
|
|
case "steer_vehicle":
|
|
var PlayToServerPacketParamsSteerVehicleTmp PlayToServerPacketSteerVehicle
|
|
err = PlayToServerPacketParamsSteerVehicleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSteerVehicleTmp
|
|
case "tab_complete":
|
|
var PlayToServerPacketParamsTabCompleteTmp PlayToServerPacketTabComplete
|
|
err = PlayToServerPacketParamsTabCompleteTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTabCompleteTmp
|
|
case "teleport_confirm":
|
|
var PlayToServerPacketParamsTeleportConfirmTmp PlayToServerPacketTeleportConfirm
|
|
err = PlayToServerPacketParamsTeleportConfirmTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTeleportConfirmTmp
|
|
case "transaction":
|
|
var PlayToServerPacketParamsTransactionTmp PlayToServerPacketTransaction
|
|
err = PlayToServerPacketParamsTransactionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTransactionTmp
|
|
case "update_sign":
|
|
var PlayToServerPacketParamsUpdateSignTmp PlayToServerPacketUpdateSign
|
|
err = PlayToServerPacketParamsUpdateSignTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateSignTmp
|
|
case "use_entity":
|
|
var PlayToServerPacketParamsUseEntityTmp PlayToServerPacketUseEntity
|
|
err = PlayToServerPacketParamsUseEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUseEntityTmp
|
|
case "use_item":
|
|
var PlayToServerPacketParamsUseItemTmp PlayToServerPacketUseItem
|
|
err = PlayToServerPacketParamsUseItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUseItemTmp
|
|
case "vehicle_move":
|
|
var PlayToServerPacketParamsVehicleMoveTmp PlayToServerPacketVehicleMove
|
|
err = PlayToServerPacketParamsVehicleMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsVehicleMoveTmp
|
|
case "window_click":
|
|
var PlayToServerPacketParamsWindowClickTmp PlayToServerPacketWindowClick
|
|
err = PlayToServerPacketParamsWindowClickTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsWindowClickTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToServerPacketNameReverseMap = map[string]int32{"teleport_confirm": 0x00, "tab_complete": 0x01, "chat": 0x02, "client_command": 0x03, "settings": 0x04, "transaction": 0x05, "enchant_item": 0x06, "window_click": 0x07, "close_window": 0x08, "custom_payload": 0x09, "use_entity": 0x0a, "keep_alive": 0x0b, "flying": 0x0c, "position": 0x0d, "position_look": 0x0e, "look": 0x0f, "vehicle_move": 0x10, "steer_boat": 0x11, "craft_recipe_request": 0x12, "abilities": 0x13, "block_dig": 0x14, "entity_action": 0x15, "steer_vehicle": 0x16, "crafting_book_data": 0x17, "resource_pack_receive": 0x18, "advancement_tab": 0x19, "held_item_slot": 0x1a, "set_creative_slot": 0x1b, "update_sign": 0x1c, "arm_animation": 0x1d, "spectate": 0x1e, "block_place": 0x1f, "use_item": 0x20}
|
|
|
|
func (ret *PlayToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vPlayToServerPacketName int32
|
|
vPlayToServerPacketName, err = proto_base.ErroringIndex(PlayToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAbilities)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "advancement_tab":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAdvancementTab)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "arm_animation":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketArmAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_dig":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockDig)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_place":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockPlace)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "client_command":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketClientCommand)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "close_window":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCloseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_recipe_request":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftRecipeRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "crafting_book_data":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftingBookData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "enchant_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEnchantItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_action":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEntityAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "flying":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketFlying)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "held_item_slot":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketHeldItemSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "look":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position_look":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPositionLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "resource_pack_receive":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketResourcePackReceive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_creative_slot":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetCreativeSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "settings":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSettings)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spectate":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSpectate)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "steer_boat":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerBoat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "steer_vehicle":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerVehicle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tab_complete":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTabComplete)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "teleport_confirm":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTeleportConfirm)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "transaction":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTransaction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_sign":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateSign)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "use_entity":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "use_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vehicle_move":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketVehicleMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "window_click":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketWindowClick)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketAbilities struct {
|
|
Flags int8
|
|
FlyingSpeed float32
|
|
WalkingSpeed float32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketAbilities) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketAbilities) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketAdvancementTab struct {
|
|
Action int32
|
|
TabId any
|
|
}
|
|
|
|
func (ret *PlayToServerPacketAdvancementTab) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToServerPacketAdvancementTabTabId0Tmp string
|
|
PlayToServerPacketAdvancementTabTabId0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TabId = PlayToServerPacketAdvancementTabTabId0Tmp
|
|
case 1:
|
|
var PlayToServerPacketAdvancementTabTabId1Tmp struct {
|
|
}
|
|
ret.TabId = PlayToServerPacketAdvancementTabTabId1Tmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketAdvancementTab) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToServerPacketAdvancementTabTabId, ok := ret.TabId.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToServerPacketAdvancementTabTabId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
_, ok := ret.TabId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketArmAnimation struct {
|
|
Hand int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketArmAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketArmAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketBlockDig struct {
|
|
Status int32
|
|
Location Position
|
|
Face int8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketBlockDig) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Status, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Face)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketBlockDig) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Status)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketBlockDigLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketBlockDigLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Face)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketBlockPlace struct {
|
|
Location Position
|
|
Direction int32
|
|
Hand int32
|
|
CursorX float32
|
|
CursorY float32
|
|
CursorZ float32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketBlockPlace) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Direction, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketBlockPlace) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketBlockPlaceLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketBlockPlaceLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChat struct {
|
|
Message string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketChat) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Message, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketChat) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Message)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketClientCommand struct {
|
|
ActionId int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketClientCommand) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ActionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketClientCommand) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ActionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCloseWindow struct {
|
|
WindowId uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCloseWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCloseWindow) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCraftRecipeRequest struct {
|
|
WindowId int8
|
|
Recipe int32
|
|
MakeAll bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCraftRecipeRequest) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipe, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.MakeAll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCraftRecipeRequest) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Recipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.MakeAll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCraftingBookData struct {
|
|
Type int32
|
|
Anon any
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCraftingBookData) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case 0:
|
|
var PlayToServerPacketCraftingBookDataAnon0Tmp struct {
|
|
DisplayedRecipe int32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon0Tmp.DisplayedRecipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = PlayToServerPacketCraftingBookDataAnon0Tmp
|
|
case 1:
|
|
var PlayToServerPacketCraftingBookDataAnon1Tmp struct {
|
|
CraftingBookOpen bool
|
|
CraftingFilter bool
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.CraftingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = PlayToServerPacketCraftingBookDataAnon1Tmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCraftingBookData) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case 0:
|
|
PlayToServerPacketCraftingBookDataAnon, ok := ret.Anon.(struct {
|
|
DisplayedRecipe int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.DisplayedRecipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
PlayToServerPacketCraftingBookDataAnon, ok := ret.Anon.(struct {
|
|
CraftingBookOpen bool
|
|
CraftingFilter bool
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.CraftingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCustomPayload) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketCustomPayloadDataEncTmp := ret.Data
|
|
err = PlayToServerPacketCustomPayloadDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEnchantItem struct {
|
|
WindowId int8
|
|
Enchantment int8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketEnchantItem) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Enchantment)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketEnchantItem) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Enchantment)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEntityAction struct {
|
|
EntityId int32
|
|
ActionId int32
|
|
JumpBoost int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketEntityAction) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ActionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.JumpBoost, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketEntityAction) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ActionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.JumpBoost)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketFlying struct {
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketFlying) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketFlying) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketHeldItemSlot struct {
|
|
SlotId int16
|
|
}
|
|
|
|
func (ret *PlayToServerPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.SlotId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketHeldItemSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.SlotId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (ret *PlayToServerPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketKeepAlive) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketLook struct {
|
|
Yaw float32
|
|
Pitch float32
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketLook) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketLook) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPosition struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketPosition) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketPosition) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPositionLook struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketPositionLook) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketPositionLook) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketResourcePackReceive struct {
|
|
Result int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketResourcePackReceive) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Result, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Result)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetCreativeSlot struct {
|
|
Slot int16
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSetCreativeSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSetCreativeSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketSetCreativeSlotItemEncTmp := ret.Item
|
|
err = PlayToServerPacketSetCreativeSlotItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSpectate struct {
|
|
Target uuid.UUID
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSpectate) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Target[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSpectate) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Target[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSteerBoat struct {
|
|
LeftPaddle bool
|
|
RightPaddle bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSteerBoat) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.LeftPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.RightPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSteerBoat) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.LeftPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.RightPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSteerVehicle struct {
|
|
Sideways float32
|
|
Forward float32
|
|
Jump uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSteerVehicle) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Sideways)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forward)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Jump)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSteerVehicle) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Sideways)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forward)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Jump)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTabComplete struct {
|
|
Text string
|
|
AssumeCommand bool
|
|
LookedAtBlock *Position
|
|
}
|
|
|
|
func (ret *PlayToServerPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Text, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.AssumeCommand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToServerPacketTabCompleteLookedAtBlockPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTabCompleteLookedAtBlockPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketTabCompleteLookedAtBlockPresent {
|
|
var PlayToServerPacketTabCompleteLookedAtBlockPresentValue Position
|
|
err = PlayToServerPacketTabCompleteLookedAtBlockPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.LookedAtBlock = &PlayToServerPacketTabCompleteLookedAtBlockPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketTabComplete) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Text)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AssumeCommand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.LookedAtBlock != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.LookedAtBlock != nil {
|
|
PlayToServerPacketTabCompleteLookedAtBlockEncTmp := *ret.LookedAtBlock
|
|
err = PlayToServerPacketTabCompleteLookedAtBlockEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTeleportConfirm struct {
|
|
TeleportId int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketTeleportConfirm) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TeleportId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketTeleportConfirm) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TeleportId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTransaction struct {
|
|
WindowId int8
|
|
Action int16
|
|
Accepted bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketTransaction) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Accepted)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketTransaction) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Accepted)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateSign struct {
|
|
Location Position
|
|
Text1 string
|
|
Text2 string
|
|
Text3 string
|
|
Text4 string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateSign) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text1, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text2, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text3, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text4, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateSign) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketUpdateSignLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketUpdateSignLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text1)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text2)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text3)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text4)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUseEntity struct {
|
|
Target int32
|
|
Mouse int32
|
|
X any
|
|
Y any
|
|
Z any
|
|
Hand any
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUseEntity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Target, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mouse, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityX2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityX2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToServerPacketUseEntityX2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityXTmp struct {
|
|
}
|
|
ret.X = PlayToServerPacketUseEntityXTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityY2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityY2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToServerPacketUseEntityY2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityYTmp struct {
|
|
}
|
|
ret.Y = PlayToServerPacketUseEntityYTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityZ2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityZ2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToServerPacketUseEntityZ2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityZTmp struct {
|
|
}
|
|
ret.Z = PlayToServerPacketUseEntityZTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 0:
|
|
var PlayToServerPacketUseEntityHand0Tmp int32
|
|
PlayToServerPacketUseEntityHand0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHand0Tmp
|
|
case 2:
|
|
var PlayToServerPacketUseEntityHand2Tmp int32
|
|
PlayToServerPacketUseEntityHand2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHand2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityHandTmp struct {
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHandTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUseEntity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Target)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mouse)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityX, ok := ret.X.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.X.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityY, ok := ret.Y.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Y.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityZ, ok := ret.Z.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Z.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 0:
|
|
PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Hand.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUseItem struct {
|
|
Hand int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUseItem) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUseItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketVehicleMove struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketVehicleMove) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketVehicleMove) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketWindowClick struct {
|
|
WindowId uint8
|
|
Slot int16
|
|
MouseButton int8
|
|
Action int16
|
|
Mode int8
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToServerPacketWindowClick) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.MouseButton)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketWindowClick) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.MouseButton)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketWindowClickItemEncTmp := ret.Item
|
|
err = PlayToServerPacketWindowClickItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var StatusToClientPacketNameMap = map[int32]string{0x00: "server_info", 0x01: "ping"}
|
|
|
|
func (ret *StatusToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var StatusToClientPacketNameKey int32
|
|
StatusToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(StatusToClientPacketNameMap, StatusToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
var StatusToClientPacketParamsPingTmp StatusToClientPacketPing
|
|
err = StatusToClientPacketParamsPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToClientPacketParamsPingTmp
|
|
case "server_info":
|
|
var StatusToClientPacketParamsServerInfoTmp StatusToClientPacketServerInfo
|
|
err = StatusToClientPacketParamsServerInfoTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToClientPacketParamsServerInfoTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var StatusToClientPacketNameReverseMap = map[string]int32{"server_info": 0x00, "ping": 0x01}
|
|
|
|
func (ret *StatusToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vStatusToClientPacketName int32
|
|
vStatusToClientPacketName, err = proto_base.ErroringIndex(StatusToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vStatusToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToClientPacketParamsEncTmp := StatusToClientPacketParams
|
|
err = StatusToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "server_info":
|
|
StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketServerInfo)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToClientPacketParamsEncTmp := StatusToClientPacketParams
|
|
err = StatusToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketPing struct {
|
|
Time int64
|
|
}
|
|
|
|
func (ret *StatusToClientPacketPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketServerInfo struct {
|
|
Response string
|
|
}
|
|
|
|
func (ret *StatusToClientPacketServerInfo) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Response, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketServerInfo) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Response)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var StatusToServerPacketNameMap = map[int32]string{0x00: "ping_start", 0x01: "ping"}
|
|
|
|
func (ret *StatusToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var StatusToServerPacketNameKey int32
|
|
StatusToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(StatusToServerPacketNameMap, StatusToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
var StatusToServerPacketParamsPingTmp StatusToServerPacketPing
|
|
err = StatusToServerPacketParamsPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToServerPacketParamsPingTmp
|
|
case "ping_start":
|
|
var StatusToServerPacketParamsPingStartTmp StatusToServerPacketPingStart
|
|
err = StatusToServerPacketParamsPingStartTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToServerPacketParamsPingStartTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var StatusToServerPacketNameReverseMap = map[string]int32{"ping_start": 0x00, "ping": 0x01}
|
|
|
|
func (ret *StatusToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vStatusToServerPacketName int32
|
|
vStatusToServerPacketName, err = proto_base.ErroringIndex(StatusToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vStatusToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToServerPacketParamsEncTmp := StatusToServerPacketParams
|
|
err = StatusToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping_start":
|
|
StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPingStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToServerPacketParamsEncTmp := StatusToServerPacketParams
|
|
err = StatusToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketPing struct {
|
|
Time int64
|
|
}
|
|
|
|
func (ret *StatusToServerPacketPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketPingStart struct {
|
|
}
|
|
|
|
func (ret *StatusToServerPacketPingStart) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketPingStart) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|