strom/mc/proto_generated/v1_8/proto.go

// Code generated by strom. DO NOT EDIT.
// source: minecraft-data/pc/1.8/protocol.json (sha256:79fe774bfc255dd281899c004fbb9c7adc40fb107de9353da1dd0371ea4b53af)
// version: v0.6.6-0.20260805154326-fa70ea36c6f5+dirty (go1.26.2)
package v1_8

import (
	"encoding/binary"
	"io"
	"github.com/admin-else/strom/mc/proto_base"
	"github.com/admin-else/strom/mc/nbt"
	"github.com/google/uuid"
)

type ByteArray struct {
	Val []byte
}

func (ret *ByteArray) Decode(r io.ReadSeeker) (err error) {
	var lByteArray int32
	lByteArray, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val, err = io.ReadAll(io.LimitReader(r, int64(lByteArray)))
	if err != nil {
		return
	}
	return
}
func (ret *ByteArray) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.Val)
	if err != nil {
		return
	}
	return
}

type EntityMetadata struct {
	Val map[byte]struct {
		Anon struct {
			Type uint8
			Key  uint8
		}
		Value any
	}
}

func (ret *EntityMetadata) Decode(r io.ReadSeeker) (err error) {
	ret.Val = make(map[uint8]struct {
		Anon struct {
			Type uint8
			Key  uint8
		}
		Value any
	})
	var id uint8
	for {
		err = binary.Read(r, binary.BigEndian, &id)
		if err != nil {
			return
		}
		if id == 127 {
			break
		}
		_, err = r.Seek(-1, io.SeekCurrent)
		if err != nil {
			return
		}
		var entry struct {
			Anon struct {
				Type uint8
				Key  uint8
			}
			Value any
		}
		var EntityMetadataInnerAnonPacked uint8
		err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerAnonPacked)
		if err != nil {
			return
		}
		entry.Anon.Type = EntityMetadataInnerAnonPacked << 0 >> 5
		entry.Anon.Key = EntityMetadataInnerAnonPacked << 3 >> 3
		ret.Val[id] = entry
	}
	return
}
func (ret *EntityMetadata) Encode(w io.Writer) (err error) {
	for _, v := range ret.Val {
		var EntityMetadataAnonPacked uint8
		EntityMetadataAnonPacked |= (uint8(v.Anon.Key) & 0x1F) << 0x0
		EntityMetadataAnonPacked |= (uint8(v.Anon.Type) & 0x7) << 0x5
		err = binary.Write(w, binary.BigEndian, EntityMetadataAnonPacked)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, uint8(127))
	if err != nil {
		return
	}
	return
}

type EntityMetadataItem struct {
	Val any
}

func (ret *EntityMetadataItem) Decode(r io.ReadSeeker) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *EntityMetadataItem) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type Position struct {
	X int32
	Y int16
	Z int32
}

func (ret *Position) Decode(r io.ReadSeeker) (err error) {
	var PositionPacked uint64
	err = binary.Read(r, binary.BigEndian, &PositionPacked)
	if err != nil {
		return
	}
	ret.X = int32(PositionPacked << 0 >> 38)
	if ret.X >= 1<<25 {
		ret.X -= 1 << 26
	}
	ret.Y = int16(PositionPacked << 26 >> 52)
	if ret.Y >= 1<<11 {
		ret.Y -= 1 << 12
	}
	ret.Z = int32(PositionPacked << 38 >> 38)
	if ret.Z >= 1<<25 {
		ret.Z -= 1 << 26
	}
	return
}
func (ret *Position) Encode(w io.Writer) (err error) {
	var PositionPacked uint64
	PositionPacked |= (uint64(ret.Z) & 0x3FFFFFF) << 0x0
	PositionPacked |= (uint64(ret.Y) & 0xFFF) << 0x1A
	PositionPacked |= (uint64(ret.X) & 0x3FFFFFF) << 0x26
	err = binary.Write(w, binary.BigEndian, PositionPacked)
	if err != nil {
		return
	}
	return
}

type Slot struct {
	BlockId int16
	Anon    any
}

func (ret *Slot) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.BlockId)
	if err != nil {
		return
	}
	switch ret.BlockId {
	case -1:
		var SlotAnon1Tmp struct {
		}
		ret.Anon = SlotAnon1Tmp
	default:
		var SlotAnonTmp struct {
			ItemCount  int8
			ItemDamage int16
			NbtData    nbt.Tag
		}
		err = binary.Read(r, binary.BigEndian, &SlotAnonTmp.ItemCount)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &SlotAnonTmp.ItemDamage)
		if err != nil {
			return
		}
		err = SlotAnonTmp.NbtData.Decode(r)
		if err != nil {
			return
		}
		ret.Anon = SlotAnonTmp
	}
	return
}
func (ret *Slot) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.BlockId)
	if err != nil {
		return
	}
	switch ret.BlockId {
	case -1:
		_, ok := ret.Anon.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Anon.(struct {
			ItemCount  int8
			ItemDamage int16
			NbtData    nbt.Tag
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Anon.(struct {
			ItemCount  int8
			ItemDamage int16
			NbtData    nbt.Tag
		}).ItemCount)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Anon.(struct {
			ItemCount  int8
			ItemDamage int16
			NbtData    nbt.Tag
		}).ItemDamage)
		if err != nil {
			return
		}
		SlotAnonNbtDataEncTmp := ret.Anon.(struct {
			ItemCount  int8
			ItemDamage int16
			NbtData    nbt.Tag
		}).NbtData
		err = SlotAnonNbtDataEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type Vec3i16 struct {
	X int16
	Y int16
	Z int16
}

func (ret *Vec3i16) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	return
}
func (ret *Vec3i16) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	return
}

type HandshakingToClientPacket struct {
	Name   string
	Params any
}

var HandshakingToClientPacketNameMap = map[int32]string{}

func (ret *HandshakingToClientPacket) Decode(r io.ReadSeeker) (err error) {
	var HandshakingToClientPacketNameKey int32
	HandshakingToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(HandshakingToClientPacketNameMap, HandshakingToClientPacketNameKey)
	if err != nil {
		return
	}
	return
}

var HandshakingToClientPacketNameReverseMap = map[string]int32{}

func (ret *HandshakingToClientPacket) Encode(w io.Writer) (err error) {
	var vHandshakingToClientPacketName int32
	vHandshakingToClientPacketName, err = proto_base.ErroringIndex(HandshakingToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vHandshakingToClientPacketName)
	if err != nil {
		return
	}
	return
}

type HandshakingToServerPacket struct {
	Name   string
	Params any
}

var HandshakingToServerPacketNameMap = map[int32]string{0x00: "set_protocol", 0xfe: "legacy_server_list_ping"}

func (ret *HandshakingToServerPacket) Decode(r io.ReadSeeker) (err error) {
	var HandshakingToServerPacketNameKey int32
	HandshakingToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(HandshakingToServerPacketNameMap, HandshakingToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "legacy_server_list_ping":
		var HandshakingToServerPacketParamsLegacyServerListPingTmp HandshakingToServerPacketLegacyServerListPing
		err = HandshakingToServerPacketParamsLegacyServerListPingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = HandshakingToServerPacketParamsLegacyServerListPingTmp
	case "set_protocol":
		var HandshakingToServerPacketParamsSetProtocolTmp HandshakingToServerPacketSetProtocol
		err = HandshakingToServerPacketParamsSetProtocolTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = HandshakingToServerPacketParamsSetProtocolTmp
	}
	return
}

var HandshakingToServerPacketNameReverseMap = map[string]int32{"set_protocol": 0x00, "legacy_server_list_ping": 0xfe}

func (ret *HandshakingToServerPacket) Encode(w io.Writer) (err error) {
	var vHandshakingToServerPacketName int32
	vHandshakingToServerPacketName, err = proto_base.ErroringIndex(HandshakingToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vHandshakingToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "legacy_server_list_ping":
		HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketLegacyServerListPing)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		HandshakingToServerPacketParamsEncTmp := HandshakingToServerPacketParams
		err = HandshakingToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_protocol":
		HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketSetProtocol)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		HandshakingToServerPacketParamsEncTmp := HandshakingToServerPacketParams
		err = HandshakingToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketLegacyServerListPing struct {
	Payload uint8
}

func (ret *HandshakingToServerPacketLegacyServerListPing) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Payload)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToServerPacketLegacyServerListPing) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Payload)
	if err != nil {
		return
	}
	return
}

type HandshakingToServerPacketSetProtocol struct {
	ProtocolVersion int32
	ServerHost      string
	ServerPort      uint16
	NextState       int32
}

func (ret *HandshakingToServerPacketSetProtocol) Decode(r io.ReadSeeker) (err error) {
	ret.ProtocolVersion, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ServerHost, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ServerPort)
	if err != nil {
		return
	}
	ret.NextState, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToServerPacketSetProtocol) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ProtocolVersion)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.ServerHost)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ServerPort)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.NextState)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacket struct {
	Name   string
	Params any
}

var LoginToClientPacketNameMap = map[int32]string{0x00: "disconnect", 0x01: "encryption_begin", 0x02: "success", 0x03: "compress"}

func (ret *LoginToClientPacket) Decode(r io.ReadSeeker) (err error) {
	var LoginToClientPacketNameKey int32
	LoginToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(LoginToClientPacketNameMap, LoginToClientPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "compress":
		var LoginToClientPacketParamsCompressTmp LoginToClientPacketCompress
		err = LoginToClientPacketParamsCompressTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsCompressTmp
	case "disconnect":
		var LoginToClientPacketParamsDisconnectTmp LoginToClientPacketDisconnect
		err = LoginToClientPacketParamsDisconnectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsDisconnectTmp
	case "encryption_begin":
		var LoginToClientPacketParamsEncryptionBeginTmp LoginToClientPacketEncryptionBegin
		err = LoginToClientPacketParamsEncryptionBeginTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsEncryptionBeginTmp
	case "success":
		var LoginToClientPacketParamsSuccessTmp LoginToClientPacketSuccess
		err = LoginToClientPacketParamsSuccessTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsSuccessTmp
	}
	return
}

var LoginToClientPacketNameReverseMap = map[string]int32{"disconnect": 0x00, "encryption_begin": 0x01, "success": 0x02, "compress": 0x03}

func (ret *LoginToClientPacket) Encode(w io.Writer) (err error) {
	var vLoginToClientPacketName int32
	vLoginToClientPacketName, err = proto_base.ErroringIndex(LoginToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vLoginToClientPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "compress":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCompress)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
		err = LoginToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "disconnect":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketDisconnect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
		err = LoginToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "encryption_begin":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketEncryptionBegin)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
		err = LoginToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "success":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketSuccess)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
		err = LoginToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCompress struct {
	Threshold int32
}

func (ret *LoginToClientPacketCompress) Decode(r io.ReadSeeker) (err error) {
	ret.Threshold, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketCompress) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Threshold)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketDisconnect struct {
	Reason string
}

func (ret *LoginToClientPacketDisconnect) Decode(r io.ReadSeeker) (err error) {
	ret.Reason, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketDisconnect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Reason)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketEncryptionBegin struct {
	ServerId    string
	PublicKey   []byte
	VerifyToken []byte
}

func (ret *LoginToClientPacketEncryptionBegin) Decode(r io.ReadSeeker) (err error) {
	ret.ServerId, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var lLoginToClientPacketEncryptionBeginPublicKey int32
	lLoginToClientPacketEncryptionBeginPublicKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.PublicKey, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginPublicKey)))
	if err != nil {
		return
	}
	var lLoginToClientPacketEncryptionBeginVerifyToken int32
	lLoginToClientPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginVerifyToken)))
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketEncryptionBegin) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.ServerId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.PublicKey)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.PublicKey)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.VerifyToken)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketSuccess struct {
	Uuid     string
	Username string
}

func (ret *LoginToClientPacketSuccess) Decode(r io.ReadSeeker) (err error) {
	ret.Uuid, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Username, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketSuccess) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Uuid)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Username)
	if err != nil {
		return
	}
	return
}

type LoginToServerPacket struct {
	Name   string
	Params any
}

var LoginToServerPacketNameMap = map[int32]string{0x00: "login_start", 0x01: "encryption_begin"}

func (ret *LoginToServerPacket) Decode(r io.ReadSeeker) (err error) {
	var LoginToServerPacketNameKey int32
	LoginToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(LoginToServerPacketNameMap, LoginToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "encryption_begin":
		var LoginToServerPacketParamsEncryptionBeginTmp LoginToServerPacketEncryptionBegin
		err = LoginToServerPacketParamsEncryptionBeginTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToServerPacketParamsEncryptionBeginTmp
	case "login_start":
		var LoginToServerPacketParamsLoginStartTmp LoginToServerPacketLoginStart
		err = LoginToServerPacketParamsLoginStartTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToServerPacketParamsLoginStartTmp
	}
	return
}

var LoginToServerPacketNameReverseMap = map[string]int32{"login_start": 0x00, "encryption_begin": 0x01}

func (ret *LoginToServerPacket) Encode(w io.Writer) (err error) {
	var vLoginToServerPacketName int32
	vLoginToServerPacketName, err = proto_base.ErroringIndex(LoginToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vLoginToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "encryption_begin":
		LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketEncryptionBegin)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
		err = LoginToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "login_start":
		LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginStart)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
		err = LoginToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketEncryptionBegin struct {
	SharedSecret []byte
	VerifyToken  []byte
}

func (ret *LoginToServerPacketEncryptionBegin) Decode(r io.ReadSeeker) (err error) {
	var lLoginToServerPacketEncryptionBeginSharedSecret int32
	lLoginToServerPacketEncryptionBeginSharedSecret, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SharedSecret, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginSharedSecret)))
	if err != nil {
		return
	}
	var lLoginToServerPacketEncryptionBeginVerifyToken int32
	lLoginToServerPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginVerifyToken)))
	if err != nil {
		return
	}
	return
}
func (ret *LoginToServerPacketEncryptionBegin) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.SharedSecret)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.SharedSecret)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.VerifyToken)
	if err != nil {
		return
	}
	return
}

type LoginToServerPacketLoginStart struct {
	Username string
}

func (ret *LoginToServerPacketLoginStart) Decode(r io.ReadSeeker) (err error) {
	ret.Username, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToServerPacketLoginStart) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Username)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacket struct {
	Name   string
	Params any
}

var PlayToClientPacketNameMap = map[int32]string{0x00: "keep_alive", 0x01: "login", 0x02: "chat", 0x03: "update_time", 0x04: "entity_equipment", 0x05: "spawn_position", 0x06: "update_health", 0x07: "respawn", 0x08: "position", 0x09: "held_item_slot", 0x0a: "bed", 0x0b: "animation", 0x0c: "named_entity_spawn", 0x0d: "collect", 0x0e: "spawn_entity", 0x0f: "spawn_entity_living", 0x10: "spawn_entity_painting", 0x11: "spawn_entity_experience_orb", 0x12: "entity_velocity", 0x13: "entity_destroy", 0x14: "entity", 0x15: "rel_entity_move", 0x16: "entity_look", 0x17: "entity_move_look", 0x18: "entity_teleport", 0x19: "entity_head_rotation", 0x1a: "entity_status", 0x1b: "attach_entity", 0x1c: "entity_metadata", 0x1d: "entity_effect", 0x1e: "remove_entity_effect", 0x1f: "experience", 0x20: "update_attributes", 0x21: "map_chunk", 0x22: "multi_block_change", 0x23: "block_change", 0x24: "block_action", 0x25: "block_break_animation", 0x26: "map_chunk_bulk", 0x27: "explosion", 0x28: "world_event", 0x29: "named_sound_effect", 0x2a: "world_particles", 0x2b: "game_state_change", 0x2c: "spawn_entity_weather", 0x2d: "open_window", 0x2e: "close_window", 0x2f: "set_slot", 0x30: "window_items", 0x31: "craft_progress_bar", 0x32: "transaction", 0x33: "update_sign", 0x34: "map", 0x35: "tile_entity_data", 0x36: "open_sign_entity", 0x37: "statistics", 0x38: "player_info", 0x39: "abilities", 0x3a: "tab_complete", 0x3b: "scoreboard_objective", 0x3c: "scoreboard_score", 0x3d: "scoreboard_display_objective", 0x3e: "scoreboard_team", 0x3f: "custom_payload", 0x40: "kick_disconnect", 0x41: "difficulty", 0x42: "combat_event", 0x43: "camera", 0x44: "world_border", 0x45: "title", 0x46: "set_compression", 0x47: "playerlist_header", 0x48: "resource_pack_send", 0x49: "update_entity_nbt"}

func (ret *PlayToClientPacket) Decode(r io.ReadSeeker) (err error) {
	var PlayToClientPacketNameKey int32
	PlayToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(PlayToClientPacketNameMap, PlayToClientPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		var PlayToClientPacketParamsAbilitiesTmp PlayToClientPacketAbilities
		err = PlayToClientPacketParamsAbilitiesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAbilitiesTmp
	case "animation":
		var PlayToClientPacketParamsAnimationTmp PlayToClientPacketAnimation
		err = PlayToClientPacketParamsAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAnimationTmp
	case "attach_entity":
		var PlayToClientPacketParamsAttachEntityTmp PlayToClientPacketAttachEntity
		err = PlayToClientPacketParamsAttachEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAttachEntityTmp
	case "bed":
		var PlayToClientPacketParamsBedTmp PlayToClientPacketBed
		err = PlayToClientPacketParamsBedTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBedTmp
	case "block_action":
		var PlayToClientPacketParamsBlockActionTmp PlayToClientPacketBlockAction
		err = PlayToClientPacketParamsBlockActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockActionTmp
	case "block_break_animation":
		var PlayToClientPacketParamsBlockBreakAnimationTmp PlayToClientPacketBlockBreakAnimation
		err = PlayToClientPacketParamsBlockBreakAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockBreakAnimationTmp
	case "block_change":
		var PlayToClientPacketParamsBlockChangeTmp PlayToClientPacketBlockChange
		err = PlayToClientPacketParamsBlockChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockChangeTmp
	case "camera":
		var PlayToClientPacketParamsCameraTmp PlayToClientPacketCamera
		err = PlayToClientPacketParamsCameraTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCameraTmp
	case "chat":
		var PlayToClientPacketParamsChatTmp PlayToClientPacketChat
		err = PlayToClientPacketParamsChatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsChatTmp
	case "close_window":
		var PlayToClientPacketParamsCloseWindowTmp PlayToClientPacketCloseWindow
		err = PlayToClientPacketParamsCloseWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCloseWindowTmp
	case "collect":
		var PlayToClientPacketParamsCollectTmp PlayToClientPacketCollect
		err = PlayToClientPacketParamsCollectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCollectTmp
	case "combat_event":
		var PlayToClientPacketParamsCombatEventTmp PlayToClientPacketCombatEvent
		err = PlayToClientPacketParamsCombatEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCombatEventTmp
	case "craft_progress_bar":
		var PlayToClientPacketParamsCraftProgressBarTmp PlayToClientPacketCraftProgressBar
		err = PlayToClientPacketParamsCraftProgressBarTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCraftProgressBarTmp
	case "custom_payload":
		var PlayToClientPacketParamsCustomPayloadTmp PlayToClientPacketCustomPayload
		err = PlayToClientPacketParamsCustomPayloadTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCustomPayloadTmp
	case "difficulty":
		var PlayToClientPacketParamsDifficultyTmp PlayToClientPacketDifficulty
		err = PlayToClientPacketParamsDifficultyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDifficultyTmp
	case "entity":
		var PlayToClientPacketParamsEntityTmp PlayToClientPacketEntity
		err = PlayToClientPacketParamsEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityTmp
	case "entity_destroy":
		var PlayToClientPacketParamsEntityDestroyTmp PlayToClientPacketEntityDestroy
		err = PlayToClientPacketParamsEntityDestroyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityDestroyTmp
	case "entity_effect":
		var PlayToClientPacketParamsEntityEffectTmp PlayToClientPacketEntityEffect
		err = PlayToClientPacketParamsEntityEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityEffectTmp
	case "entity_equipment":
		var PlayToClientPacketParamsEntityEquipmentTmp PlayToClientPacketEntityEquipment
		err = PlayToClientPacketParamsEntityEquipmentTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityEquipmentTmp
	case "entity_head_rotation":
		var PlayToClientPacketParamsEntityHeadRotationTmp PlayToClientPacketEntityHeadRotation
		err = PlayToClientPacketParamsEntityHeadRotationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityHeadRotationTmp
	case "entity_look":
		var PlayToClientPacketParamsEntityLookTmp PlayToClientPacketEntityLook
		err = PlayToClientPacketParamsEntityLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityLookTmp
	case "entity_metadata":
		var PlayToClientPacketParamsEntityMetadataTmp PlayToClientPacketEntityMetadata
		err = PlayToClientPacketParamsEntityMetadataTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityMetadataTmp
	case "entity_move_look":
		var PlayToClientPacketParamsEntityMoveLookTmp PlayToClientPacketEntityMoveLook
		err = PlayToClientPacketParamsEntityMoveLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityMoveLookTmp
	case "entity_status":
		var PlayToClientPacketParamsEntityStatusTmp PlayToClientPacketEntityStatus
		err = PlayToClientPacketParamsEntityStatusTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityStatusTmp
	case "entity_teleport":
		var PlayToClientPacketParamsEntityTeleportTmp PlayToClientPacketEntityTeleport
		err = PlayToClientPacketParamsEntityTeleportTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityTeleportTmp
	case "entity_velocity":
		var PlayToClientPacketParamsEntityVelocityTmp PlayToClientPacketEntityVelocity
		err = PlayToClientPacketParamsEntityVelocityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityVelocityTmp
	case "experience":
		var PlayToClientPacketParamsExperienceTmp PlayToClientPacketExperience
		err = PlayToClientPacketParamsExperienceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsExperienceTmp
	case "explosion":
		var PlayToClientPacketParamsExplosionTmp PlayToClientPacketExplosion
		err = PlayToClientPacketParamsExplosionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsExplosionTmp
	case "game_state_change":
		var PlayToClientPacketParamsGameStateChangeTmp PlayToClientPacketGameStateChange
		err = PlayToClientPacketParamsGameStateChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsGameStateChangeTmp
	case "held_item_slot":
		var PlayToClientPacketParamsHeldItemSlotTmp PlayToClientPacketHeldItemSlot
		err = PlayToClientPacketParamsHeldItemSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsHeldItemSlotTmp
	case "keep_alive":
		var PlayToClientPacketParamsKeepAliveTmp PlayToClientPacketKeepAlive
		err = PlayToClientPacketParamsKeepAliveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsKeepAliveTmp
	case "kick_disconnect":
		var PlayToClientPacketParamsKickDisconnectTmp PlayToClientPacketKickDisconnect
		err = PlayToClientPacketParamsKickDisconnectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsKickDisconnectTmp
	case "login":
		var PlayToClientPacketParamsLoginTmp PlayToClientPacketLogin
		err = PlayToClientPacketParamsLoginTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsLoginTmp
	case "map":
		var PlayToClientPacketParamsMapTmp PlayToClientPacketMap
		err = PlayToClientPacketParamsMapTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMapTmp
	case "map_chunk":
		var PlayToClientPacketParamsMapChunkTmp PlayToClientPacketMapChunk
		err = PlayToClientPacketParamsMapChunkTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMapChunkTmp
	case "map_chunk_bulk":
		var PlayToClientPacketParamsMapChunkBulkTmp PlayToClientPacketMapChunkBulk
		err = PlayToClientPacketParamsMapChunkBulkTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMapChunkBulkTmp
	case "multi_block_change":
		var PlayToClientPacketParamsMultiBlockChangeTmp PlayToClientPacketMultiBlockChange
		err = PlayToClientPacketParamsMultiBlockChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMultiBlockChangeTmp
	case "named_entity_spawn":
		var PlayToClientPacketParamsNamedEntitySpawnTmp PlayToClientPacketNamedEntitySpawn
		err = PlayToClientPacketParamsNamedEntitySpawnTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsNamedEntitySpawnTmp
	case "named_sound_effect":
		var PlayToClientPacketParamsNamedSoundEffectTmp PlayToClientPacketNamedSoundEffect
		err = PlayToClientPacketParamsNamedSoundEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsNamedSoundEffectTmp
	case "open_sign_entity":
		var PlayToClientPacketParamsOpenSignEntityTmp PlayToClientPacketOpenSignEntity
		err = PlayToClientPacketParamsOpenSignEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenSignEntityTmp
	case "open_window":
		var PlayToClientPacketParamsOpenWindowTmp PlayToClientPacketOpenWindow
		err = PlayToClientPacketParamsOpenWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenWindowTmp
	case "player_info":
		var PlayToClientPacketParamsPlayerInfoTmp PlayToClientPacketPlayerInfo
		err = PlayToClientPacketParamsPlayerInfoTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerInfoTmp
	case "playerlist_header":
		var PlayToClientPacketParamsPlayerlistHeaderTmp PlayToClientPacketPlayerlistHeader
		err = PlayToClientPacketParamsPlayerlistHeaderTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerlistHeaderTmp
	case "position":
		var PlayToClientPacketParamsPositionTmp PlayToClientPacketPosition
		err = PlayToClientPacketParamsPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPositionTmp
	case "rel_entity_move":
		var PlayToClientPacketParamsRelEntityMoveTmp PlayToClientPacketRelEntityMove
		err = PlayToClientPacketParamsRelEntityMoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRelEntityMoveTmp
	case "remove_entity_effect":
		var PlayToClientPacketParamsRemoveEntityEffectTmp PlayToClientPacketRemoveEntityEffect
		err = PlayToClientPacketParamsRemoveEntityEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRemoveEntityEffectTmp
	case "resource_pack_send":
		var PlayToClientPacketParamsResourcePackSendTmp PlayToClientPacketResourcePackSend
		err = PlayToClientPacketParamsResourcePackSendTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsResourcePackSendTmp
	case "respawn":
		var PlayToClientPacketParamsRespawnTmp PlayToClientPacketRespawn
		err = PlayToClientPacketParamsRespawnTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRespawnTmp
	case "scoreboard_display_objective":
		var PlayToClientPacketParamsScoreboardDisplayObjectiveTmp PlayToClientPacketScoreboardDisplayObjective
		err = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp
	case "scoreboard_objective":
		var PlayToClientPacketParamsScoreboardObjectiveTmp PlayToClientPacketScoreboardObjective
		err = PlayToClientPacketParamsScoreboardObjectiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardObjectiveTmp
	case "scoreboard_score":
		var PlayToClientPacketParamsScoreboardScoreTmp PlayToClientPacketScoreboardScore
		err = PlayToClientPacketParamsScoreboardScoreTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardScoreTmp
	case "scoreboard_team":
		var PlayToClientPacketParamsScoreboardTeamTmp PlayToClientPacketScoreboardTeam
		err = PlayToClientPacketParamsScoreboardTeamTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardTeamTmp
	case "set_compression":
		var PlayToClientPacketParamsSetCompressionTmp PlayToClientPacketSetCompression
		err = PlayToClientPacketParamsSetCompressionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetCompressionTmp
	case "set_slot":
		var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot
		err = PlayToClientPacketParamsSetSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetSlotTmp
	case "spawn_entity":
		var PlayToClientPacketParamsSpawnEntityTmp PlayToClientPacketSpawnEntity
		err = PlayToClientPacketParamsSpawnEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityTmp
	case "spawn_entity_experience_orb":
		var PlayToClientPacketParamsSpawnEntityExperienceOrbTmp PlayToClientPacketSpawnEntityExperienceOrb
		err = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp
	case "spawn_entity_living":
		var PlayToClientPacketParamsSpawnEntityLivingTmp PlayToClientPacketSpawnEntityLiving
		err = PlayToClientPacketParamsSpawnEntityLivingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityLivingTmp
	case "spawn_entity_painting":
		var PlayToClientPacketParamsSpawnEntityPaintingTmp PlayToClientPacketSpawnEntityPainting
		err = PlayToClientPacketParamsSpawnEntityPaintingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityPaintingTmp
	case "spawn_entity_weather":
		var PlayToClientPacketParamsSpawnEntityWeatherTmp PlayToClientPacketSpawnEntityWeather
		err = PlayToClientPacketParamsSpawnEntityWeatherTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityWeatherTmp
	case "spawn_position":
		var PlayToClientPacketParamsSpawnPositionTmp PlayToClientPacketSpawnPosition
		err = PlayToClientPacketParamsSpawnPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnPositionTmp
	case "statistics":
		var PlayToClientPacketParamsStatisticsTmp PlayToClientPacketStatistics
		err = PlayToClientPacketParamsStatisticsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsStatisticsTmp
	case "tab_complete":
		var PlayToClientPacketParamsTabCompleteTmp PlayToClientPacketTabComplete
		err = PlayToClientPacketParamsTabCompleteTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTabCompleteTmp
	case "tile_entity_data":
		var PlayToClientPacketParamsTileEntityDataTmp PlayToClientPacketTileEntityData
		err = PlayToClientPacketParamsTileEntityDataTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTileEntityDataTmp
	case "title":
		var PlayToClientPacketParamsTitleTmp PlayToClientPacketTitle
		err = PlayToClientPacketParamsTitleTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTitleTmp
	case "transaction":
		var PlayToClientPacketParamsTransactionTmp PlayToClientPacketTransaction
		err = PlayToClientPacketParamsTransactionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTransactionTmp
	case "update_attributes":
		var PlayToClientPacketParamsUpdateAttributesTmp PlayToClientPacketUpdateAttributes
		err = PlayToClientPacketParamsUpdateAttributesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateAttributesTmp
	case "update_entity_nbt":
		var PlayToClientPacketParamsUpdateEntityNbtTmp PlayToClientPacketUpdateEntityNbt
		err = PlayToClientPacketParamsUpdateEntityNbtTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateEntityNbtTmp
	case "update_health":
		var PlayToClientPacketParamsUpdateHealthTmp PlayToClientPacketUpdateHealth
		err = PlayToClientPacketParamsUpdateHealthTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateHealthTmp
	case "update_sign":
		var PlayToClientPacketParamsUpdateSignTmp PlayToClientPacketUpdateSign
		err = PlayToClientPacketParamsUpdateSignTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateSignTmp
	case "update_time":
		var PlayToClientPacketParamsUpdateTimeTmp PlayToClientPacketUpdateTime
		err = PlayToClientPacketParamsUpdateTimeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateTimeTmp
	case "window_items":
		var PlayToClientPacketParamsWindowItemsTmp PlayToClientPacketWindowItems
		err = PlayToClientPacketParamsWindowItemsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWindowItemsTmp
	case "world_border":
		var PlayToClientPacketParamsWorldBorderTmp PlayToClientPacketWorldBorder
		err = PlayToClientPacketParamsWorldBorderTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldBorderTmp
	case "world_event":
		var PlayToClientPacketParamsWorldEventTmp PlayToClientPacketWorldEvent
		err = PlayToClientPacketParamsWorldEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldEventTmp
	case "world_particles":
		var PlayToClientPacketParamsWorldParticlesTmp PlayToClientPacketWorldParticles
		err = PlayToClientPacketParamsWorldParticlesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldParticlesTmp
	}
	return
}

var PlayToClientPacketNameReverseMap = map[string]int32{"keep_alive": 0x00, "login": 0x01, "chat": 0x02, "update_time": 0x03, "entity_equipment": 0x04, "spawn_position": 0x05, "update_health": 0x06, "respawn": 0x07, "position": 0x08, "held_item_slot": 0x09, "bed": 0x0a, "animation": 0x0b, "named_entity_spawn": 0x0c, "collect": 0x0d, "spawn_entity": 0x0e, "spawn_entity_living": 0x0f, "spawn_entity_painting": 0x10, "spawn_entity_experience_orb": 0x11, "entity_velocity": 0x12, "entity_destroy": 0x13, "entity": 0x14, "rel_entity_move": 0x15, "entity_look": 0x16, "entity_move_look": 0x17, "entity_teleport": 0x18, "entity_head_rotation": 0x19, "entity_status": 0x1a, "attach_entity": 0x1b, "entity_metadata": 0x1c, "entity_effect": 0x1d, "remove_entity_effect": 0x1e, "experience": 0x1f, "update_attributes": 0x20, "map_chunk": 0x21, "multi_block_change": 0x22, "block_change": 0x23, "block_action": 0x24, "block_break_animation": 0x25, "map_chunk_bulk": 0x26, "explosion": 0x27, "world_event": 0x28, "named_sound_effect": 0x29, "world_particles": 0x2a, "game_state_change": 0x2b, "spawn_entity_weather": 0x2c, "open_window": 0x2d, "close_window": 0x2e, "set_slot": 0x2f, "window_items": 0x30, "craft_progress_bar": 0x31, "transaction": 0x32, "update_sign": 0x33, "map": 0x34, "tile_entity_data": 0x35, "open_sign_entity": 0x36, "statistics": 0x37, "player_info": 0x38, "abilities": 0x39, "tab_complete": 0x3a, "scoreboard_objective": 0x3b, "scoreboard_score": 0x3c, "scoreboard_display_objective": 0x3d, "scoreboard_team": 0x3e, "custom_payload": 0x3f, "kick_disconnect": 0x40, "difficulty": 0x41, "combat_event": 0x42, "camera": 0x43, "world_border": 0x44, "title": 0x45, "set_compression": 0x46, "playerlist_header": 0x47, "resource_pack_send": 0x48, "update_entity_nbt": 0x49}

func (ret *PlayToClientPacket) Encode(w io.Writer) (err error) {
	var vPlayToClientPacketName int32
	vPlayToClientPacketName, err = proto_base.ErroringIndex(PlayToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAbilities)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "animation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "attach_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAttachEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "bed":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBed)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_action":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_break_animation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockBreakAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "camera":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCamera)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "chat":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "close_window":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCloseWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "collect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCollect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "combat_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCombatEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "craft_progress_bar":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftProgressBar)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "custom_payload":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCustomPayload)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "difficulty":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDifficulty)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_destroy":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityDestroy)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_equipment":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEquipment)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_head_rotation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityHeadRotation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_look":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_metadata":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMetadata)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_move_look":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMoveLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_status":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityStatus)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_teleport":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityTeleport)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_velocity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityVelocity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "experience":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExperience)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "explosion":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExplosion)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "game_state_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameStateChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "held_item_slot":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHeldItemSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "keep_alive":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKeepAlive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "kick_disconnect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKickDisconnect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "login":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketLogin)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "map":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMap)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "map_chunk":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunk)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "map_chunk_bulk":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunkBulk)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "multi_block_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMultiBlockChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "named_entity_spawn":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNamedEntitySpawn)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "named_sound_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNamedSoundEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "open_sign_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenSignEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "open_window":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "player_info":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerInfo)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "playerlist_header":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerlistHeader)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "rel_entity_move":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRelEntityMove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "remove_entity_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRemoveEntityEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "resource_pack_send":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResourcePackSend)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "respawn":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRespawn)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_display_objective":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardDisplayObjective)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_objective":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardObjective)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_score":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardScore)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_team":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardTeam)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_compression":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCompression)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_slot":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity_experience_orb":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityExperienceOrb)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity_living":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityLiving)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity_painting":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityPainting)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity_weather":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityWeather)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "statistics":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStatistics)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "tab_complete":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTabComplete)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "tile_entity_data":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTileEntityData)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "title":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTitle)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "transaction":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTransaction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_attributes":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateAttributes)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_entity_nbt":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateEntityNbt)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_health":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateHealth)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_sign":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateSign)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_time":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateTime)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "window_items":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWindowItems)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "world_border":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorder)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "world_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "world_particles":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldParticles)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketAbilities struct {
	Flags        int8
	FlyingSpeed  float32
	WalkingSpeed float32
}

func (ret *PlayToClientPacketAbilities) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketAbilities) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketAnimation struct {
	EntityId  int32
	Animation uint8
}

func (ret *PlayToClientPacketAnimation) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Animation)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketAnimation) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Animation)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketAttachEntity struct {
	EntityId  int32
	VehicleId int32
	Leash     bool
}

func (ret *PlayToClientPacketAttachEntity) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.VehicleId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Leash)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketAttachEntity) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.VehicleId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Leash)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketBed struct {
	EntityId int32
	Location Position
}

func (ret *PlayToClientPacketBed) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketBed) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	PlayToClientPacketBedLocationEncTmp := ret.Location
	err = PlayToClientPacketBedLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketBlockAction struct {
	Location Position
	Byte1    uint8
	Byte2    uint8
	BlockId  int32
}

func (ret *PlayToClientPacketBlockAction) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Byte1)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Byte2)
	if err != nil {
		return
	}
	ret.BlockId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketBlockAction) Encode(w io.Writer) (err error) {
	PlayToClientPacketBlockActionLocationEncTmp := ret.Location
	err = PlayToClientPacketBlockActionLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Byte1)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Byte2)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.BlockId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketBlockBreakAnimation struct {
	EntityId     int32
	Location     Position
	DestroyStage int8
}

func (ret *PlayToClientPacketBlockBreakAnimation) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DestroyStage)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketBlockBreakAnimation) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	PlayToClientPacketBlockBreakAnimationLocationEncTmp := ret.Location
	err = PlayToClientPacketBlockBreakAnimationLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DestroyStage)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketBlockChange struct {
	Location Position
	Type     int32
}

func (ret *PlayToClientPacketBlockChange) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketBlockChange) Encode(w io.Writer) (err error) {
	PlayToClientPacketBlockChangeLocationEncTmp := ret.Location
	err = PlayToClientPacketBlockChangeLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Type)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCamera struct {
	CameraId int32
}

func (ret *PlayToClientPacketCamera) Decode(r io.ReadSeeker) (err error) {
	ret.CameraId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCamera) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.CameraId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketChat struct {
	Message  string
	Position int8
}

func (ret *PlayToClientPacketChat) Decode(r io.ReadSeeker) (err error) {
	ret.Message, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Position)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketChat) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Message)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Position)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCloseWindow struct {
	WindowId uint8
}

func (ret *PlayToClientPacketCloseWindow) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCloseWindow) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCollect struct {
	CollectedEntityId int32
	CollectorEntityId int32
}

func (ret *PlayToClientPacketCollect) Decode(r io.ReadSeeker) (err error) {
	ret.CollectedEntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.CollectorEntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCollect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.CollectedEntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.CollectorEntityId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCombatEvent struct {
	Event    int32
	Duration any
	PlayerId any
	EntityId any
	Message  any
}

func (ret *PlayToClientPacketCombatEvent) Decode(r io.ReadSeeker) (err error) {
	ret.Event, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Event {
	case 1:
		var PlayToClientPacketCombatEventDuration1Tmp int32
		PlayToClientPacketCombatEventDuration1Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Duration = PlayToClientPacketCombatEventDuration1Tmp
	default:
		var PlayToClientPacketCombatEventDurationTmp struct {
		}
		ret.Duration = PlayToClientPacketCombatEventDurationTmp
	}
	switch ret.Event {
	case 2:
		var PlayToClientPacketCombatEventPlayerId2Tmp int32
		PlayToClientPacketCombatEventPlayerId2Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.PlayerId = PlayToClientPacketCombatEventPlayerId2Tmp
	default:
		var PlayToClientPacketCombatEventPlayerIdTmp struct {
		}
		ret.PlayerId = PlayToClientPacketCombatEventPlayerIdTmp
	}
	switch ret.Event {
	case 1:
		var PlayToClientPacketCombatEventEntityId1Tmp int32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCombatEventEntityId1Tmp)
		if err != nil {
			return
		}
		ret.EntityId = PlayToClientPacketCombatEventEntityId1Tmp
	case 2:
		var PlayToClientPacketCombatEventEntityId2Tmp int32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCombatEventEntityId2Tmp)
		if err != nil {
			return
		}
		ret.EntityId = PlayToClientPacketCombatEventEntityId2Tmp
	default:
		var PlayToClientPacketCombatEventEntityIdTmp struct {
		}
		ret.EntityId = PlayToClientPacketCombatEventEntityIdTmp
	}
	switch ret.Event {
	case 2:
		var PlayToClientPacketCombatEventMessage2Tmp string
		PlayToClientPacketCombatEventMessage2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Message = PlayToClientPacketCombatEventMessage2Tmp
	default:
		var PlayToClientPacketCombatEventMessageTmp struct {
		}
		ret.Message = PlayToClientPacketCombatEventMessageTmp
	}
	return
}
func (ret *PlayToClientPacketCombatEvent) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Event)
	if err != nil {
		return
	}
	switch ret.Event {
	case 1:
		PlayToClientPacketCombatEventDuration, ok := ret.Duration.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketCombatEventDuration)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Duration.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Event {
	case 2:
		PlayToClientPacketCombatEventPlayerId, ok := ret.PlayerId.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketCombatEventPlayerId)
		if err != nil {
			return
		}
	default:
		_, ok := ret.PlayerId.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Event {
	case 1:
		PlayToClientPacketCombatEventEntityId, ok := ret.EntityId.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketCombatEventEntityId)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketCombatEventEntityId, ok := ret.EntityId.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketCombatEventEntityId)
		if err != nil {
			return
		}
	default:
		_, ok := ret.EntityId.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Event {
	case 2:
		PlayToClientPacketCombatEventMessage, ok := ret.Message.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketCombatEventMessage)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Message.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketCraftProgressBar struct {
	WindowId uint8
	Property int16
	Value    int16
}

func (ret *PlayToClientPacketCraftProgressBar) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Property)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Value)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCraftProgressBar) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Property)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCustomPayload struct {
	Channel string
	Data    proto_base.RestBuffer
}

func (ret *PlayToClientPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
	ret.Channel, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCustomPayload) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Channel)
	if err != nil {
		return
	}
	PlayToClientPacketCustomPayloadDataEncTmp := ret.Data
	err = PlayToClientPacketCustomPayloadDataEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDifficulty struct {
	Difficulty uint8
}

func (ret *PlayToClientPacketDifficulty) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Difficulty)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDifficulty) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Difficulty)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntity struct {
	EntityId int32
}

func (ret *PlayToClientPacketEntity) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityDestroy struct {
	EntityIds []int32
}

func (ret *PlayToClientPacketEntityDestroy) Decode(r io.ReadSeeker) (err error) {
	var lPlayToClientPacketEntityDestroyEntityIds int32
	lPlayToClientPacketEntityDestroyEntityIds, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EntityIds = []int32{}
	for range lPlayToClientPacketEntityDestroyEntityIds {
		var PlayToClientPacketEntityDestroyEntityIdsElement int32
		PlayToClientPacketEntityDestroyEntityIdsElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.EntityIds = append(ret.EntityIds, PlayToClientPacketEntityDestroyEntityIdsElement)
	}
	return
}
func (ret *PlayToClientPacketEntityDestroy) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.EntityIds)))
	if err != nil {
		return
	}
	for iPlayToClientPacketEntityDestroyEntityIds := range len(ret.EntityIds) {
		err = proto_base.EncodeVarInt(w, ret.EntityIds[iPlayToClientPacketEntityDestroyEntityIds])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketEntityEffect struct {
	EntityId      int32
	EffectId      int8
	Amplifier     int8
	Duration      int32
	HideParticles bool
}

func (ret *PlayToClientPacketEntityEffect) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EffectId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Amplifier)
	if err != nil {
		return
	}
	ret.Duration, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HideParticles)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityEffect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EffectId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Amplifier)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Duration)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HideParticles)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityEquipment struct {
	EntityId int32
	Slot     int16
	Item     Slot
}

func (ret *PlayToClientPacketEntityEquipment) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Slot)
	if err != nil {
		return
	}
	err = ret.Item.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Slot)
	if err != nil {
		return
	}
	PlayToClientPacketEntityEquipmentItemEncTmp := ret.Item
	err = PlayToClientPacketEntityEquipmentItemEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityHeadRotation struct {
	EntityId int32
	HeadYaw  int8
}

func (ret *PlayToClientPacketEntityHeadRotation) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HeadYaw)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityHeadRotation) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HeadYaw)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityLook struct {
	EntityId int32
	Yaw      int8
	Pitch    int8
	OnGround bool
}

func (ret *PlayToClientPacketEntityLook) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityLook) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityMetadata struct {
	EntityId int32
	Metadata EntityMetadata
}

func (ret *PlayToClientPacketEntityMetadata) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Metadata.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityMetadata) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	PlayToClientPacketEntityMetadataMetadataEncTmp := ret.Metadata
	err = PlayToClientPacketEntityMetadataMetadataEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityMoveLook struct {
	EntityId int32
	DX       int8
	DY       int8
	DZ       int8
	Yaw      int8
	Pitch    int8
	OnGround bool
}

func (ret *PlayToClientPacketEntityMoveLook) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityMoveLook) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityStatus struct {
	EntityId     int32
	EntityStatus int8
}

func (ret *PlayToClientPacketEntityStatus) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EntityStatus)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityStatus) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EntityStatus)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityTeleport struct {
	EntityId int32
	X        int32
	Y        int32
	Z        int32
	Yaw      int8
	Pitch    int8
	OnGround bool
}

func (ret *PlayToClientPacketEntityTeleport) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityTeleport) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityVelocity struct {
	EntityId int32
	Velocity Vec3i16
}

func (ret *PlayToClientPacketEntityVelocity) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Velocity.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityVelocity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	PlayToClientPacketEntityVelocityVelocityEncTmp := ret.Velocity
	err = PlayToClientPacketEntityVelocityVelocityEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketExperience struct {
	ExperienceBar   float32
	Level           int32
	TotalExperience int32
}

func (ret *PlayToClientPacketExperience) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.ExperienceBar)
	if err != nil {
		return
	}
	ret.Level, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.TotalExperience, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketExperience) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.ExperienceBar)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Level)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.TotalExperience)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketExplosion struct {
	X                    float32
	Y                    float32
	Z                    float32
	Radius               float32
	AffectedBlockOffsets []struct {
		X int8
		Y int8
		Z int8
	}
	PlayerMotionX float32
	PlayerMotionY float32
	PlayerMotionZ float32
}

func (ret *PlayToClientPacketExplosion) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Radius)
	if err != nil {
		return
	}
	var lPlayToClientPacketExplosionAffectedBlockOffsets int32
	err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketExplosionAffectedBlockOffsets)
	if err != nil {
		return
	}
	ret.AffectedBlockOffsets = []struct {
		X int8
		Y int8
		Z int8
	}{}
	for range lPlayToClientPacketExplosionAffectedBlockOffsets {
		var PlayToClientPacketExplosionAffectedBlockOffsetsElement struct {
			X int8
			Y int8
			Z int8
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.X)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.Y)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.Z)
		if err != nil {
			return
		}
		ret.AffectedBlockOffsets = append(ret.AffectedBlockOffsets, PlayToClientPacketExplosionAffectedBlockOffsetsElement)
	}
	err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionZ)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketExplosion) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Radius)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, int32(len(ret.AffectedBlockOffsets)))
	if err != nil {
		return
	}
	for iPlayToClientPacketExplosionAffectedBlockOffsets := range len(ret.AffectedBlockOffsets) {
		err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].X)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].Y)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].Z)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.PlayerMotionX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PlayerMotionY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PlayerMotionZ)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketGameStateChange struct {
	Reason   uint8
	GameMode float32
}

func (ret *PlayToClientPacketGameStateChange) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Reason)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.GameMode)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketGameStateChange) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Reason)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.GameMode)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketHeldItemSlot struct {
	Slot int8
}

func (ret *PlayToClientPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Slot)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketHeldItemSlot) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Slot)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketKeepAlive struct {
	KeepAliveId int32
}

func (ret *PlayToClientPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
	ret.KeepAliveId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketKeepAlive) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketKickDisconnect struct {
	Reason string
}

func (ret *PlayToClientPacketKickDisconnect) Decode(r io.ReadSeeker) (err error) {
	ret.Reason, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketKickDisconnect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Reason)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketLogin struct {
	EntityId         int32
	GameMode         uint8
	Dimension        int8
	Difficulty       uint8
	MaxPlayers       uint8
	LevelType        string
	ReducedDebugInfo bool
}

func (ret *PlayToClientPacketLogin) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.GameMode)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Dimension)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Difficulty)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.MaxPlayers)
	if err != nil {
		return
	}
	ret.LevelType, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ReducedDebugInfo)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketLogin) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.GameMode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Dimension)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Difficulty)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.MaxPlayers)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.LevelType)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ReducedDebugInfo)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketMap struct {
	ItemDamage int32
	Scale      int8
	Icons      []struct {
		DirectionAndType int8
		X                int8
		Z                int8
	}
	Columns int8
	Rows    any
	X       any
	Y       any
	Data    any
}

func (ret *PlayToClientPacketMap) Decode(r io.ReadSeeker) (err error) {
	ret.ItemDamage, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Scale)
	if err != nil {
		return
	}
	var lPlayToClientPacketMapIcons int32
	lPlayToClientPacketMapIcons, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Icons = []struct {
		DirectionAndType int8
		X                int8
		Z                int8
	}{}
	for range lPlayToClientPacketMapIcons {
		var PlayToClientPacketMapIconsElement struct {
			DirectionAndType int8
			X                int8
			Z                int8
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.DirectionAndType)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.X)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Z)
		if err != nil {
			return
		}
		ret.Icons = append(ret.Icons, PlayToClientPacketMapIconsElement)
	}
	err = binary.Read(r, binary.BigEndian, &ret.Columns)
	if err != nil {
		return
	}
	switch ret.Columns {
	case 0:
		var PlayToClientPacketMapRows0Tmp struct {
		}
		ret.Rows = PlayToClientPacketMapRows0Tmp
	default:
		var PlayToClientPacketMapRowsTmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapRowsTmp)
		if err != nil {
			return
		}
		ret.Rows = PlayToClientPacketMapRowsTmp
	}
	switch ret.Columns {
	case 0:
		var PlayToClientPacketMapX0Tmp struct {
		}
		ret.X = PlayToClientPacketMapX0Tmp
	default:
		var PlayToClientPacketMapXTmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapXTmp)
		if err != nil {
			return
		}
		ret.X = PlayToClientPacketMapXTmp
	}
	switch ret.Columns {
	case 0:
		var PlayToClientPacketMapY0Tmp struct {
		}
		ret.Y = PlayToClientPacketMapY0Tmp
	default:
		var PlayToClientPacketMapYTmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapYTmp)
		if err != nil {
			return
		}
		ret.Y = PlayToClientPacketMapYTmp
	}
	switch ret.Columns {
	case 0:
		var PlayToClientPacketMapData0Tmp struct {
		}
		ret.Data = PlayToClientPacketMapData0Tmp
	default:
		var PlayToClientPacketMapDataTmp []byte
		var lPlayToClientPacketMapData int32
		lPlayToClientPacketMapData, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketMapDataTmp, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapData)))
		if err != nil {
			return
		}
		ret.Data = PlayToClientPacketMapDataTmp
	}
	return
}
func (ret *PlayToClientPacketMap) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ItemDamage)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Scale)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Icons)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapIcons := range len(ret.Icons) {
		err = binary.Write(w, binary.BigEndian, ret.Icons[iPlayToClientPacketMapIcons].DirectionAndType)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Icons[iPlayToClientPacketMapIcons].X)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Icons[iPlayToClientPacketMapIcons].Z)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Columns)
	if err != nil {
		return
	}
	switch ret.Columns {
	case 0:
		_, ok := ret.Rows.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Rows.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Rows.(int8))
		if err != nil {
			return
		}
	}
	switch ret.Columns {
	case 0:
		_, ok := ret.X.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.X.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.X.(int8))
		if err != nil {
			return
		}
	}
	switch ret.Columns {
	case 0:
		_, ok := ret.Y.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Y.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Y.(int8))
		if err != nil {
			return
		}
	}
	switch ret.Columns {
	case 0:
		_, ok := ret.Data.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Data.([]byte)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.Data.([]byte))))
		if err != nil {
			return
		}
		_, err = w.Write(ret.Data.([]byte))
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketMapChunk struct {
	X         int32
	Z         int32
	GroundUp  bool
	BitMap    uint16
	ChunkData []byte
}

func (ret *PlayToClientPacketMapChunk) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.GroundUp)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.BitMap)
	if err != nil {
		return
	}
	var lPlayToClientPacketMapChunkChunkData int32
	lPlayToClientPacketMapChunkChunkData, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ChunkData, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapChunkChunkData)))
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketMapChunk) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.GroundUp)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.BitMap)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.ChunkData)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.ChunkData)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketMapChunkBulk struct {
	SkyLightSent bool
	Meta         []struct {
		X      int32
		Z      int32
		BitMap uint16
	}
	Data proto_base.RestBuffer
}

func (ret *PlayToClientPacketMapChunkBulk) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.SkyLightSent)
	if err != nil {
		return
	}
	var lPlayToClientPacketMapChunkBulkMeta int32
	lPlayToClientPacketMapChunkBulkMeta, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Meta = []struct {
		X      int32
		Z      int32
		BitMap uint16
	}{}
	for range lPlayToClientPacketMapChunkBulkMeta {
		var PlayToClientPacketMapChunkBulkMetaElement struct {
			X      int32
			Z      int32
			BitMap uint16
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBulkMetaElement.X)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBulkMetaElement.Z)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBulkMetaElement.BitMap)
		if err != nil {
			return
		}
		ret.Meta = append(ret.Meta, PlayToClientPacketMapChunkBulkMetaElement)
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketMapChunkBulk) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.SkyLightSent)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Meta)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkBulkMeta := range len(ret.Meta) {
		err = binary.Write(w, binary.BigEndian, ret.Meta[iPlayToClientPacketMapChunkBulkMeta].X)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Meta[iPlayToClientPacketMapChunkBulkMeta].Z)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Meta[iPlayToClientPacketMapChunkBulkMeta].BitMap)
		if err != nil {
			return
		}
	}
	PlayToClientPacketMapChunkBulkDataEncTmp := ret.Data
	err = PlayToClientPacketMapChunkBulkDataEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketMultiBlockChange struct {
	ChunkX  int32
	ChunkZ  int32
	Records []struct {
		HorizontalPos uint8
		Y             uint8
		BlockId       int32
	}
}

func (ret *PlayToClientPacketMultiBlockChange) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.ChunkX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChunkZ)
	if err != nil {
		return
	}
	var lPlayToClientPacketMultiBlockChangeRecords int32
	lPlayToClientPacketMultiBlockChangeRecords, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Records = []struct {
		HorizontalPos uint8
		Y             uint8
		BlockId       int32
	}{}
	for range lPlayToClientPacketMultiBlockChangeRecords {
		var PlayToClientPacketMultiBlockChangeRecordsElement struct {
			HorizontalPos uint8
			Y             uint8
			BlockId       int32
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeRecordsElement.HorizontalPos)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeRecordsElement.Y)
		if err != nil {
			return
		}
		PlayToClientPacketMultiBlockChangeRecordsElement.BlockId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement)
	}
	return
}
func (ret *PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.ChunkX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChunkZ)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Records)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) {
		err = binary.Write(w, binary.BigEndian, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].HorizontalPos)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].Y)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Records[iPlayToClientPacketMultiBlockChangeRecords].BlockId)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketNamedEntitySpawn struct {
	EntityId    int32
	PlayerUUID  uuid.UUID
	X           int32
	Y           int32
	Z           int32
	Yaw         int8
	Pitch       int8
	CurrentItem int16
	Metadata    EntityMetadata
}

func (ret *PlayToClientPacketNamedEntitySpawn) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	_, err = io.ReadFull(r, ret.PlayerUUID[:])
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CurrentItem)
	if err != nil {
		return
	}
	err = ret.Metadata.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketNamedEntitySpawn) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	_, err = w.Write(ret.PlayerUUID[:])
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CurrentItem)
	if err != nil {
		return
	}
	PlayToClientPacketNamedEntitySpawnMetadataEncTmp := ret.Metadata
	err = PlayToClientPacketNamedEntitySpawnMetadataEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketNamedSoundEffect struct {
	SoundName string
	X         int32
	Y         int32
	Z         int32
	Volume    float32
	Pitch     uint8
}

func (ret *PlayToClientPacketNamedSoundEffect) Decode(r io.ReadSeeker) (err error) {
	ret.SoundName, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Volume)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketNamedSoundEffect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.SoundName)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Volume)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketOpenSignEntity struct {
	Location Position
}

func (ret *PlayToClientPacketOpenSignEntity) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketOpenSignEntity) Encode(w io.Writer) (err error) {
	PlayToClientPacketOpenSignEntityLocationEncTmp := ret.Location
	err = PlayToClientPacketOpenSignEntityLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketOpenWindow struct {
	WindowId      uint8
	InventoryType string
	WindowTitle   string
	SlotCount     uint8
	EntityId      any
}

func (ret *PlayToClientPacketOpenWindow) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	ret.InventoryType, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.WindowTitle, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SlotCount)
	if err != nil {
		return
	}
	switch ret.InventoryType {
	case "EntityHorse":
		var PlayToClientPacketOpenWindowEntityIdEntityHorseTmp int32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketOpenWindowEntityIdEntityHorseTmp)
		if err != nil {
			return
		}
		ret.EntityId = PlayToClientPacketOpenWindowEntityIdEntityHorseTmp
	default:
		var PlayToClientPacketOpenWindowEntityIdTmp struct {
		}
		ret.EntityId = PlayToClientPacketOpenWindowEntityIdTmp
	}
	return
}
func (ret *PlayToClientPacketOpenWindow) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.InventoryType)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.WindowTitle)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SlotCount)
	if err != nil {
		return
	}
	switch ret.InventoryType {
	case "EntityHorse":
		PlayToClientPacketOpenWindowEntityId, ok := ret.EntityId.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketOpenWindowEntityId)
		if err != nil {
			return
		}
	default:
		_, ok := ret.EntityId.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketPlayerInfo struct {
	Action string
	Data   []struct {
		Uuid uuid.UUID
		Anon any
	}
}

var PlayToClientPacketPlayerInfoActionMap = map[int32]string{0: "add_player", 1: "update_game_mode", 2: "update_latency", 3: "update_display_name", 4: "remove_player"}

func (ret *PlayToClientPacketPlayerInfo) Decode(r io.ReadSeeker) (err error) {
	var PlayToClientPacketPlayerInfoActionKey int32
	PlayToClientPacketPlayerInfoActionKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Action, err = proto_base.ErroringIndex(PlayToClientPacketPlayerInfoActionMap, PlayToClientPacketPlayerInfoActionKey)
	if err != nil {
		return
	}
	var lPlayToClientPacketPlayerInfoData int32
	lPlayToClientPacketPlayerInfoData, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Data = []struct {
		Uuid uuid.UUID
		Anon any
	}{}
	for range lPlayToClientPacketPlayerInfoData {
		var PlayToClientPacketPlayerInfoDataElement struct {
			Uuid uuid.UUID
			Anon any
		}
		_, err = io.ReadFull(r, PlayToClientPacketPlayerInfoDataElement.Uuid[:])
		if err != nil {
			return
		}
		switch ret.Action {
		case "add_player":
			var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp struct {
				Name       string
				Properties []struct {
					Name      string
					Value     string
					Signature *string
				}
				Gamemode    int32
				Ping        int32
				DisplayName *string
			}
			PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Name, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			var lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties int32
			lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties = []struct {
				Name      string
				Value     string
				Signature *string
			}{}
			for range lPlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpProperties {
				var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement struct {
					Name      string
					Value     string
					Signature *string
				}
				PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Name, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Value, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent bool
				err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent)
				if err != nil {
					return
				}
				if PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresent {
					var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue string
					PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r)
					if err != nil {
						return
					}
					PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement.Signature = &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElementSignaturePresentValue
				}
				PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties = append(PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Properties, PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpPropertiesElement)
			}
			PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Gamemode, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.Ping, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent bool
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent)
			if err != nil {
				return
			}
			if PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresent {
				var PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue string
				PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp.DisplayName = &PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmpDisplayNamePresentValue
			}
			PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonAddPlayerTmp
		case "remove_player":
			var PlayToClientPacketPlayerInfoDataElementAnonRemovePlayerTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonRemovePlayerTmp
		case "update_display_name":
			var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp struct {
				DisplayName *string
			}
			var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent bool
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent)
			if err != nil {
				return
			}
			if PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresent {
				var PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue string
				PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp.DisplayName = &PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmpDisplayNamePresentValue
			}
			PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateDisplayNameTmp
		case "update_game_mode":
			var PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp struct {
				Gamemode int32
			}
			PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp.Gamemode, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateGameModeTmp
		case "update_latency":
			var PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp struct {
				Ping int32
			}
			PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp.Ping, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.Anon = PlayToClientPacketPlayerInfoDataElementAnonUpdateLatencyTmp
		}
		ret.Data = append(ret.Data, PlayToClientPacketPlayerInfoDataElement)
	}
	return
}

var PlayToClientPacketPlayerInfoActionReverseMap = map[string]int32{"add_player": 0, "update_game_mode": 1, "update_latency": 2, "update_display_name": 3, "remove_player": 4}

func (ret *PlayToClientPacketPlayerInfo) Encode(w io.Writer) (err error) {
	var vPlayToClientPacketPlayerInfoAction int32
	vPlayToClientPacketPlayerInfoAction, err = proto_base.ErroringIndex(PlayToClientPacketPlayerInfoActionReverseMap, ret.Action)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientPacketPlayerInfoAction)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Data)))
	if err != nil {
		return
	}
	for iPlayToClientPacketPlayerInfoData := range len(ret.Data) {
		_, err = w.Write(ret.Data[iPlayToClientPacketPlayerInfoData].Uuid[:])
		if err != nil {
			return
		}
		switch ret.Action {
		case "add_player":
			PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
				Name       string
				Properties []struct {
					Name      string
					Value     string
					Signature *string
				}
				Gamemode    int32
				Ping        int32
				DisplayName *string
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Name)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketPlayerInfoDataInnerAnon.Properties)))
			if err != nil {
				return
			}
			for iPlayToClientPacketPlayerInfoDataInnerAnonProperties := range len(PlayToClientPacketPlayerInfoDataInnerAnon.Properties) {
				err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Name)
				if err != nil {
					return
				}
				err = proto_base.EncodeString(w, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Value)
				if err != nil {
					return
				}
				err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature != nil)
				if err != nil {
					return
				}
				if PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature != nil {
					err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.Properties[iPlayToClientPacketPlayerInfoDataInnerAnonProperties].Signature)
					if err != nil {
						return
					}
				}
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Gamemode)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Ping)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil)
			if err != nil {
				return
			}
			if PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil {
				err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName)
				if err != nil {
					return
				}
			}
		case "remove_player":
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "update_display_name":
			PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
				DisplayName *string
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil)
			if err != nil {
				return
			}
			if PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName != nil {
				err = proto_base.EncodeString(w, *PlayToClientPacketPlayerInfoDataInnerAnon.DisplayName)
				if err != nil {
					return
				}
			}
		case "update_game_mode":
			PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
				Gamemode int32
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Gamemode)
			if err != nil {
				return
			}
		case "update_latency":
			PlayToClientPacketPlayerInfoDataInnerAnon, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Anon.(struct {
				Ping int32
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerAnon.Ping)
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientPacketPlayerlistHeader struct {
	Header string
	Footer string
}

func (ret *PlayToClientPacketPlayerlistHeader) Decode(r io.ReadSeeker) (err error) {
	ret.Header, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Footer, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketPlayerlistHeader) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Header)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Footer)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketPosition struct {
	X     float64
	Y     float64
	Z     float64
	Yaw   float32
	Pitch float32
	Flags int8
}

func (ret *PlayToClientPacketPosition) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketPosition) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketRelEntityMove struct {
	EntityId int32
	DX       int8
	DY       int8
	DZ       int8
	OnGround bool
}

func (ret *PlayToClientPacketRelEntityMove) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketRelEntityMove) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketRemoveEntityEffect struct {
	EntityId int32
	EffectId int8
}

func (ret *PlayToClientPacketRemoveEntityEffect) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EffectId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketRemoveEntityEffect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EffectId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketResourcePackSend struct {
	Url  string
	Hash string
}

func (ret *PlayToClientPacketResourcePackSend) Decode(r io.ReadSeeker) (err error) {
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketResourcePackSend) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketRespawn struct {
	Dimension  int32
	Difficulty uint8
	Gamemode   uint8
	LevelType  string
}

func (ret *PlayToClientPacketRespawn) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Dimension)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Difficulty)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Gamemode)
	if err != nil {
		return
	}
	ret.LevelType, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketRespawn) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Dimension)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Difficulty)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Gamemode)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.LevelType)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketScoreboardDisplayObjective struct {
	Position int8
	Name     string
}

func (ret *PlayToClientPacketScoreboardDisplayObjective) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Position)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketScoreboardDisplayObjective) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Position)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketScoreboardObjective struct {
	Name        string
	Action      int8
	DisplayText any
	Type        any
}

func (ret *PlayToClientPacketScoreboardObjective) Decode(r io.ReadSeeker) (err error) {
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketScoreboardObjectiveDisplayText0Tmp string
		PlayToClientPacketScoreboardObjectiveDisplayText0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp
	case 2:
		var PlayToClientPacketScoreboardObjectiveDisplayText2Tmp string
		PlayToClientPacketScoreboardObjectiveDisplayText2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp
	default:
		var PlayToClientPacketScoreboardObjectiveDisplayTextTmp struct {
		}
		ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayTextTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketScoreboardObjectiveType0Tmp string
		PlayToClientPacketScoreboardObjectiveType0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Type = PlayToClientPacketScoreboardObjectiveType0Tmp
	case 2:
		var PlayToClientPacketScoreboardObjectiveType2Tmp string
		PlayToClientPacketScoreboardObjectiveType2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Type = PlayToClientPacketScoreboardObjectiveType2Tmp
	default:
		var PlayToClientPacketScoreboardObjectiveTypeTmp struct {
		}
		ret.Type = PlayToClientPacketScoreboardObjectiveTypeTmp
	}
	return
}
func (ret *PlayToClientPacketScoreboardObjective) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardObjectiveDisplayText)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardObjectiveDisplayText)
		if err != nil {
			return
		}
	default:
		_, ok := ret.DisplayText.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardObjectiveType)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardObjectiveType)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Type.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketScoreboardScore struct {
	ItemName  string
	Action    int32
	ScoreName string
	Value     any
}

func (ret *PlayToClientPacketScoreboardScore) Decode(r io.ReadSeeker) (err error) {
	ret.ItemName, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ScoreName, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	switch ret.Action {
	case 1:
		var PlayToClientPacketScoreboardScoreValue1Tmp struct {
		}
		ret.Value = PlayToClientPacketScoreboardScoreValue1Tmp
	default:
		var PlayToClientPacketScoreboardScoreValueTmp int32
		PlayToClientPacketScoreboardScoreValueTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = PlayToClientPacketScoreboardScoreValueTmp
	}
	return
}
func (ret *PlayToClientPacketScoreboardScore) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.ItemName)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.ScoreName)
	if err != nil {
		return
	}
	switch ret.Action {
	case 1:
		_, ok := ret.Value.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Value.(int32))
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketScoreboardTeam struct {
	Team              string
	Mode              int8
	Name              any
	Prefix            any
	Suffix            any
	FriendlyFire      any
	NameTagVisibility any
	Color             any
	Players           any
}

func (ret *PlayToClientPacketScoreboardTeam) Decode(r io.ReadSeeker) (err error) {
	ret.Team, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Mode)
	if err != nil {
		return
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketScoreboardTeamName0Tmp string
		PlayToClientPacketScoreboardTeamName0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Name = PlayToClientPacketScoreboardTeamName0Tmp
	case 2:
		var PlayToClientPacketScoreboardTeamName2Tmp string
		PlayToClientPacketScoreboardTeamName2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Name = PlayToClientPacketScoreboardTeamName2Tmp
	default:
		var PlayToClientPacketScoreboardTeamNameTmp struct {
		}
		ret.Name = PlayToClientPacketScoreboardTeamNameTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketScoreboardTeamPrefix0Tmp string
		PlayToClientPacketScoreboardTeamPrefix0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Prefix = PlayToClientPacketScoreboardTeamPrefix0Tmp
	case 2:
		var PlayToClientPacketScoreboardTeamPrefix2Tmp string
		PlayToClientPacketScoreboardTeamPrefix2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Prefix = PlayToClientPacketScoreboardTeamPrefix2Tmp
	default:
		var PlayToClientPacketScoreboardTeamPrefixTmp struct {
		}
		ret.Prefix = PlayToClientPacketScoreboardTeamPrefixTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketScoreboardTeamSuffix0Tmp string
		PlayToClientPacketScoreboardTeamSuffix0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Suffix = PlayToClientPacketScoreboardTeamSuffix0Tmp
	case 2:
		var PlayToClientPacketScoreboardTeamSuffix2Tmp string
		PlayToClientPacketScoreboardTeamSuffix2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Suffix = PlayToClientPacketScoreboardTeamSuffix2Tmp
	default:
		var PlayToClientPacketScoreboardTeamSuffixTmp struct {
		}
		ret.Suffix = PlayToClientPacketScoreboardTeamSuffixTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketScoreboardTeamFriendlyFire0Tmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardTeamFriendlyFire0Tmp)
		if err != nil {
			return
		}
		ret.FriendlyFire = PlayToClientPacketScoreboardTeamFriendlyFire0Tmp
	case 2:
		var PlayToClientPacketScoreboardTeamFriendlyFire2Tmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardTeamFriendlyFire2Tmp)
		if err != nil {
			return
		}
		ret.FriendlyFire = PlayToClientPacketScoreboardTeamFriendlyFire2Tmp
	default:
		var PlayToClientPacketScoreboardTeamFriendlyFireTmp struct {
		}
		ret.FriendlyFire = PlayToClientPacketScoreboardTeamFriendlyFireTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketScoreboardTeamNameTagVisibility0Tmp string
		PlayToClientPacketScoreboardTeamNameTagVisibility0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.NameTagVisibility = PlayToClientPacketScoreboardTeamNameTagVisibility0Tmp
	case 2:
		var PlayToClientPacketScoreboardTeamNameTagVisibility2Tmp string
		PlayToClientPacketScoreboardTeamNameTagVisibility2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.NameTagVisibility = PlayToClientPacketScoreboardTeamNameTagVisibility2Tmp
	default:
		var PlayToClientPacketScoreboardTeamNameTagVisibilityTmp struct {
		}
		ret.NameTagVisibility = PlayToClientPacketScoreboardTeamNameTagVisibilityTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketScoreboardTeamColor0Tmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardTeamColor0Tmp)
		if err != nil {
			return
		}
		ret.Color = PlayToClientPacketScoreboardTeamColor0Tmp
	case 2:
		var PlayToClientPacketScoreboardTeamColor2Tmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardTeamColor2Tmp)
		if err != nil {
			return
		}
		ret.Color = PlayToClientPacketScoreboardTeamColor2Tmp
	default:
		var PlayToClientPacketScoreboardTeamColorTmp struct {
		}
		ret.Color = PlayToClientPacketScoreboardTeamColorTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketScoreboardTeamPlayers0Tmp []string
		var lPlayToClientPacketScoreboardTeamPlayers0Tmp int32
		lPlayToClientPacketScoreboardTeamPlayers0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketScoreboardTeamPlayers0Tmp = []string{}
		for range lPlayToClientPacketScoreboardTeamPlayers0Tmp {
			var PlayToClientPacketScoreboardTeamPlayers0TmpElement string
			PlayToClientPacketScoreboardTeamPlayers0TmpElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardTeamPlayers0Tmp = append(PlayToClientPacketScoreboardTeamPlayers0Tmp, PlayToClientPacketScoreboardTeamPlayers0TmpElement)
		}
		ret.Players = PlayToClientPacketScoreboardTeamPlayers0Tmp
	case 3:
		var PlayToClientPacketScoreboardTeamPlayers3Tmp []string
		var lPlayToClientPacketScoreboardTeamPlayers3Tmp int32
		lPlayToClientPacketScoreboardTeamPlayers3Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketScoreboardTeamPlayers3Tmp = []string{}
		for range lPlayToClientPacketScoreboardTeamPlayers3Tmp {
			var PlayToClientPacketScoreboardTeamPlayers3TmpElement string
			PlayToClientPacketScoreboardTeamPlayers3TmpElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardTeamPlayers3Tmp = append(PlayToClientPacketScoreboardTeamPlayers3Tmp, PlayToClientPacketScoreboardTeamPlayers3TmpElement)
		}
		ret.Players = PlayToClientPacketScoreboardTeamPlayers3Tmp
	case 4:
		var PlayToClientPacketScoreboardTeamPlayers4Tmp []string
		var lPlayToClientPacketScoreboardTeamPlayers4Tmp int32
		lPlayToClientPacketScoreboardTeamPlayers4Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketScoreboardTeamPlayers4Tmp = []string{}
		for range lPlayToClientPacketScoreboardTeamPlayers4Tmp {
			var PlayToClientPacketScoreboardTeamPlayers4TmpElement string
			PlayToClientPacketScoreboardTeamPlayers4TmpElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardTeamPlayers4Tmp = append(PlayToClientPacketScoreboardTeamPlayers4Tmp, PlayToClientPacketScoreboardTeamPlayers4TmpElement)
		}
		ret.Players = PlayToClientPacketScoreboardTeamPlayers4Tmp
	default:
		var PlayToClientPacketScoreboardTeamPlayersTmp struct {
		}
		ret.Players = PlayToClientPacketScoreboardTeamPlayersTmp
	}
	return
}
func (ret *PlayToClientPacketScoreboardTeam) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Team)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Mode)
	if err != nil {
		return
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketScoreboardTeamName, ok := ret.Name.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamName)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardTeamName, ok := ret.Name.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamName)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Name.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketScoreboardTeamPrefix, ok := ret.Prefix.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPrefix)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardTeamPrefix, ok := ret.Prefix.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPrefix)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Prefix.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketScoreboardTeamSuffix, ok := ret.Suffix.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamSuffix)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardTeamSuffix, ok := ret.Suffix.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamSuffix)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Suffix.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketScoreboardTeamFriendlyFire, ok := ret.FriendlyFire.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardTeamFriendlyFire)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardTeamFriendlyFire, ok := ret.FriendlyFire.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardTeamFriendlyFire)
		if err != nil {
			return
		}
	default:
		_, ok := ret.FriendlyFire.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketScoreboardTeamNameTagVisibility, ok := ret.NameTagVisibility.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamNameTagVisibility)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardTeamNameTagVisibility, ok := ret.NameTagVisibility.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamNameTagVisibility)
		if err != nil {
			return
		}
	default:
		_, ok := ret.NameTagVisibility.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketScoreboardTeamColor, ok := ret.Color.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardTeamColor)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardTeamColor, ok := ret.Color.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardTeamColor)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Color.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketScoreboardTeamPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketScoreboardTeamPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketScoreboardTeamPlayers := range len(PlayToClientPacketScoreboardTeamPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPlayers[iPlayToClientPacketScoreboardTeamPlayers])
			if err != nil {
				return
			}
		}
	case 3:
		PlayToClientPacketScoreboardTeamPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketScoreboardTeamPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketScoreboardTeamPlayers := range len(PlayToClientPacketScoreboardTeamPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPlayers[iPlayToClientPacketScoreboardTeamPlayers])
			if err != nil {
				return
			}
		}
	case 4:
		PlayToClientPacketScoreboardTeamPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketScoreboardTeamPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketScoreboardTeamPlayers := range len(PlayToClientPacketScoreboardTeamPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketScoreboardTeamPlayers[iPlayToClientPacketScoreboardTeamPlayers])
			if err != nil {
				return
			}
		}
	default:
		_, ok := ret.Players.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketSetCompression struct {
	Threshold int32
}

func (ret *PlayToClientPacketSetCompression) Decode(r io.ReadSeeker) (err error) {
	ret.Threshold, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetCompression) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Threshold)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetSlot struct {
	WindowId int8
	Slot     int16
	Item     Slot
}

func (ret *PlayToClientPacketSetSlot) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Slot)
	if err != nil {
		return
	}
	err = ret.Item.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetSlot) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Slot)
	if err != nil {
		return
	}
	PlayToClientPacketSetSlotItemEncTmp := ret.Item
	err = PlayToClientPacketSetSlotItemEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSpawnEntity struct {
	EntityId   int32
	Type       int8
	X          int32
	Y          int32
	Z          int32
	Pitch      int8
	Yaw        int8
	ObjectData int32
	Velocity   any
}

func (ret *PlayToClientPacketSpawnEntity) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Type)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ObjectData)
	if err != nil {
		return
	}
	switch ret.ObjectData {
	case 0:
		var PlayToClientPacketSpawnEntityVelocity0Tmp struct {
		}
		ret.Velocity = PlayToClientPacketSpawnEntityVelocity0Tmp
	default:
		var PlayToClientPacketSpawnEntityVelocityTmp Vec3i16
		err = PlayToClientPacketSpawnEntityVelocityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Velocity = PlayToClientPacketSpawnEntityVelocityTmp
	}
	return
}
func (ret *PlayToClientPacketSpawnEntity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Type)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ObjectData)
	if err != nil {
		return
	}
	switch ret.ObjectData {
	case 0:
		_, ok := ret.Velocity.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Velocity.(Vec3i16)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketSpawnEntityVelocityEncTmp := ret.Velocity.(Vec3i16)
		err = PlayToClientPacketSpawnEntityVelocityEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketSpawnEntityExperienceOrb struct {
	EntityId int32
	X        int32
	Y        int32
	Z        int32
	Count    int16
}

func (ret *PlayToClientPacketSpawnEntityExperienceOrb) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Count)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSpawnEntityExperienceOrb) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Count)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSpawnEntityLiving struct {
	EntityId  int32
	Type      uint8
	X         int32
	Y         int32
	Z         int32
	Yaw       int8
	Pitch     int8
	HeadPitch int8
	Velocity  Vec3i16
	Metadata  EntityMetadata
}

func (ret *PlayToClientPacketSpawnEntityLiving) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Type)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HeadPitch)
	if err != nil {
		return
	}
	err = ret.Velocity.Decode(r)
	if err != nil {
		return
	}
	err = ret.Metadata.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSpawnEntityLiving) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Type)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HeadPitch)
	if err != nil {
		return
	}
	PlayToClientPacketSpawnEntityLivingVelocityEncTmp := ret.Velocity
	err = PlayToClientPacketSpawnEntityLivingVelocityEncTmp.Encode(w)
	if err != nil {
		return
	}
	PlayToClientPacketSpawnEntityLivingMetadataEncTmp := ret.Metadata
	err = PlayToClientPacketSpawnEntityLivingMetadataEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSpawnEntityPainting struct {
	EntityId  int32
	Title     string
	Location  Position
	Direction uint8
}

func (ret *PlayToClientPacketSpawnEntityPainting) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Title, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Direction)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSpawnEntityPainting) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Title)
	if err != nil {
		return
	}
	PlayToClientPacketSpawnEntityPaintingLocationEncTmp := ret.Location
	err = PlayToClientPacketSpawnEntityPaintingLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Direction)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSpawnEntityWeather struct {
	EntityId int32
	Type     int8
	X        int32
	Y        int32
	Z        int32
}

func (ret *PlayToClientPacketSpawnEntityWeather) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Type)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSpawnEntityWeather) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Type)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSpawnPosition struct {
	Location Position
}

func (ret *PlayToClientPacketSpawnPosition) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSpawnPosition) Encode(w io.Writer) (err error) {
	PlayToClientPacketSpawnPositionLocationEncTmp := ret.Location
	err = PlayToClientPacketSpawnPositionLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketStatistics struct {
	Entries []struct {
		Name  string
		Value int32
	}
}

func (ret *PlayToClientPacketStatistics) Decode(r io.ReadSeeker) (err error) {
	var lPlayToClientPacketStatisticsEntries int32
	lPlayToClientPacketStatisticsEntries, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Entries = []struct {
		Name  string
		Value int32
	}{}
	for range lPlayToClientPacketStatisticsEntries {
		var PlayToClientPacketStatisticsEntriesElement struct {
			Name  string
			Value int32
		}
		PlayToClientPacketStatisticsEntriesElement.Name, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		PlayToClientPacketStatisticsEntriesElement.Value, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Entries = append(ret.Entries, PlayToClientPacketStatisticsEntriesElement)
	}
	return
}
func (ret *PlayToClientPacketStatistics) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
	if err != nil {
		return
	}
	for iPlayToClientPacketStatisticsEntries := range len(ret.Entries) {
		err = proto_base.EncodeString(w, ret.Entries[iPlayToClientPacketStatisticsEntries].Name)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].Value)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketTabComplete struct {
	Matches []string
}

func (ret *PlayToClientPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
	var lPlayToClientPacketTabCompleteMatches int32
	lPlayToClientPacketTabCompleteMatches, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Matches = []string{}
	for range lPlayToClientPacketTabCompleteMatches {
		var PlayToClientPacketTabCompleteMatchesElement string
		PlayToClientPacketTabCompleteMatchesElement, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Matches = append(ret.Matches, PlayToClientPacketTabCompleteMatchesElement)
	}
	return
}
func (ret *PlayToClientPacketTabComplete) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Matches)))
	if err != nil {
		return
	}
	for iPlayToClientPacketTabCompleteMatches := range len(ret.Matches) {
		err = proto_base.EncodeString(w, ret.Matches[iPlayToClientPacketTabCompleteMatches])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketTileEntityData struct {
	Location Position
	Action   uint8
	NbtData  nbt.Tag
}

func (ret *PlayToClientPacketTileEntityData) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Action)
	if err != nil {
		return
	}
	err = ret.NbtData.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketTileEntityData) Encode(w io.Writer) (err error) {
	PlayToClientPacketTileEntityDataLocationEncTmp := ret.Location
	err = PlayToClientPacketTileEntityDataLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Action)
	if err != nil {
		return
	}
	PlayToClientPacketTileEntityDataNbtDataEncTmp := ret.NbtData
	err = PlayToClientPacketTileEntityDataNbtDataEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketTitle struct {
	Action  int32
	Text    any
	FadeIn  any
	Stay    any
	FadeOut any
}

func (ret *PlayToClientPacketTitle) Decode(r io.ReadSeeker) (err error) {
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketTitleText0Tmp string
		PlayToClientPacketTitleText0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Text = PlayToClientPacketTitleText0Tmp
	case 1:
		var PlayToClientPacketTitleText1Tmp string
		PlayToClientPacketTitleText1Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Text = PlayToClientPacketTitleText1Tmp
	default:
		var PlayToClientPacketTitleTextTmp struct {
		}
		ret.Text = PlayToClientPacketTitleTextTmp
	}
	switch ret.Action {
	case 2:
		var PlayToClientPacketTitleFadeIn2Tmp int32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleFadeIn2Tmp)
		if err != nil {
			return
		}
		ret.FadeIn = PlayToClientPacketTitleFadeIn2Tmp
	default:
		var PlayToClientPacketTitleFadeInTmp struct {
		}
		ret.FadeIn = PlayToClientPacketTitleFadeInTmp
	}
	switch ret.Action {
	case 2:
		var PlayToClientPacketTitleStay2Tmp int32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleStay2Tmp)
		if err != nil {
			return
		}
		ret.Stay = PlayToClientPacketTitleStay2Tmp
	default:
		var PlayToClientPacketTitleStayTmp struct {
		}
		ret.Stay = PlayToClientPacketTitleStayTmp
	}
	switch ret.Action {
	case 2:
		var PlayToClientPacketTitleFadeOut2Tmp int32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTitleFadeOut2Tmp)
		if err != nil {
			return
		}
		ret.FadeOut = PlayToClientPacketTitleFadeOut2Tmp
	default:
		var PlayToClientPacketTitleFadeOutTmp struct {
		}
		ret.FadeOut = PlayToClientPacketTitleFadeOutTmp
	}
	return
}
func (ret *PlayToClientPacketTitle) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketTitleText, ok := ret.Text.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTitleText)
		if err != nil {
			return
		}
	case 1:
		PlayToClientPacketTitleText, ok := ret.Text.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTitleText)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Text.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 2:
		PlayToClientPacketTitleFadeIn, ok := ret.FadeIn.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleFadeIn)
		if err != nil {
			return
		}
	default:
		_, ok := ret.FadeIn.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 2:
		PlayToClientPacketTitleStay, ok := ret.Stay.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleStay)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Stay.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 2:
		PlayToClientPacketTitleFadeOut, ok := ret.FadeOut.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketTitleFadeOut)
		if err != nil {
			return
		}
	default:
		_, ok := ret.FadeOut.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketTransaction struct {
	WindowId int8
	Action   int16
	Accepted bool
}

func (ret *PlayToClientPacketTransaction) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Action)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Accepted)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketTransaction) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Action)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Accepted)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateAttributes struct {
	EntityId   int32
	Properties []struct {
		Key       string
		Value     float64
		Modifiers []struct {
			Uuid      uuid.UUID
			Amount    float64
			Operation int8
		}
	}
}

func (ret *PlayToClientPacketUpdateAttributes) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketUpdateAttributesProperties int32
	err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketUpdateAttributesProperties)
	if err != nil {
		return
	}
	ret.Properties = []struct {
		Key       string
		Value     float64
		Modifiers []struct {
			Uuid      uuid.UUID
			Amount    float64
			Operation int8
		}
	}{}
	for range lPlayToClientPacketUpdateAttributesProperties {
		var PlayToClientPacketUpdateAttributesPropertiesElement struct {
			Key       string
			Value     float64
			Modifiers []struct {
				Uuid      uuid.UUID
				Amount    float64
				Operation int8
			}
		}
		PlayToClientPacketUpdateAttributesPropertiesElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateAttributesPropertiesElement.Value)
		if err != nil {
			return
		}
		var lPlayToClientPacketUpdateAttributesPropertiesElementModifiers int32
		lPlayToClientPacketUpdateAttributesPropertiesElementModifiers, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketUpdateAttributesPropertiesElement.Modifiers = []struct {
			Uuid      uuid.UUID
			Amount    float64
			Operation int8
		}{}
		for range lPlayToClientPacketUpdateAttributesPropertiesElementModifiers {
			var PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement struct {
				Uuid      uuid.UUID
				Amount    float64
				Operation int8
			}
			_, err = io.ReadFull(r, PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement.Uuid[:])
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement.Amount)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement.Operation)
			if err != nil {
				return
			}
			PlayToClientPacketUpdateAttributesPropertiesElement.Modifiers = append(PlayToClientPacketUpdateAttributesPropertiesElement.Modifiers, PlayToClientPacketUpdateAttributesPropertiesElementModifiersElement)
		}
		ret.Properties = append(ret.Properties, PlayToClientPacketUpdateAttributesPropertiesElement)
	}
	return
}
func (ret *PlayToClientPacketUpdateAttributes) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, int32(len(ret.Properties)))
	if err != nil {
		return
	}
	for iPlayToClientPacketUpdateAttributesProperties := range len(ret.Properties) {
		err = proto_base.EncodeString(w, ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Key)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Value)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketUpdateAttributesPropertiesInnerModifiers := range len(ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers) {
			_, err = w.Write(ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers[iPlayToClientPacketUpdateAttributesPropertiesInnerModifiers].Uuid[:])
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers[iPlayToClientPacketUpdateAttributesPropertiesInnerModifiers].Amount)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketUpdateAttributesProperties].Modifiers[iPlayToClientPacketUpdateAttributesPropertiesInnerModifiers].Operation)
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientPacketUpdateEntityNbt struct {
	EntityId int32
	Tag      nbt.Tag
}

func (ret *PlayToClientPacketUpdateEntityNbt) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Tag.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateEntityNbt) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	PlayToClientPacketUpdateEntityNbtTagEncTmp := ret.Tag
	err = PlayToClientPacketUpdateEntityNbtTagEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateHealth struct {
	Health         float32
	Food           int32
	FoodSaturation float32
}

func (ret *PlayToClientPacketUpdateHealth) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Health)
	if err != nil {
		return
	}
	ret.Food, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FoodSaturation)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateHealth) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Health)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Food)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FoodSaturation)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateSign struct {
	Location Position
	Text1    string
	Text2    string
	Text3    string
	Text4    string
}

func (ret *PlayToClientPacketUpdateSign) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Text1, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text2, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text3, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text4, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateSign) Encode(w io.Writer) (err error) {
	PlayToClientPacketUpdateSignLocationEncTmp := ret.Location
	err = PlayToClientPacketUpdateSignLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text1)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text2)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text3)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text4)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateTime struct {
	Age  int64
	Time int64
}

func (ret *PlayToClientPacketUpdateTime) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Age)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Time)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateTime) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Age)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Time)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWindowItems struct {
	WindowId uint8
	Items    []Slot
}

func (ret *PlayToClientPacketWindowItems) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	var lPlayToClientPacketWindowItemsItems int16
	err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketWindowItemsItems)
	if err != nil {
		return
	}
	ret.Items = []Slot{}
	for range lPlayToClientPacketWindowItemsItems {
		var PlayToClientPacketWindowItemsItemsElement Slot
		err = PlayToClientPacketWindowItemsItemsElement.Decode(r)
		if err != nil {
			return
		}
		ret.Items = append(ret.Items, PlayToClientPacketWindowItemsItemsElement)
	}
	return
}
func (ret *PlayToClientPacketWindowItems) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, int16(len(ret.Items)))
	if err != nil {
		return
	}
	for iPlayToClientPacketWindowItemsItems := range len(ret.Items) {
		PlayToClientPacketWindowItemsItemsInnerEncTmp := ret.Items[iPlayToClientPacketWindowItemsItems]
		err = PlayToClientPacketWindowItemsItemsInnerEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketWorldBorder struct {
	Action         int32
	Radius         any
	X              any
	Z              any
	OldRadius      any
	NewRadius      any
	Speed          any
	PortalBoundary any
	WarningTime    any
	WarningBlocks  any
}

func (ret *PlayToClientPacketWorldBorder) Decode(r io.ReadSeeker) (err error) {
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketWorldBorderRadius0Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderRadius0Tmp)
		if err != nil {
			return
		}
		ret.Radius = PlayToClientPacketWorldBorderRadius0Tmp
	default:
		var PlayToClientPacketWorldBorderRadiusTmp struct {
		}
		ret.Radius = PlayToClientPacketWorldBorderRadiusTmp
	}
	switch ret.Action {
	case 2:
		var PlayToClientPacketWorldBorderX2Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderX2Tmp)
		if err != nil {
			return
		}
		ret.X = PlayToClientPacketWorldBorderX2Tmp
	case 3:
		var PlayToClientPacketWorldBorderX3Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderX3Tmp)
		if err != nil {
			return
		}
		ret.X = PlayToClientPacketWorldBorderX3Tmp
	default:
		var PlayToClientPacketWorldBorderXTmp struct {
		}
		ret.X = PlayToClientPacketWorldBorderXTmp
	}
	switch ret.Action {
	case 2:
		var PlayToClientPacketWorldBorderZ2Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderZ2Tmp)
		if err != nil {
			return
		}
		ret.Z = PlayToClientPacketWorldBorderZ2Tmp
	case 3:
		var PlayToClientPacketWorldBorderZ3Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderZ3Tmp)
		if err != nil {
			return
		}
		ret.Z = PlayToClientPacketWorldBorderZ3Tmp
	default:
		var PlayToClientPacketWorldBorderZTmp struct {
		}
		ret.Z = PlayToClientPacketWorldBorderZTmp
	}
	switch ret.Action {
	case 1:
		var PlayToClientPacketWorldBorderOldRadius1Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderOldRadius1Tmp)
		if err != nil {
			return
		}
		ret.OldRadius = PlayToClientPacketWorldBorderOldRadius1Tmp
	case 3:
		var PlayToClientPacketWorldBorderOldRadius3Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderOldRadius3Tmp)
		if err != nil {
			return
		}
		ret.OldRadius = PlayToClientPacketWorldBorderOldRadius3Tmp
	default:
		var PlayToClientPacketWorldBorderOldRadiusTmp struct {
		}
		ret.OldRadius = PlayToClientPacketWorldBorderOldRadiusTmp
	}
	switch ret.Action {
	case 1:
		var PlayToClientPacketWorldBorderNewRadius1Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderNewRadius1Tmp)
		if err != nil {
			return
		}
		ret.NewRadius = PlayToClientPacketWorldBorderNewRadius1Tmp
	case 3:
		var PlayToClientPacketWorldBorderNewRadius3Tmp float64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldBorderNewRadius3Tmp)
		if err != nil {
			return
		}
		ret.NewRadius = PlayToClientPacketWorldBorderNewRadius3Tmp
	default:
		var PlayToClientPacketWorldBorderNewRadiusTmp struct {
		}
		ret.NewRadius = PlayToClientPacketWorldBorderNewRadiusTmp
	}
	switch ret.Action {
	case 1:
		var PlayToClientPacketWorldBorderSpeed1Tmp int64
		PlayToClientPacketWorldBorderSpeed1Tmp, err = proto_base.DecodeVarLong(r)
		if err != nil {
			return
		}
		ret.Speed = PlayToClientPacketWorldBorderSpeed1Tmp
	case 3:
		var PlayToClientPacketWorldBorderSpeed3Tmp int64
		PlayToClientPacketWorldBorderSpeed3Tmp, err = proto_base.DecodeVarLong(r)
		if err != nil {
			return
		}
		ret.Speed = PlayToClientPacketWorldBorderSpeed3Tmp
	default:
		var PlayToClientPacketWorldBorderSpeedTmp struct {
		}
		ret.Speed = PlayToClientPacketWorldBorderSpeedTmp
	}
	switch ret.Action {
	case 3:
		var PlayToClientPacketWorldBorderPortalBoundary3Tmp int32
		PlayToClientPacketWorldBorderPortalBoundary3Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.PortalBoundary = PlayToClientPacketWorldBorderPortalBoundary3Tmp
	default:
		var PlayToClientPacketWorldBorderPortalBoundaryTmp struct {
		}
		ret.PortalBoundary = PlayToClientPacketWorldBorderPortalBoundaryTmp
	}
	switch ret.Action {
	case 3:
		var PlayToClientPacketWorldBorderWarningTime3Tmp int32
		PlayToClientPacketWorldBorderWarningTime3Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.WarningTime = PlayToClientPacketWorldBorderWarningTime3Tmp
	case 4:
		var PlayToClientPacketWorldBorderWarningTime4Tmp int32
		PlayToClientPacketWorldBorderWarningTime4Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.WarningTime = PlayToClientPacketWorldBorderWarningTime4Tmp
	default:
		var PlayToClientPacketWorldBorderWarningTimeTmp struct {
		}
		ret.WarningTime = PlayToClientPacketWorldBorderWarningTimeTmp
	}
	switch ret.Action {
	case 3:
		var PlayToClientPacketWorldBorderWarningBlocks3Tmp int32
		PlayToClientPacketWorldBorderWarningBlocks3Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocks3Tmp
	case 5:
		var PlayToClientPacketWorldBorderWarningBlocks5Tmp int32
		PlayToClientPacketWorldBorderWarningBlocks5Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocks5Tmp
	default:
		var PlayToClientPacketWorldBorderWarningBlocksTmp struct {
		}
		ret.WarningBlocks = PlayToClientPacketWorldBorderWarningBlocksTmp
	}
	return
}
func (ret *PlayToClientPacketWorldBorder) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketWorldBorderRadius, ok := ret.Radius.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderRadius)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Radius.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 2:
		PlayToClientPacketWorldBorderX, ok := ret.X.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderX)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketWorldBorderX, ok := ret.X.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderX)
		if err != nil {
			return
		}
	default:
		_, ok := ret.X.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 2:
		PlayToClientPacketWorldBorderZ, ok := ret.Z.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderZ)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketWorldBorderZ, ok := ret.Z.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderZ)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Z.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 1:
		PlayToClientPacketWorldBorderOldRadius, ok := ret.OldRadius.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderOldRadius)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketWorldBorderOldRadius, ok := ret.OldRadius.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderOldRadius)
		if err != nil {
			return
		}
	default:
		_, ok := ret.OldRadius.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 1:
		PlayToClientPacketWorldBorderNewRadius, ok := ret.NewRadius.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderNewRadius)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketWorldBorderNewRadius, ok := ret.NewRadius.(float64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldBorderNewRadius)
		if err != nil {
			return
		}
	default:
		_, ok := ret.NewRadius.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 1:
		PlayToClientPacketWorldBorderSpeed, ok := ret.Speed.(int64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarLong(w, PlayToClientPacketWorldBorderSpeed)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketWorldBorderSpeed, ok := ret.Speed.(int64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarLong(w, PlayToClientPacketWorldBorderSpeed)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Speed.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 3:
		PlayToClientPacketWorldBorderPortalBoundary, ok := ret.PortalBoundary.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderPortalBoundary)
		if err != nil {
			return
		}
	default:
		_, ok := ret.PortalBoundary.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 3:
		PlayToClientPacketWorldBorderWarningTime, ok := ret.WarningTime.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningTime)
		if err != nil {
			return
		}
	case 4:
		PlayToClientPacketWorldBorderWarningTime, ok := ret.WarningTime.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningTime)
		if err != nil {
			return
		}
	default:
		_, ok := ret.WarningTime.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 3:
		PlayToClientPacketWorldBorderWarningBlocks, ok := ret.WarningBlocks.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningBlocks)
		if err != nil {
			return
		}
	case 5:
		PlayToClientPacketWorldBorderWarningBlocks, ok := ret.WarningBlocks.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldBorderWarningBlocks)
		if err != nil {
			return
		}
	default:
		_, ok := ret.WarningBlocks.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketWorldEvent struct {
	EffectId int32
	Location Position
	Data     int32
	Global   bool
}

func (ret *PlayToClientPacketWorldEvent) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.EffectId)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Data)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Global)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWorldEvent) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.EffectId)
	if err != nil {
		return
	}
	PlayToClientPacketWorldEventLocationEncTmp := ret.Location
	err = PlayToClientPacketWorldEventLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Data)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Global)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWorldParticles struct {
	ParticleId   int32
	LongDistance bool
	X            float32
	Y            float32
	Z            float32
	OffsetX      float32
	OffsetY      float32
	OffsetZ      float32
	ParticleData float32
	Particles    int32
	Data         any
}

func (ret *PlayToClientPacketWorldParticles) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.ParticleId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.LongDistance)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ParticleData)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Particles)
	if err != nil {
		return
	}
	switch ret.ParticleId {
	case 36:
		var PlayToClientPacketWorldParticlesData36Tmp []int32
		var lPlayToClientPacketWorldParticlesData36Tmp int32
		lPlayToClientPacketWorldParticlesData36Tmp = 2
		PlayToClientPacketWorldParticlesData36Tmp = []int32{}
		for range lPlayToClientPacketWorldParticlesData36Tmp {
			var PlayToClientPacketWorldParticlesData36TmpElement int32
			PlayToClientPacketWorldParticlesData36TmpElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketWorldParticlesData36Tmp = append(PlayToClientPacketWorldParticlesData36Tmp, PlayToClientPacketWorldParticlesData36TmpElement)
		}
		ret.Data = PlayToClientPacketWorldParticlesData36Tmp
	case 37:
		var PlayToClientPacketWorldParticlesData37Tmp []int32
		var lPlayToClientPacketWorldParticlesData37Tmp int32
		lPlayToClientPacketWorldParticlesData37Tmp = 1
		PlayToClientPacketWorldParticlesData37Tmp = []int32{}
		for range lPlayToClientPacketWorldParticlesData37Tmp {
			var PlayToClientPacketWorldParticlesData37TmpElement int32
			PlayToClientPacketWorldParticlesData37TmpElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketWorldParticlesData37Tmp = append(PlayToClientPacketWorldParticlesData37Tmp, PlayToClientPacketWorldParticlesData37TmpElement)
		}
		ret.Data = PlayToClientPacketWorldParticlesData37Tmp
	case 38:
		var PlayToClientPacketWorldParticlesData38Tmp []int32
		var lPlayToClientPacketWorldParticlesData38Tmp int32
		lPlayToClientPacketWorldParticlesData38Tmp = 1
		PlayToClientPacketWorldParticlesData38Tmp = []int32{}
		for range lPlayToClientPacketWorldParticlesData38Tmp {
			var PlayToClientPacketWorldParticlesData38TmpElement int32
			PlayToClientPacketWorldParticlesData38TmpElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketWorldParticlesData38Tmp = append(PlayToClientPacketWorldParticlesData38Tmp, PlayToClientPacketWorldParticlesData38TmpElement)
		}
		ret.Data = PlayToClientPacketWorldParticlesData38Tmp
	default:
		var PlayToClientPacketWorldParticlesDataTmp struct {
		}
		ret.Data = PlayToClientPacketWorldParticlesDataTmp
	}
	return
}
func (ret *PlayToClientPacketWorldParticles) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.ParticleId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.LongDistance)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ParticleData)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Particles)
	if err != nil {
		return
	}
	switch ret.ParticleId {
	case 36:
		PlayToClientPacketWorldParticlesData, ok := ret.Data.([]int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		for iPlayToClientPacketWorldParticlesData := range len(PlayToClientPacketWorldParticlesData) {
			err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData[iPlayToClientPacketWorldParticlesData])
			if err != nil {
				return
			}
		}
	case 37:
		PlayToClientPacketWorldParticlesData, ok := ret.Data.([]int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		for iPlayToClientPacketWorldParticlesData := range len(PlayToClientPacketWorldParticlesData) {
			err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData[iPlayToClientPacketWorldParticlesData])
			if err != nil {
				return
			}
		}
	case 38:
		PlayToClientPacketWorldParticlesData, ok := ret.Data.([]int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		for iPlayToClientPacketWorldParticlesData := range len(PlayToClientPacketWorldParticlesData) {
			err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData[iPlayToClientPacketWorldParticlesData])
			if err != nil {
				return
			}
		}
	default:
		_, ok := ret.Data.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToServerPacket struct {
	Name   string
	Params any
}

var PlayToServerPacketNameMap = map[int32]string{0x00: "keep_alive", 0x01: "chat", 0x02: "use_entity", 0x03: "flying", 0x04: "position", 0x05: "look", 0x06: "position_look", 0x07: "block_dig", 0x08: "block_place", 0x09: "held_item_slot", 0x0a: "arm_animation", 0x0b: "entity_action", 0x0c: "steer_vehicle", 0x0d: "close_window", 0x0e: "window_click", 0x0f: "transaction", 0x10: "set_creative_slot", 0x11: "enchant_item", 0x12: "update_sign", 0x13: "abilities", 0x14: "tab_complete", 0x15: "settings", 0x16: "client_command", 0x17: "custom_payload", 0x18: "spectate", 0x19: "resource_pack_receive"}

func (ret *PlayToServerPacket) Decode(r io.ReadSeeker) (err error) {
	var PlayToServerPacketNameKey int32
	PlayToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(PlayToServerPacketNameMap, PlayToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		var PlayToServerPacketParamsAbilitiesTmp PlayToServerPacketAbilities
		err = PlayToServerPacketParamsAbilitiesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsAbilitiesTmp
	case "arm_animation":
		var PlayToServerPacketParamsArmAnimationTmp PlayToServerPacketArmAnimation
		err = PlayToServerPacketParamsArmAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsArmAnimationTmp
	case "block_dig":
		var PlayToServerPacketParamsBlockDigTmp PlayToServerPacketBlockDig
		err = PlayToServerPacketParamsBlockDigTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsBlockDigTmp
	case "block_place":
		var PlayToServerPacketParamsBlockPlaceTmp PlayToServerPacketBlockPlace
		err = PlayToServerPacketParamsBlockPlaceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsBlockPlaceTmp
	case "chat":
		var PlayToServerPacketParamsChatTmp PlayToServerPacketChat
		err = PlayToServerPacketParamsChatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsChatTmp
	case "client_command":
		var PlayToServerPacketParamsClientCommandTmp PlayToServerPacketClientCommand
		err = PlayToServerPacketParamsClientCommandTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsClientCommandTmp
	case "close_window":
		var PlayToServerPacketParamsCloseWindowTmp PlayToServerPacketCloseWindow
		err = PlayToServerPacketParamsCloseWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCloseWindowTmp
	case "custom_payload":
		var PlayToServerPacketParamsCustomPayloadTmp PlayToServerPacketCustomPayload
		err = PlayToServerPacketParamsCustomPayloadTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCustomPayloadTmp
	case "enchant_item":
		var PlayToServerPacketParamsEnchantItemTmp PlayToServerPacketEnchantItem
		err = PlayToServerPacketParamsEnchantItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsEnchantItemTmp
	case "entity_action":
		var PlayToServerPacketParamsEntityActionTmp PlayToServerPacketEntityAction
		err = PlayToServerPacketParamsEntityActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsEntityActionTmp
	case "flying":
		var PlayToServerPacketParamsFlyingTmp PlayToServerPacketFlying
		err = PlayToServerPacketParamsFlyingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsFlyingTmp
	case "held_item_slot":
		var PlayToServerPacketParamsHeldItemSlotTmp PlayToServerPacketHeldItemSlot
		err = PlayToServerPacketParamsHeldItemSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsHeldItemSlotTmp
	case "keep_alive":
		var PlayToServerPacketParamsKeepAliveTmp PlayToServerPacketKeepAlive
		err = PlayToServerPacketParamsKeepAliveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsKeepAliveTmp
	case "look":
		var PlayToServerPacketParamsLookTmp PlayToServerPacketLook
		err = PlayToServerPacketParamsLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsLookTmp
	case "position":
		var PlayToServerPacketParamsPositionTmp PlayToServerPacketPosition
		err = PlayToServerPacketParamsPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPositionTmp
	case "position_look":
		var PlayToServerPacketParamsPositionLookTmp PlayToServerPacketPositionLook
		err = PlayToServerPacketParamsPositionLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPositionLookTmp
	case "resource_pack_receive":
		var PlayToServerPacketParamsResourcePackReceiveTmp PlayToServerPacketResourcePackReceive
		err = PlayToServerPacketParamsResourcePackReceiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsResourcePackReceiveTmp
	case "set_creative_slot":
		var PlayToServerPacketParamsSetCreativeSlotTmp PlayToServerPacketSetCreativeSlot
		err = PlayToServerPacketParamsSetCreativeSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetCreativeSlotTmp
	case "settings":
		var PlayToServerPacketParamsSettingsTmp PlayToServerPacketSettings
		err = PlayToServerPacketParamsSettingsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSettingsTmp
	case "spectate":
		var PlayToServerPacketParamsSpectateTmp PlayToServerPacketSpectate
		err = PlayToServerPacketParamsSpectateTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSpectateTmp
	case "steer_vehicle":
		var PlayToServerPacketParamsSteerVehicleTmp PlayToServerPacketSteerVehicle
		err = PlayToServerPacketParamsSteerVehicleTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSteerVehicleTmp
	case "tab_complete":
		var PlayToServerPacketParamsTabCompleteTmp PlayToServerPacketTabComplete
		err = PlayToServerPacketParamsTabCompleteTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTabCompleteTmp
	case "transaction":
		var PlayToServerPacketParamsTransactionTmp PlayToServerPacketTransaction
		err = PlayToServerPacketParamsTransactionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTransactionTmp
	case "update_sign":
		var PlayToServerPacketParamsUpdateSignTmp PlayToServerPacketUpdateSign
		err = PlayToServerPacketParamsUpdateSignTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateSignTmp
	case "use_entity":
		var PlayToServerPacketParamsUseEntityTmp PlayToServerPacketUseEntity
		err = PlayToServerPacketParamsUseEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUseEntityTmp
	case "window_click":
		var PlayToServerPacketParamsWindowClickTmp PlayToServerPacketWindowClick
		err = PlayToServerPacketParamsWindowClickTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsWindowClickTmp
	}
	return
}

var PlayToServerPacketNameReverseMap = map[string]int32{"keep_alive": 0x00, "chat": 0x01, "use_entity": 0x02, "flying": 0x03, "position": 0x04, "look": 0x05, "position_look": 0x06, "block_dig": 0x07, "block_place": 0x08, "held_item_slot": 0x09, "arm_animation": 0x0a, "entity_action": 0x0b, "steer_vehicle": 0x0c, "close_window": 0x0d, "window_click": 0x0e, "transaction": 0x0f, "set_creative_slot": 0x10, "enchant_item": 0x11, "update_sign": 0x12, "abilities": 0x13, "tab_complete": 0x14, "settings": 0x15, "client_command": 0x16, "custom_payload": 0x17, "spectate": 0x18, "resource_pack_receive": 0x19}

func (ret *PlayToServerPacket) Encode(w io.Writer) (err error) {
	var vPlayToServerPacketName int32
	vPlayToServerPacketName, err = proto_base.ErroringIndex(PlayToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAbilities)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "arm_animation":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketArmAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_dig":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockDig)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_place":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockPlace)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "chat":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "client_command":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketClientCommand)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "close_window":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCloseWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "custom_payload":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCustomPayload)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "enchant_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEnchantItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_action":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEntityAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "flying":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketFlying)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "held_item_slot":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketHeldItemSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "keep_alive":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketKeepAlive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "look":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "position":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "position_look":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPositionLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "resource_pack_receive":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketResourcePackReceive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_creative_slot":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetCreativeSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "settings":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSettings)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spectate":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSpectate)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "steer_vehicle":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerVehicle)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "tab_complete":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTabComplete)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "transaction":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTransaction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_sign":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateSign)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "use_entity":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "window_click":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketWindowClick)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketAbilities struct {
	Flags        int8
	FlyingSpeed  float32
	WalkingSpeed float32
}

func (ret *PlayToServerPacketAbilities) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketAbilities) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketArmAnimation struct {
}

func (ret *PlayToServerPacketArmAnimation) Decode(r io.ReadSeeker) (err error) {
	return
}
func (ret *PlayToServerPacketArmAnimation) Encode(w io.Writer) (err error) {
	return
}

type PlayToServerPacketBlockDig struct {
	Status   int32
	Location Position
	Face     int8
}

func (ret *PlayToServerPacketBlockDig) Decode(r io.ReadSeeker) (err error) {
	ret.Status, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Face)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketBlockDig) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Status)
	if err != nil {
		return
	}
	PlayToServerPacketBlockDigLocationEncTmp := ret.Location
	err = PlayToServerPacketBlockDigLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Face)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketBlockPlace struct {
	Location  Position
	Direction int8
	HeldItem  Slot
	CursorX   int8
	CursorY   int8
	CursorZ   int8
}

func (ret *PlayToServerPacketBlockPlace) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Direction)
	if err != nil {
		return
	}
	err = ret.HeldItem.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CursorX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CursorY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CursorZ)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketBlockPlace) Encode(w io.Writer) (err error) {
	PlayToServerPacketBlockPlaceLocationEncTmp := ret.Location
	err = PlayToServerPacketBlockPlaceLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Direction)
	if err != nil {
		return
	}
	PlayToServerPacketBlockPlaceHeldItemEncTmp := ret.HeldItem
	err = PlayToServerPacketBlockPlaceHeldItemEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CursorX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CursorY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CursorZ)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketChat struct {
	Message string
}

func (ret *PlayToServerPacketChat) Decode(r io.ReadSeeker) (err error) {
	ret.Message, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketChat) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Message)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketClientCommand struct {
	Payload int32
}

func (ret *PlayToServerPacketClientCommand) Decode(r io.ReadSeeker) (err error) {
	ret.Payload, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketClientCommand) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Payload)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketCloseWindow struct {
	WindowId uint8
}

func (ret *PlayToServerPacketCloseWindow) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketCloseWindow) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketCustomPayload struct {
	Channel string
	Data    proto_base.RestBuffer
}

func (ret *PlayToServerPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
	ret.Channel, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketCustomPayload) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Channel)
	if err != nil {
		return
	}
	PlayToServerPacketCustomPayloadDataEncTmp := ret.Data
	err = PlayToServerPacketCustomPayloadDataEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketEnchantItem struct {
	WindowId    int8
	Enchantment int8
}

func (ret *PlayToServerPacketEnchantItem) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Enchantment)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketEnchantItem) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Enchantment)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketEntityAction struct {
	EntityId  int32
	ActionId  int32
	JumpBoost int32
}

func (ret *PlayToServerPacketEntityAction) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ActionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.JumpBoost, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketEntityAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ActionId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.JumpBoost)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketFlying struct {
	OnGround bool
}

func (ret *PlayToServerPacketFlying) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketFlying) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketHeldItemSlot struct {
	SlotId int16
}

func (ret *PlayToServerPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.SlotId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketHeldItemSlot) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.SlotId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketKeepAlive struct {
	KeepAliveId int32
}

func (ret *PlayToServerPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
	ret.KeepAliveId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketKeepAlive) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketLook struct {
	Yaw      float32
	Pitch    float32
	OnGround bool
}

func (ret *PlayToServerPacketLook) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketLook) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPosition struct {
	X        float64
	Y        float64
	Z        float64
	OnGround bool
}

func (ret *PlayToServerPacketPosition) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPosition) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPositionLook struct {
	X        float64
	Y        float64
	Z        float64
	Yaw      float32
	Pitch    float32
	OnGround bool
}

func (ret *PlayToServerPacketPositionLook) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPositionLook) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketResourcePackReceive struct {
	Hash   string
	Result int32
}

func (ret *PlayToServerPacketResourcePackReceive) Decode(r io.ReadSeeker) (err error) {
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Result, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Result)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSetCreativeSlot struct {
	Slot int16
	Item Slot
}

func (ret *PlayToServerPacketSetCreativeSlot) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Slot)
	if err != nil {
		return
	}
	err = ret.Item.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSetCreativeSlot) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Slot)
	if err != nil {
		return
	}
	PlayToServerPacketSetCreativeSlotItemEncTmp := ret.Item
	err = PlayToServerPacketSetCreativeSlotItemEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSettings struct {
	Locale       string
	ViewDistance int8
	ChatFlags    int8
	ChatColors   bool
	SkinParts    uint8
}

func (ret *PlayToServerPacketSettings) Decode(r io.ReadSeeker) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSpectate struct {
	Target uuid.UUID
}

func (ret *PlayToServerPacketSpectate) Decode(r io.ReadSeeker) (err error) {
	_, err = io.ReadFull(r, ret.Target[:])
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSpectate) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Target[:])
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSteerVehicle struct {
	Sideways float32
	Forward  float32
	Jump     uint8
}

func (ret *PlayToServerPacketSteerVehicle) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Sideways)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forward)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Jump)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSteerVehicle) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Sideways)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forward)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Jump)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketTabComplete struct {
	Text  string
	Block *Position
}

func (ret *PlayToServerPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
	ret.Text, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var PlayToServerPacketTabCompleteBlockPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTabCompleteBlockPresent)
	if err != nil {
		return
	}
	if PlayToServerPacketTabCompleteBlockPresent {
		var PlayToServerPacketTabCompleteBlockPresentValue Position
		err = PlayToServerPacketTabCompleteBlockPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Block = &PlayToServerPacketTabCompleteBlockPresentValue
	}
	return
}
func (ret *PlayToServerPacketTabComplete) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Text)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Block != nil)
	if err != nil {
		return
	}
	if ret.Block != nil {
		PlayToServerPacketTabCompleteBlockEncTmp := *ret.Block
		err = PlayToServerPacketTabCompleteBlockEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketTransaction struct {
	WindowId int8
	Action   int16
	Accepted bool
}

func (ret *PlayToServerPacketTransaction) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Action)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Accepted)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketTransaction) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Action)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Accepted)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUpdateSign struct {
	Location Position
	Text1    string
	Text2    string
	Text3    string
	Text4    string
}

func (ret *PlayToServerPacketUpdateSign) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Text1, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text2, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text3, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text4, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUpdateSign) Encode(w io.Writer) (err error) {
	PlayToServerPacketUpdateSignLocationEncTmp := ret.Location
	err = PlayToServerPacketUpdateSignLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text1)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text2)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text3)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text4)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUseEntity struct {
	Target int32
	Mouse  int32
	X      any
	Y      any
	Z      any
}

func (ret *PlayToServerPacketUseEntity) Decode(r io.ReadSeeker) (err error) {
	ret.Target, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Mouse, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Mouse {
	case 2:
		var PlayToServerPacketUseEntityX2Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityX2Tmp)
		if err != nil {
			return
		}
		ret.X = PlayToServerPacketUseEntityX2Tmp
	default:
		var PlayToServerPacketUseEntityXTmp struct {
		}
		ret.X = PlayToServerPacketUseEntityXTmp
	}
	switch ret.Mouse {
	case 2:
		var PlayToServerPacketUseEntityY2Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityY2Tmp)
		if err != nil {
			return
		}
		ret.Y = PlayToServerPacketUseEntityY2Tmp
	default:
		var PlayToServerPacketUseEntityYTmp struct {
		}
		ret.Y = PlayToServerPacketUseEntityYTmp
	}
	switch ret.Mouse {
	case 2:
		var PlayToServerPacketUseEntityZ2Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityZ2Tmp)
		if err != nil {
			return
		}
		ret.Z = PlayToServerPacketUseEntityZ2Tmp
	default:
		var PlayToServerPacketUseEntityZTmp struct {
		}
		ret.Z = PlayToServerPacketUseEntityZTmp
	}
	return
}
func (ret *PlayToServerPacketUseEntity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Target)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mouse)
	if err != nil {
		return
	}
	switch ret.Mouse {
	case 2:
		PlayToServerPacketUseEntityX, ok := ret.X.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityX)
		if err != nil {
			return
		}
	default:
		_, ok := ret.X.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mouse {
	case 2:
		PlayToServerPacketUseEntityY, ok := ret.Y.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityY)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Y.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mouse {
	case 2:
		PlayToServerPacketUseEntityZ, ok := ret.Z.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityZ)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Z.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToServerPacketWindowClick struct {
	WindowId    uint8
	Slot        int16
	MouseButton int8
	Action      int16
	Mode        int8
	Item        Slot
}

func (ret *PlayToServerPacketWindowClick) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Slot)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.MouseButton)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Action)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Mode)
	if err != nil {
		return
	}
	err = ret.Item.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketWindowClick) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Slot)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.MouseButton)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Action)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Mode)
	if err != nil {
		return
	}
	PlayToServerPacketWindowClickItemEncTmp := ret.Item
	err = PlayToServerPacketWindowClickItemEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type StatusToClientPacket struct {
	Name   string
	Params any
}

var StatusToClientPacketNameMap = map[int32]string{0x00: "server_info", 0x01: "ping"}

func (ret *StatusToClientPacket) Decode(r io.ReadSeeker) (err error) {
	var StatusToClientPacketNameKey int32
	StatusToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(StatusToClientPacketNameMap, StatusToClientPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "ping":
		var StatusToClientPacketParamsPingTmp StatusToClientPacketPing
		err = StatusToClientPacketParamsPingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = StatusToClientPacketParamsPingTmp
	case "server_info":
		var StatusToClientPacketParamsServerInfoTmp StatusToClientPacketServerInfo
		err = StatusToClientPacketParamsServerInfoTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = StatusToClientPacketParamsServerInfoTmp
	}
	return
}

var StatusToClientPacketNameReverseMap = map[string]int32{"server_info": 0x00, "ping": 0x01}

func (ret *StatusToClientPacket) Encode(w io.Writer) (err error) {
	var vStatusToClientPacketName int32
	vStatusToClientPacketName, err = proto_base.ErroringIndex(StatusToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vStatusToClientPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "ping":
		StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketPing)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		StatusToClientPacketParamsEncTmp := StatusToClientPacketParams
		err = StatusToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "server_info":
		StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketServerInfo)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		StatusToClientPacketParamsEncTmp := StatusToClientPacketParams
		err = StatusToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketPing struct {
	Time int64
}

func (ret *StatusToClientPacketPing) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Time)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToClientPacketPing) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Time)
	if err != nil {
		return
	}
	return
}

type StatusToClientPacketServerInfo struct {
	Response string
}

func (ret *StatusToClientPacketServerInfo) Decode(r io.ReadSeeker) (err error) {
	ret.Response, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToClientPacketServerInfo) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Response)
	if err != nil {
		return
	}
	return
}

type StatusToServerPacket struct {
	Name   string
	Params any
}

var StatusToServerPacketNameMap = map[int32]string{0x00: "ping_start", 0x01: "ping"}

func (ret *StatusToServerPacket) Decode(r io.ReadSeeker) (err error) {
	var StatusToServerPacketNameKey int32
	StatusToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(StatusToServerPacketNameMap, StatusToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "ping":
		var StatusToServerPacketParamsPingTmp StatusToServerPacketPing
		err = StatusToServerPacketParamsPingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = StatusToServerPacketParamsPingTmp
	case "ping_start":
		var StatusToServerPacketParamsPingStartTmp StatusToServerPacketPingStart
		err = StatusToServerPacketParamsPingStartTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = StatusToServerPacketParamsPingStartTmp
	}
	return
}

var StatusToServerPacketNameReverseMap = map[string]int32{"ping_start": 0x00, "ping": 0x01}

func (ret *StatusToServerPacket) Encode(w io.Writer) (err error) {
	var vStatusToServerPacketName int32
	vStatusToServerPacketName, err = proto_base.ErroringIndex(StatusToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vStatusToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "ping":
		StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPing)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		StatusToServerPacketParamsEncTmp := StatusToServerPacketParams
		err = StatusToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "ping_start":
		StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPingStart)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		StatusToServerPacketParamsEncTmp := StatusToServerPacketParams
		err = StatusToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketPing struct {
	Time int64
}

func (ret *StatusToServerPacketPing) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Time)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToServerPacketPing) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Time)
	if err != nil {
		return
	}
	return
}

type StatusToServerPacketPingStart struct {
}

func (ret *StatusToServerPacketPingStart) Decode(r io.ReadSeeker) (err error) {
	return
}
func (ret *StatusToServerPacketPingStart) Encode(w io.Writer) (err error) {
	return
}