// Code generated by strom. DO NOT EDIT. // source: minecraft-data/pc/1.8/protocol.json (sha256:79fe774bfc255dd281899c004fbb9c7adc40fb107de9353da1dd0371ea4b53af) // version: v0.6.6-0.20260805202908-e58499ed0924+dirty (go1.26.2) package v1_8 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 { Type uint8 Key uint8 } Value any } } func (ret *EntityMetadata) Decode(r io.ReadSeeker) (err error) { ret.Val = make(map[uint8]struct { Anon struct { Type uint8 Key uint8 } Value any }) var id uint8 for { err = binary.Read(r, binary.BigEndian, &id) if err != nil { return } if id == 127 { break } _, err = r.Seek(-1, io.SeekCurrent) if err != nil { return } var entry struct { Anon struct { Type uint8 Key uint8 } Value any } var EntityMetadataInnerAnonPacked uint8 err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerAnonPacked) if err != nil { return } entry.Anon.Key = EntityMetadataInnerAnonPacked >> 0 & 31 entry.Anon.Type = EntityMetadataInnerAnonPacked >> 5 & 7 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 int16 err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue1Tmp) if err != nil { return } entry.Value = EntityMetadataInnerValue1Tmp case 2: var EntityMetadataInnerValue2Tmp int32 err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue2Tmp) if err != nil { return } entry.Value = EntityMetadataInnerValue2Tmp case 3: var EntityMetadataInnerValue3Tmp float32 err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue3Tmp) 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 struct { X int32 Y int32 Z int32 } err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue6Tmp.X) if err != nil { return } err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue6Tmp.Y) if err != nil { return } err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue6Tmp.Z) 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 } ret.Val[id] = entry } return } func (ret *EntityMetadata) Encode(w io.Writer) (err error) { for _, v := range ret.Val { var EntityMetadataAnonPacked uint8 EntityMetadataAnonPacked |= (uint8(v.Anon.Key) & 0x1F) << 0x0 EntityMetadataAnonPacked |= (uint8(v.Anon.Type) & 0x7) << 0x5 err = binary.Write(w, binary.BigEndian, EntityMetadataAnonPacked) 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.(int16) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataValue) if err != nil { return } case 2: EntityMetadataValue, ok := v.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataValue) if err != nil { return } case 3: EntityMetadataValue, ok := v.Value.(float32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, 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.(struct { X int32 Y int32 Z int32 }) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataValue.X) if err != nil { return } err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Y) if err != nil { return } err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Z) 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 } } } err = binary.Write(w, binary.BigEndian, uint8(127)) 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.Z = int32(PositionPacked >> 0 & 67108863) if ret.Z >= 1<<25 { ret.Z -= 1 << 26 } ret.Y = int16(PositionPacked >> 26 & 4095) if ret.Y >= 1<<11 { ret.Y -= 1 << 12 } ret.X = int32(PositionPacked >> 38 & 67108863) if ret.X >= 1<<25 { ret.X -= 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: "keep_alive", 0x01: "login", 0x02: "chat", 0x03: "update_time", 0x04: "entity_equipment", 0x05: "spawn_position", 0x06: "update_health", 0x07: "respawn", 0x08: "position", 0x09: "held_item_slot", 0x0a: "bed", 0x0b: "animation", 0x0c: "named_entity_spawn", 0x0d: "collect", 0x0e: "spawn_entity", 0x0f: "spawn_entity_living", 0x10: "spawn_entity_painting", 0x11: "spawn_entity_experience_orb", 0x12: "entity_velocity", 0x13: "entity_destroy", 0x14: "entity", 0x15: "rel_entity_move", 0x16: "entity_look", 0x17: "entity_move_look", 0x18: "entity_teleport", 0x19: "entity_head_rotation", 0x1a: "entity_status", 0x1b: "attach_entity", 0x1c: "entity_metadata", 0x1d: "entity_effect", 0x1e: "remove_entity_effect", 0x1f: "experience", 0x20: "update_attributes", 0x21: "map_chunk", 0x22: "multi_block_change", 0x23: "block_change", 0x24: "block_action", 0x25: "block_break_animation", 0x26: "map_chunk_bulk", 0x27: "explosion", 0x28: "world_event", 0x29: "named_sound_effect", 0x2a: "world_particles", 0x2b: "game_state_change", 0x2c: "spawn_entity_weather", 0x2d: "open_window", 0x2e: "close_window", 0x2f: "set_slot", 0x30: "window_items", 0x31: "craft_progress_bar", 0x32: "transaction", 0x33: "update_sign", 0x34: "map", 0x35: "tile_entity_data", 0x36: "open_sign_entity", 0x37: "statistics", 0x38: "player_info", 0x39: "abilities", 0x3a: "tab_complete", 0x3b: "scoreboard_objective", 0x3c: "scoreboard_score", 0x3d: "scoreboard_display_objective", 0x3e: "scoreboard_team", 0x3f: "custom_payload", 0x40: "kick_disconnect", 0x41: "difficulty", 0x42: "combat_event", 0x43: "camera", 0x44: "world_border", 0x45: "title", 0x46: "set_compression", 0x47: "playerlist_header", 0x48: "resource_pack_send", 0x49: "update_entity_nbt"} 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 "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 "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 "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_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 "map_chunk_bulk": var PlayToClientPacketParamsMapChunkBulkTmp PlayToClientPacketMapChunkBulk err = PlayToClientPacketParamsMapChunkBulkTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsMapChunkBulkTmp 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 "scoreboard_team": var PlayToClientPacketParamsScoreboardTeamTmp PlayToClientPacketScoreboardTeam err = PlayToClientPacketParamsScoreboardTeamTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsScoreboardTeamTmp case "set_compression": var PlayToClientPacketParamsSetCompressionTmp PlayToClientPacketSetCompression err = PlayToClientPacketParamsSetCompressionTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetCompressionTmp case "set_slot": var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot err = PlayToClientPacketParamsSetSlotTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetSlotTmp 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 "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 "update_attributes": var PlayToClientPacketParamsUpdateAttributesTmp PlayToClientPacketUpdateAttributes err = PlayToClientPacketParamsUpdateAttributesTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsUpdateAttributesTmp case "update_entity_nbt": var PlayToClientPacketParamsUpdateEntityNbtTmp PlayToClientPacketUpdateEntityNbt err = PlayToClientPacketParamsUpdateEntityNbtTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsUpdateEntityNbtTmp case "update_health": var PlayToClientPacketParamsUpdateHealthTmp PlayToClientPacketUpdateHealth err = PlayToClientPacketParamsUpdateHealthTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsUpdateHealthTmp case "update_sign": var PlayToClientPacketParamsUpdateSignTmp PlayToClientPacketUpdateSign err = PlayToClientPacketParamsUpdateSignTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsUpdateSignTmp case "update_time": var PlayToClientPacketParamsUpdateTimeTmp PlayToClientPacketUpdateTime err = PlayToClientPacketParamsUpdateTimeTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsUpdateTimeTmp 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{"keep_alive": 0x00, "login": 0x01, "chat": 0x02, "update_time": 0x03, "entity_equipment": 0x04, "spawn_position": 0x05, "update_health": 0x06, "respawn": 0x07, "position": 0x08, "held_item_slot": 0x09, "bed": 0x0a, "animation": 0x0b, "named_entity_spawn": 0x0c, "collect": 0x0d, "spawn_entity": 0x0e, "spawn_entity_living": 0x0f, "spawn_entity_painting": 0x10, "spawn_entity_experience_orb": 0x11, "entity_velocity": 0x12, "entity_destroy": 0x13, "entity": 0x14, "rel_entity_move": 0x15, "entity_look": 0x16, "entity_move_look": 0x17, "entity_teleport": 0x18, "entity_head_rotation": 0x19, "entity_status": 0x1a, "attach_entity": 0x1b, "entity_metadata": 0x1c, "entity_effect": 0x1d, "remove_entity_effect": 0x1e, "experience": 0x1f, "update_attributes": 0x20, "map_chunk": 0x21, "multi_block_change": 0x22, "block_change": 0x23, "block_action": 0x24, "block_break_animation": 0x25, "map_chunk_bulk": 0x26, "explosion": 0x27, "world_event": 0x28, "named_sound_effect": 0x29, "world_particles": 0x2a, "game_state_change": 0x2b, "spawn_entity_weather": 0x2c, "open_window": 0x2d, "close_window": 0x2e, "set_slot": 0x2f, "window_items": 0x30, "craft_progress_bar": 0x31, "transaction": 0x32, "update_sign": 0x33, "map": 0x34, "tile_entity_data": 0x35, "open_sign_entity": 0x36, "statistics": 0x37, "player_info": 0x38, "abilities": 0x39, "tab_complete": 0x3a, "scoreboard_objective": 0x3b, "scoreboard_score": 0x3c, "scoreboard_display_objective": 0x3d, "scoreboard_team": 0x3e, "custom_payload": 0x3f, "kick_disconnect": 0x40, "difficulty": 0x41, "combat_event": 0x42, "camera": 0x43, "world_border": 0x44, "title": 0x45, "set_compression": 0x46, "playerlist_header": 0x47, "resource_pack_send": 0x48, "update_entity_nbt": 0x49} 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 "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 "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 "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_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 "map_chunk_bulk": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunkBulk) 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 "scoreboard_team": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardTeam) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "set_compression": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCompression) 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 "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 "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 "update_attributes": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateAttributes) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "update_entity_nbt": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateEntityNbt) 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_sign": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateSign) 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 "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 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 Leash bool } 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 } err = binary.Read(r, binary.BigEndian, &ret.Leash) 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 } err = binary.Write(w, binary.BigEndian, ret.Leash) 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 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 } 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 } 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 } 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 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 bool } 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 int16 Item Slot } func (ret *PlayToClientPacketEntityEquipment) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) 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 *PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.EntityId) if err != nil { return } err = binary.Write(w, binary.BigEndian, 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 int8 DY int8 DZ int8 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 int32 Y int32 Z int32 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 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 int32 } func (ret *PlayToClientPacketKeepAlive) Decode(r io.ReadSeeker) (err error) { ret.KeepAliveId, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketKeepAlive) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, 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 int8 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 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 } 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 = 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 uint16 ChunkData []byte } 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 } err = binary.Read(r, binary.BigEndian, &ret.BitMap) 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 } 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 = binary.Write(w, binary.BigEndian, 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 } return } type PlayToClientPacketMapChunkBulk struct { SkyLightSent bool Meta []struct { X int32 Z int32 BitMap uint16 } Data proto_base.RestBuffer } func (ret *PlayToClientPacketMapChunkBulk) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.SkyLightSent) if err != nil { return } var lPlayToClientPacketMapChunkBulkMeta int32 lPlayToClientPacketMapChunkBulkMeta, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Meta = []struct { X int32 Z int32 BitMap uint16 }{} for range lPlayToClientPacketMapChunkBulkMeta { var PlayToClientPacketMapChunkBulkMetaElement struct { X int32 Z int32 BitMap uint16 } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBulkMetaElement.X) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBulkMetaElement.Z) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBulkMetaElement.BitMap) if err != nil { return } ret.Meta = append(ret.Meta, PlayToClientPacketMapChunkBulkMetaElement) } err = ret.Data.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketMapChunkBulk) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.SkyLightSent) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Meta))) if err != nil { return } for iPlayToClientPacketMapChunkBulkMeta := range len(ret.Meta) { err = binary.Write(w, binary.BigEndian, ret.Meta[iPlayToClientPacketMapChunkBulkMeta].X) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Meta[iPlayToClientPacketMapChunkBulkMeta].Z) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Meta[iPlayToClientPacketMapChunkBulkMeta].BitMap) if err != nil { return } } PlayToClientPacketMapChunkBulkDataEncTmp := ret.Data err = PlayToClientPacketMapChunkBulkDataEncTmp.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 int32 Y int32 Z int32 Yaw int8 Pitch int8 CurrentItem int16 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 = binary.Read(r, binary.BigEndian, &ret.CurrentItem) 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 } err = binary.Write(w, binary.BigEndian, ret.CurrentItem) if err != nil { return } PlayToClientPacketNamedEntitySpawnMetadataEncTmp := ret.Metadata err = PlayToClientPacketNamedEntitySpawnMetadataEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketNamedSoundEffect struct { SoundName string X int32 Y int32 Z int32 Volume float32 Pitch uint8 } func (ret *PlayToClientPacketNamedSoundEffect) Decode(r io.ReadSeeker) (err error) { ret.SoundName, err = proto_base.DecodeString(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 = 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 } 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 } 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 } return } type PlayToClientPacketRelEntityMove struct { EntityId int32 DX int8 DY int8 DZ int8 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 PlayToClientPacketScoreboardTeam struct { Team string Mode int8 Name any Prefix any Suffix any FriendlyFire any NameTagVisibility any Color any Players any } func (ret *PlayToClientPacketScoreboardTeam) 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 PlayToClientPacketScoreboardTeamName0Tmp string PlayToClientPacketScoreboardTeamName0Tmp, err = proto_base.DecodeString(r) if err != nil { return } ret.Name = PlayToClientPacketScoreboardTeamName0Tmp case 2: var PlayToClientPacketScoreboardTeamName2Tmp string PlayToClientPacketScoreboardTeamName2Tmp, err = proto_base.DecodeString(r) if err != nil { return } ret.Name = PlayToClientPacketScoreboardTeamName2Tmp default: var PlayToClientPacketScoreboardTeamNameTmp struct { } ret.Name = PlayToClientPacketScoreboardTeamNameTmp } switch ret.Mode { case 0: var PlayToClientPacketScoreboardTeamPrefix0Tmp string PlayToClientPacketScoreboardTeamPrefix0Tmp, err = proto_base.DecodeString(r) if err != nil { return } ret.Prefix = PlayToClientPacketScoreboardTeamPrefix0Tmp case 2: var PlayToClientPacketScoreboardTeamPrefix2Tmp string PlayToClientPacketScoreboardTeamPrefix2Tmp, err = proto_base.DecodeString(r) if err != nil { return } ret.Prefix = PlayToClientPacketScoreboardTeamPrefix2Tmp default: var PlayToClientPacketScoreboardTeamPrefixTmp struct { } ret.Prefix = PlayToClientPacketScoreboardTeamPrefixTmp } switch ret.Mode { case 0: var PlayToClientPacketScoreboardTeamSuffix0Tmp string PlayToClientPacketScoreboardTeamSuffix0Tmp, err = proto_base.DecodeString(r) if err != nil { return } ret.Suffix = PlayToClientPacketScoreboardTeamSuffix0Tmp case 2: var PlayToClientPacketScoreboardTeamSuffix2Tmp string PlayToClientPacketScoreboardTeamSuffix2Tmp, err = proto_base.DecodeString(r) if err != nil { return } ret.Suffix = PlayToClientPacketScoreboardTeamSuffix2Tmp default: var PlayToClientPacketScoreboardTeamSuffixTmp struct { } ret.Suffix = PlayToClientPacketScoreboardTeamSuffixTmp } switch ret.Mode { case 0: var PlayToClientPacketScoreboardTeamFriendlyFire0Tmp int8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardTeamFriendlyFire0Tmp) if err != nil { return } ret.FriendlyFire = PlayToClientPacketScoreboardTeamFriendlyFire0Tmp case 2: var PlayToClientPacketScoreboardTeamFriendlyFire2Tmp int8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardTeamFriendlyFire2Tmp) if err != nil { return } ret.FriendlyFire = PlayToClientPacketScoreboardTeamFriendlyFire2Tmp default: var PlayToClientPacketScoreboardTeamFriendlyFireTmp struct { } ret.FriendlyFire = PlayToClientPacketScoreboardTeamFriendlyFireTmp } switch ret.Mode { case 0: var PlayToClientPacketScoreboardTeamNameTagVisibility0Tmp string PlayToClientPacketScoreboardTeamNameTagVisibility0Tmp, err = proto_base.DecodeString(r) if err != nil { return } ret.NameTagVisibility = PlayToClientPacketScoreboardTeamNameTagVisibility0Tmp case 2: var PlayToClientPacketScoreboardTeamNameTagVisibility2Tmp string PlayToClientPacketScoreboardTeamNameTagVisibility2Tmp, err = proto_base.DecodeString(r) if err != nil { return } ret.NameTagVisibility = PlayToClientPacketScoreboardTeamNameTagVisibility2Tmp default: var PlayToClientPacketScoreboardTeamNameTagVisibilityTmp struct { } ret.NameTagVisibility = PlayToClientPacketScoreboardTeamNameTagVisibilityTmp } switch ret.Mode { case 0: var PlayToClientPacketScoreboardTeamColor0Tmp int8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardTeamColor0Tmp) if err != nil { return } ret.Color = PlayToClientPacketScoreboardTeamColor0Tmp case 2: var PlayToClientPacketScoreboardTeamColor2Tmp int8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardTeamColor2Tmp) if err != nil { return } ret.Color = PlayToClientPacketScoreboardTeamColor2Tmp default: var PlayToClientPacketScoreboardTeamColorTmp struct { } ret.Color = PlayToClientPacketScoreboardTeamColorTmp } switch ret.Mode { case 0: var PlayToClientPacketScoreboardTeamPlayers0Tmp []string var lPlayToClientPacketScoreboardTeamPlayers0Tmp int32 lPlayToClientPacketScoreboardTeamPlayers0Tmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketScoreboardTeamPlayers0Tmp = []string{} for range lPlayToClientPacketScoreboardTeamPlayers0Tmp { var PlayToClientPacketScoreboardTeamPlayers0TmpElement string PlayToClientPacketScoreboardTeamPlayers0TmpElement, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketScoreboardTeamPlayers0Tmp = append(PlayToClientPacketScoreboardTeamPlayers0Tmp, PlayToClientPacketScoreboardTeamPlayers0TmpElement) } ret.Players = PlayToClientPacketScoreboardTeamPlayers0Tmp case 3: var PlayToClientPacketScoreboardTeamPlayers3Tmp []string var lPlayToClientPacketScoreboardTeamPlayers3Tmp int32 lPlayToClientPacketScoreboardTeamPlayers3Tmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketScoreboardTeamPlayers3Tmp = []string{} for range lPlayToClientPacketScoreboardTeamPlayers3Tmp { var PlayToClientPacketScoreboardTeamPlayers3TmpElement string PlayToClientPacketScoreboardTeamPlayers3TmpElement, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketScoreboardTeamPlayers3Tmp = append(PlayToClientPacketScoreboardTeamPlayers3Tmp, PlayToClientPacketScoreboardTeamPlayers3TmpElement) } ret.Players = PlayToClientPacketScoreboardTeamPlayers3Tmp case 4: var PlayToClientPacketScoreboardTeamPlayers4Tmp []string var lPlayToClientPacketScoreboardTeamPlayers4Tmp int32 lPlayToClientPacketScoreboardTeamPlayers4Tmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketScoreboardTeamPlayers4Tmp = []string{} for range lPlayToClientPacketScoreboardTeamPlayers4Tmp { var PlayToClientPacketScoreboardTeamPlayers4TmpElement string PlayToClientPacketScoreboardTeamPlayers4TmpElement, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketScoreboardTeamPlayers4Tmp = append(PlayToClientPacketScoreboardTeamPlayers4Tmp, PlayToClientPacketScoreboardTeamPlayers4TmpElement) } ret.Players = PlayToClientPacketScoreboardTeamPlayers4Tmp default: var PlayToClientPacketScoreboardTeamPlayersTmp struct { } ret.Players = PlayToClientPacketScoreboardTeamPlayersTmp } return } func (ret *PlayToClientPacketScoreboardTeam) 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: PlayToClientPacketScoreboardTeamName, ok := ret.Name.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamName) if err != nil { return } case 2: PlayToClientPacketScoreboardTeamName, ok := ret.Name.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamName) if err != nil { return } default: _, ok := ret.Name.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Mode { case 0: PlayToClientPacketScoreboardTeamPrefix, ok := ret.Prefix.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPrefix) if err != nil { return } case 2: PlayToClientPacketScoreboardTeamPrefix, ok := ret.Prefix.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPrefix) if err != nil { return } default: _, ok := ret.Prefix.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Mode { case 0: PlayToClientPacketScoreboardTeamSuffix, ok := ret.Suffix.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamSuffix) if err != nil { return } case 2: PlayToClientPacketScoreboardTeamSuffix, ok := ret.Suffix.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamSuffix) if err != nil { return } default: _, ok := ret.Suffix.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Mode { case 0: PlayToClientPacketScoreboardTeamFriendlyFire, ok := ret.FriendlyFire.(int8) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardTeamFriendlyFire) if err != nil { return } case 2: PlayToClientPacketScoreboardTeamFriendlyFire, ok := ret.FriendlyFire.(int8) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardTeamFriendlyFire) if err != nil { return } default: _, ok := ret.FriendlyFire.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Mode { case 0: PlayToClientPacketScoreboardTeamNameTagVisibility, ok := ret.NameTagVisibility.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamNameTagVisibility) if err != nil { return } case 2: PlayToClientPacketScoreboardTeamNameTagVisibility, ok := ret.NameTagVisibility.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamNameTagVisibility) if err != nil { return } default: _, ok := ret.NameTagVisibility.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Mode { case 0: PlayToClientPacketScoreboardTeamColor, ok := ret.Color.(int8) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardTeamColor) if err != nil { return } case 2: PlayToClientPacketScoreboardTeamColor, ok := ret.Color.(int8) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardTeamColor) if err != nil { return } default: _, ok := ret.Color.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Mode { case 0: PlayToClientPacketScoreboardTeamPlayers, ok := ret.Players.([]string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketScoreboardTeamPlayers))) if err != nil { return } for iPlayToClientPacketScoreboardTeamPlayers := range len(PlayToClientPacketScoreboardTeamPlayers) { err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPlayers[iPlayToClientPacketScoreboardTeamPlayers]) if err != nil { return } } case 3: PlayToClientPacketScoreboardTeamPlayers, ok := ret.Players.([]string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketScoreboardTeamPlayers))) if err != nil { return } for iPlayToClientPacketScoreboardTeamPlayers := range len(PlayToClientPacketScoreboardTeamPlayers) { err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPlayers[iPlayToClientPacketScoreboardTeamPlayers]) if err != nil { return } } case 4: PlayToClientPacketScoreboardTeamPlayers, ok := ret.Players.([]string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketScoreboardTeamPlayers))) if err != nil { return } for iPlayToClientPacketScoreboardTeamPlayers := range len(PlayToClientPacketScoreboardTeamPlayers) { err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPlayers[iPlayToClientPacketScoreboardTeamPlayers]) if err != nil { return } } default: _, ok := ret.Players.(struct { }) if !ok { err = proto_base.BadTypeError return } } return } type PlayToClientPacketSetCompression struct { Threshold int32 } func (ret *PlayToClientPacketSetCompression) Decode(r io.ReadSeeker) (err error) { ret.Threshold, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketSetCompression) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Threshold) 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 PlayToClientPacketSpawnEntity struct { EntityId int32 Type int8 X int32 Y int32 Z int32 Pitch int8 Yaw int8 ObjectData int32 Velocity any } func (ret *PlayToClientPacketSpawnEntity) 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 } 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 } switch ret.ObjectData { case 0: var PlayToClientPacketSpawnEntityVelocity0Tmp struct { } ret.Velocity = PlayToClientPacketSpawnEntityVelocity0Tmp default: var PlayToClientPacketSpawnEntityVelocityTmp Vec3i16 err = PlayToClientPacketSpawnEntityVelocityTmp.Decode(r) if err != nil { return } ret.Velocity = PlayToClientPacketSpawnEntityVelocityTmp } return } func (ret *PlayToClientPacketSpawnEntity) 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 } 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 } switch ret.ObjectData { case 0: _, ok := ret.Velocity.(struct { }) if !ok { err = proto_base.BadTypeError return } default: _, ok := ret.Velocity.(Vec3i16) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketSpawnEntityVelocityEncTmp := ret.Velocity.(Vec3i16) err = PlayToClientPacketSpawnEntityVelocityEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketSpawnEntityExperienceOrb struct { EntityId int32 X int32 Y int32 Z int32 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 Type uint8 X int32 Y int32 Z int32 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 = 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.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 = 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.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 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 } 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 = 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 int32 Y int32 Z int32 } 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 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 default: var PlayToClientPacketTitleTextTmp struct { } ret.Text = PlayToClientPacketTitleTextTmp } switch ret.Action { case 2: var PlayToClientPacketTitleFadeIn2Tmp int32 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleFadeIn2Tmp) if err != nil { return } ret.FadeIn = PlayToClientPacketTitleFadeIn2Tmp default: var PlayToClientPacketTitleFadeInTmp struct { } ret.FadeIn = PlayToClientPacketTitleFadeInTmp } switch ret.Action { case 2: var PlayToClientPacketTitleStay2Tmp int32 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleStay2Tmp) if err != nil { return } ret.Stay = PlayToClientPacketTitleStay2Tmp default: var PlayToClientPacketTitleStayTmp struct { } ret.Stay = PlayToClientPacketTitleStayTmp } switch ret.Action { case 2: var PlayToClientPacketTitleFadeOut2Tmp int32 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleFadeOut2Tmp) if err != nil { return } ret.FadeOut = PlayToClientPacketTitleFadeOut2Tmp 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 } default: _, ok := ret.Text.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action { case 2: 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 2: 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 2: 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 PlayToClientPacketUpdateAttributes struct { EntityId int32 Properties []struct { Key string Value float64 Modifiers []struct { Uuid uuid.UUID Amount float64 Operation int8 } } } func (ret *PlayToClientPacketUpdateAttributes) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } var lPlayToClientPacketUpdateAttributesProperties int32 err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketUpdateAttributesProperties) if err != nil { return } ret.Properties = []struct { Key string Value float64 Modifiers []struct { Uuid uuid.UUID Amount float64 Operation int8 } }{} for range lPlayToClientPacketUpdateAttributesProperties { var PlayToClientPacketUpdateAttributesPropertiesElement struct { Key string Value float64 Modifiers []struct { Uuid uuid.UUID Amount float64 Operation int8 } } PlayToClientPacketUpdateAttributesPropertiesElement.Key, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateAttributesPropertiesElement.Value) if err != nil { return } var lPlayToClientPacketUpdateAttributesPropertiesElementModifiers int32 lPlayToClientPacketUpdateAttributesPropertiesElementModifiers, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketUpdateAttributesPropertiesElement.Modifiers = []struct { Uuid uuid.UUID Amount float64 Operation int8 }{} for range lPlayToClientPacketUpdateAttributesPropertiesElementModifiers { var PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement struct { Uuid uuid.UUID Amount float64 Operation int8 } _, err = io.ReadFull(r, PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement.Uuid[:]) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement.Amount) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement.Operation) if err != nil { return } PlayToClientPacketUpdateAttributesPropertiesElement.Modifiers = append(PlayToClientPacketUpdateAttributesPropertiesElement.Modifiers, PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement) } ret.Properties = append(ret.Properties, PlayToClientPacketUpdateAttributesPropertiesElement) } return } func (ret *PlayToClientPacketUpdateAttributes) 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 iPlayToClientPacketUpdateAttributesProperties := range len(ret.Properties) { err = proto_base.EncodeString(w, ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Value) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers))) if err != nil { return } for iPlayToClientPacketUpdateAttributesPropertiesInnerModifiers := range len(ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers) { _, err = w.Write(ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers[iPlayToClientPacketUpdateAttributesPropertiesInnerModifiers].Uuid[:]) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers[iPlayToClientPacketUpdateAttributesPropertiesInnerModifiers].Amount) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers[iPlayToClientPacketUpdateAttributesPropertiesInnerModifiers].Operation) if err != nil { return } } } return } type PlayToClientPacketUpdateEntityNbt struct { EntityId int32 Tag nbt.Tag } func (ret *PlayToClientPacketUpdateEntityNbt) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = ret.Tag.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketUpdateEntityNbt) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.EntityId) if err != nil { return } PlayToClientPacketUpdateEntityNbtTagEncTmp := ret.Tag err = PlayToClientPacketUpdateEntityNbtTagEncTmp.Encode(w) if err != nil { 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 PlayToClientPacketUpdateSign struct { Location Position Text1 string Text2 string Text3 string Text4 string } func (ret *PlayToClientPacketUpdateSign) 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 *PlayToClientPacketUpdateSign) Encode(w io.Writer) (err error) { PlayToClientPacketUpdateSignLocationEncTmp := ret.Location err = PlayToClientPacketUpdateSignLocationEncTmp.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 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 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: "keep_alive", 0x01: "chat", 0x02: "use_entity", 0x03: "flying", 0x04: "position", 0x05: "look", 0x06: "position_look", 0x07: "block_dig", 0x08: "block_place", 0x09: "held_item_slot", 0x0a: "arm_animation", 0x0b: "entity_action", 0x0c: "steer_vehicle", 0x0d: "close_window", 0x0e: "window_click", 0x0f: "transaction", 0x10: "set_creative_slot", 0x11: "enchant_item", 0x12: "update_sign", 0x13: "abilities", 0x14: "tab_complete", 0x15: "settings", 0x16: "client_command", 0x17: "custom_payload", 0x18: "spectate", 0x19: "resource_pack_receive"} 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 "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 "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_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 "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 "window_click": var PlayToServerPacketParamsWindowClickTmp PlayToServerPacketWindowClick err = PlayToServerPacketParamsWindowClickTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsWindowClickTmp } return } var PlayToServerPacketNameReverseMap = map[string]int32{"keep_alive": 0x00, "chat": 0x01, "use_entity": 0x02, "flying": 0x03, "position": 0x04, "look": 0x05, "position_look": 0x06, "block_dig": 0x07, "block_place": 0x08, "held_item_slot": 0x09, "arm_animation": 0x0a, "entity_action": 0x0b, "steer_vehicle": 0x0c, "close_window": 0x0d, "window_click": 0x0e, "transaction": 0x0f, "set_creative_slot": 0x10, "enchant_item": 0x11, "update_sign": 0x12, "abilities": 0x13, "tab_complete": 0x14, "settings": 0x15, "client_command": 0x16, "custom_payload": 0x17, "spectate": 0x18, "resource_pack_receive": 0x19} 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 "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 "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_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 "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 "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 PlayToServerPacketArmAnimation struct { } func (ret *PlayToServerPacketArmAnimation) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToServerPacketArmAnimation) Encode(w io.Writer) (err error) { 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 int8 HeldItem Slot CursorX int8 CursorY int8 CursorZ int8 } func (ret *PlayToServerPacketBlockPlace) Decode(r io.ReadSeeker) (err error) { err = ret.Location.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Direction) if err != nil { return } err = ret.HeldItem.Decode(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 = binary.Write(w, binary.BigEndian, ret.Direction) if err != nil { return } PlayToServerPacketBlockPlaceHeldItemEncTmp := ret.HeldItem err = PlayToServerPacketBlockPlaceHeldItemEncTmp.Encode(w) 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 { Payload int32 } func (ret *PlayToServerPacketClientCommand) Decode(r io.ReadSeeker) (err error) { ret.Payload, 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.Payload) 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 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 int32 } func (ret *PlayToServerPacketKeepAlive) Decode(r io.ReadSeeker) (err error) { ret.KeepAliveId, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToServerPacketKeepAlive) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, 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 { Hash string Result int32 } func (ret *PlayToServerPacketResourcePackReceive) Decode(r io.ReadSeeker) (err error) { ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } ret.Result, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } 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 int8 ChatColors bool SkinParts uint8 } 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 } err = binary.Read(r, binary.BigEndian, &ret.ChatFlags) 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 } 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 = binary.Write(w, binary.BigEndian, 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 } 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 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 Block *Position } func (ret *PlayToServerPacketTabComplete) Decode(r io.ReadSeeker) (err error) { ret.Text, err = proto_base.DecodeString(r) if err != nil { return } var PlayToServerPacketTabCompleteBlockPresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTabCompleteBlockPresent) if err != nil { return } if PlayToServerPacketTabCompleteBlockPresent { var PlayToServerPacketTabCompleteBlockPresentValue Position err = PlayToServerPacketTabCompleteBlockPresentValue.Decode(r) if err != nil { return } ret.Block = &PlayToServerPacketTabCompleteBlockPresentValue } 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.Block != nil) if err != nil { return } if ret.Block != nil { PlayToServerPacketTabCompleteBlockEncTmp := *ret.Block err = PlayToServerPacketTabCompleteBlockEncTmp.Encode(w) 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 } 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 } 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 } } 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 }