OpenCode
f4c2762881
- Add with_any_potion (id 2), only_with_component (id 3), dyed (id 7) - Shift existing IDs: item 2→4, item_stack 3→5, tag 4→6, smithing_trim 5→8, with_remainder 6→9, composite 7→10 - RecipeBookAdd now decodes successfully (was index not found) - Verified against decompiled client jar via SlotDisplays.bootstrap()
14077 lines
368 KiB
Go
14077 lines
368 KiB
Go
// Code generated by strom. DO NOT EDIT.
|
|
// source: minecraft-data/pc/1.14.4/protocol.json (sha256:b6edff5abaaf234037b5019024d749e27e746250a23253bb4ad77d8f76e93167)
|
|
// version: v0.6.6-0.20260805175346-53d366ae5301+dirty (go1.26.2)
|
|
package v1_14_4
|
|
|
|
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 CommandNode struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
HasCustomSuggestions bool
|
|
HasRedirectNode bool
|
|
HasCommand bool
|
|
CommandNodeType uint8
|
|
}
|
|
Children []int32
|
|
RedirectNode any
|
|
ExtraNodeData any
|
|
}
|
|
|
|
func (ret *CommandNode) Decode(r io.ReadSeeker) (err error) {
|
|
var CommandNodeFlagsPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags.Unused = CommandNodeFlagsPacked << 0 >> 5
|
|
ret.Flags.HasCustomSuggestions = CommandNodeFlagsPacked<<3>>7 == 1
|
|
ret.Flags.HasRedirectNode = CommandNodeFlagsPacked<<4>>7 == 1
|
|
ret.Flags.HasCommand = CommandNodeFlagsPacked<<5>>7 == 1
|
|
ret.Flags.CommandNodeType = CommandNodeFlagsPacked << 6 >> 6
|
|
var lCommandNodeChildren int32
|
|
lCommandNodeChildren, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Children = []int32{}
|
|
for range lCommandNodeChildren {
|
|
var CommandNodeChildrenElement int32
|
|
CommandNodeChildrenElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Children = append(ret.Children, CommandNodeChildrenElement)
|
|
}
|
|
switch ret.Flags.HasRedirectNode {
|
|
case true:
|
|
var CommandNodeRedirectNode1Tmp int32
|
|
CommandNodeRedirectNode1Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RedirectNode = CommandNodeRedirectNode1Tmp
|
|
default:
|
|
var CommandNodeRedirectNodeTmp struct {
|
|
}
|
|
ret.RedirectNode = CommandNodeRedirectNodeTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *CommandNode) Encode(w io.Writer) (err error) {
|
|
var CommandNodeFlagsPacked uint8
|
|
CommandNodeFlagsPacked |= (uint8(ret.Flags.CommandNodeType) & 0x3) << 0x0
|
|
CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasCommand) & 0x1) << 0x2
|
|
CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasRedirectNode) & 0x1) << 0x3
|
|
CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasCustomSuggestions) & 0x1) << 0x4
|
|
CommandNodeFlagsPacked |= (uint8(ret.Flags.Unused) & 0x7) << 0x5
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Children)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iCommandNodeChildren := range len(ret.Children) {
|
|
err = proto_base.EncodeVarInt(w, ret.Children[iCommandNodeChildren])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags.HasRedirectNode {
|
|
case true:
|
|
CommandNodeRedirectNode, ok := ret.RedirectNode.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, CommandNodeRedirectNode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.RedirectNode.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadata struct {
|
|
Val map[byte]struct {
|
|
Anon struct {
|
|
Key uint8
|
|
Type int32
|
|
}
|
|
Value any
|
|
}
|
|
}
|
|
|
|
func (ret *EntityMetadata) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Val = make(map[uint8]struct {
|
|
Anon struct {
|
|
Key uint8
|
|
Type int32
|
|
}
|
|
Value any
|
|
})
|
|
var id uint8
|
|
for {
|
|
err = binary.Read(r, binary.BigEndian, &id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if id == 255 {
|
|
break
|
|
}
|
|
_, err = r.Seek(-1, io.SeekCurrent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var entry struct {
|
|
Anon struct {
|
|
Key uint8
|
|
Type int32
|
|
}
|
|
Value any
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &entry.Anon.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Anon.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch entry.Anon.Type {
|
|
case 0:
|
|
var EntityMetadataInnerValue0Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue0Tmp
|
|
case 1:
|
|
var EntityMetadataInnerValue1Tmp int32
|
|
EntityMetadataInnerValue1Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue1Tmp
|
|
case 10:
|
|
var EntityMetadataInnerValue10Tmp *Position
|
|
var EntityMetadataInnerValue10TmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue10TmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataInnerValue10TmpPresent {
|
|
var EntityMetadataInnerValue10TmpPresentValue Position
|
|
err = EntityMetadataInnerValue10TmpPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataInnerValue10Tmp = &EntityMetadataInnerValue10TmpPresentValue
|
|
}
|
|
entry.Value = EntityMetadataInnerValue10Tmp
|
|
case 11:
|
|
var EntityMetadataInnerValue11Tmp int32
|
|
EntityMetadataInnerValue11Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue11Tmp
|
|
case 12:
|
|
var EntityMetadataInnerValue12Tmp *uuid.UUID
|
|
var EntityMetadataInnerValue12TmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue12TmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataInnerValue12TmpPresent {
|
|
var EntityMetadataInnerValue12TmpPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, EntityMetadataInnerValue12TmpPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataInnerValue12Tmp = &EntityMetadataInnerValue12TmpPresentValue
|
|
}
|
|
entry.Value = EntityMetadataInnerValue12Tmp
|
|
case 13:
|
|
var EntityMetadataInnerValue13Tmp int32
|
|
EntityMetadataInnerValue13Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue13Tmp
|
|
case 14:
|
|
var EntityMetadataInnerValue14Tmp nbt.Tag
|
|
err = EntityMetadataInnerValue14Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue14Tmp
|
|
case 15:
|
|
var EntityMetadataInnerValue15Tmp Particle
|
|
err = EntityMetadataInnerValue15Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue15Tmp
|
|
case 16:
|
|
var EntityMetadataInnerValue16Tmp struct {
|
|
VillagerType int32
|
|
VillagerProfession int32
|
|
Level int32
|
|
}
|
|
EntityMetadataInnerValue16Tmp.VillagerType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataInnerValue16Tmp.VillagerProfession, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataInnerValue16Tmp.Level, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue16Tmp
|
|
case 17:
|
|
var EntityMetadataInnerValue17Tmp Optvarint
|
|
err = EntityMetadataInnerValue17Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue17Tmp
|
|
case 18:
|
|
var EntityMetadataInnerValue18Tmp int32
|
|
EntityMetadataInnerValue18Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue18Tmp
|
|
case 2:
|
|
var EntityMetadataInnerValue2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue2Tmp
|
|
case 3:
|
|
var EntityMetadataInnerValue3Tmp string
|
|
EntityMetadataInnerValue3Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue3Tmp
|
|
case 4:
|
|
var EntityMetadataInnerValue4Tmp string
|
|
EntityMetadataInnerValue4Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue4Tmp
|
|
case 5:
|
|
var EntityMetadataInnerValue5Tmp *string
|
|
var EntityMetadataInnerValue5TmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue5TmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataInnerValue5TmpPresent {
|
|
var EntityMetadataInnerValue5TmpPresentValue string
|
|
EntityMetadataInnerValue5TmpPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataInnerValue5Tmp = &EntityMetadataInnerValue5TmpPresentValue
|
|
}
|
|
entry.Value = EntityMetadataInnerValue5Tmp
|
|
case 6:
|
|
var EntityMetadataInnerValue6Tmp Slot
|
|
err = EntityMetadataInnerValue6Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue6Tmp
|
|
case 7:
|
|
var EntityMetadataInnerValue7Tmp bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue7Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue7Tmp
|
|
case 8:
|
|
var EntityMetadataInnerValue8Tmp struct {
|
|
Pitch float32
|
|
Yaw float32
|
|
Roll float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue8Tmp.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue8Tmp.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue8Tmp.Roll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue8Tmp
|
|
case 9:
|
|
var EntityMetadataInnerValue9Tmp Position
|
|
err = EntityMetadataInnerValue9Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
entry.Value = EntityMetadataInnerValue9Tmp
|
|
}
|
|
ret.Val[id] = entry
|
|
}
|
|
return
|
|
}
|
|
func (ret *EntityMetadata) Encode(w io.Writer) (err error) {
|
|
for _, v := range ret.Val {
|
|
err = binary.Write(w, binary.BigEndian, v.Anon.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, v.Anon.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch v.Anon.Type {
|
|
case 0:
|
|
EntityMetadataValue, ok := v.Value.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
EntityMetadataValue, ok := v.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 10:
|
|
EntityMetadataValue, ok := v.Value.(*Position)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataValue != nil {
|
|
EntityMetadataValueEncTmp := *EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 11:
|
|
EntityMetadataValue, ok := v.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 12:
|
|
EntityMetadataValue, ok := v.Value.(*uuid.UUID)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataValue != nil {
|
|
_, err = w.Write((*EntityMetadataValue)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 13:
|
|
EntityMetadataValue, ok := v.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 14:
|
|
EntityMetadataValue, ok := v.Value.(nbt.Tag)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataValueEncTmp := EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 15:
|
|
EntityMetadataValue, ok := v.Value.(Particle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataValueEncTmp := EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 16:
|
|
EntityMetadataValue, ok := v.Value.(struct {
|
|
VillagerType int32
|
|
VillagerProfession int32
|
|
Level int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue.VillagerType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue.VillagerProfession)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue.Level)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 17:
|
|
EntityMetadataValue, ok := v.Value.(Optvarint)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataValueEncTmp := EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 18:
|
|
EntityMetadataValue, ok := v.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
EntityMetadataValue, ok := v.Value.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
EntityMetadataValue, ok := v.Value.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
EntityMetadataValue, ok := v.Value.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 5:
|
|
EntityMetadataValue, ok := v.Value.(*string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataValue != nil {
|
|
err = proto_base.EncodeString(w, *EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 6:
|
|
EntityMetadataValue, ok := v.Value.(Slot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataValueEncTmp := EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 7:
|
|
EntityMetadataValue, ok := v.Value.(bool)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 8:
|
|
EntityMetadataValue, ok := v.Value.(struct {
|
|
Pitch float32
|
|
Yaw float32
|
|
Roll float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Roll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 9:
|
|
EntityMetadataValue, ok := v.Value.(Position)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataValueEncTmp := EntityMetadataValue
|
|
err = EntityMetadataValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, uint8(255))
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadataItem struct {
|
|
Val any
|
|
}
|
|
|
|
func (ret *EntityMetadataItem) Decode(r io.ReadSeeker) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret *EntityMetadataItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type Ingredient struct {
|
|
Val []Slot
|
|
}
|
|
|
|
func (ret *Ingredient) Decode(r io.ReadSeeker) (err error) {
|
|
var lIngredient int32
|
|
lIngredient, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []Slot{}
|
|
for range lIngredient {
|
|
var IngredientElement Slot
|
|
err = IngredientElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = append(ret.Val, IngredientElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *Ingredient) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iIngredient := range len(ret.Val) {
|
|
IngredientInnerEncTmp := ret.Val[iIngredient]
|
|
err = IngredientInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type MinecraftSmeltingFormat struct {
|
|
Group string
|
|
Ingredient Ingredient
|
|
Result Slot
|
|
Experience float32
|
|
CookTime int32
|
|
}
|
|
|
|
func (ret *MinecraftSmeltingFormat) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Group, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Ingredient.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Experience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CookTime, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *MinecraftSmeltingFormat) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Group)
|
|
if err != nil {
|
|
return
|
|
}
|
|
MinecraftSmeltingFormatIngredientEncTmp := ret.Ingredient
|
|
err = MinecraftSmeltingFormatIngredientEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
MinecraftSmeltingFormatResultEncTmp := ret.Result
|
|
err = MinecraftSmeltingFormatResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Experience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.CookTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Optvarint struct {
|
|
Val int32
|
|
}
|
|
|
|
func (ret *Optvarint) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Val, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *Optvarint) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Particle struct {
|
|
ParticleId int32
|
|
Data any
|
|
}
|
|
|
|
func (ret *Particle) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ParticleId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.ParticleId {
|
|
case 14:
|
|
var ParticleData14Tmp struct {
|
|
Red float32
|
|
Green float32
|
|
Blue float32
|
|
Scale float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleData14Tmp.Red)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleData14Tmp.Green)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleData14Tmp.Blue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleData14Tmp.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleData14Tmp
|
|
case 23:
|
|
var ParticleData23Tmp struct {
|
|
BlockState int32
|
|
}
|
|
ParticleData23Tmp.BlockState, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleData23Tmp
|
|
case 3:
|
|
var ParticleData3Tmp struct {
|
|
BlockState int32
|
|
}
|
|
ParticleData3Tmp.BlockState, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleData3Tmp
|
|
case 32:
|
|
var ParticleData32Tmp struct {
|
|
Item Slot
|
|
}
|
|
err = ParticleData32Tmp.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleData32Tmp
|
|
default:
|
|
var ParticleDataTmp struct {
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *Particle) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ParticleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.ParticleId {
|
|
case 14:
|
|
ParticleData, ok := ret.Data.(struct {
|
|
Red float32
|
|
Green float32
|
|
Blue float32
|
|
Scale float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Red)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Green)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Blue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 23:
|
|
ParticleData, ok := ret.Data.(struct {
|
|
BlockState int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleData.BlockState)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
ParticleData, ok := ret.Data.(struct {
|
|
BlockState int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleData.BlockState)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 32:
|
|
ParticleData, ok := ret.Data.(struct {
|
|
Item Slot
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ParticleDataItemEncTmp := ParticleData.Item
|
|
err = ParticleDataItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ParticleData struct {
|
|
Val any
|
|
}
|
|
|
|
func (ret *ParticleData) Decode(r io.ReadSeeker) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret *ParticleData) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type Position struct {
|
|
X int32
|
|
Z int32
|
|
Y int16
|
|
}
|
|
|
|
func (ret *Position) Decode(r io.ReadSeeker) (err error) {
|
|
var PositionPacked uint64
|
|
err = binary.Read(r, binary.BigEndian, &PositionPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = int32(PositionPacked << 0 >> 38)
|
|
if ret.X >= 1<<25 {
|
|
ret.X -= 1 << 26
|
|
}
|
|
ret.Z = int32(PositionPacked << 26 >> 38)
|
|
if ret.Z >= 1<<25 {
|
|
ret.Z -= 1 << 26
|
|
}
|
|
ret.Y = int16(PositionPacked << 52 >> 52)
|
|
if ret.Y >= 1<<11 {
|
|
ret.Y -= 1 << 12
|
|
}
|
|
return
|
|
}
|
|
func (ret *Position) Encode(w io.Writer) (err error) {
|
|
var PositionPacked uint64
|
|
PositionPacked |= (uint64(ret.Y) & 0xFFF) << 0x0
|
|
PositionPacked |= (uint64(ret.Z) & 0x3FFFFFF) << 0xC
|
|
PositionPacked |= (uint64(ret.X) & 0x3FFFFFF) << 0x26
|
|
err = binary.Write(w, binary.BigEndian, PositionPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Slot struct {
|
|
Present bool
|
|
Anon any
|
|
}
|
|
|
|
func (ret *Slot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Present)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Present {
|
|
case false:
|
|
var SlotAnonFalseTmp struct {
|
|
}
|
|
ret.Anon = SlotAnonFalseTmp
|
|
case true:
|
|
var SlotAnonTrueTmp struct {
|
|
ItemId int32
|
|
ItemCount int8
|
|
NbtData nbt.Tag
|
|
}
|
|
SlotAnonTrueTmp.ItemId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &SlotAnonTrueTmp.ItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = SlotAnonTrueTmp.NbtData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = SlotAnonTrueTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *Slot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Present)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Present {
|
|
case false:
|
|
_, ok := ret.Anon.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case true:
|
|
SlotAnon, ok := ret.Anon.(struct {
|
|
ItemId int32
|
|
ItemCount int8
|
|
NbtData nbt.Tag
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, SlotAnon.ItemId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, SlotAnon.ItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
SlotAnonNbtDataEncTmp := SlotAnon.NbtData
|
|
err = SlotAnonNbtDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type Tags struct {
|
|
Val []struct {
|
|
TagName string
|
|
Entries []int32
|
|
}
|
|
}
|
|
|
|
func (ret *Tags) Decode(r io.ReadSeeker) (err error) {
|
|
var lTags int32
|
|
lTags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []struct {
|
|
TagName string
|
|
Entries []int32
|
|
}{}
|
|
for range lTags {
|
|
var TagsElement struct {
|
|
TagName string
|
|
Entries []int32
|
|
}
|
|
TagsElement.TagName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lTagsElementEntries int32
|
|
lTagsElementEntries, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
TagsElement.Entries = []int32{}
|
|
for range lTagsElementEntries {
|
|
var TagsElementEntriesElement int32
|
|
TagsElementEntriesElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
TagsElement.Entries = append(TagsElement.Entries, TagsElementEntriesElement)
|
|
}
|
|
ret.Val = append(ret.Val, TagsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *Tags) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iTags := range len(ret.Val) {
|
|
err = proto_base.EncodeString(w, ret.Val[iTags].TagName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val[iTags].Entries)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iTagsInnerEntries := range len(ret.Val[iTags].Entries) {
|
|
err = proto_base.EncodeVarInt(w, ret.Val[iTags].Entries[iTagsInnerEntries])
|
|
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", 0x04: "login_plugin_request"}
|
|
|
|
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 "login_plugin_request":
|
|
var LoginToClientPacketParamsLoginPluginRequestTmp LoginToClientPacketLoginPluginRequest
|
|
err = LoginToClientPacketParamsLoginPluginRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsLoginPluginRequestTmp
|
|
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, "login_plugin_request": 0x04}
|
|
|
|
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 "login_plugin_request":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketLoginPluginRequest)
|
|
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 LoginToClientPacketLoginPluginRequest struct {
|
|
MessageId int32
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *LoginToClientPacketLoginPluginRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.MessageId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketLoginPluginRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.MessageId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToClientPacketLoginPluginRequestDataEncTmp := ret.Data
|
|
err = LoginToClientPacketLoginPluginRequestDataEncTmp.Encode(w)
|
|
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", 0x02: "login_plugin_response"}
|
|
|
|
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_plugin_response":
|
|
var LoginToServerPacketParamsLoginPluginResponseTmp LoginToServerPacketLoginPluginResponse
|
|
err = LoginToServerPacketParamsLoginPluginResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsLoginPluginResponseTmp
|
|
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, "login_plugin_response": 0x02}
|
|
|
|
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_plugin_response":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginPluginResponse)
|
|
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 LoginToServerPacketLoginPluginResponse struct {
|
|
MessageId int32
|
|
Data *proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *LoginToServerPacketLoginPluginResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.MessageId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var LoginToServerPacketLoginPluginResponseDataPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToServerPacketLoginPluginResponseDataPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToServerPacketLoginPluginResponseDataPresent {
|
|
var LoginToServerPacketLoginPluginResponseDataPresentValue proto_base.RestBuffer
|
|
err = LoginToServerPacketLoginPluginResponseDataPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = &LoginToServerPacketLoginPluginResponseDataPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketLoginPluginResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.MessageId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Data != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Data != nil {
|
|
LoginToServerPacketLoginPluginResponseDataEncTmp := *ret.Data
|
|
err = LoginToServerPacketLoginPluginResponseDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketLoginStart struct {
|
|
Username string
|
|
}
|
|
|
|
func (ret *LoginToServerPacketLoginStart) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Username, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketLoginStart) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Username)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var PlayToClientPacketNameMap = map[int32]string{0x00: "spawn_entity", 0x01: "spawn_entity_experience_orb", 0x02: "spawn_entity_weather", 0x03: "spawn_entity_living", 0x04: "spawn_entity_painting", 0x05: "named_entity_spawn", 0x06: "animation", 0x07: "statistics", 0x08: "block_break_animation", 0x09: "tile_entity_data", 0x0a: "block_action", 0x0b: "block_change", 0x0c: "boss_bar", 0x0d: "difficulty", 0x0e: "chat", 0x0f: "multi_block_change", 0x10: "tab_complete", 0x11: "declare_commands", 0x12: "transaction", 0x13: "close_window", 0x14: "window_items", 0x15: "craft_progress_bar", 0x16: "set_slot", 0x17: "set_cooldown", 0x18: "custom_payload", 0x19: "named_sound_effect", 0x1a: "kick_disconnect", 0x1b: "entity_status", 0x1c: "explosion", 0x1d: "unload_chunk", 0x1e: "game_state_change", 0x1f: "open_horse_window", 0x20: "keep_alive", 0x21: "map_chunk", 0x22: "world_event", 0x23: "world_particles", 0x24: "update_light", 0x25: "login", 0x26: "map", 0x27: "trade_list", 0x28: "rel_entity_move", 0x29: "entity_move_look", 0x2a: "entity_look", 0x2b: "entity", 0x2c: "vehicle_move", 0x2d: "open_book", 0x2e: "open_window", 0x2f: "open_sign_entity", 0x30: "craft_recipe_response", 0x31: "abilities", 0x32: "combat_event", 0x33: "player_info", 0x34: "face_player", 0x35: "position", 0x36: "unlock_recipes", 0x37: "entity_destroy", 0x38: "remove_entity_effect", 0x39: "resource_pack_send", 0x3a: "respawn", 0x3b: "entity_head_rotation", 0x3c: "select_advancement_tab", 0x3d: "world_border", 0x3e: "camera", 0x3f: "held_item_slot", 0x40: "update_view_position", 0x41: "update_view_distance", 0x42: "scoreboard_display_objective", 0x43: "entity_metadata", 0x44: "attach_entity", 0x45: "entity_velocity", 0x46: "entity_equipment", 0x47: "experience", 0x48: "update_health", 0x49: "scoreboard_objective", 0x4a: "set_passengers", 0x4b: "teams", 0x4c: "scoreboard_score", 0x4d: "spawn_position", 0x4e: "update_time", 0x4f: "title", 0x50: "entity_sound_effect", 0x51: "sound_effect", 0x52: "stop_sound", 0x53: "playerlist_header", 0x54: "nbt_query_response", 0x55: "collect", 0x56: "entity_teleport", 0x57: "advancements", 0x58: "entity_update_attributes", 0x59: "entity_effect", 0x5a: "declare_recipes", 0x5b: "tags", 0x5c: "acknowledge_player_digging"}
|
|
|
|
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 "acknowledge_player_digging":
|
|
var PlayToClientPacketParamsAcknowledgePlayerDiggingTmp PlayToClientPacketAcknowledgePlayerDigging
|
|
err = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp
|
|
case "advancements":
|
|
var PlayToClientPacketParamsAdvancementsTmp PlayToClientPacketAdvancements
|
|
err = PlayToClientPacketParamsAdvancementsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAdvancementsTmp
|
|
case "animation":
|
|
var PlayToClientPacketParamsAnimationTmp PlayToClientPacketAnimation
|
|
err = PlayToClientPacketParamsAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAnimationTmp
|
|
case "attach_entity":
|
|
var PlayToClientPacketParamsAttachEntityTmp PlayToClientPacketAttachEntity
|
|
err = PlayToClientPacketParamsAttachEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAttachEntityTmp
|
|
case "block_action":
|
|
var PlayToClientPacketParamsBlockActionTmp PlayToClientPacketBlockAction
|
|
err = PlayToClientPacketParamsBlockActionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockActionTmp
|
|
case "block_break_animation":
|
|
var PlayToClientPacketParamsBlockBreakAnimationTmp PlayToClientPacketBlockBreakAnimation
|
|
err = PlayToClientPacketParamsBlockBreakAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockBreakAnimationTmp
|
|
case "block_change":
|
|
var PlayToClientPacketParamsBlockChangeTmp PlayToClientPacketBlockChange
|
|
err = PlayToClientPacketParamsBlockChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockChangeTmp
|
|
case "boss_bar":
|
|
var PlayToClientPacketParamsBossBarTmp PlayToClientPacketBossBar
|
|
err = PlayToClientPacketParamsBossBarTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBossBarTmp
|
|
case "camera":
|
|
var PlayToClientPacketParamsCameraTmp PlayToClientPacketCamera
|
|
err = PlayToClientPacketParamsCameraTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCameraTmp
|
|
case "chat":
|
|
var PlayToClientPacketParamsChatTmp PlayToClientPacketChat
|
|
err = PlayToClientPacketParamsChatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsChatTmp
|
|
case "close_window":
|
|
var PlayToClientPacketParamsCloseWindowTmp PlayToClientPacketCloseWindow
|
|
err = PlayToClientPacketParamsCloseWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCloseWindowTmp
|
|
case "collect":
|
|
var PlayToClientPacketParamsCollectTmp PlayToClientPacketCollect
|
|
err = PlayToClientPacketParamsCollectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCollectTmp
|
|
case "combat_event":
|
|
var PlayToClientPacketParamsCombatEventTmp PlayToClientPacketCombatEvent
|
|
err = PlayToClientPacketParamsCombatEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCombatEventTmp
|
|
case "craft_progress_bar":
|
|
var PlayToClientPacketParamsCraftProgressBarTmp PlayToClientPacketCraftProgressBar
|
|
err = PlayToClientPacketParamsCraftProgressBarTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCraftProgressBarTmp
|
|
case "craft_recipe_response":
|
|
var PlayToClientPacketParamsCraftRecipeResponseTmp PlayToClientPacketCraftRecipeResponse
|
|
err = PlayToClientPacketParamsCraftRecipeResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCraftRecipeResponseTmp
|
|
case "custom_payload":
|
|
var PlayToClientPacketParamsCustomPayloadTmp PlayToClientPacketCustomPayload
|
|
err = PlayToClientPacketParamsCustomPayloadTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCustomPayloadTmp
|
|
case "declare_commands":
|
|
var PlayToClientPacketParamsDeclareCommandsTmp PlayToClientPacketDeclareCommands
|
|
err = PlayToClientPacketParamsDeclareCommandsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDeclareCommandsTmp
|
|
case "declare_recipes":
|
|
var PlayToClientPacketParamsDeclareRecipesTmp PlayToClientPacketDeclareRecipes
|
|
err = PlayToClientPacketParamsDeclareRecipesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDeclareRecipesTmp
|
|
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_sound_effect":
|
|
var PlayToClientPacketParamsEntitySoundEffectTmp PlayToClientPacketEntitySoundEffect
|
|
err = PlayToClientPacketParamsEntitySoundEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntitySoundEffectTmp
|
|
case "entity_status":
|
|
var PlayToClientPacketParamsEntityStatusTmp PlayToClientPacketEntityStatus
|
|
err = PlayToClientPacketParamsEntityStatusTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityStatusTmp
|
|
case "entity_teleport":
|
|
var PlayToClientPacketParamsEntityTeleportTmp PlayToClientPacketEntityTeleport
|
|
err = PlayToClientPacketParamsEntityTeleportTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityTeleportTmp
|
|
case "entity_update_attributes":
|
|
var PlayToClientPacketParamsEntityUpdateAttributesTmp PlayToClientPacketEntityUpdateAttributes
|
|
err = PlayToClientPacketParamsEntityUpdateAttributesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityUpdateAttributesTmp
|
|
case "entity_velocity":
|
|
var PlayToClientPacketParamsEntityVelocityTmp PlayToClientPacketEntityVelocity
|
|
err = PlayToClientPacketParamsEntityVelocityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityVelocityTmp
|
|
case "experience":
|
|
var PlayToClientPacketParamsExperienceTmp PlayToClientPacketExperience
|
|
err = PlayToClientPacketParamsExperienceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsExperienceTmp
|
|
case "explosion":
|
|
var PlayToClientPacketParamsExplosionTmp PlayToClientPacketExplosion
|
|
err = PlayToClientPacketParamsExplosionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsExplosionTmp
|
|
case "face_player":
|
|
var PlayToClientPacketParamsFacePlayerTmp PlayToClientPacketFacePlayer
|
|
err = PlayToClientPacketParamsFacePlayerTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsFacePlayerTmp
|
|
case "game_state_change":
|
|
var PlayToClientPacketParamsGameStateChangeTmp PlayToClientPacketGameStateChange
|
|
err = PlayToClientPacketParamsGameStateChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsGameStateChangeTmp
|
|
case "held_item_slot":
|
|
var PlayToClientPacketParamsHeldItemSlotTmp PlayToClientPacketHeldItemSlot
|
|
err = PlayToClientPacketParamsHeldItemSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsHeldItemSlotTmp
|
|
case "keep_alive":
|
|
var PlayToClientPacketParamsKeepAliveTmp PlayToClientPacketKeepAlive
|
|
err = PlayToClientPacketParamsKeepAliveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsKeepAliveTmp
|
|
case "kick_disconnect":
|
|
var PlayToClientPacketParamsKickDisconnectTmp PlayToClientPacketKickDisconnect
|
|
err = PlayToClientPacketParamsKickDisconnectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsKickDisconnectTmp
|
|
case "login":
|
|
var PlayToClientPacketParamsLoginTmp PlayToClientPacketLogin
|
|
err = PlayToClientPacketParamsLoginTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsLoginTmp
|
|
case "map":
|
|
var PlayToClientPacketParamsMapTmp PlayToClientPacketMap
|
|
err = PlayToClientPacketParamsMapTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMapTmp
|
|
case "map_chunk":
|
|
var PlayToClientPacketParamsMapChunkTmp PlayToClientPacketMapChunk
|
|
err = PlayToClientPacketParamsMapChunkTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMapChunkTmp
|
|
case "multi_block_change":
|
|
var PlayToClientPacketParamsMultiBlockChangeTmp PlayToClientPacketMultiBlockChange
|
|
err = PlayToClientPacketParamsMultiBlockChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMultiBlockChangeTmp
|
|
case "named_entity_spawn":
|
|
var PlayToClientPacketParamsNamedEntitySpawnTmp PlayToClientPacketNamedEntitySpawn
|
|
err = PlayToClientPacketParamsNamedEntitySpawnTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsNamedEntitySpawnTmp
|
|
case "named_sound_effect":
|
|
var PlayToClientPacketParamsNamedSoundEffectTmp PlayToClientPacketNamedSoundEffect
|
|
err = PlayToClientPacketParamsNamedSoundEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsNamedSoundEffectTmp
|
|
case "nbt_query_response":
|
|
var PlayToClientPacketParamsNbtQueryResponseTmp PlayToClientPacketNbtQueryResponse
|
|
err = PlayToClientPacketParamsNbtQueryResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsNbtQueryResponseTmp
|
|
case "open_book":
|
|
var PlayToClientPacketParamsOpenBookTmp PlayToClientPacketOpenBook
|
|
err = PlayToClientPacketParamsOpenBookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenBookTmp
|
|
case "open_horse_window":
|
|
var PlayToClientPacketParamsOpenHorseWindowTmp PlayToClientPacketOpenHorseWindow
|
|
err = PlayToClientPacketParamsOpenHorseWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenHorseWindowTmp
|
|
case "open_sign_entity":
|
|
var PlayToClientPacketParamsOpenSignEntityTmp PlayToClientPacketOpenSignEntity
|
|
err = PlayToClientPacketParamsOpenSignEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenSignEntityTmp
|
|
case "open_window":
|
|
var PlayToClientPacketParamsOpenWindowTmp PlayToClientPacketOpenWindow
|
|
err = PlayToClientPacketParamsOpenWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenWindowTmp
|
|
case "player_info":
|
|
var PlayToClientPacketParamsPlayerInfoTmp PlayToClientPacketPlayerInfo
|
|
err = PlayToClientPacketParamsPlayerInfoTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPlayerInfoTmp
|
|
case "playerlist_header":
|
|
var PlayToClientPacketParamsPlayerlistHeaderTmp PlayToClientPacketPlayerlistHeader
|
|
err = PlayToClientPacketParamsPlayerlistHeaderTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPlayerlistHeaderTmp
|
|
case "position":
|
|
var PlayToClientPacketParamsPositionTmp PlayToClientPacketPosition
|
|
err = PlayToClientPacketParamsPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPositionTmp
|
|
case "rel_entity_move":
|
|
var PlayToClientPacketParamsRelEntityMoveTmp PlayToClientPacketRelEntityMove
|
|
err = PlayToClientPacketParamsRelEntityMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRelEntityMoveTmp
|
|
case "remove_entity_effect":
|
|
var PlayToClientPacketParamsRemoveEntityEffectTmp PlayToClientPacketRemoveEntityEffect
|
|
err = PlayToClientPacketParamsRemoveEntityEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRemoveEntityEffectTmp
|
|
case "resource_pack_send":
|
|
var PlayToClientPacketParamsResourcePackSendTmp PlayToClientPacketResourcePackSend
|
|
err = PlayToClientPacketParamsResourcePackSendTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsResourcePackSendTmp
|
|
case "respawn":
|
|
var PlayToClientPacketParamsRespawnTmp PlayToClientPacketRespawn
|
|
err = PlayToClientPacketParamsRespawnTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRespawnTmp
|
|
case "scoreboard_display_objective":
|
|
var PlayToClientPacketParamsScoreboardDisplayObjectiveTmp PlayToClientPacketScoreboardDisplayObjective
|
|
err = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp
|
|
case "scoreboard_objective":
|
|
var PlayToClientPacketParamsScoreboardObjectiveTmp PlayToClientPacketScoreboardObjective
|
|
err = PlayToClientPacketParamsScoreboardObjectiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardObjectiveTmp
|
|
case "scoreboard_score":
|
|
var PlayToClientPacketParamsScoreboardScoreTmp PlayToClientPacketScoreboardScore
|
|
err = PlayToClientPacketParamsScoreboardScoreTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardScoreTmp
|
|
case "select_advancement_tab":
|
|
var PlayToClientPacketParamsSelectAdvancementTabTmp PlayToClientPacketSelectAdvancementTab
|
|
err = PlayToClientPacketParamsSelectAdvancementTabTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSelectAdvancementTabTmp
|
|
case "set_cooldown":
|
|
var PlayToClientPacketParamsSetCooldownTmp PlayToClientPacketSetCooldown
|
|
err = PlayToClientPacketParamsSetCooldownTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetCooldownTmp
|
|
case "set_passengers":
|
|
var PlayToClientPacketParamsSetPassengersTmp PlayToClientPacketSetPassengers
|
|
err = PlayToClientPacketParamsSetPassengersTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetPassengersTmp
|
|
case "set_slot":
|
|
var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot
|
|
err = PlayToClientPacketParamsSetSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetSlotTmp
|
|
case "sound_effect":
|
|
var PlayToClientPacketParamsSoundEffectTmp PlayToClientPacketSoundEffect
|
|
err = PlayToClientPacketParamsSoundEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSoundEffectTmp
|
|
case "spawn_entity":
|
|
var PlayToClientPacketParamsSpawnEntityTmp PlayToClientPacketSpawnEntity
|
|
err = PlayToClientPacketParamsSpawnEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityTmp
|
|
case "spawn_entity_experience_orb":
|
|
var PlayToClientPacketParamsSpawnEntityExperienceOrbTmp PlayToClientPacketSpawnEntityExperienceOrb
|
|
err = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp
|
|
case "spawn_entity_living":
|
|
var PlayToClientPacketParamsSpawnEntityLivingTmp PlayToClientPacketSpawnEntityLiving
|
|
err = PlayToClientPacketParamsSpawnEntityLivingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityLivingTmp
|
|
case "spawn_entity_painting":
|
|
var PlayToClientPacketParamsSpawnEntityPaintingTmp PlayToClientPacketSpawnEntityPainting
|
|
err = PlayToClientPacketParamsSpawnEntityPaintingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityPaintingTmp
|
|
case "spawn_entity_weather":
|
|
var PlayToClientPacketParamsSpawnEntityWeatherTmp PlayToClientPacketSpawnEntityWeather
|
|
err = PlayToClientPacketParamsSpawnEntityWeatherTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityWeatherTmp
|
|
case "spawn_position":
|
|
var PlayToClientPacketParamsSpawnPositionTmp PlayToClientPacketSpawnPosition
|
|
err = PlayToClientPacketParamsSpawnPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnPositionTmp
|
|
case "statistics":
|
|
var PlayToClientPacketParamsStatisticsTmp PlayToClientPacketStatistics
|
|
err = PlayToClientPacketParamsStatisticsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsStatisticsTmp
|
|
case "stop_sound":
|
|
var PlayToClientPacketParamsStopSoundTmp PlayToClientPacketStopSound
|
|
err = PlayToClientPacketParamsStopSoundTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsStopSoundTmp
|
|
case "tab_complete":
|
|
var PlayToClientPacketParamsTabCompleteTmp PlayToClientPacketTabComplete
|
|
err = PlayToClientPacketParamsTabCompleteTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTabCompleteTmp
|
|
case "tags":
|
|
var PlayToClientPacketParamsTagsTmp PlayToClientPacketTags
|
|
err = PlayToClientPacketParamsTagsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTagsTmp
|
|
case "teams":
|
|
var PlayToClientPacketParamsTeamsTmp PlayToClientPacketTeams
|
|
err = PlayToClientPacketParamsTeamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTeamsTmp
|
|
case "tile_entity_data":
|
|
var PlayToClientPacketParamsTileEntityDataTmp PlayToClientPacketTileEntityData
|
|
err = PlayToClientPacketParamsTileEntityDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTileEntityDataTmp
|
|
case "title":
|
|
var PlayToClientPacketParamsTitleTmp PlayToClientPacketTitle
|
|
err = PlayToClientPacketParamsTitleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTitleTmp
|
|
case "trade_list":
|
|
var PlayToClientPacketParamsTradeListTmp PlayToClientPacketTradeList
|
|
err = PlayToClientPacketParamsTradeListTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTradeListTmp
|
|
case "transaction":
|
|
var PlayToClientPacketParamsTransactionTmp PlayToClientPacketTransaction
|
|
err = PlayToClientPacketParamsTransactionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTransactionTmp
|
|
case "unload_chunk":
|
|
var PlayToClientPacketParamsUnloadChunkTmp PlayToClientPacketUnloadChunk
|
|
err = PlayToClientPacketParamsUnloadChunkTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUnloadChunkTmp
|
|
case "unlock_recipes":
|
|
var PlayToClientPacketParamsUnlockRecipesTmp PlayToClientPacketUnlockRecipes
|
|
err = PlayToClientPacketParamsUnlockRecipesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUnlockRecipesTmp
|
|
case "update_health":
|
|
var PlayToClientPacketParamsUpdateHealthTmp PlayToClientPacketUpdateHealth
|
|
err = PlayToClientPacketParamsUpdateHealthTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateHealthTmp
|
|
case "update_light":
|
|
var PlayToClientPacketParamsUpdateLightTmp PlayToClientPacketUpdateLight
|
|
err = PlayToClientPacketParamsUpdateLightTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateLightTmp
|
|
case "update_time":
|
|
var PlayToClientPacketParamsUpdateTimeTmp PlayToClientPacketUpdateTime
|
|
err = PlayToClientPacketParamsUpdateTimeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateTimeTmp
|
|
case "update_view_distance":
|
|
var PlayToClientPacketParamsUpdateViewDistanceTmp PlayToClientPacketUpdateViewDistance
|
|
err = PlayToClientPacketParamsUpdateViewDistanceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateViewDistanceTmp
|
|
case "update_view_position":
|
|
var PlayToClientPacketParamsUpdateViewPositionTmp PlayToClientPacketUpdateViewPosition
|
|
err = PlayToClientPacketParamsUpdateViewPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateViewPositionTmp
|
|
case "vehicle_move":
|
|
var PlayToClientPacketParamsVehicleMoveTmp PlayToClientPacketVehicleMove
|
|
err = PlayToClientPacketParamsVehicleMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsVehicleMoveTmp
|
|
case "window_items":
|
|
var PlayToClientPacketParamsWindowItemsTmp PlayToClientPacketWindowItems
|
|
err = PlayToClientPacketParamsWindowItemsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWindowItemsTmp
|
|
case "world_border":
|
|
var PlayToClientPacketParamsWorldBorderTmp PlayToClientPacketWorldBorder
|
|
err = PlayToClientPacketParamsWorldBorderTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldBorderTmp
|
|
case "world_event":
|
|
var PlayToClientPacketParamsWorldEventTmp PlayToClientPacketWorldEvent
|
|
err = PlayToClientPacketParamsWorldEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldEventTmp
|
|
case "world_particles":
|
|
var PlayToClientPacketParamsWorldParticlesTmp PlayToClientPacketWorldParticles
|
|
err = PlayToClientPacketParamsWorldParticlesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldParticlesTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketNameReverseMap = map[string]int32{"spawn_entity": 0x00, "spawn_entity_experience_orb": 0x01, "spawn_entity_weather": 0x02, "spawn_entity_living": 0x03, "spawn_entity_painting": 0x04, "named_entity_spawn": 0x05, "animation": 0x06, "statistics": 0x07, "block_break_animation": 0x08, "tile_entity_data": 0x09, "block_action": 0x0a, "block_change": 0x0b, "boss_bar": 0x0c, "difficulty": 0x0d, "chat": 0x0e, "multi_block_change": 0x0f, "tab_complete": 0x10, "declare_commands": 0x11, "transaction": 0x12, "close_window": 0x13, "window_items": 0x14, "craft_progress_bar": 0x15, "set_slot": 0x16, "set_cooldown": 0x17, "custom_payload": 0x18, "named_sound_effect": 0x19, "kick_disconnect": 0x1a, "entity_status": 0x1b, "explosion": 0x1c, "unload_chunk": 0x1d, "game_state_change": 0x1e, "open_horse_window": 0x1f, "keep_alive": 0x20, "map_chunk": 0x21, "world_event": 0x22, "world_particles": 0x23, "update_light": 0x24, "login": 0x25, "map": 0x26, "trade_list": 0x27, "rel_entity_move": 0x28, "entity_move_look": 0x29, "entity_look": 0x2a, "entity": 0x2b, "vehicle_move": 0x2c, "open_book": 0x2d, "open_window": 0x2e, "open_sign_entity": 0x2f, "craft_recipe_response": 0x30, "abilities": 0x31, "combat_event": 0x32, "player_info": 0x33, "face_player": 0x34, "position": 0x35, "unlock_recipes": 0x36, "entity_destroy": 0x37, "remove_entity_effect": 0x38, "resource_pack_send": 0x39, "respawn": 0x3a, "entity_head_rotation": 0x3b, "select_advancement_tab": 0x3c, "world_border": 0x3d, "camera": 0x3e, "held_item_slot": 0x3f, "update_view_position": 0x40, "update_view_distance": 0x41, "scoreboard_display_objective": 0x42, "entity_metadata": 0x43, "attach_entity": 0x44, "entity_velocity": 0x45, "entity_equipment": 0x46, "experience": 0x47, "update_health": 0x48, "scoreboard_objective": 0x49, "set_passengers": 0x4a, "teams": 0x4b, "scoreboard_score": 0x4c, "spawn_position": 0x4d, "update_time": 0x4e, "title": 0x4f, "entity_sound_effect": 0x50, "sound_effect": 0x51, "stop_sound": 0x52, "playerlist_header": 0x53, "nbt_query_response": 0x54, "collect": 0x55, "entity_teleport": 0x56, "advancements": 0x57, "entity_update_attributes": 0x58, "entity_effect": 0x59, "declare_recipes": 0x5a, "tags": 0x5b, "acknowledge_player_digging": 0x5c}
|
|
|
|
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 "acknowledge_player_digging":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAcknowledgePlayerDigging)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "advancements":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAdvancements)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "attach_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAttachEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_action":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_break_animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockBreakAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "boss_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBossBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "camera":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCamera)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "close_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCloseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "collect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCollect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "combat_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCombatEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_progress_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftProgressBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_recipe_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftRecipeResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "declare_commands":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareCommands)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "declare_recipes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareRecipes)
|
|
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_sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntitySoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_status":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityStatus)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_teleport":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityTeleport)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_update_attributes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityUpdateAttributes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_velocity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityVelocity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "experience":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExperience)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "explosion":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExplosion)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "face_player":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketFacePlayer)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "game_state_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameStateChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "held_item_slot":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHeldItemSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "kick_disconnect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKickDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketLogin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "map":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMap)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "map_chunk":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunk)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "multi_block_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMultiBlockChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "named_entity_spawn":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNamedEntitySpawn)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "named_sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNamedSoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "nbt_query_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNbtQueryResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_book":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenBook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_horse_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenHorseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_sign_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenSignEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_info":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerInfo)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "playerlist_header":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerlistHeader)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "rel_entity_move":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRelEntityMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_entity_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRemoveEntityEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "resource_pack_send":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResourcePackSend)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "respawn":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRespawn)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_display_objective":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardDisplayObjective)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_objective":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardObjective)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_score":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardScore)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_advancement_tab":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSelectAdvancementTab)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_cooldown":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCooldown)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_passengers":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPassengers)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_slot":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_experience_orb":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityExperienceOrb)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_living":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityLiving)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_painting":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityPainting)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_weather":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityWeather)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "statistics":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStatistics)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "stop_sound":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStopSound)
|
|
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 "tags":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTags)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "teams":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTeams)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tile_entity_data":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTileEntityData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "title":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTitle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "trade_list":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTradeList)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "transaction":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTransaction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "unload_chunk":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnloadChunk)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "unlock_recipes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnlockRecipes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_health":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateHealth)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_light":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateLight)
|
|
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 "update_view_distance":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewDistance)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_view_position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vehicle_move":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketVehicleMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "window_items":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWindowItems)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorder)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_particles":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldParticles)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAbilities struct {
|
|
Flags int8
|
|
FlyingSpeed float32
|
|
WalkingSpeed float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAbilities) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAbilities) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAcknowledgePlayerDigging struct {
|
|
Location Position
|
|
Block int32
|
|
Status int32
|
|
Successful bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAcknowledgePlayerDigging) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Block, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Status, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Successful)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAcknowledgePlayerDigging) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketAcknowledgePlayerDiggingLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketAcknowledgePlayerDiggingLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Block)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Status)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Successful)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAdvancements struct {
|
|
Reset bool
|
|
AdvancementMapping []struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title string
|
|
Description string
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Criteria []struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}
|
|
Requirements [][]string
|
|
}
|
|
}
|
|
Identifiers []string
|
|
ProgressMapping []struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAdvancements) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Reset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketAdvancementsAdvancementMapping int32
|
|
lPlayToClientPacketAdvancementsAdvancementMapping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AdvancementMapping = []struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title string
|
|
Description string
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Criteria []struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}
|
|
Requirements [][]string
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMapping {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElement struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title string
|
|
Description string
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Criteria []struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}
|
|
Requirements [][]string
|
|
}
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.ParentId = &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue struct {
|
|
Title string
|
|
Description string
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Title, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Description, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Icon.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.FrameType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked uint32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Unused = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked << 0 >> 3
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Hidden = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<29>>31 == 1
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.ShowToast = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<30>>31 == 1
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<31>>31 == 1
|
|
switch PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture {
|
|
case true:
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp
|
|
default:
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp struct {
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.XCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.YCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.DisplayData = &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue
|
|
}
|
|
var lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria int32
|
|
lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria = []struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement struct {
|
|
Key string
|
|
Value struct {
|
|
}
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria, PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement)
|
|
}
|
|
var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements int32
|
|
lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = [][]string{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement []string
|
|
var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement int32
|
|
lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = []string{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = append(PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement)
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement)
|
|
}
|
|
ret.AdvancementMapping = append(ret.AdvancementMapping, PlayToClientPacketAdvancementsAdvancementMappingElement)
|
|
}
|
|
var lPlayToClientPacketAdvancementsIdentifiers int32
|
|
lPlayToClientPacketAdvancementsIdentifiers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Identifiers = []string{}
|
|
for range lPlayToClientPacketAdvancementsIdentifiers {
|
|
var PlayToClientPacketAdvancementsIdentifiersElement string
|
|
PlayToClientPacketAdvancementsIdentifiersElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Identifiers = append(ret.Identifiers, PlayToClientPacketAdvancementsIdentifiersElement)
|
|
}
|
|
var lPlayToClientPacketAdvancementsProgressMapping int32
|
|
lPlayToClientPacketAdvancementsProgressMapping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ProgressMapping = []struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsProgressMapping {
|
|
var PlayToClientPacketAdvancementsProgressMappingElement struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketAdvancementsProgressMappingElementValue int32
|
|
lPlayToClientPacketAdvancementsProgressMappingElementValue, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Value = []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsProgressMappingElementValue {
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElement struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionIdentifier, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent {
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionProgress = &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Value = append(PlayToClientPacketAdvancementsProgressMappingElement.Value, PlayToClientPacketAdvancementsProgressMappingElementValueElement)
|
|
}
|
|
ret.ProgressMapping = append(ret.ProgressMapping, PlayToClientPacketAdvancementsProgressMappingElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAdvancements) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Reset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMapping := range len(ret.AdvancementMapping) {
|
|
err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil {
|
|
err = proto_base.EncodeString(w, *ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil {
|
|
err = proto_base.EncodeString(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Title)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Description)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataIconEncTmp := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Icon
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataIconEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).FrameType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked uint32
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture) & 0x1) << 0x0
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.ShowToast) & 0x1) << 0x1
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Hidden) & 0x1) << 0x2
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Unused) & 0x1FFFFFFF) << 0x3
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture {
|
|
case true:
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).XCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).YCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueCriteria := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria) {
|
|
err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueCriteria].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements])))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements]) {
|
|
err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements][iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Identifiers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsIdentifiers := range len(ret.Identifiers) {
|
|
err = proto_base.EncodeString(w, ret.Identifiers[iPlayToClientPacketAdvancementsIdentifiers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsProgressMapping := range len(ret.ProgressMapping) {
|
|
err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsProgressMappingInnerValue := range len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value) {
|
|
err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionIdentifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil {
|
|
err = binary.Write(w, binary.BigEndian, *ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAnimation struct {
|
|
EntityId int32
|
|
Animation uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Animation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Animation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAttachEntity struct {
|
|
EntityId int32
|
|
VehicleId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAttachEntity) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VehicleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAttachEntity) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VehicleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockAction struct {
|
|
Location Position
|
|
Byte1 uint8
|
|
Byte2 uint8
|
|
BlockId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockAction) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Byte1)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Byte2)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockAction) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketBlockActionLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockActionLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Byte1)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Byte2)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.BlockId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockBreakAnimation struct {
|
|
EntityId int32
|
|
Location Position
|
|
DestroyStage int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockBreakAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DestroyStage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockBreakAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketBlockBreakAnimationLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockBreakAnimationLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DestroyStage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockChange struct {
|
|
Location Position
|
|
Type int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockChange) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockChange) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketBlockChangeLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockChangeLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBossBar struct {
|
|
EntityUUID uuid.UUID
|
|
Action int32
|
|
Title any
|
|
Health any
|
|
Color any
|
|
Dividers any
|
|
Flags any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBossBar) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarTitle0Tmp string
|
|
PlayToClientPacketBossBarTitle0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitle0Tmp
|
|
case 3:
|
|
var PlayToClientPacketBossBarTitle3Tmp string
|
|
PlayToClientPacketBossBarTitle3Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitle3Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarTitleTmp struct {
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitleTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarHealth0Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealth0Tmp
|
|
case 2:
|
|
var PlayToClientPacketBossBarHealth2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealth2Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarHealthTmp struct {
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealthTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarColor0Tmp int32
|
|
PlayToClientPacketBossBarColor0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColor0Tmp
|
|
case 4:
|
|
var PlayToClientPacketBossBarColor4Tmp int32
|
|
PlayToClientPacketBossBarColor4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColor4Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarColorTmp struct {
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColorTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarDividers0Tmp int32
|
|
PlayToClientPacketBossBarDividers0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividers0Tmp
|
|
case 4:
|
|
var PlayToClientPacketBossBarDividers4Tmp int32
|
|
PlayToClientPacketBossBarDividers4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividers4Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarDividersTmp struct {
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividersTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarFlags0Tmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlags0Tmp
|
|
case 5:
|
|
var PlayToClientPacketBossBarFlags5Tmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags5Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlags5Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarFlagsTmp struct {
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlagsTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBossBar) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarTitle, ok := ret.Title.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketBossBarTitle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketBossBarTitle, ok := ret.Title.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketBossBarTitle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Title.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Health.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Color.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Dividers.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 5:
|
|
PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Flags.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCamera struct {
|
|
CameraId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCamera) Decode(r io.ReadSeeker) (err error) {
|
|
ret.CameraId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCamera) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.CameraId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChat struct {
|
|
Message string
|
|
Position int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketChat) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Message, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Position)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketChat) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Message)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Position)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCloseWindow struct {
|
|
WindowId uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCloseWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCloseWindow) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCollect struct {
|
|
CollectedEntityId int32
|
|
CollectorEntityId int32
|
|
PickupItemCount int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCollect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.CollectedEntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollectorEntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PickupItemCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCollect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.CollectedEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.CollectorEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.PickupItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCombatEvent struct {
|
|
Event int32
|
|
Duration any
|
|
PlayerId any
|
|
EntityId any
|
|
Message any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCombatEvent) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Event, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Event {
|
|
case 1:
|
|
var PlayToClientPacketCombatEventDuration1Tmp int32
|
|
PlayToClientPacketCombatEventDuration1Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Duration = PlayToClientPacketCombatEventDuration1Tmp
|
|
default:
|
|
var PlayToClientPacketCombatEventDurationTmp struct {
|
|
}
|
|
ret.Duration = PlayToClientPacketCombatEventDurationTmp
|
|
}
|
|
switch ret.Event {
|
|
case 2:
|
|
var PlayToClientPacketCombatEventPlayerId2Tmp int32
|
|
PlayToClientPacketCombatEventPlayerId2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PlayerId = PlayToClientPacketCombatEventPlayerId2Tmp
|
|
default:
|
|
var PlayToClientPacketCombatEventPlayerIdTmp struct {
|
|
}
|
|
ret.PlayerId = PlayToClientPacketCombatEventPlayerIdTmp
|
|
}
|
|
switch ret.Event {
|
|
case 1:
|
|
var PlayToClientPacketCombatEventEntityId1Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCombatEventEntityId1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketCombatEventEntityId1Tmp
|
|
case 2:
|
|
var PlayToClientPacketCombatEventEntityId2Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCombatEventEntityId2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketCombatEventEntityId2Tmp
|
|
default:
|
|
var PlayToClientPacketCombatEventEntityIdTmp struct {
|
|
}
|
|
ret.EntityId = PlayToClientPacketCombatEventEntityIdTmp
|
|
}
|
|
switch ret.Event {
|
|
case 2:
|
|
var PlayToClientPacketCombatEventMessage2Tmp string
|
|
PlayToClientPacketCombatEventMessage2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Message = PlayToClientPacketCombatEventMessage2Tmp
|
|
default:
|
|
var PlayToClientPacketCombatEventMessageTmp struct {
|
|
}
|
|
ret.Message = PlayToClientPacketCombatEventMessageTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCombatEvent) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Event)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Event {
|
|
case 1:
|
|
PlayToClientPacketCombatEventDuration, ok := ret.Duration.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketCombatEventDuration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Duration.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Event {
|
|
case 2:
|
|
PlayToClientPacketCombatEventPlayerId, ok := ret.PlayerId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketCombatEventPlayerId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.PlayerId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Event {
|
|
case 1:
|
|
PlayToClientPacketCombatEventEntityId, ok := ret.EntityId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketCombatEventEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketCombatEventEntityId, ok := ret.EntityId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketCombatEventEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Event {
|
|
case 2:
|
|
PlayToClientPacketCombatEventMessage, ok := ret.Message.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketCombatEventMessage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Message.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCraftProgressBar struct {
|
|
WindowId uint8
|
|
Property int16
|
|
Value int16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCraftProgressBar) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Property)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCraftProgressBar) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Property)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCraftRecipeResponse struct {
|
|
WindowId int8
|
|
Recipe string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCraftRecipeResponse) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipe, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCraftRecipeResponse) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Recipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCustomPayload) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketCustomPayloadDataEncTmp := ret.Data
|
|
err = PlayToClientPacketCustomPayloadDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDeclareCommands struct {
|
|
Nodes []CommandNode
|
|
RootIndex int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDeclareCommands) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketDeclareCommandsNodes int32
|
|
lPlayToClientPacketDeclareCommandsNodes, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Nodes = []CommandNode{}
|
|
for range lPlayToClientPacketDeclareCommandsNodes {
|
|
var PlayToClientPacketDeclareCommandsNodesElement CommandNode
|
|
err = PlayToClientPacketDeclareCommandsNodesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Nodes = append(ret.Nodes, PlayToClientPacketDeclareCommandsNodesElement)
|
|
}
|
|
ret.RootIndex, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketDeclareCommands) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Nodes)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareCommandsNodes := range len(ret.Nodes) {
|
|
PlayToClientPacketDeclareCommandsNodesInnerEncTmp := ret.Nodes[iPlayToClientPacketDeclareCommandsNodes]
|
|
err = PlayToClientPacketDeclareCommandsNodesInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.RootIndex)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDeclareRecipes struct {
|
|
Recipes []struct {
|
|
Type string
|
|
RecipeId string
|
|
Data any
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDeclareRecipes) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketDeclareRecipesRecipes int32
|
|
lPlayToClientPacketDeclareRecipesRecipes, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes = []struct {
|
|
Type string
|
|
RecipeId string
|
|
Data any
|
|
}{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipes {
|
|
var PlayToClientPacketDeclareRecipesRecipesElement struct {
|
|
Type string
|
|
RecipeId string
|
|
Data any
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Type, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.RecipeId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch PlayToClientPacketDeclareRecipesRecipesElement.Type {
|
|
case "minecraft:blasting":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp MinecraftSmeltingFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp
|
|
case "minecraft:campfire_cooking":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp MinecraftSmeltingFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp
|
|
case "minecraft:crafting_shaped":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp struct {
|
|
Width int32
|
|
Height int32
|
|
Group string
|
|
Ingredients [][]Ingredient
|
|
Result Slot
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Width, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Height, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Group, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients int32
|
|
lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Width
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients = [][]Ingredient{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients {
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement []Ingredient
|
|
var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement int32
|
|
lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Height
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = []Ingredient{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement {
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement Ingredient
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement)
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement)
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp
|
|
case "minecraft:crafting_shapeless":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp struct {
|
|
Group string
|
|
Ingredients []Ingredient
|
|
Result Slot
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Group, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients int32
|
|
lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients = []Ingredient{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients {
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement Ingredient
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement)
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp
|
|
case "minecraft:crafting_special_armordye":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialArmordyeTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialArmordyeTmp
|
|
case "minecraft:crafting_special_banneraddpattern":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBanneraddpatternTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBanneraddpatternTmp
|
|
case "minecraft:crafting_special_bannerduplicate":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBannerduplicateTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBannerduplicateTmp
|
|
case "minecraft:crafting_special_bookcloning":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBookcloningTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBookcloningTmp
|
|
case "minecraft:crafting_special_firework_rocket":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkRocketTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkRocketTmp
|
|
case "minecraft:crafting_special_firework_star":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarTmp
|
|
case "minecraft:crafting_special_firework_star_fade":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarFadeTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarFadeTmp
|
|
case "minecraft:crafting_special_mapcloning":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapcloningTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapcloningTmp
|
|
case "minecraft:crafting_special_mapextending":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapextendingTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapextendingTmp
|
|
case "minecraft:crafting_special_repairitem":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialRepairitemTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialRepairitemTmp
|
|
case "minecraft:crafting_special_shielddecoration":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShielddecorationTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShielddecorationTmp
|
|
case "minecraft:crafting_special_shulkerboxcoloring":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShulkerboxcoloringTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShulkerboxcoloringTmp
|
|
case "minecraft:crafting_special_suspiciousstew":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialSuspiciousstewTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialSuspiciousstewTmp
|
|
case "minecraft:crafting_special_tippedarrow":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialTippedarrowTmp struct {
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialTippedarrowTmp
|
|
case "minecraft:smelting":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp MinecraftSmeltingFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp
|
|
case "minecraft:smoking":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp MinecraftSmeltingFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp
|
|
case "minecraft:stonecutting":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp struct {
|
|
Group string
|
|
Ingredient Ingredient
|
|
Result Slot
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Group, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Ingredient.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp
|
|
}
|
|
ret.Recipes = append(ret.Recipes, PlayToClientPacketDeclareRecipesRecipesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketDeclareRecipes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareRecipesRecipes := range len(ret.Recipes) {
|
|
err = proto_base.EncodeString(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].RecipeId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Type {
|
|
case "minecraft:blasting":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:campfire_cooking":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_shaped":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
Width int32
|
|
Height int32
|
|
Group string
|
|
Ingredients [][]Ingredient
|
|
Result Slot
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Width)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Height)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients) {
|
|
for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInner := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients]) {
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerInnerEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients][iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInner]
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_shapeless":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
Group string
|
|
Ingredients []Ingredient
|
|
Result Slot
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients) {
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients]
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_armordye":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_banneraddpattern":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_bannerduplicate":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_bookcloning":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_firework_rocket":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_firework_star":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_firework_star_fade":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_mapcloning":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_mapextending":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_repairitem":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_shielddecoration":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_shulkerboxcoloring":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_suspiciousstew":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_tippedarrow":
|
|
_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:smelting":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:smoking":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:stonecutting":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
Group string
|
|
Ingredient Ingredient
|
|
Result Slot
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredient
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDifficulty struct {
|
|
Difficulty uint8
|
|
DifficultyLocked bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDifficulty) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DifficultyLocked)
|
|
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
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DifficultyLocked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntity struct {
|
|
EntityId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityDestroy struct {
|
|
EntityIds []int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityDestroy) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketEntityDestroyEntityIds int32
|
|
lPlayToClientPacketEntityDestroyEntityIds, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityIds = []int32{}
|
|
for range lPlayToClientPacketEntityDestroyEntityIds {
|
|
var PlayToClientPacketEntityDestroyEntityIdsElement int32
|
|
PlayToClientPacketEntityDestroyEntityIdsElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityIds = append(ret.EntityIds, PlayToClientPacketEntityDestroyEntityIdsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityDestroy) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.EntityIds)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityDestroyEntityIds := range len(ret.EntityIds) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityIds[iPlayToClientPacketEntityDestroyEntityIds])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityEffect struct {
|
|
EntityId int32
|
|
EffectId int8
|
|
Amplifier int8
|
|
Duration int32
|
|
HideParticles int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Amplifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Duration, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HideParticles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Amplifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Duration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HideParticles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityEquipment struct {
|
|
EntityId int32
|
|
Slot int32
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityEquipment) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Slot, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityEquipmentItemEncTmp := ret.Item
|
|
err = PlayToClientPacketEntityEquipmentItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityHeadRotation struct {
|
|
EntityId int32
|
|
HeadYaw int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityHeadRotation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HeadYaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityHeadRotation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HeadYaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityLook struct {
|
|
EntityId int32
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityLook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityLook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityMetadata struct {
|
|
EntityId int32
|
|
Metadata EntityMetadata
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityMetadata) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Metadata.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityMetadata) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityMetadataMetadataEncTmp := ret.Metadata
|
|
err = PlayToClientPacketEntityMetadataMetadataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityMoveLook struct {
|
|
EntityId int32
|
|
DX int16
|
|
DY int16
|
|
DZ int16
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityMoveLook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityMoveLook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntitySoundEffect struct {
|
|
SoundId int32
|
|
SoundCategory int32
|
|
EntityId int32
|
|
Volume float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntitySoundEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.SoundId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SoundCategory, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
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 *PlayToClientPacketEntitySoundEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.SoundId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SoundCategory)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
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 PlayToClientPacketEntityStatus struct {
|
|
EntityId int32
|
|
EntityStatus int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityStatus) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityStatus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityStatus) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityStatus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityTeleport struct {
|
|
EntityId int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityTeleport) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityTeleport) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityUpdateAttributes struct {
|
|
EntityId int32
|
|
Properties []struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityUpdateAttributes) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketEntityUpdateAttributesProperties int32
|
|
err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketEntityUpdateAttributesProperties)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Properties = []struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketEntityUpdateAttributesProperties {
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElement struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElement.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers int32
|
|
lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}{}
|
|
for range lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers {
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
_, err = io.ReadFull(r, PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Amount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Operation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = append(PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers, PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement)
|
|
}
|
|
ret.Properties = append(ret.Properties, PlayToClientPacketEntityUpdateAttributesPropertiesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityUpdateAttributes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, int32(len(ret.Properties)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityUpdateAttributesProperties := range len(ret.Properties) {
|
|
err = proto_base.EncodeString(w, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers := range len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers) {
|
|
_, err = w.Write(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Amount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Operation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityVelocity struct {
|
|
EntityId int32
|
|
Velocity Vec3i16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityVelocity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Velocity.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityVelocity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityVelocityVelocityEncTmp := ret.Velocity
|
|
err = PlayToClientPacketEntityVelocityVelocityEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketExperience struct {
|
|
ExperienceBar float32
|
|
Level int32
|
|
TotalExperience int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketExperience) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ExperienceBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Level, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TotalExperience, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketExperience) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ExperienceBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Level)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.TotalExperience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketExplosion struct {
|
|
X float32
|
|
Y float32
|
|
Z float32
|
|
Radius float32
|
|
AffectedBlockOffsets []struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}
|
|
PlayerMotionX float32
|
|
PlayerMotionY float32
|
|
PlayerMotionZ float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketExplosion) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Radius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketExplosionAffectedBlockOffsets int32
|
|
err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketExplosionAffectedBlockOffsets)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AffectedBlockOffsets = []struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}{}
|
|
for range lPlayToClientPacketExplosionAffectedBlockOffsets {
|
|
var PlayToClientPacketExplosionAffectedBlockOffsetsElement struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AffectedBlockOffsets = append(ret.AffectedBlockOffsets, PlayToClientPacketExplosionAffectedBlockOffsetsElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketExplosion) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Radius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, int32(len(ret.AffectedBlockOffsets)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketExplosionAffectedBlockOffsets := range len(ret.AffectedBlockOffsets) {
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketFacePlayer struct {
|
|
FeetEyes int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
IsEntity bool
|
|
EntityId any
|
|
EntityFeetEyes any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketFacePlayer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.FeetEyes, 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.IsEntity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
var PlayToClientPacketFacePlayerEntityIdTrueTmp int32
|
|
PlayToClientPacketFacePlayerEntityIdTrueTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketFacePlayerEntityIdTrueTmp
|
|
default:
|
|
var PlayToClientPacketFacePlayerEntityIdTmp struct {
|
|
}
|
|
ret.EntityId = PlayToClientPacketFacePlayerEntityIdTmp
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
var PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp string
|
|
PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp
|
|
default:
|
|
var PlayToClientPacketFacePlayerEntityFeetEyesTmp struct {
|
|
}
|
|
ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketFacePlayer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.FeetEyes)
|
|
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.IsEntity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
PlayToClientPacketFacePlayerEntityId, ok := ret.EntityId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
PlayToClientPacketFacePlayerEntityFeetEyes, ok := ret.EntityFeetEyes.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketFacePlayerEntityFeetEyes)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityFeetEyes.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketGameStateChange struct {
|
|
Reason uint8
|
|
GameMode float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketGameStateChange) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.GameMode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketGameStateChange) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.GameMode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketHeldItemSlot struct {
|
|
Slot int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketHeldItemSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketKeepAlive) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketKickDisconnect struct {
|
|
Reason string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketKickDisconnect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Reason, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketKickDisconnect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketLogin struct {
|
|
EntityId int32
|
|
GameMode uint8
|
|
Dimension int32
|
|
MaxPlayers uint8
|
|
LevelType string
|
|
ViewDistance int32
|
|
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.MaxPlayers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.LevelType, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ViewDistance, err = proto_base.DecodeVarInt(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.MaxPlayers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.LevelType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ReducedDebugInfo)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMap struct {
|
|
ItemDamage int32
|
|
Scale int8
|
|
TrackingPosition bool
|
|
Locked bool
|
|
Icons []struct {
|
|
Type int32
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *string
|
|
}
|
|
Columns int8
|
|
Rows any
|
|
X any
|
|
Y any
|
|
Data any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMap) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ItemDamage, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.TrackingPosition)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Locked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapIcons int32
|
|
lPlayToClientPacketMapIcons, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Icons = []struct {
|
|
Type int32
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *string
|
|
}{}
|
|
for range lPlayToClientPacketMapIcons {
|
|
var PlayToClientPacketMapIconsElement struct {
|
|
Type int32
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *string
|
|
}
|
|
PlayToClientPacketMapIconsElement.Type, err = proto_base.DecodeVarInt(r)
|
|
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
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketMapIconsElementDisplayNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElementDisplayNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketMapIconsElementDisplayNamePresent {
|
|
var PlayToClientPacketMapIconsElementDisplayNamePresentValue string
|
|
PlayToClientPacketMapIconsElementDisplayNamePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapIconsElement.DisplayName = &PlayToClientPacketMapIconsElementDisplayNamePresentValue
|
|
}
|
|
ret.Icons = append(ret.Icons, PlayToClientPacketMapIconsElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Columns)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapRows0Tmp struct {
|
|
}
|
|
ret.Rows = PlayToClientPacketMapRows0Tmp
|
|
default:
|
|
var PlayToClientPacketMapRowsTmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapRowsTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rows = PlayToClientPacketMapRowsTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapX0Tmp struct {
|
|
}
|
|
ret.X = PlayToClientPacketMapX0Tmp
|
|
default:
|
|
var PlayToClientPacketMapXTmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapXTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketMapXTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapY0Tmp struct {
|
|
}
|
|
ret.Y = PlayToClientPacketMapY0Tmp
|
|
default:
|
|
var PlayToClientPacketMapYTmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapYTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToClientPacketMapYTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapData0Tmp struct {
|
|
}
|
|
ret.Data = PlayToClientPacketMapData0Tmp
|
|
default:
|
|
var PlayToClientPacketMapDataTmp []byte
|
|
var lPlayToClientPacketMapData int32
|
|
lPlayToClientPacketMapData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapDataTmp, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientPacketMapDataTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketMap) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ItemDamage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.TrackingPosition)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Locked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Icons)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapIcons := range len(ret.Icons) {
|
|
err = proto_base.EncodeVarInt(w, ret.Icons[iPlayToClientPacketMapIcons].Type)
|
|
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.Icons[iPlayToClientPacketMapIcons].Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Icons[iPlayToClientPacketMapIcons].DisplayName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Icons[iPlayToClientPacketMapIcons].DisplayName != nil {
|
|
err = proto_base.EncodeString(w, *ret.Icons[iPlayToClientPacketMapIcons].DisplayName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Columns)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Rows.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Rows.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Rows.(int8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.X.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.X.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X.(int8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Y.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Y.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y.(int8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data.([]byte)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Data.([]byte))))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.Data.([]byte))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMapChunk struct {
|
|
X int32
|
|
Z int32
|
|
GroundUp bool
|
|
BitMap int32
|
|
Heightmaps nbt.Tag
|
|
ChunkData []byte
|
|
BlockEntities []nbt.Tag
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMapChunk) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.GroundUp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BitMap, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Heightmaps.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapChunkChunkData int32
|
|
lPlayToClientPacketMapChunkChunkData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkData, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapChunkChunkData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapChunkBlockEntities int32
|
|
lPlayToClientPacketMapChunkBlockEntities, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockEntities = []nbt.Tag{}
|
|
for range lPlayToClientPacketMapChunkBlockEntities {
|
|
var PlayToClientPacketMapChunkBlockEntitiesElement nbt.Tag
|
|
err = PlayToClientPacketMapChunkBlockEntitiesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockEntities = append(ret.BlockEntities, PlayToClientPacketMapChunkBlockEntitiesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketMapChunk) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.GroundUp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.BitMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapChunkHeightmapsEncTmp := ret.Heightmaps
|
|
err = PlayToClientPacketMapChunkHeightmapsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ChunkData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.ChunkData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockEntities)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkBlockEntities := range len(ret.BlockEntities) {
|
|
PlayToClientPacketMapChunkBlockEntitiesInnerEncTmp := ret.BlockEntities[iPlayToClientPacketMapChunkBlockEntities]
|
|
err = PlayToClientPacketMapChunkBlockEntitiesInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMultiBlockChange struct {
|
|
ChunkX int32
|
|
ChunkZ int32
|
|
Records []struct {
|
|
HorizontalPos uint8
|
|
Y uint8
|
|
BlockId int32
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMultiBlockChange) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMultiBlockChangeRecords int32
|
|
lPlayToClientPacketMultiBlockChangeRecords, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Records = []struct {
|
|
HorizontalPos uint8
|
|
Y uint8
|
|
BlockId int32
|
|
}{}
|
|
for range lPlayToClientPacketMultiBlockChangeRecords {
|
|
var PlayToClientPacketMultiBlockChangeRecordsElement struct {
|
|
HorizontalPos uint8
|
|
Y uint8
|
|
BlockId int32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeRecordsElement.HorizontalPos)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeRecordsElement.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMultiBlockChangeRecordsElement.BlockId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Records)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].HorizontalPos)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].BlockId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketNamedEntitySpawn struct {
|
|
EntityId int32
|
|
PlayerUUID uuid.UUID
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw int8
|
|
Pitch int8
|
|
Metadata EntityMetadata
|
|
}
|
|
|
|
func (ret *PlayToClientPacketNamedEntitySpawn) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.PlayerUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Metadata.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketNamedEntitySpawn) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.PlayerUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketNamedEntitySpawnMetadataEncTmp := ret.Metadata
|
|
err = PlayToClientPacketNamedEntitySpawnMetadataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketNamedSoundEffect struct {
|
|
SoundName string
|
|
SoundCategory int32
|
|
X int32
|
|
Y int32
|
|
Z int32
|
|
Volume float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketNamedSoundEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.SoundName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SoundCategory, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketNamedSoundEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.SoundName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SoundCategory)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketNbtQueryResponse struct {
|
|
TransactionId int32
|
|
Nbt nbt.Tag
|
|
}
|
|
|
|
func (ret *PlayToClientPacketNbtQueryResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Nbt.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketNbtQueryResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketNbtQueryResponseNbtEncTmp := ret.Nbt
|
|
err = PlayToClientPacketNbtQueryResponseNbtEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenBook struct {
|
|
Hand int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenBook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenBook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenHorseWindow struct {
|
|
WindowId uint8
|
|
NbSlots int32
|
|
EntityId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenHorseWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NbSlots, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenHorseWindow) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.NbSlots)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
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 int32
|
|
InventoryType int32
|
|
WindowTitle string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenWindow) Decode(r io.ReadSeeker) (err error) {
|
|
ret.WindowId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.InventoryType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WindowTitle, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenWindow) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.InventoryType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.WindowTitle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerInfo struct {
|
|
Action string
|
|
Data []struct {
|
|
Uuid uuid.UUID
|
|
Anon any
|
|
}
|
|
}
|
|
|
|
var PlayToClientPacketPlayerInfoActionMap = map[int32]string{0: "add_player", 1: "update_game_mode", 2: "update_latency", 3: "update_display_name", 4: "remove_player"}
|
|
|
|
func (ret *PlayToClientPacketPlayerInfo) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketPlayerInfoActionKey int32
|
|
PlayToClientPacketPlayerInfoActionKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.ErroringIndex(PlayToClientPacketPlayerInfoActionMap, PlayToClientPacketPlayerInfoActionKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketPlayerInfoData int32
|
|
lPlayToClientPacketPlayerInfoData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = []struct {
|
|
Uuid uuid.UUID
|
|
Anon any
|
|
}{}
|
|
for range lPlayToClientPacketPlayerInfoData {
|
|
var PlayToClientPacketPlayerInfoDataElement struct {
|
|
Uuid uuid.UUID
|
|
Anon any
|
|
}
|
|
_, err = io.ReadFull(r, PlayToClientPacketPlayerInfoDataElement.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case "add_player":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp struct {
|
|
Name string
|
|
Properties []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
Gamemode int32
|
|
Ping int32
|
|
DisplayName *string
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties int32
|
|
lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties = []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}{}
|
|
for range lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties {
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Value, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent {
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue string
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Signature = &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties = append(PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties, PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement)
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Gamemode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Ping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent {
|
|
var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue string
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.DisplayName = &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp
|
|
case "remove_player":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonRemovePlayerTmp struct {
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonRemovePlayerTmp
|
|
case "update_display_name":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp struct {
|
|
DisplayName *string
|
|
}
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent {
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue string
|
|
PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp.DisplayName = &PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp
|
|
case "update_game_mode":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp struct {
|
|
Gamemode int32
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp.Gamemode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp
|
|
case "update_latency":
|
|
var PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp struct {
|
|
Ping int32
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp.Ping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp
|
|
}
|
|
ret.Data = append(ret.Data, PlayToClientPacketPlayerInfoDataElement)
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketPlayerInfoActionReverseMap = map[string]int32{"add_player": 0, "update_game_mode": 1, "update_latency": 2, "update_display_name": 3, "remove_player": 4}
|
|
|
|
func (ret *PlayToClientPacketPlayerInfo) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientPacketPlayerInfoAction int32
|
|
vPlayToClientPacketPlayerInfoAction, err = proto_base.ErroringIndex(PlayToClientPacketPlayerInfoActionReverseMap, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToClientPacketPlayerInfoAction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Data)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketPlayerInfoData := range len(ret.Data) {
|
|
_, err = w.Write(ret.Data[iPlayToClientPacketPlayerInfoData].Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case "add_player":
|
|
PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
Name string
|
|
Properties []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
Gamemode int32
|
|
Ping int32
|
|
DisplayName *string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketPlayerInfoDataInnerAnon.Properties)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketPlayerInfoDataInnerAnonProperties := range len(PlayToClientPacketPlayerInfoDataInnerAnon.Properties) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature != nil {
|
|
err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Gamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Ping)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil {
|
|
err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "remove_player":
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "update_display_name":
|
|
PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
DisplayName *string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil {
|
|
err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "update_game_mode":
|
|
PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
Gamemode int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Gamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_latency":
|
|
PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
|
|
Ping int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Ping)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerlistHeader struct {
|
|
Header string
|
|
Footer string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPlayerlistHeader) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Header, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Footer, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPlayerlistHeader) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Header)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Footer)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPosition struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
Flags int8
|
|
TeleportId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPosition) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TeleportId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPosition) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.TeleportId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRelEntityMove struct {
|
|
EntityId int32
|
|
DX int16
|
|
DY int16
|
|
DZ int16
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketRelEntityMove) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketRelEntityMove) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRemoveEntityEffect struct {
|
|
EntityId int32
|
|
EffectId int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketRemoveEntityEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketRemoveEntityEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketResourcePackSend struct {
|
|
Url string
|
|
Hash string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketResourcePackSend) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketResourcePackSend) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRespawn struct {
|
|
Dimension int32
|
|
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.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.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 int32
|
|
PlayToClientPacketScoreboardObjectiveType0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveType0Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveType2Tmp int32
|
|
PlayToClientPacketScoreboardObjectiveType2Tmp, err = proto_base.DecodeVarInt(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.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketScoreboardObjectiveType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketScoreboardObjectiveType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Type.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardScore struct {
|
|
ItemName string
|
|
Action int32
|
|
ScoreName string
|
|
Value any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketScoreboardScore) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ItemName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ScoreName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
var PlayToClientPacketScoreboardScoreValue1Tmp struct {
|
|
}
|
|
ret.Value = PlayToClientPacketScoreboardScoreValue1Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardScoreValueTmp int32
|
|
PlayToClientPacketScoreboardScoreValueTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = PlayToClientPacketScoreboardScoreValueTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketScoreboardScore) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.ItemName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.ScoreName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
_, ok := ret.Value.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Value.(int32))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSelectAdvancementTab struct {
|
|
Id *string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSelectAdvancementTab) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketSelectAdvancementTabIdPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketSelectAdvancementTabIdPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketSelectAdvancementTabIdPresent {
|
|
var PlayToClientPacketSelectAdvancementTabIdPresentValue string
|
|
PlayToClientPacketSelectAdvancementTabIdPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Id = &PlayToClientPacketSelectAdvancementTabIdPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSelectAdvancementTab) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Id != nil {
|
|
err = proto_base.EncodeString(w, *ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetCooldown struct {
|
|
ItemID int32
|
|
CooldownTicks int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetCooldown) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ItemID, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CooldownTicks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetCooldown) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ItemID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.CooldownTicks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetPassengers struct {
|
|
EntityId int32
|
|
Passengers []int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetPassengers) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketSetPassengersPassengers int32
|
|
lPlayToClientPacketSetPassengersPassengers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Passengers = []int32{}
|
|
for range lPlayToClientPacketSetPassengersPassengers {
|
|
var PlayToClientPacketSetPassengersPassengersElement int32
|
|
PlayToClientPacketSetPassengersPassengersElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Passengers = append(ret.Passengers, PlayToClientPacketSetPassengersPassengersElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetPassengers) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Passengers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketSetPassengersPassengers := range len(ret.Passengers) {
|
|
err = proto_base.EncodeVarInt(w, ret.Passengers[iPlayToClientPacketSetPassengersPassengers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetSlot struct {
|
|
WindowId int8
|
|
Slot int16
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSetSlotItemEncTmp := ret.Item
|
|
err = PlayToClientPacketSetSlotItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSoundEffect struct {
|
|
SoundId int32
|
|
SoundCategory int32
|
|
X int32
|
|
Y int32
|
|
Z int32
|
|
Volume float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSoundEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.SoundId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SoundCategory, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSoundEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.SoundId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SoundCategory)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntity struct {
|
|
EntityId int32
|
|
ObjectUUID uuid.UUID
|
|
Type int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Pitch int8
|
|
Yaw int8
|
|
ObjectData int32
|
|
Velocity Vec3i16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.ObjectUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ObjectData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Velocity.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.ObjectUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ObjectData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityVelocityEncTmp := ret.Velocity
|
|
err = PlayToClientPacketSpawnEntityVelocityEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityExperienceOrb struct {
|
|
EntityId int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Count int16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityExperienceOrb) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Count)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityExperienceOrb) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Count)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityLiving struct {
|
|
EntityId int32
|
|
EntityUUID uuid.UUID
|
|
Type int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw int8
|
|
Pitch int8
|
|
HeadPitch int8
|
|
Velocity Vec3i16
|
|
Metadata EntityMetadata
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityLiving) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HeadPitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Velocity.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Metadata.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityLiving) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HeadPitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityLivingVelocityEncTmp := ret.Velocity
|
|
err = PlayToClientPacketSpawnEntityLivingVelocityEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityLivingMetadataEncTmp := ret.Metadata
|
|
err = PlayToClientPacketSpawnEntityLivingMetadataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityPainting struct {
|
|
EntityId int32
|
|
EntityUUID uuid.UUID
|
|
Title int32
|
|
Location Position
|
|
Direction uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityPainting) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityPainting) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Title)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityPaintingLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketSpawnEntityPaintingLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityWeather struct {
|
|
EntityId int32
|
|
Type int8
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityWeather) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityWeather) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnPosition struct {
|
|
Location Position
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnPosition) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnPosition) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketSpawnPositionLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketSpawnPositionLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStatistics struct {
|
|
Entries []struct {
|
|
CategoryId int32
|
|
StatisticId int32
|
|
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 {
|
|
CategoryId int32
|
|
StatisticId int32
|
|
Value int32
|
|
}{}
|
|
for range lPlayToClientPacketStatisticsEntries {
|
|
var PlayToClientPacketStatisticsEntriesElement struct {
|
|
CategoryId int32
|
|
StatisticId int32
|
|
Value int32
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.CategoryId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.StatisticId, err = proto_base.DecodeVarInt(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.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].CategoryId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].StatisticId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStopSound struct {
|
|
Flags int8
|
|
Source any
|
|
Sound any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketStopSound) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
var PlayToClientPacketStopSoundSource1Tmp int32
|
|
PlayToClientPacketStopSoundSource1Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSource1Tmp
|
|
case 3:
|
|
var PlayToClientPacketStopSoundSource3Tmp int32
|
|
PlayToClientPacketStopSoundSource3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSource3Tmp
|
|
default:
|
|
var PlayToClientPacketStopSoundSourceTmp struct {
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSourceTmp
|
|
}
|
|
switch ret.Flags {
|
|
case 2:
|
|
var PlayToClientPacketStopSoundSound2Tmp string
|
|
PlayToClientPacketStopSoundSound2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sound = PlayToClientPacketStopSoundSound2Tmp
|
|
case 3:
|
|
var PlayToClientPacketStopSoundSound3Tmp string
|
|
PlayToClientPacketStopSoundSound3Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sound = PlayToClientPacketStopSoundSound3Tmp
|
|
default:
|
|
var PlayToClientPacketStopSoundSoundTmp struct {
|
|
}
|
|
ret.Sound = PlayToClientPacketStopSoundSoundTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketStopSound) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
PlayToClientPacketStopSoundSource, ok := ret.Source.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketStopSoundSource, ok := ret.Source.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Source.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags {
|
|
case 2:
|
|
PlayToClientPacketStopSoundSound, ok := ret.Sound.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketStopSoundSound, ok := ret.Sound.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Sound.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTabComplete struct {
|
|
TransactionId int32
|
|
Start int32
|
|
Length int32
|
|
Matches []struct {
|
|
Match string
|
|
Tooltip *string
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Start, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Length, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketTabCompleteMatches int32
|
|
lPlayToClientPacketTabCompleteMatches, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Matches = []struct {
|
|
Match string
|
|
Tooltip *string
|
|
}{}
|
|
for range lPlayToClientPacketTabCompleteMatches {
|
|
var PlayToClientPacketTabCompleteMatchesElement struct {
|
|
Match string
|
|
Tooltip *string
|
|
}
|
|
PlayToClientPacketTabCompleteMatchesElement.Match, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketTabCompleteMatchesElementTooltipPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTabCompleteMatchesElementTooltipPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketTabCompleteMatchesElementTooltipPresent {
|
|
var PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue string
|
|
PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTabCompleteMatchesElement.Tooltip = &PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue
|
|
}
|
|
ret.Matches = append(ret.Matches, PlayToClientPacketTabCompleteMatchesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTabComplete) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Start)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Length)
|
|
if err != nil {
|
|
return
|
|
}
|
|
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].Match)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil {
|
|
err = proto_base.EncodeString(w, *ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTags struct {
|
|
BlockTags Tags
|
|
ItemTags Tags
|
|
FluidTags Tags
|
|
EntityTags Tags
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTags) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.BlockTags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.ItemTags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.FluidTags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.EntityTags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTags) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketTagsBlockTagsEncTmp := ret.BlockTags
|
|
err = PlayToClientPacketTagsBlockTagsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTagsItemTagsEncTmp := ret.ItemTags
|
|
err = PlayToClientPacketTagsItemTagsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTagsFluidTagsEncTmp := ret.FluidTags
|
|
err = PlayToClientPacketTagsFluidTagsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTagsEntityTagsEncTmp := ret.EntityTags
|
|
err = PlayToClientPacketTagsEntityTagsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTeams struct {
|
|
Team string
|
|
Mode int8
|
|
Name any
|
|
FriendlyFire any
|
|
NameTagVisibility any
|
|
CollisionRule any
|
|
Formatting any
|
|
Prefix any
|
|
Suffix any
|
|
Players any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTeams) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Team, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsName0Tmp string
|
|
PlayToClientPacketTeamsName0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsName0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsName2Tmp string
|
|
PlayToClientPacketTeamsName2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsName2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsNameTmp struct {
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsNameTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsFriendlyFire0Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsFriendlyFire0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFire0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsFriendlyFire2Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsFriendlyFire2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFire2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsFriendlyFireTmp struct {
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFireTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsNameTagVisibility0Tmp string
|
|
PlayToClientPacketTeamsNameTagVisibility0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibility0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsNameTagVisibility2Tmp string
|
|
PlayToClientPacketTeamsNameTagVisibility2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibility2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsNameTagVisibilityTmp struct {
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibilityTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsCollisionRule0Tmp string
|
|
PlayToClientPacketTeamsCollisionRule0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRule0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsCollisionRule2Tmp string
|
|
PlayToClientPacketTeamsCollisionRule2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRule2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsCollisionRuleTmp struct {
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRuleTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsFormatting0Tmp int32
|
|
PlayToClientPacketTeamsFormatting0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Formatting = PlayToClientPacketTeamsFormatting0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsFormatting2Tmp int32
|
|
PlayToClientPacketTeamsFormatting2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Formatting = PlayToClientPacketTeamsFormatting2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsFormattingTmp struct {
|
|
}
|
|
ret.Formatting = PlayToClientPacketTeamsFormattingTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsPrefix0Tmp string
|
|
PlayToClientPacketTeamsPrefix0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefix0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsPrefix2Tmp string
|
|
PlayToClientPacketTeamsPrefix2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefix2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsPrefixTmp struct {
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefixTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsSuffix0Tmp string
|
|
PlayToClientPacketTeamsSuffix0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffix0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsSuffix2Tmp string
|
|
PlayToClientPacketTeamsSuffix2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffix2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsSuffixTmp struct {
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffixTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsPlayers0Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers0Tmp int32
|
|
lPlayToClientPacketTeamsPlayers0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers0Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers0Tmp {
|
|
var PlayToClientPacketTeamsPlayers0TmpElement string
|
|
PlayToClientPacketTeamsPlayers0TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers0Tmp = append(PlayToClientPacketTeamsPlayers0Tmp, PlayToClientPacketTeamsPlayers0TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers0Tmp
|
|
case 3:
|
|
var PlayToClientPacketTeamsPlayers3Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers3Tmp int32
|
|
lPlayToClientPacketTeamsPlayers3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers3Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers3Tmp {
|
|
var PlayToClientPacketTeamsPlayers3TmpElement string
|
|
PlayToClientPacketTeamsPlayers3TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers3Tmp = append(PlayToClientPacketTeamsPlayers3Tmp, PlayToClientPacketTeamsPlayers3TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers3Tmp
|
|
case 4:
|
|
var PlayToClientPacketTeamsPlayers4Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers4Tmp int32
|
|
lPlayToClientPacketTeamsPlayers4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers4Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers4Tmp {
|
|
var PlayToClientPacketTeamsPlayers4TmpElement string
|
|
PlayToClientPacketTeamsPlayers4TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers4Tmp = append(PlayToClientPacketTeamsPlayers4Tmp, PlayToClientPacketTeamsPlayers4TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers4Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsPlayersTmp struct {
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayersTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTeams) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Team)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsName, ok := ret.Name.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsName, ok := ret.Name.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Name.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsFriendlyFire, ok := ret.FriendlyFire.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsFriendlyFire)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsFriendlyFire, ok := ret.FriendlyFire.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsFriendlyFire)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.FriendlyFire.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsNameTagVisibility, ok := ret.NameTagVisibility.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsNameTagVisibility)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsNameTagVisibility, ok := ret.NameTagVisibility.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsNameTagVisibility)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.NameTagVisibility.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsCollisionRule, ok := ret.CollisionRule.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsCollisionRule)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsCollisionRule, ok := ret.CollisionRule.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsCollisionRule)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.CollisionRule.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsFormatting, ok := ret.Formatting.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsFormatting)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsFormatting, ok := ret.Formatting.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsFormatting)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Formatting.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsPrefix, ok := ret.Prefix.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPrefix)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsPrefix, ok := ret.Prefix.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPrefix)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Prefix.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsSuffix, ok := ret.Suffix.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsSuffix)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsSuffix, ok := ret.Suffix.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsSuffix)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Suffix.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 3:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 4:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Players.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTileEntityData struct {
|
|
Location Position
|
|
Action uint8
|
|
NbtData nbt.Tag
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTileEntityData) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NbtData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTileEntityData) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketTileEntityDataLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketTileEntityDataLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTileEntityDataNbtDataEncTmp := ret.NbtData
|
|
err = PlayToClientPacketTileEntityDataNbtDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTitle struct {
|
|
Action int32
|
|
Text any
|
|
FadeIn any
|
|
Stay any
|
|
FadeOut any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTitle) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketTitleText0Tmp string
|
|
PlayToClientPacketTitleText0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text = PlayToClientPacketTitleText0Tmp
|
|
case 1:
|
|
var PlayToClientPacketTitleText1Tmp string
|
|
PlayToClientPacketTitleText1Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text = PlayToClientPacketTitleText1Tmp
|
|
case 2:
|
|
var PlayToClientPacketTitleText2Tmp string
|
|
PlayToClientPacketTitleText2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text = PlayToClientPacketTitleText2Tmp
|
|
default:
|
|
var PlayToClientPacketTitleTextTmp struct {
|
|
}
|
|
ret.Text = PlayToClientPacketTitleTextTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketTitleFadeIn3Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleFadeIn3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FadeIn = PlayToClientPacketTitleFadeIn3Tmp
|
|
default:
|
|
var PlayToClientPacketTitleFadeInTmp struct {
|
|
}
|
|
ret.FadeIn = PlayToClientPacketTitleFadeInTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketTitleStay3Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleStay3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Stay = PlayToClientPacketTitleStay3Tmp
|
|
default:
|
|
var PlayToClientPacketTitleStayTmp struct {
|
|
}
|
|
ret.Stay = PlayToClientPacketTitleStayTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketTitleFadeOut3Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleFadeOut3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FadeOut = PlayToClientPacketTitleFadeOut3Tmp
|
|
default:
|
|
var PlayToClientPacketTitleFadeOutTmp struct {
|
|
}
|
|
ret.FadeOut = PlayToClientPacketTitleFadeOutTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTitle) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketTitleText, ok := ret.Text.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTitleText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
PlayToClientPacketTitleText, ok := ret.Text.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTitleText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTitleText, ok := ret.Text.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTitleText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Text.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketTitleFadeIn, ok := ret.FadeIn.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleFadeIn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.FadeIn.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketTitleStay, ok := ret.Stay.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleStay)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Stay.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketTitleFadeOut, ok := ret.FadeOut.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleFadeOut)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.FadeOut.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTradeList struct {
|
|
WindowId int32
|
|
Trades []struct {
|
|
InputItem1 Slot
|
|
OutputItem Slot
|
|
InputItem2 *Slot
|
|
TradeDisabled bool
|
|
NbTradeUses int32
|
|
MaximumNbTradeUses int32
|
|
Xp int32
|
|
SpecialPrice int32
|
|
PriceMultiplier float32
|
|
Demand int32
|
|
}
|
|
VillagerLevel int32
|
|
Experience int32
|
|
IsRegularVillager bool
|
|
CanRestock bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTradeList) Decode(r io.ReadSeeker) (err error) {
|
|
ret.WindowId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketTradeListTrades uint8
|
|
err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketTradeListTrades)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Trades = []struct {
|
|
InputItem1 Slot
|
|
OutputItem Slot
|
|
InputItem2 *Slot
|
|
TradeDisabled bool
|
|
NbTradeUses int32
|
|
MaximumNbTradeUses int32
|
|
Xp int32
|
|
SpecialPrice int32
|
|
PriceMultiplier float32
|
|
Demand int32
|
|
}{}
|
|
for range lPlayToClientPacketTradeListTrades {
|
|
var PlayToClientPacketTradeListTradesElement struct {
|
|
InputItem1 Slot
|
|
OutputItem Slot
|
|
InputItem2 *Slot
|
|
TradeDisabled bool
|
|
NbTradeUses int32
|
|
MaximumNbTradeUses int32
|
|
Xp int32
|
|
SpecialPrice int32
|
|
PriceMultiplier float32
|
|
Demand int32
|
|
}
|
|
err = PlayToClientPacketTradeListTradesElement.InputItem1.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTradeListTradesElement.OutputItem.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketTradeListTradesElementInputItem2Present bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElementInputItem2Present)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketTradeListTradesElementInputItem2Present {
|
|
var PlayToClientPacketTradeListTradesElementInputItem2PresentValue Slot
|
|
err = PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem2 = &PlayToClientPacketTradeListTradesElementInputItem2PresentValue
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.TradeDisabled)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.NbTradeUses)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.MaximumNbTradeUses)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Xp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.SpecialPrice)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.PriceMultiplier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Demand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Trades = append(ret.Trades, PlayToClientPacketTradeListTradesElement)
|
|
}
|
|
ret.VillagerLevel, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Experience, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsRegularVillager)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CanRestock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTradeList) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, uint8(len(ret.Trades)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTradeListTrades := range len(ret.Trades) {
|
|
PlayToClientPacketTradeListTradesInnerInputItem1EncTmp := ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1
|
|
err = PlayToClientPacketTradeListTradesInnerInputItem1EncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesInnerOutputItemEncTmp := ret.Trades[iPlayToClientPacketTradeListTrades].OutputItem
|
|
err = PlayToClientPacketTradeListTradesInnerOutputItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil {
|
|
PlayToClientPacketTradeListTradesInnerInputItem2EncTmp := *ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2
|
|
err = PlayToClientPacketTradeListTradesInnerInputItem2EncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].TradeDisabled)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].NbTradeUses)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].MaximumNbTradeUses)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Xp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].SpecialPrice)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].PriceMultiplier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Demand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.VillagerLevel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Experience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsRegularVillager)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CanRestock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTransaction struct {
|
|
WindowId int8
|
|
Action int16
|
|
Accepted bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTransaction) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Accepted)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTransaction) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Accepted)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUnloadChunk struct {
|
|
ChunkX int32
|
|
ChunkZ int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUnloadChunk) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUnloadChunk) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUnlockRecipes struct {
|
|
Action int32
|
|
CraftingBookOpen bool
|
|
FilteringCraftable bool
|
|
SmeltingBookOpen bool
|
|
FilteringSmeltable bool
|
|
Recipes1 []string
|
|
Recipes2 any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUnlockRecipes) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FilteringCraftable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SmeltingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FilteringSmeltable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketUnlockRecipesRecipes1 int32
|
|
lPlayToClientPacketUnlockRecipesRecipes1, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes1 = []string{}
|
|
for range lPlayToClientPacketUnlockRecipesRecipes1 {
|
|
var PlayToClientPacketUnlockRecipesRecipes1Element string
|
|
PlayToClientPacketUnlockRecipesRecipes1Element, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes1 = append(ret.Recipes1, PlayToClientPacketUnlockRecipesRecipes1Element)
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketUnlockRecipesRecipes20Tmp []string
|
|
var lPlayToClientPacketUnlockRecipesRecipes20Tmp int32
|
|
lPlayToClientPacketUnlockRecipesRecipes20Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUnlockRecipesRecipes20Tmp = []string{}
|
|
for range lPlayToClientPacketUnlockRecipesRecipes20Tmp {
|
|
var PlayToClientPacketUnlockRecipesRecipes20TmpElement string
|
|
PlayToClientPacketUnlockRecipesRecipes20TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUnlockRecipesRecipes20Tmp = append(PlayToClientPacketUnlockRecipesRecipes20Tmp, PlayToClientPacketUnlockRecipesRecipes20TmpElement)
|
|
}
|
|
ret.Recipes2 = PlayToClientPacketUnlockRecipesRecipes20Tmp
|
|
default:
|
|
var PlayToClientPacketUnlockRecipesRecipes2Tmp struct {
|
|
}
|
|
ret.Recipes2 = PlayToClientPacketUnlockRecipesRecipes2Tmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUnlockRecipes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilteringCraftable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SmeltingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilteringSmeltable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes1)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUnlockRecipesRecipes1 := range len(ret.Recipes1) {
|
|
err = proto_base.EncodeString(w, ret.Recipes1[iPlayToClientPacketUnlockRecipesRecipes1])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketUnlockRecipesRecipes2, ok := ret.Recipes2.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketUnlockRecipesRecipes2)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUnlockRecipesRecipes2 := range len(PlayToClientPacketUnlockRecipesRecipes2) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketUnlockRecipesRecipes2[iPlayToClientPacketUnlockRecipesRecipes2])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Recipes2.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateHealth struct {
|
|
Health float32
|
|
Food int32
|
|
FoodSaturation float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateHealth) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Health)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Food, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FoodSaturation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateHealth) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Health)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Food)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FoodSaturation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateLight struct {
|
|
ChunkX int32
|
|
ChunkZ int32
|
|
SkyLightMask int32
|
|
BlockLightMask int32
|
|
EmptySkyLightMask int32
|
|
EmptyBlockLightMask int32
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateLight) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ChunkX, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkZ, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptySkyLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptyBlockLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateLight) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SkyLightMask)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.BlockLightMask)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.EmptySkyLightMask)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.EmptyBlockLightMask)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUpdateLightDataEncTmp := ret.Data
|
|
err = PlayToClientPacketUpdateLightDataEncTmp.Encode(w)
|
|
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 PlayToClientPacketUpdateViewDistance struct {
|
|
ViewDistance int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateViewDistance) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ViewDistance, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateViewDistance) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateViewPosition struct {
|
|
ChunkX int32
|
|
ChunkZ int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateViewPosition) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ChunkX, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkZ, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateViewPosition) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketVehicleMove struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketVehicleMove) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketVehicleMove) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWindowItems struct {
|
|
WindowId uint8
|
|
Items []Slot
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWindowItems) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketWindowItemsItems int16
|
|
err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketWindowItemsItems)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Items = []Slot{}
|
|
for range lPlayToClientPacketWindowItemsItems {
|
|
var PlayToClientPacketWindowItemsItemsElement Slot
|
|
err = PlayToClientPacketWindowItemsItemsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Items = append(ret.Items, PlayToClientPacketWindowItemsItemsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWindowItems) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, int16(len(ret.Items)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketWindowItemsItems := range len(ret.Items) {
|
|
PlayToClientPacketWindowItemsItemsInnerEncTmp := ret.Items[iPlayToClientPacketWindowItemsItems]
|
|
err = PlayToClientPacketWindowItemsItemsInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorder struct {
|
|
Action int32
|
|
Radius any
|
|
X any
|
|
Z any
|
|
OldRadius any
|
|
NewRadius any
|
|
Speed any
|
|
PortalBoundary any
|
|
WarningTime any
|
|
WarningBlocks any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldBorder) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketWorldBorderRadius0Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderRadius0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Radius = PlayToClientPacketWorldBorderRadius0Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderRadiusTmp struct {
|
|
}
|
|
ret.Radius = PlayToClientPacketWorldBorderRadiusTmp
|
|
}
|
|
switch ret.Action {
|
|
case 2:
|
|
var PlayToClientPacketWorldBorderX2Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderX2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketWorldBorderX2Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderX3Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderX3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketWorldBorderX3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderXTmp struct {
|
|
}
|
|
ret.X = PlayToClientPacketWorldBorderXTmp
|
|
}
|
|
switch ret.Action {
|
|
case 2:
|
|
var PlayToClientPacketWorldBorderZ2Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderZ2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToClientPacketWorldBorderZ2Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderZ3Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderZ3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToClientPacketWorldBorderZ3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderZTmp struct {
|
|
}
|
|
ret.Z = PlayToClientPacketWorldBorderZTmp
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
var PlayToClientPacketWorldBorderOldRadius1Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderOldRadius1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.OldRadius = PlayToClientPacketWorldBorderOldRadius1Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderOldRadius3Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderOldRadius3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.OldRadius = PlayToClientPacketWorldBorderOldRadius3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderOldRadiusTmp struct {
|
|
}
|
|
ret.OldRadius = PlayToClientPacketWorldBorderOldRadiusTmp
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
var PlayToClientPacketWorldBorderNewRadius1Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderNewRadius1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NewRadius = PlayToClientPacketWorldBorderNewRadius1Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderNewRadius3Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderNewRadius3Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NewRadius = PlayToClientPacketWorldBorderNewRadius3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderNewRadiusTmp struct {
|
|
}
|
|
ret.NewRadius = PlayToClientPacketWorldBorderNewRadiusTmp
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
var PlayToClientPacketWorldBorderSpeed1Tmp int64
|
|
PlayToClientPacketWorldBorderSpeed1Tmp, err = proto_base.DecodeVarLong(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Speed = PlayToClientPacketWorldBorderSpeed1Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderSpeed3Tmp int64
|
|
PlayToClientPacketWorldBorderSpeed3Tmp, err = proto_base.DecodeVarLong(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Speed = PlayToClientPacketWorldBorderSpeed3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderSpeedTmp struct {
|
|
}
|
|
ret.Speed = PlayToClientPacketWorldBorderSpeedTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderPortalBoundary3Tmp int32
|
|
PlayToClientPacketWorldBorderPortalBoundary3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PortalBoundary = PlayToClientPacketWorldBorderPortalBoundary3Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderPortalBoundaryTmp struct {
|
|
}
|
|
ret.PortalBoundary = PlayToClientPacketWorldBorderPortalBoundaryTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderWarningTime3Tmp int32
|
|
PlayToClientPacketWorldBorderWarningTime3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningTime = PlayToClientPacketWorldBorderWarningTime3Tmp
|
|
case 4:
|
|
var PlayToClientPacketWorldBorderWarningTime4Tmp int32
|
|
PlayToClientPacketWorldBorderWarningTime4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningTime = PlayToClientPacketWorldBorderWarningTime4Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderWarningTimeTmp struct {
|
|
}
|
|
ret.WarningTime = PlayToClientPacketWorldBorderWarningTimeTmp
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
var PlayToClientPacketWorldBorderWarningBlocks3Tmp int32
|
|
PlayToClientPacketWorldBorderWarningBlocks3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocks3Tmp
|
|
case 5:
|
|
var PlayToClientPacketWorldBorderWarningBlocks5Tmp int32
|
|
PlayToClientPacketWorldBorderWarningBlocks5Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocks5Tmp
|
|
default:
|
|
var PlayToClientPacketWorldBorderWarningBlocksTmp struct {
|
|
}
|
|
ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocksTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldBorder) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketWorldBorderRadius, ok := ret.Radius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Radius.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 2:
|
|
PlayToClientPacketWorldBorderX, ok := ret.X.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderX, ok := ret.X.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.X.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 2:
|
|
PlayToClientPacketWorldBorderZ, ok := ret.Z.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderZ, ok := ret.Z.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Z.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
PlayToClientPacketWorldBorderOldRadius, ok := ret.OldRadius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderOldRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderOldRadius, ok := ret.OldRadius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderOldRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.OldRadius.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
PlayToClientPacketWorldBorderNewRadius, ok := ret.NewRadius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderNewRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderNewRadius, ok := ret.NewRadius.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderNewRadius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.NewRadius.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 1:
|
|
PlayToClientPacketWorldBorderSpeed, ok := ret.Speed.(int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarLong(w, PlayToClientPacketWorldBorderSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldBorderSpeed, ok := ret.Speed.(int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarLong(w, PlayToClientPacketWorldBorderSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Speed.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketWorldBorderPortalBoundary, ok := ret.PortalBoundary.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderPortalBoundary)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.PortalBoundary.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketWorldBorderWarningTime, ok := ret.WarningTime.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketWorldBorderWarningTime, ok := ret.WarningTime.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.WarningTime.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 3:
|
|
PlayToClientPacketWorldBorderWarningBlocks, ok := ret.WarningBlocks.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningBlocks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 5:
|
|
PlayToClientPacketWorldBorderWarningBlocks, ok := ret.WarningBlocks.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningBlocks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.WarningBlocks.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldEvent struct {
|
|
EffectId int32
|
|
Location Position
|
|
Data int32
|
|
Global bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldEvent) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Data)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Global)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldEvent) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketWorldEventLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketWorldEventLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Data)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Global)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldParticles struct {
|
|
ParticleId int32
|
|
LongDistance bool
|
|
X float32
|
|
Y float32
|
|
Z float32
|
|
OffsetX float32
|
|
OffsetY float32
|
|
OffsetZ float32
|
|
ParticleData float32
|
|
Particles int32
|
|
Data any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldParticles) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ParticleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.LongDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Particles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.ParticleId {
|
|
case 14:
|
|
var PlayToClientPacketWorldParticlesData14Tmp struct {
|
|
Red float32
|
|
Green float32
|
|
Blue float32
|
|
Scale float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldParticlesData14Tmp.Red)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldParticlesData14Tmp.Green)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldParticlesData14Tmp.Blue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldParticlesData14Tmp.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientPacketWorldParticlesData14Tmp
|
|
case 23:
|
|
var PlayToClientPacketWorldParticlesData23Tmp struct {
|
|
BlockState int32
|
|
}
|
|
PlayToClientPacketWorldParticlesData23Tmp.BlockState, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientPacketWorldParticlesData23Tmp
|
|
case 3:
|
|
var PlayToClientPacketWorldParticlesData3Tmp struct {
|
|
BlockState int32
|
|
}
|
|
PlayToClientPacketWorldParticlesData3Tmp.BlockState, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientPacketWorldParticlesData3Tmp
|
|
case 32:
|
|
var PlayToClientPacketWorldParticlesData32Tmp struct {
|
|
Item Slot
|
|
}
|
|
err = PlayToClientPacketWorldParticlesData32Tmp.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientPacketWorldParticlesData32Tmp
|
|
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 14:
|
|
PlayToClientPacketWorldParticlesData, ok := ret.Data.(struct {
|
|
Red float32
|
|
Green float32
|
|
Blue float32
|
|
Scale float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldParticlesData.Red)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldParticlesData.Green)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldParticlesData.Blue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldParticlesData.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 23:
|
|
PlayToClientPacketWorldParticlesData, ok := ret.Data.(struct {
|
|
BlockState int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData.BlockState)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketWorldParticlesData, ok := ret.Data.(struct {
|
|
BlockState int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData.BlockState)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 32:
|
|
PlayToClientPacketWorldParticlesData, ok := ret.Data.(struct {
|
|
Item Slot
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketWorldParticlesDataItemEncTmp := PlayToClientPacketWorldParticlesData.Item
|
|
err = PlayToClientPacketWorldParticlesDataItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var PlayToServerPacketNameMap = map[int32]string{0x00: "teleport_confirm", 0x01: "query_block_nbt", 0x02: "set_difficulty", 0x03: "chat", 0x04: "client_command", 0x05: "settings", 0x06: "tab_complete", 0x07: "transaction", 0x08: "enchant_item", 0x09: "window_click", 0x0a: "close_window", 0x0b: "custom_payload", 0x0c: "edit_book", 0x0d: "query_entity_nbt", 0x0e: "use_entity", 0x0f: "keep_alive", 0x10: "lock_difficulty", 0x11: "position", 0x12: "position_look", 0x13: "look", 0x14: "flying", 0x15: "vehicle_move", 0x16: "steer_boat", 0x17: "pick_item", 0x18: "craft_recipe_request", 0x19: "abilities", 0x1a: "block_dig", 0x1b: "entity_action", 0x1c: "steer_vehicle", 0x1d: "crafting_book_data", 0x1e: "name_item", 0x1f: "resource_pack_receive", 0x20: "advancement_tab", 0x21: "select_trade", 0x22: "set_beacon_effect", 0x23: "held_item_slot", 0x24: "update_command_block", 0x25: "update_command_block_minecart", 0x26: "set_creative_slot", 0x27: "update_jigsaw_block", 0x28: "update_structure_block", 0x29: "update_sign", 0x2a: "arm_animation", 0x2b: "spectate", 0x2c: "block_place", 0x2d: "use_item"}
|
|
|
|
func (ret *PlayToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToServerPacketNameKey int32
|
|
PlayToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(PlayToServerPacketNameMap, PlayToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
var PlayToServerPacketParamsAbilitiesTmp PlayToServerPacketAbilities
|
|
err = PlayToServerPacketParamsAbilitiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsAbilitiesTmp
|
|
case "advancement_tab":
|
|
var PlayToServerPacketParamsAdvancementTabTmp PlayToServerPacketAdvancementTab
|
|
err = PlayToServerPacketParamsAdvancementTabTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsAdvancementTabTmp
|
|
case "arm_animation":
|
|
var PlayToServerPacketParamsArmAnimationTmp PlayToServerPacketArmAnimation
|
|
err = PlayToServerPacketParamsArmAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsArmAnimationTmp
|
|
case "block_dig":
|
|
var PlayToServerPacketParamsBlockDigTmp PlayToServerPacketBlockDig
|
|
err = PlayToServerPacketParamsBlockDigTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsBlockDigTmp
|
|
case "block_place":
|
|
var PlayToServerPacketParamsBlockPlaceTmp PlayToServerPacketBlockPlace
|
|
err = PlayToServerPacketParamsBlockPlaceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsBlockPlaceTmp
|
|
case "chat":
|
|
var PlayToServerPacketParamsChatTmp PlayToServerPacketChat
|
|
err = PlayToServerPacketParamsChatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsChatTmp
|
|
case "client_command":
|
|
var PlayToServerPacketParamsClientCommandTmp PlayToServerPacketClientCommand
|
|
err = PlayToServerPacketParamsClientCommandTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsClientCommandTmp
|
|
case "close_window":
|
|
var PlayToServerPacketParamsCloseWindowTmp PlayToServerPacketCloseWindow
|
|
err = PlayToServerPacketParamsCloseWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCloseWindowTmp
|
|
case "craft_recipe_request":
|
|
var PlayToServerPacketParamsCraftRecipeRequestTmp PlayToServerPacketCraftRecipeRequest
|
|
err = PlayToServerPacketParamsCraftRecipeRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCraftRecipeRequestTmp
|
|
case "crafting_book_data":
|
|
var PlayToServerPacketParamsCraftingBookDataTmp PlayToServerPacketCraftingBookData
|
|
err = PlayToServerPacketParamsCraftingBookDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCraftingBookDataTmp
|
|
case "custom_payload":
|
|
var PlayToServerPacketParamsCustomPayloadTmp PlayToServerPacketCustomPayload
|
|
err = PlayToServerPacketParamsCustomPayloadTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCustomPayloadTmp
|
|
case "edit_book":
|
|
var PlayToServerPacketParamsEditBookTmp PlayToServerPacketEditBook
|
|
err = PlayToServerPacketParamsEditBookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsEditBookTmp
|
|
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 "lock_difficulty":
|
|
var PlayToServerPacketParamsLockDifficultyTmp PlayToServerPacketLockDifficulty
|
|
err = PlayToServerPacketParamsLockDifficultyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsLockDifficultyTmp
|
|
case "look":
|
|
var PlayToServerPacketParamsLookTmp PlayToServerPacketLook
|
|
err = PlayToServerPacketParamsLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsLookTmp
|
|
case "name_item":
|
|
var PlayToServerPacketParamsNameItemTmp PlayToServerPacketNameItem
|
|
err = PlayToServerPacketParamsNameItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsNameItemTmp
|
|
case "pick_item":
|
|
var PlayToServerPacketParamsPickItemTmp PlayToServerPacketPickItem
|
|
err = PlayToServerPacketParamsPickItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsPickItemTmp
|
|
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 "query_block_nbt":
|
|
var PlayToServerPacketParamsQueryBlockNbtTmp PlayToServerPacketQueryBlockNbt
|
|
err = PlayToServerPacketParamsQueryBlockNbtTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsQueryBlockNbtTmp
|
|
case "query_entity_nbt":
|
|
var PlayToServerPacketParamsQueryEntityNbtTmp PlayToServerPacketQueryEntityNbt
|
|
err = PlayToServerPacketParamsQueryEntityNbtTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsQueryEntityNbtTmp
|
|
case "resource_pack_receive":
|
|
var PlayToServerPacketParamsResourcePackReceiveTmp PlayToServerPacketResourcePackReceive
|
|
err = PlayToServerPacketParamsResourcePackReceiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsResourcePackReceiveTmp
|
|
case "select_trade":
|
|
var PlayToServerPacketParamsSelectTradeTmp PlayToServerPacketSelectTrade
|
|
err = PlayToServerPacketParamsSelectTradeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSelectTradeTmp
|
|
case "set_beacon_effect":
|
|
var PlayToServerPacketParamsSetBeaconEffectTmp PlayToServerPacketSetBeaconEffect
|
|
err = PlayToServerPacketParamsSetBeaconEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSetBeaconEffectTmp
|
|
case "set_creative_slot":
|
|
var PlayToServerPacketParamsSetCreativeSlotTmp PlayToServerPacketSetCreativeSlot
|
|
err = PlayToServerPacketParamsSetCreativeSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSetCreativeSlotTmp
|
|
case "set_difficulty":
|
|
var PlayToServerPacketParamsSetDifficultyTmp PlayToServerPacketSetDifficulty
|
|
err = PlayToServerPacketParamsSetDifficultyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSetDifficultyTmp
|
|
case "settings":
|
|
var PlayToServerPacketParamsSettingsTmp PlayToServerPacketSettings
|
|
err = PlayToServerPacketParamsSettingsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSettingsTmp
|
|
case "spectate":
|
|
var PlayToServerPacketParamsSpectateTmp PlayToServerPacketSpectate
|
|
err = PlayToServerPacketParamsSpectateTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSpectateTmp
|
|
case "steer_boat":
|
|
var PlayToServerPacketParamsSteerBoatTmp PlayToServerPacketSteerBoat
|
|
err = PlayToServerPacketParamsSteerBoatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSteerBoatTmp
|
|
case "steer_vehicle":
|
|
var PlayToServerPacketParamsSteerVehicleTmp PlayToServerPacketSteerVehicle
|
|
err = PlayToServerPacketParamsSteerVehicleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSteerVehicleTmp
|
|
case "tab_complete":
|
|
var PlayToServerPacketParamsTabCompleteTmp PlayToServerPacketTabComplete
|
|
err = PlayToServerPacketParamsTabCompleteTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTabCompleteTmp
|
|
case "teleport_confirm":
|
|
var PlayToServerPacketParamsTeleportConfirmTmp PlayToServerPacketTeleportConfirm
|
|
err = PlayToServerPacketParamsTeleportConfirmTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTeleportConfirmTmp
|
|
case "transaction":
|
|
var PlayToServerPacketParamsTransactionTmp PlayToServerPacketTransaction
|
|
err = PlayToServerPacketParamsTransactionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTransactionTmp
|
|
case "update_command_block":
|
|
var PlayToServerPacketParamsUpdateCommandBlockTmp PlayToServerPacketUpdateCommandBlock
|
|
err = PlayToServerPacketParamsUpdateCommandBlockTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateCommandBlockTmp
|
|
case "update_command_block_minecart":
|
|
var PlayToServerPacketParamsUpdateCommandBlockMinecartTmp PlayToServerPacketUpdateCommandBlockMinecart
|
|
err = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp
|
|
case "update_jigsaw_block":
|
|
var PlayToServerPacketParamsUpdateJigsawBlockTmp PlayToServerPacketUpdateJigsawBlock
|
|
err = PlayToServerPacketParamsUpdateJigsawBlockTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateJigsawBlockTmp
|
|
case "update_sign":
|
|
var PlayToServerPacketParamsUpdateSignTmp PlayToServerPacketUpdateSign
|
|
err = PlayToServerPacketParamsUpdateSignTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateSignTmp
|
|
case "update_structure_block":
|
|
var PlayToServerPacketParamsUpdateStructureBlockTmp PlayToServerPacketUpdateStructureBlock
|
|
err = PlayToServerPacketParamsUpdateStructureBlockTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateStructureBlockTmp
|
|
case "use_entity":
|
|
var PlayToServerPacketParamsUseEntityTmp PlayToServerPacketUseEntity
|
|
err = PlayToServerPacketParamsUseEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUseEntityTmp
|
|
case "use_item":
|
|
var PlayToServerPacketParamsUseItemTmp PlayToServerPacketUseItem
|
|
err = PlayToServerPacketParamsUseItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUseItemTmp
|
|
case "vehicle_move":
|
|
var PlayToServerPacketParamsVehicleMoveTmp PlayToServerPacketVehicleMove
|
|
err = PlayToServerPacketParamsVehicleMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsVehicleMoveTmp
|
|
case "window_click":
|
|
var PlayToServerPacketParamsWindowClickTmp PlayToServerPacketWindowClick
|
|
err = PlayToServerPacketParamsWindowClickTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsWindowClickTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToServerPacketNameReverseMap = map[string]int32{"teleport_confirm": 0x00, "query_block_nbt": 0x01, "set_difficulty": 0x02, "chat": 0x03, "client_command": 0x04, "settings": 0x05, "tab_complete": 0x06, "transaction": 0x07, "enchant_item": 0x08, "window_click": 0x09, "close_window": 0x0a, "custom_payload": 0x0b, "edit_book": 0x0c, "query_entity_nbt": 0x0d, "use_entity": 0x0e, "keep_alive": 0x0f, "lock_difficulty": 0x10, "position": 0x11, "position_look": 0x12, "look": 0x13, "flying": 0x14, "vehicle_move": 0x15, "steer_boat": 0x16, "pick_item": 0x17, "craft_recipe_request": 0x18, "abilities": 0x19, "block_dig": 0x1a, "entity_action": 0x1b, "steer_vehicle": 0x1c, "crafting_book_data": 0x1d, "name_item": 0x1e, "resource_pack_receive": 0x1f, "advancement_tab": 0x20, "select_trade": 0x21, "set_beacon_effect": 0x22, "held_item_slot": 0x23, "update_command_block": 0x24, "update_command_block_minecart": 0x25, "set_creative_slot": 0x26, "update_jigsaw_block": 0x27, "update_structure_block": 0x28, "update_sign": 0x29, "arm_animation": 0x2a, "spectate": 0x2b, "block_place": 0x2c, "use_item": 0x2d}
|
|
|
|
func (ret *PlayToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vPlayToServerPacketName int32
|
|
vPlayToServerPacketName, err = proto_base.ErroringIndex(PlayToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAbilities)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "advancement_tab":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAdvancementTab)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "arm_animation":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketArmAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_dig":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockDig)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_place":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockPlace)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "client_command":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketClientCommand)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "close_window":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCloseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_recipe_request":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftRecipeRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "crafting_book_data":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftingBookData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "edit_book":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEditBook)
|
|
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 "lock_difficulty":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLockDifficulty)
|
|
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 "name_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketNameItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "pick_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItem)
|
|
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 "query_block_nbt":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryBlockNbt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "query_entity_nbt":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryEntityNbt)
|
|
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 "select_trade":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectTrade)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_beacon_effect":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetBeaconEffect)
|
|
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 "set_difficulty":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetDifficulty)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "settings":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSettings)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spectate":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSpectate)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "steer_boat":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerBoat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "steer_vehicle":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerVehicle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tab_complete":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTabComplete)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "teleport_confirm":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTeleportConfirm)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "transaction":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTransaction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_command_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_command_block_minecart":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlockMinecart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_jigsaw_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateJigsawBlock)
|
|
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 "update_structure_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateStructureBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "use_entity":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "use_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vehicle_move":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketVehicleMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "window_click":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketWindowClick)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketAbilities struct {
|
|
Flags int8
|
|
FlyingSpeed float32
|
|
WalkingSpeed float32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketAbilities) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketAbilities) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketAdvancementTab struct {
|
|
Action int32
|
|
TabId any
|
|
}
|
|
|
|
func (ret *PlayToServerPacketAdvancementTab) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToServerPacketAdvancementTabTabId0Tmp string
|
|
PlayToServerPacketAdvancementTabTabId0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TabId = PlayToServerPacketAdvancementTabTabId0Tmp
|
|
case 1:
|
|
var PlayToServerPacketAdvancementTabTabId1Tmp struct {
|
|
}
|
|
ret.TabId = PlayToServerPacketAdvancementTabTabId1Tmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketAdvancementTab) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToServerPacketAdvancementTabTabId, ok := ret.TabId.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToServerPacketAdvancementTabTabId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
_, ok := ret.TabId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketArmAnimation struct {
|
|
Hand int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketArmAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketArmAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketBlockDig struct {
|
|
Status int32
|
|
Location Position
|
|
Face int8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketBlockDig) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Status, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Face)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketBlockDig) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Status)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketBlockDigLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketBlockDigLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Face)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketBlockPlace struct {
|
|
Hand int32
|
|
Location Position
|
|
Direction int32
|
|
CursorX float32
|
|
CursorY float32
|
|
CursorZ float32
|
|
InsideBlock bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketBlockPlace) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Direction, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.InsideBlock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketBlockPlace) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketBlockPlaceLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketBlockPlaceLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Direction)
|
|
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
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.InsideBlock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChat struct {
|
|
Message string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketChat) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Message, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketChat) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Message)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketClientCommand struct {
|
|
ActionId int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketClientCommand) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ActionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketClientCommand) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ActionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCloseWindow struct {
|
|
WindowId uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCloseWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCloseWindow) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCraftRecipeRequest struct {
|
|
WindowId int8
|
|
Recipe string
|
|
MakeAll bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCraftRecipeRequest) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipe, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.MakeAll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCraftRecipeRequest) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Recipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.MakeAll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCraftingBookData struct {
|
|
Type int32
|
|
Anon any
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCraftingBookData) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case 0:
|
|
var PlayToServerPacketCraftingBookDataAnon0Tmp struct {
|
|
DisplayedRecipe string
|
|
}
|
|
PlayToServerPacketCraftingBookDataAnon0Tmp.DisplayedRecipe, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = PlayToServerPacketCraftingBookDataAnon0Tmp
|
|
case 1:
|
|
var PlayToServerPacketCraftingBookDataAnon1Tmp struct {
|
|
CraftingBookOpen bool
|
|
CraftingFilter bool
|
|
SmeltingBookOpen bool
|
|
SmeltingFilter bool
|
|
BlastingBookOpen bool
|
|
BlastingFilter bool
|
|
SmokingBookOpen bool
|
|
SmokingFilter bool
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.CraftingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.SmeltingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.SmeltingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.BlastingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.BlastingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.SmokingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCraftingBookDataAnon1Tmp.SmokingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = PlayToServerPacketCraftingBookDataAnon1Tmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCraftingBookData) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case 0:
|
|
PlayToServerPacketCraftingBookDataAnon, ok := ret.Anon.(struct {
|
|
DisplayedRecipe string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToServerPacketCraftingBookDataAnon.DisplayedRecipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
PlayToServerPacketCraftingBookDataAnon, ok := ret.Anon.(struct {
|
|
CraftingBookOpen bool
|
|
CraftingFilter bool
|
|
SmeltingBookOpen bool
|
|
SmeltingFilter bool
|
|
BlastingBookOpen bool
|
|
BlastingFilter bool
|
|
SmokingBookOpen bool
|
|
SmokingFilter bool
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.CraftingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.SmeltingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.SmeltingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.BlastingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.BlastingFilter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.SmokingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketCraftingBookDataAnon.SmokingFilter)
|
|
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 PlayToServerPacketEditBook struct {
|
|
NewBook Slot
|
|
Signing bool
|
|
Hand int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketEditBook) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.NewBook.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Signing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketEditBook) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketEditBookNewBookEncTmp := ret.NewBook
|
|
err = PlayToServerPacketEditBookNewBookEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Signing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEnchantItem struct {
|
|
WindowId int8
|
|
Enchantment int8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketEnchantItem) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Enchantment)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketEnchantItem) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Enchantment)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEntityAction struct {
|
|
EntityId int32
|
|
ActionId int32
|
|
JumpBoost int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketEntityAction) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ActionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.JumpBoost, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketEntityAction) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ActionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.JumpBoost)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketFlying struct {
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketFlying) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketFlying) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketHeldItemSlot struct {
|
|
SlotId int16
|
|
}
|
|
|
|
func (ret *PlayToServerPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.SlotId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketHeldItemSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.SlotId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (ret *PlayToServerPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketKeepAlive) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketLockDifficulty struct {
|
|
Locked bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketLockDifficulty) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Locked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketLockDifficulty) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Locked)
|
|
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 PlayToServerPacketNameItem struct {
|
|
Name string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketNameItem) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketNameItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPickItem struct {
|
|
Slot int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketPickItem) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Slot, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketPickItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Slot)
|
|
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 PlayToServerPacketQueryBlockNbt struct {
|
|
TransactionId int32
|
|
Location Position
|
|
}
|
|
|
|
func (ret *PlayToServerPacketQueryBlockNbt) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketQueryBlockNbt) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketQueryBlockNbtLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketQueryBlockNbtLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketQueryEntityNbt struct {
|
|
TransactionId int32
|
|
EntityId int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketQueryEntityNbt) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketQueryEntityNbt) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketResourcePackReceive struct {
|
|
Result int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketResourcePackReceive) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Result, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Result)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSelectTrade struct {
|
|
Slot int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSelectTrade) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Slot, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSelectTrade) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetBeaconEffect struct {
|
|
PrimaryEffect int32
|
|
SecondaryEffect int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSetBeaconEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.PrimaryEffect, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SecondaryEffect, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSetBeaconEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.PrimaryEffect)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SecondaryEffect)
|
|
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 PlayToServerPacketSetDifficulty struct {
|
|
NewDifficulty uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSetDifficulty) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.NewDifficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSetDifficulty) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.NewDifficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSpectate struct {
|
|
Target uuid.UUID
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSpectate) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Target[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSpectate) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Target[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSteerBoat struct {
|
|
LeftPaddle bool
|
|
RightPaddle bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSteerBoat) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.LeftPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.RightPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSteerBoat) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.LeftPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.RightPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSteerVehicle struct {
|
|
Sideways float32
|
|
Forward float32
|
|
Jump uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSteerVehicle) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Sideways)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forward)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Jump)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSteerVehicle) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Sideways)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forward)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Jump)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTabComplete struct {
|
|
TransactionId int32
|
|
Text string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketTabComplete) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTeleportConfirm struct {
|
|
TeleportId int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketTeleportConfirm) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TeleportId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketTeleportConfirm) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TeleportId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTransaction struct {
|
|
WindowId int8
|
|
Action int16
|
|
Accepted bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketTransaction) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Accepted)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketTransaction) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Accepted)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateCommandBlock struct {
|
|
Location Position
|
|
Command string
|
|
Mode int32
|
|
Flags uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateCommandBlock) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Command, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateCommandBlock) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketUpdateCommandBlockLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketUpdateCommandBlockLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Command)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateCommandBlockMinecart struct {
|
|
EntityId int32
|
|
Command string
|
|
TrackOutput bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateCommandBlockMinecart) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Command, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.TrackOutput)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateCommandBlockMinecart) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Command)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.TrackOutput)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateJigsawBlock struct {
|
|
Location Position
|
|
AttachmentType string
|
|
TargetPool string
|
|
FinalState string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateJigsawBlock) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AttachmentType, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TargetPool, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FinalState, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateJigsawBlock) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketUpdateJigsawBlockLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketUpdateJigsawBlockLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.AttachmentType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.TargetPool)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.FinalState)
|
|
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 PlayToServerPacketUpdateStructureBlock struct {
|
|
Location Position
|
|
Action int32
|
|
Mode int32
|
|
Name string
|
|
OffsetX int8
|
|
OffsetY int8
|
|
OffsetZ int8
|
|
SizeX int8
|
|
SizeY int8
|
|
SizeZ int8
|
|
Mirror int32
|
|
Rotation int32
|
|
Metadata string
|
|
Integrity float32
|
|
Seed int64
|
|
Flags uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateStructureBlock) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
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.SizeX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SizeY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SizeZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mirror, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rotation, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Metadata, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Integrity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Seed, err = proto_base.DecodeVarLong(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateStructureBlock) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketUpdateStructureBlockLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketUpdateStructureBlockLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
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.SizeX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SizeY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SizeZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mirror)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Rotation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Metadata)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Integrity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarLong(w, ret.Seed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUseEntity struct {
|
|
Target int32
|
|
Mouse int32
|
|
X any
|
|
Y any
|
|
Z any
|
|
Hand any
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUseEntity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Target, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mouse, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityX2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityX2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToServerPacketUseEntityX2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityXTmp struct {
|
|
}
|
|
ret.X = PlayToServerPacketUseEntityXTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityY2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityY2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToServerPacketUseEntityY2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityYTmp struct {
|
|
}
|
|
ret.Y = PlayToServerPacketUseEntityYTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityZ2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityZ2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToServerPacketUseEntityZ2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityZTmp struct {
|
|
}
|
|
ret.Z = PlayToServerPacketUseEntityZTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 0:
|
|
var PlayToServerPacketUseEntityHand0Tmp int32
|
|
PlayToServerPacketUseEntityHand0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHand0Tmp
|
|
case 2:
|
|
var PlayToServerPacketUseEntityHand2Tmp int32
|
|
PlayToServerPacketUseEntityHand2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHand2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityHandTmp struct {
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHandTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUseEntity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Target)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mouse)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityX, ok := ret.X.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.X.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityY, ok := ret.Y.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Y.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityZ, ok := ret.Z.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Z.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 0:
|
|
PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Hand.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUseItem struct {
|
|
Hand int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUseItem) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUseItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketVehicleMove struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketVehicleMove) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketVehicleMove) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketWindowClick struct {
|
|
WindowId uint8
|
|
Slot int16
|
|
MouseButton int8
|
|
Action int16
|
|
Mode int8
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToServerPacketWindowClick) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.MouseButton)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketWindowClick) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.MouseButton)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketWindowClickItemEncTmp := ret.Item
|
|
err = PlayToServerPacketWindowClickItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var StatusToClientPacketNameMap = map[int32]string{0x00: "server_info", 0x01: "ping"}
|
|
|
|
func (ret *StatusToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var StatusToClientPacketNameKey int32
|
|
StatusToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(StatusToClientPacketNameMap, StatusToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
var StatusToClientPacketParamsPingTmp StatusToClientPacketPing
|
|
err = StatusToClientPacketParamsPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToClientPacketParamsPingTmp
|
|
case "server_info":
|
|
var StatusToClientPacketParamsServerInfoTmp StatusToClientPacketServerInfo
|
|
err = StatusToClientPacketParamsServerInfoTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToClientPacketParamsServerInfoTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var StatusToClientPacketNameReverseMap = map[string]int32{"server_info": 0x00, "ping": 0x01}
|
|
|
|
func (ret *StatusToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vStatusToClientPacketName int32
|
|
vStatusToClientPacketName, err = proto_base.ErroringIndex(StatusToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vStatusToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToClientPacketParamsEncTmp := StatusToClientPacketParams
|
|
err = StatusToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "server_info":
|
|
StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketServerInfo)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToClientPacketParamsEncTmp := StatusToClientPacketParams
|
|
err = StatusToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketPing struct {
|
|
Time int64
|
|
}
|
|
|
|
func (ret *StatusToClientPacketPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketServerInfo struct {
|
|
Response string
|
|
}
|
|
|
|
func (ret *StatusToClientPacketServerInfo) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Response, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketServerInfo) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Response)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var StatusToServerPacketNameMap = map[int32]string{0x00: "ping_start", 0x01: "ping"}
|
|
|
|
func (ret *StatusToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var StatusToServerPacketNameKey int32
|
|
StatusToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(StatusToServerPacketNameMap, StatusToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
var StatusToServerPacketParamsPingTmp StatusToServerPacketPing
|
|
err = StatusToServerPacketParamsPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToServerPacketParamsPingTmp
|
|
case "ping_start":
|
|
var StatusToServerPacketParamsPingStartTmp StatusToServerPacketPingStart
|
|
err = StatusToServerPacketParamsPingStartTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToServerPacketParamsPingStartTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var StatusToServerPacketNameReverseMap = map[string]int32{"ping_start": 0x00, "ping": 0x01}
|
|
|
|
func (ret *StatusToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vStatusToServerPacketName int32
|
|
vStatusToServerPacketName, err = proto_base.ErroringIndex(StatusToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vStatusToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToServerPacketParamsEncTmp := StatusToServerPacketParams
|
|
err = StatusToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping_start":
|
|
StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPingStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToServerPacketParamsEncTmp := StatusToServerPacketParams
|
|
err = StatusToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketPing struct {
|
|
Time int64
|
|
}
|
|
|
|
func (ret *StatusToServerPacketPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketPingStart struct {
|
|
}
|
|
|
|
func (ret *StatusToServerPacketPingStart) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketPingStart) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|