// Code generated by strom. DO NOT EDIT.
// source: minecraft-data/pc/1.16.2/protocol.json (sha256:d96a3c5a7a7ddf2105e23990c2471b3aeafe4a6975e0c9d7d7943b599af9dfb3)
// version: v0.6.6-0.20260805191907-f4c27628815b+dirty (go1.26.2)
package v1_16_5

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

type ByteArray struct {
	Val []byte
}

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

type CommandNode struct {
	Flags struct {
		Unused               uint8
		HasCustomSuggestions bool
		HasRedirectNode      bool
		HasCommand           bool
		CommandNodeType      uint8
	}
	Children      []int32
	RedirectNode  any
	ExtraNodeData any
}

var CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpMap = map[int32]string{0: "SINGLE_WORD", 1: "QUOTABLE_PHRASE", 2: "GREEDY_PHRASE"}

func (ret *CommandNode) Decode(r io.ReadSeeker) (err error) {
	var CommandNodeFlagsPacked uint8
	err = binary.Read(r, binary.BigEndian, &CommandNodeFlagsPacked)
	if err != nil {
		return
	}
	ret.Flags.CommandNodeType = CommandNodeFlagsPacked >> 0 & 3
	ret.Flags.HasCommand = CommandNodeFlagsPacked>>2&1 == 1
	ret.Flags.HasRedirectNode = CommandNodeFlagsPacked>>3&1 == 1
	ret.Flags.HasCustomSuggestions = CommandNodeFlagsPacked>>4&1 == 1
	ret.Flags.Unused = CommandNodeFlagsPacked >> 5 & 7
	var lCommandNodeChildren int32
	lCommandNodeChildren, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Children = []int32{}
	for range lCommandNodeChildren {
		var CommandNodeChildrenElement int32
		CommandNodeChildrenElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Children = append(ret.Children, CommandNodeChildrenElement)
	}
	switch ret.Flags.HasRedirectNode {
	case true:
		var CommandNodeRedirectNode1Tmp int32
		CommandNodeRedirectNode1Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.RedirectNode = CommandNodeRedirectNode1Tmp
	default:
		var CommandNodeRedirectNodeTmp struct {
		}
		ret.RedirectNode = CommandNodeRedirectNodeTmp
	}
	switch ret.Flags.CommandNodeType {
	case 0:
		var CommandNodeExtraNodeData0Tmp struct {
		}
		ret.ExtraNodeData = CommandNodeExtraNodeData0Tmp
	case 1:
		var CommandNodeExtraNodeData1Tmp struct {
			Name string
		}
		CommandNodeExtraNodeData1Tmp.Name, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.ExtraNodeData = CommandNodeExtraNodeData1Tmp
	case 2:
		var CommandNodeExtraNodeData2Tmp struct {
			Name           string
			Parser         string
			Properties     any
			SuggestionType any
		}
		CommandNodeExtraNodeData2Tmp.Name, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		CommandNodeExtraNodeData2Tmp.Parser, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		switch CommandNodeExtraNodeData2Tmp.Parser {
		case "brigadier:bool":
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierBoolTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierBoolTmp
		case "brigadier:double":
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp struct {
				Flags struct {
					Unused     uint8
					MaxPresent bool
					MinPresent bool
				}
				Min any
				Max any
			}
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked uint8
			err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.MinPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked>>0&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.MaxPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked>>1&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.Unused = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked >> 2 & 63
			switch CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.MinPresent {
			case true:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMin1Tmp float64
				err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMin1Tmp)
				if err != nil {
					return
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMin1Tmp
			default:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMinTmp struct {
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMinTmp
			}
			switch CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.MaxPresent {
			case true:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMax1Tmp float64
				err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMax1Tmp)
				if err != nil {
					return
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMax1Tmp
			default:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMaxTmp struct {
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMaxTmp
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp
		case "brigadier:float":
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp struct {
				Flags struct {
					Unused     uint8
					MaxPresent bool
					MinPresent bool
				}
				Min any
				Max any
			}
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked uint8
			err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.MinPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked>>0&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.MaxPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked>>1&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.Unused = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked >> 2 & 63
			switch CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.MinPresent {
			case true:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMin1Tmp float32
				err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMin1Tmp)
				if err != nil {
					return
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMin1Tmp
			default:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMinTmp struct {
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMinTmp
			}
			switch CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.MaxPresent {
			case true:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMax1Tmp float32
				err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMax1Tmp)
				if err != nil {
					return
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMax1Tmp
			default:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMaxTmp struct {
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMaxTmp
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp
		case "brigadier:integer":
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp struct {
				Flags struct {
					Unused     uint8
					MaxPresent bool
					MinPresent bool
				}
				Min any
				Max any
			}
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked uint8
			err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.MinPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked>>0&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.MaxPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked>>1&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.Unused = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked >> 2 & 63
			switch CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.MinPresent {
			case true:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMin1Tmp int32
				err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMin1Tmp)
				if err != nil {
					return
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMin1Tmp
			default:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMinTmp struct {
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMinTmp
			}
			switch CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.MaxPresent {
			case true:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMax1Tmp int32
				err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMax1Tmp)
				if err != nil {
					return
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMax1Tmp
			default:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMaxTmp struct {
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMaxTmp
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp
		case "brigadier:long":
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp struct {
				Flags struct {
					Unused     uint8
					MaxPresent bool
					MinPresent bool
				}
				Min any
				Max any
			}
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked uint8
			err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.MinPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked>>0&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.MaxPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked>>1&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.Unused = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked >> 2 & 63
			switch CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.MinPresent {
			case true:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMin1Tmp int64
				err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMin1Tmp)
				if err != nil {
					return
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMin1Tmp
			default:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMinTmp struct {
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMinTmp
			}
			switch CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.MaxPresent {
			case true:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMax1Tmp int64
				err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMax1Tmp)
				if err != nil {
					return
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMax1Tmp
			default:
				var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMaxTmp struct {
				}
				CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMaxTmp
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp
		case "brigadier:string":
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmp string
			var CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpKey int32
			CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpKey, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmp, err = proto_base.ErroringIndex(CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpMap, CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpKey)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmp
		case "minecraft:angle":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftAngleTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftAngleTmp
		case "minecraft:block_pos":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockPosTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockPosTmp
		case "minecraft:block_predicate":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockPredicateTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockPredicateTmp
		case "minecraft:block_state":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockStateTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockStateTmp
		case "minecraft:color":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftColorTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftColorTmp
		case "minecraft:column_pos":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftColumnPosTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftColumnPosTmp
		case "minecraft:component":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftComponentTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftComponentTmp
		case "minecraft:dimension":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftDimensionTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftDimensionTmp
		case "minecraft:entity":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp struct {
				Unused            uint8
				OnlyAllowPlayers  bool
				OnlyAllowEntities bool
			}
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked uint8
			err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp.OnlyAllowEntities = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked>>0&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp.OnlyAllowPlayers = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked>>1&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp.Unused = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked >> 2 & 63
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp
		case "minecraft:entity_anchor":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityAnchorTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityAnchorTmp
		case "minecraft:entity_summon":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftEntitySummonTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntitySummonTmp
		case "minecraft:float_range":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftFloatRangeTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftFloatRangeTmp
		case "minecraft:function":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftFunctionTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftFunctionTmp
		case "minecraft:game_profile":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftGameProfileTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftGameProfileTmp
		case "minecraft:int_range":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftIntRangeTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftIntRangeTmp
		case "minecraft:item_enchantment":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftItemEnchantmentTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftItemEnchantmentTmp
		case "minecraft:item_predicate":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftItemPredicateTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftItemPredicateTmp
		case "minecraft:item_slot":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftItemSlotTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftItemSlotTmp
		case "minecraft:item_stack":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftItemStackTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftItemStackTmp
		case "minecraft:message":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftMessageTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftMessageTmp
		case "minecraft:mob_effect":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftMobEffectTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftMobEffectTmp
		case "minecraft:nbt":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtTmp
		case "minecraft:nbt_compound_tag":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtCompoundTagTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtCompoundTagTmp
		case "minecraft:nbt_path":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtPathTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtPathTmp
		case "minecraft:objective":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftObjectiveTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftObjectiveTmp
		case "minecraft:objective_criteria":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftObjectiveCriteriaTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftObjectiveCriteriaTmp
		case "minecraft:operation":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftOperationTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftOperationTmp
		case "minecraft:particle":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftParticleTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftParticleTmp
		case "minecraft:range":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftRangeTmp struct {
				AllowDecimals bool
			}
			err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesMinecraftRangeTmp.AllowDecimals)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftRangeTmp
		case "minecraft:resource":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp struct {
				Registry string
			}
			CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp.Registry, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp
		case "minecraft:resource_location":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceLocationTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceLocationTmp
		case "minecraft:resource_or_tag":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagTmp struct {
				Registry string
			}
			CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagTmp.Registry, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagTmp
		case "minecraft:rotation":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftRotationTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftRotationTmp
		case "minecraft:score_holder":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmp struct {
				Unused        uint8
				AllowMultiple bool
			}
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmpPacked uint8
			err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmpPacked)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmp.AllowMultiple = CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmpPacked>>0&1 == 1
			CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmp.Unused = CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmpPacked >> 1 & 127
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmp
		case "minecraft:scoreboard_slot":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreboardSlotTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreboardSlotTmp
		case "minecraft:swizzle":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftSwizzleTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftSwizzleTmp
		case "minecraft:team":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftTeamTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftTeamTmp
		case "minecraft:time":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftTimeTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftTimeTmp
		case "minecraft:uuid":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftUuidTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftUuidTmp
		case "minecraft:vec2":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftVec2Tmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftVec2Tmp
		case "minecraft:vec3":
			var CommandNodeExtraNodeData2TmpPropertiesMinecraftVec3Tmp struct {
			}
			CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftVec3Tmp
		}
		switch ret.Flags.HasCustomSuggestions {
		case true:
			var CommandNodeExtraNodeData2TmpSuggestionType1Tmp string
			CommandNodeExtraNodeData2TmpSuggestionType1Tmp, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			CommandNodeExtraNodeData2Tmp.SuggestionType = CommandNodeExtraNodeData2TmpSuggestionType1Tmp
		default:
			var CommandNodeExtraNodeData2TmpSuggestionTypeTmp struct {
			}
			CommandNodeExtraNodeData2Tmp.SuggestionType = CommandNodeExtraNodeData2TmpSuggestionTypeTmp
		}
		ret.ExtraNodeData = CommandNodeExtraNodeData2Tmp
	}
	return
}

var CommandNodeExtraNodeDataPropertiesReverseMap = map[string]int32{"SINGLE_WORD": 0, "QUOTABLE_PHRASE": 1, "GREEDY_PHRASE": 2}

func (ret *CommandNode) Encode(w io.Writer) (err error) {
	var CommandNodeFlagsPacked uint8
	CommandNodeFlagsPacked |= (uint8(ret.Flags.CommandNodeType) & 0x3) << 0x0
	CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasCommand) & 0x1) << 0x2
	CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasRedirectNode) & 0x1) << 0x3
	CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasCustomSuggestions) & 0x1) << 0x4
	CommandNodeFlagsPacked |= (uint8(ret.Flags.Unused) & 0x7) << 0x5
	err = binary.Write(w, binary.BigEndian, CommandNodeFlagsPacked)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Children)))
	if err != nil {
		return
	}
	for iCommandNodeChildren := range len(ret.Children) {
		err = proto_base.EncodeVarInt(w, ret.Children[iCommandNodeChildren])
		if err != nil {
			return
		}
	}
	switch ret.Flags.HasRedirectNode {
	case true:
		CommandNodeRedirectNode, ok := ret.RedirectNode.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, CommandNodeRedirectNode)
		if err != nil {
			return
		}
	default:
		_, ok := ret.RedirectNode.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Flags.CommandNodeType {
	case 0:
		_, ok := ret.ExtraNodeData.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	case 1:
		CommandNodeExtraNodeData, ok := ret.ExtraNodeData.(struct {
			Name string
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, CommandNodeExtraNodeData.Name)
		if err != nil {
			return
		}
	case 2:
		CommandNodeExtraNodeData, ok := ret.ExtraNodeData.(struct {
			Name           string
			Parser         string
			Properties     any
			SuggestionType any
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, CommandNodeExtraNodeData.Name)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, CommandNodeExtraNodeData.Parser)
		if err != nil {
			return
		}
		switch CommandNodeExtraNodeData.Parser {
		case "brigadier:bool":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "brigadier:double":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				Flags struct {
					Unused     uint8
					MaxPresent bool
					MinPresent bool
				}
				Min any
				Max any
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			var CommandNodeExtraNodeDataPropertiesFlagsPacked uint8
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MinPresent) & 0x1) << 0x0
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MaxPresent) & 0x1) << 0x1
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (uint8(CommandNodeExtraNodeDataProperties.Flags.Unused) & 0x3F) << 0x2
			err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesFlagsPacked)
			if err != nil {
				return
			}
			switch CommandNodeExtraNodeDataProperties.Flags.MinPresent {
			case true:
				CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(float64)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin)
				if err != nil {
					return
				}
			default:
				_, ok := CommandNodeExtraNodeDataProperties.Min.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
			switch CommandNodeExtraNodeDataProperties.Flags.MaxPresent {
			case true:
				CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(float64)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax)
				if err != nil {
					return
				}
			default:
				_, ok := CommandNodeExtraNodeDataProperties.Max.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
		case "brigadier:float":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				Flags struct {
					Unused     uint8
					MaxPresent bool
					MinPresent bool
				}
				Min any
				Max any
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			var CommandNodeExtraNodeDataPropertiesFlagsPacked uint8
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MinPresent) & 0x1) << 0x0
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MaxPresent) & 0x1) << 0x1
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (uint8(CommandNodeExtraNodeDataProperties.Flags.Unused) & 0x3F) << 0x2
			err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesFlagsPacked)
			if err != nil {
				return
			}
			switch CommandNodeExtraNodeDataProperties.Flags.MinPresent {
			case true:
				CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(float32)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin)
				if err != nil {
					return
				}
			default:
				_, ok := CommandNodeExtraNodeDataProperties.Min.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
			switch CommandNodeExtraNodeDataProperties.Flags.MaxPresent {
			case true:
				CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(float32)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax)
				if err != nil {
					return
				}
			default:
				_, ok := CommandNodeExtraNodeDataProperties.Max.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
		case "brigadier:integer":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				Flags struct {
					Unused     uint8
					MaxPresent bool
					MinPresent bool
				}
				Min any
				Max any
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			var CommandNodeExtraNodeDataPropertiesFlagsPacked uint8
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MinPresent) & 0x1) << 0x0
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MaxPresent) & 0x1) << 0x1
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (uint8(CommandNodeExtraNodeDataProperties.Flags.Unused) & 0x3F) << 0x2
			err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesFlagsPacked)
			if err != nil {
				return
			}
			switch CommandNodeExtraNodeDataProperties.Flags.MinPresent {
			case true:
				CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(int32)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin)
				if err != nil {
					return
				}
			default:
				_, ok := CommandNodeExtraNodeDataProperties.Min.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
			switch CommandNodeExtraNodeDataProperties.Flags.MaxPresent {
			case true:
				CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(int32)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax)
				if err != nil {
					return
				}
			default:
				_, ok := CommandNodeExtraNodeDataProperties.Max.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
		case "brigadier:long":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				Flags struct {
					Unused     uint8
					MaxPresent bool
					MinPresent bool
				}
				Min any
				Max any
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			var CommandNodeExtraNodeDataPropertiesFlagsPacked uint8
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MinPresent) & 0x1) << 0x0
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MaxPresent) & 0x1) << 0x1
			CommandNodeExtraNodeDataPropertiesFlagsPacked |= (uint8(CommandNodeExtraNodeDataProperties.Flags.Unused) & 0x3F) << 0x2
			err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesFlagsPacked)
			if err != nil {
				return
			}
			switch CommandNodeExtraNodeDataProperties.Flags.MinPresent {
			case true:
				CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(int64)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin)
				if err != nil {
					return
				}
			default:
				_, ok := CommandNodeExtraNodeDataProperties.Min.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
			switch CommandNodeExtraNodeDataProperties.Flags.MaxPresent {
			case true:
				CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(int64)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax)
				if err != nil {
					return
				}
			default:
				_, ok := CommandNodeExtraNodeDataProperties.Max.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
		case "brigadier:string":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(string)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			var vCommandNodeExtraNodeDataProperties int32
			vCommandNodeExtraNodeDataProperties, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataPropertiesReverseMap, CommandNodeExtraNodeDataProperties)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, vCommandNodeExtraNodeDataProperties)
			if err != nil {
				return
			}
		case "minecraft:angle":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:block_pos":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:block_predicate":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:block_state":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:color":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:column_pos":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:component":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:dimension":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:entity":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				Unused            uint8
				OnlyAllowPlayers  bool
				OnlyAllowEntities bool
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			var CommandNodeExtraNodeDataPropertiesPacked uint8
			CommandNodeExtraNodeDataPropertiesPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.OnlyAllowEntities) & 0x1) << 0x0
			CommandNodeExtraNodeDataPropertiesPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.OnlyAllowPlayers) & 0x1) << 0x1
			CommandNodeExtraNodeDataPropertiesPacked |= (uint8(CommandNodeExtraNodeDataProperties.Unused) & 0x3F) << 0x2
			err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesPacked)
			if err != nil {
				return
			}
		case "minecraft:entity_anchor":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:entity_summon":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:float_range":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:function":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:game_profile":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:int_range":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:item_enchantment":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:item_predicate":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:item_slot":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:item_stack":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:message":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:mob_effect":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:nbt":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:nbt_compound_tag":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:nbt_path":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:objective":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:objective_criteria":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:operation":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:particle":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:range":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				AllowDecimals bool
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.AllowDecimals)
			if err != nil {
				return
			}
		case "minecraft:resource":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				Registry string
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry)
			if err != nil {
				return
			}
		case "minecraft:resource_location":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:resource_or_tag":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				Registry string
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry)
			if err != nil {
				return
			}
		case "minecraft:rotation":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:score_holder":
			CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
				Unused        uint8
				AllowMultiple bool
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			var CommandNodeExtraNodeDataPropertiesPacked uint8
			CommandNodeExtraNodeDataPropertiesPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.AllowMultiple) & 0x1) << 0x0
			CommandNodeExtraNodeDataPropertiesPacked |= (uint8(CommandNodeExtraNodeDataProperties.Unused) & 0x7F) << 0x1
			err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesPacked)
			if err != nil {
				return
			}
		case "minecraft:scoreboard_slot":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:swizzle":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:team":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:time":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:uuid":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:vec2":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:vec3":
			_, ok := CommandNodeExtraNodeData.Properties.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
		switch ret.Flags.HasCustomSuggestions {
		case true:
			CommandNodeExtraNodeDataSuggestionType, ok := CommandNodeExtraNodeData.SuggestionType.(string)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeString(w, CommandNodeExtraNodeDataSuggestionType)
			if err != nil {
				return
			}
		default:
			_, ok := CommandNodeExtraNodeData.SuggestionType.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
	}
	return
}

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

func (ret *EntityMetadata) Decode(r io.ReadSeeker) (err error) {
	ret.Val = make(map[uint8]struct {
		Anon struct {
			Key  uint8
			Type int32
		}
		Value any
	})
	var id uint8
	for {
		err = binary.Read(r, binary.BigEndian, &id)
		if err != nil {
			return
		}
		if id == 255 {
			break
		}
		_, err = r.Seek(-1, io.SeekCurrent)
		if err != nil {
			return
		}
		var entry struct {
			Anon struct {
				Key  uint8
				Type int32
			}
			Value any
		}
		err = binary.Read(r, binary.BigEndian, &entry.Anon.Key)
		if err != nil {
			return
		}
		entry.Anon.Type, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		switch entry.Anon.Type {
		case 0:
			var EntityMetadataInnerValue0Tmp int8
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue0Tmp)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue0Tmp
		case 1:
			var EntityMetadataInnerValue1Tmp int32
			EntityMetadataInnerValue1Tmp, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue1Tmp
		case 10:
			var EntityMetadataInnerValue10Tmp *Position
			var EntityMetadataInnerValue10TmpPresent bool
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue10TmpPresent)
			if err != nil {
				return
			}
			if EntityMetadataInnerValue10TmpPresent {
				var EntityMetadataInnerValue10TmpPresentValue Position
				err = EntityMetadataInnerValue10TmpPresentValue.Decode(r)
				if err != nil {
					return
				}
				EntityMetadataInnerValue10Tmp = &EntityMetadataInnerValue10TmpPresentValue
			}
			entry.Value = EntityMetadataInnerValue10Tmp
		case 11:
			var EntityMetadataInnerValue11Tmp int32
			EntityMetadataInnerValue11Tmp, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue11Tmp
		case 12:
			var EntityMetadataInnerValue12Tmp *uuid.UUID
			var EntityMetadataInnerValue12TmpPresent bool
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue12TmpPresent)
			if err != nil {
				return
			}
			if EntityMetadataInnerValue12TmpPresent {
				var EntityMetadataInnerValue12TmpPresentValue uuid.UUID
				_, err = io.ReadFull(r, EntityMetadataInnerValue12TmpPresentValue[:])
				if err != nil {
					return
				}
				EntityMetadataInnerValue12Tmp = &EntityMetadataInnerValue12TmpPresentValue
			}
			entry.Value = EntityMetadataInnerValue12Tmp
		case 13:
			var EntityMetadataInnerValue13Tmp int32
			EntityMetadataInnerValue13Tmp, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue13Tmp
		case 14:
			var EntityMetadataInnerValue14Tmp nbt.Tag
			err = EntityMetadataInnerValue14Tmp.Decode(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue14Tmp
		case 15:
			var EntityMetadataInnerValue15Tmp Particle
			err = EntityMetadataInnerValue15Tmp.Decode(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue15Tmp
		case 16:
			var EntityMetadataInnerValue16Tmp struct {
				VillagerType       int32
				VillagerProfession int32
				Level              int32
			}
			EntityMetadataInnerValue16Tmp.VillagerType, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			EntityMetadataInnerValue16Tmp.VillagerProfession, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			EntityMetadataInnerValue16Tmp.Level, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue16Tmp
		case 17:
			var EntityMetadataInnerValue17Tmp Optvarint
			err = EntityMetadataInnerValue17Tmp.Decode(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue17Tmp
		case 18:
			var EntityMetadataInnerValue18Tmp int32
			EntityMetadataInnerValue18Tmp, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue18Tmp
		case 2:
			var EntityMetadataInnerValue2Tmp float32
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue2Tmp)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue2Tmp
		case 3:
			var EntityMetadataInnerValue3Tmp string
			EntityMetadataInnerValue3Tmp, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue3Tmp
		case 4:
			var EntityMetadataInnerValue4Tmp string
			EntityMetadataInnerValue4Tmp, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue4Tmp
		case 5:
			var EntityMetadataInnerValue5Tmp *string
			var EntityMetadataInnerValue5TmpPresent bool
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue5TmpPresent)
			if err != nil {
				return
			}
			if EntityMetadataInnerValue5TmpPresent {
				var EntityMetadataInnerValue5TmpPresentValue string
				EntityMetadataInnerValue5TmpPresentValue, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				EntityMetadataInnerValue5Tmp = &EntityMetadataInnerValue5TmpPresentValue
			}
			entry.Value = EntityMetadataInnerValue5Tmp
		case 6:
			var EntityMetadataInnerValue6Tmp Slot
			err = EntityMetadataInnerValue6Tmp.Decode(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue6Tmp
		case 7:
			var EntityMetadataInnerValue7Tmp bool
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue7Tmp)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue7Tmp
		case 8:
			var EntityMetadataInnerValue8Tmp struct {
				Pitch float32
				Yaw   float32
				Roll  float32
			}
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue8Tmp.Pitch)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue8Tmp.Yaw)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &EntityMetadataInnerValue8Tmp.Roll)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue8Tmp
		case 9:
			var EntityMetadataInnerValue9Tmp Position
			err = EntityMetadataInnerValue9Tmp.Decode(r)
			if err != nil {
				return
			}
			entry.Value = EntityMetadataInnerValue9Tmp
		}
		ret.Val[id] = entry
	}
	return
}
func (ret *EntityMetadata) Encode(w io.Writer) (err error) {
	for _, v := range ret.Val {
		err = binary.Write(w, binary.BigEndian, v.Anon.Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, v.Anon.Type)
		if err != nil {
			return
		}
		switch v.Anon.Type {
		case 0:
			EntityMetadataValue, ok := v.Value.(int8)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
			if err != nil {
				return
			}
		case 1:
			EntityMetadataValue, ok := v.Value.(int32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, EntityMetadataValue)
			if err != nil {
				return
			}
		case 10:
			EntityMetadataValue, ok := v.Value.(*Position)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue != nil)
			if err != nil {
				return
			}
			if EntityMetadataValue != nil {
				EntityMetadataValueEncTmp := *EntityMetadataValue
				err = EntityMetadataValueEncTmp.Encode(w)
				if err != nil {
					return
				}
			}
		case 11:
			EntityMetadataValue, ok := v.Value.(int32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, EntityMetadataValue)
			if err != nil {
				return
			}
		case 12:
			EntityMetadataValue, ok := v.Value.(*uuid.UUID)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue != nil)
			if err != nil {
				return
			}
			if EntityMetadataValue != nil {
				_, err = w.Write((*EntityMetadataValue)[:])
				if err != nil {
					return
				}
			}
		case 13:
			EntityMetadataValue, ok := v.Value.(int32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, EntityMetadataValue)
			if err != nil {
				return
			}
		case 14:
			EntityMetadataValue, ok := v.Value.(nbt.Tag)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			EntityMetadataValueEncTmp := EntityMetadataValue
			err = EntityMetadataValueEncTmp.Encode(w)
			if err != nil {
				return
			}
		case 15:
			EntityMetadataValue, ok := v.Value.(Particle)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			EntityMetadataValueEncTmp := EntityMetadataValue
			err = EntityMetadataValueEncTmp.Encode(w)
			if err != nil {
				return
			}
		case 16:
			EntityMetadataValue, ok := v.Value.(struct {
				VillagerType       int32
				VillagerProfession int32
				Level              int32
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, EntityMetadataValue.VillagerType)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, EntityMetadataValue.VillagerProfession)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, EntityMetadataValue.Level)
			if err != nil {
				return
			}
		case 17:
			EntityMetadataValue, ok := v.Value.(Optvarint)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			EntityMetadataValueEncTmp := EntityMetadataValue
			err = EntityMetadataValueEncTmp.Encode(w)
			if err != nil {
				return
			}
		case 18:
			EntityMetadataValue, ok := v.Value.(int32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, EntityMetadataValue)
			if err != nil {
				return
			}
		case 2:
			EntityMetadataValue, ok := v.Value.(float32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
			if err != nil {
				return
			}
		case 3:
			EntityMetadataValue, ok := v.Value.(string)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeString(w, EntityMetadataValue)
			if err != nil {
				return
			}
		case 4:
			EntityMetadataValue, ok := v.Value.(string)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeString(w, EntityMetadataValue)
			if err != nil {
				return
			}
		case 5:
			EntityMetadataValue, ok := v.Value.(*string)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue != nil)
			if err != nil {
				return
			}
			if EntityMetadataValue != nil {
				err = proto_base.EncodeString(w, *EntityMetadataValue)
				if err != nil {
					return
				}
			}
		case 6:
			EntityMetadataValue, ok := v.Value.(Slot)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			EntityMetadataValueEncTmp := EntityMetadataValue
			err = EntityMetadataValueEncTmp.Encode(w)
			if err != nil {
				return
			}
		case 7:
			EntityMetadataValue, ok := v.Value.(bool)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue)
			if err != nil {
				return
			}
		case 8:
			EntityMetadataValue, ok := v.Value.(struct {
				Pitch float32
				Yaw   float32
				Roll  float32
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Pitch)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Yaw)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, EntityMetadataValue.Roll)
			if err != nil {
				return
			}
		case 9:
			EntityMetadataValue, ok := v.Value.(Position)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			EntityMetadataValueEncTmp := EntityMetadataValue
			err = EntityMetadataValueEncTmp.Encode(w)
			if err != nil {
				return
			}
		}
	}
	err = binary.Write(w, binary.BigEndian, uint8(255))
	if err != nil {
		return
	}
	return
}

type EntityMetadataItem struct {
	Val any
}

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

type Ingredient struct {
	Val []Slot
}

func (ret *Ingredient) Decode(r io.ReadSeeker) (err error) {
	var lIngredient int32
	lIngredient, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val = []Slot{}
	for range lIngredient {
		var IngredientElement Slot
		err = IngredientElement.Decode(r)
		if err != nil {
			return
		}
		ret.Val = append(ret.Val, IngredientElement)
	}
	return
}
func (ret *Ingredient) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
	if err != nil {
		return
	}
	for iIngredient := range len(ret.Val) {
		IngredientInnerEncTmp := ret.Val[iIngredient]
		err = IngredientInnerEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type MinecraftSmeltingFormat struct {
	Group      string
	Ingredient Ingredient
	Result     Slot
	Experience float32
	CookTime   int32
}

func (ret *MinecraftSmeltingFormat) Decode(r io.ReadSeeker) (err error) {
	ret.Group, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Ingredient.Decode(r)
	if err != nil {
		return
	}
	err = ret.Result.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Experience)
	if err != nil {
		return
	}
	ret.CookTime, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *MinecraftSmeltingFormat) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Group)
	if err != nil {
		return
	}
	MinecraftSmeltingFormatIngredientEncTmp := ret.Ingredient
	err = MinecraftSmeltingFormatIngredientEncTmp.Encode(w)
	if err != nil {
		return
	}
	MinecraftSmeltingFormatResultEncTmp := ret.Result
	err = MinecraftSmeltingFormatResultEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Experience)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.CookTime)
	if err != nil {
		return
	}
	return
}

type Optvarint struct {
	Val int32
}

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

type Particle struct {
	ParticleId int32
	Data       any
}

func (ret *Particle) Decode(r io.ReadSeeker) (err error) {
	ret.ParticleId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.ParticleId {
	case 14:
		var ParticleData14Tmp struct {
			Red   float32
			Green float32
			Blue  float32
			Scale float32
		}
		err = binary.Read(r, binary.BigEndian, &ParticleData14Tmp.Red)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleData14Tmp.Green)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleData14Tmp.Blue)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleData14Tmp.Scale)
		if err != nil {
			return
		}
		ret.Data = ParticleData14Tmp
	case 23:
		var ParticleData23Tmp struct {
			BlockState int32
		}
		ParticleData23Tmp.BlockState, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleData23Tmp
	case 3:
		var ParticleData3Tmp struct {
			BlockState int32
		}
		ParticleData3Tmp.BlockState, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleData3Tmp
	case 34:
		var ParticleData34Tmp struct {
			Item Slot
		}
		err = ParticleData34Tmp.Item.Decode(r)
		if err != nil {
			return
		}
		ret.Data = ParticleData34Tmp
	default:
		var ParticleDataTmp struct {
		}
		ret.Data = ParticleDataTmp
	}
	return
}
func (ret *Particle) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ParticleId)
	if err != nil {
		return
	}
	switch ret.ParticleId {
	case 14:
		ParticleData, ok := ret.Data.(struct {
			Red   float32
			Green float32
			Blue  float32
			Scale float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Red)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Green)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Blue)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Scale)
		if err != nil {
			return
		}
	case 23:
		ParticleData, ok := ret.Data.(struct {
			BlockState int32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ParticleData.BlockState)
		if err != nil {
			return
		}
	case 3:
		ParticleData, ok := ret.Data.(struct {
			BlockState int32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ParticleData.BlockState)
		if err != nil {
			return
		}
	case 34:
		ParticleData, ok := ret.Data.(struct {
			Item Slot
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		ParticleDataItemEncTmp := ParticleData.Item
		err = ParticleDataItemEncTmp.Encode(w)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Data.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type ParticleData struct {
	Val any
}

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

type Position struct {
	X int32
	Z int32
	Y int16
}

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

type Slot struct {
	Present bool
	Anon    any
}

func (ret *Slot) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Present)
	if err != nil {
		return
	}
	switch ret.Present {
	case false:
		var SlotAnonFalseTmp struct {
		}
		ret.Anon = SlotAnonFalseTmp
	case true:
		var SlotAnonTrueTmp struct {
			ItemId    int32
			ItemCount int8
			NbtData   nbt.Tag
		}
		SlotAnonTrueTmp.ItemId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &SlotAnonTrueTmp.ItemCount)
		if err != nil {
			return
		}
		err = SlotAnonTrueTmp.NbtData.Decode(r)
		if err != nil {
			return
		}
		ret.Anon = SlotAnonTrueTmp
	}
	return
}
func (ret *Slot) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Present)
	if err != nil {
		return
	}
	switch ret.Present {
	case false:
		_, ok := ret.Anon.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	case true:
		SlotAnon, ok := ret.Anon.(struct {
			ItemId    int32
			ItemCount int8
			NbtData   nbt.Tag
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, SlotAnon.ItemId)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, SlotAnon.ItemCount)
		if err != nil {
			return
		}
		SlotAnonNbtDataEncTmp := SlotAnon.NbtData
		err = SlotAnonNbtDataEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type Tags struct {
	Val []struct {
		TagName string
		Entries []int32
	}
}

func (ret *Tags) Decode(r io.ReadSeeker) (err error) {
	var lTags int32
	lTags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val = []struct {
		TagName string
		Entries []int32
	}{}
	for range lTags {
		var TagsElement struct {
			TagName string
			Entries []int32
		}
		TagsElement.TagName, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var lTagsElementEntries int32
		lTagsElementEntries, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		TagsElement.Entries = []int32{}
		for range lTagsElementEntries {
			var TagsElementEntriesElement int32
			TagsElementEntriesElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			TagsElement.Entries = append(TagsElement.Entries, TagsElementEntriesElement)
		}
		ret.Val = append(ret.Val, TagsElement)
	}
	return
}
func (ret *Tags) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
	if err != nil {
		return
	}
	for iTags := range len(ret.Val) {
		err = proto_base.EncodeString(w, ret.Val[iTags].TagName)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.Val[iTags].Entries)))
		if err != nil {
			return
		}
		for iTagsInnerEntries := range len(ret.Val[iTags].Entries) {
			err = proto_base.EncodeVarInt(w, ret.Val[iTags].Entries[iTagsInnerEntries])
			if err != nil {
				return
			}
		}
	}
	return
}

type Vec3i16 struct {
	X int16
	Y int16
	Z int16
}

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

type HandshakingToClientPacket struct {
	Name   string
	Params any
}

var HandshakingToClientPacketNameMap = map[int32]string{}

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

var HandshakingToClientPacketNameReverseMap = map[string]int32{}

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

type HandshakingToServerPacket struct {
	Name   string
	Params any
}

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

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

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

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

type HandshakingToServerPacketLegacyServerListPing struct {
	Payload uint8
}

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

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

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

type LoginToClientPacket struct {
	Name   string
	Params any
}

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

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

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

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

type LoginToClientPacketCompress struct {
	Threshold int32
}

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

type LoginToClientPacketDisconnect struct {
	Reason string
}

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

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

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

type LoginToClientPacketLoginPluginRequest struct {
	MessageId int32
	Channel   string
	Data      proto_base.RestBuffer
}

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

type LoginToClientPacketSuccess struct {
	Uuid     uuid.UUID
	Username string
}

func (ret *LoginToClientPacketSuccess) Decode(r io.ReadSeeker) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	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 = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Username)
	if err != nil {
		return
	}
	return
}

type LoginToServerPacket struct {
	Name   string
	Params any
}

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

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

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

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

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

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

type LoginToServerPacketLoginPluginResponse struct {
	MessageId int32
	Data      *proto_base.RestBuffer
}

func (ret *LoginToServerPacketLoginPluginResponse) Decode(r io.ReadSeeker) (err error) {
	ret.MessageId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var LoginToServerPacketLoginPluginResponseDataPresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToServerPacketLoginPluginResponseDataPresent)
	if err != nil {
		return
	}
	if LoginToServerPacketLoginPluginResponseDataPresent {
		var LoginToServerPacketLoginPluginResponseDataPresentValue proto_base.RestBuffer
		err = LoginToServerPacketLoginPluginResponseDataPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Data = &LoginToServerPacketLoginPluginResponseDataPresentValue
	}
	return
}
func (ret *LoginToServerPacketLoginPluginResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.MessageId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Data != nil)
	if err != nil {
		return
	}
	if ret.Data != nil {
		LoginToServerPacketLoginPluginResponseDataEncTmp := *ret.Data
		err = LoginToServerPacketLoginPluginResponseDataEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketLoginStart struct {
	Username string
}

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

type PlayToClientPacket struct {
	Name   string
	Params any
}

var PlayToClientPacketNameMap = map[int32]string{0x00: "spawn_entity", 0x01: "spawn_entity_experience_orb", 0x02: "spawn_entity_living", 0x03: "spawn_entity_painting", 0x04: "named_entity_spawn", 0x05: "animation", 0x06: "statistics", 0x07: "acknowledge_player_digging", 0x08: "block_break_animation", 0x09: "tile_entity_data", 0x0a: "block_action", 0x0b: "block_change", 0x0c: "boss_bar", 0x0d: "difficulty", 0x0e: "chat", 0x0f: "tab_complete", 0x10: "declare_commands", 0x11: "transaction", 0x12: "close_window", 0x13: "window_items", 0x14: "craft_progress_bar", 0x15: "set_slot", 0x16: "set_cooldown", 0x17: "custom_payload", 0x18: "named_sound_effect", 0x19: "kick_disconnect", 0x1a: "entity_status", 0x1b: "explosion", 0x1c: "unload_chunk", 0x1d: "game_state_change", 0x1e: "open_horse_window", 0x1f: "keep_alive", 0x20: "map_chunk", 0x21: "world_event", 0x22: "world_particles", 0x23: "update_light", 0x24: "login", 0x25: "map", 0x26: "trade_list", 0x27: "rel_entity_move", 0x28: "entity_move_look", 0x29: "entity_look", 0x2a: "entity", 0x2b: "vehicle_move", 0x2c: "open_book", 0x2d: "open_window", 0x2e: "open_sign_entity", 0x2f: "craft_recipe_response", 0x30: "abilities", 0x31: "combat_event", 0x32: "player_info", 0x33: "face_player", 0x34: "position", 0x35: "unlock_recipes", 0x36: "entity_destroy", 0x37: "remove_entity_effect", 0x38: "resource_pack_send", 0x39: "respawn", 0x3a: "entity_head_rotation", 0x3b: "multi_block_change", 0x3c: "select_advancement_tab", 0x3d: "world_border", 0x3e: "camera", 0x3f: "held_item_slot", 0x40: "update_view_position", 0x41: "update_view_distance", 0x42: "spawn_position", 0x43: "scoreboard_display_objective", 0x44: "entity_metadata", 0x45: "attach_entity", 0x46: "entity_velocity", 0x47: "entity_equipment", 0x48: "experience", 0x49: "update_health", 0x4a: "scoreboard_objective", 0x4b: "set_passengers", 0x4c: "teams", 0x4d: "scoreboard_score", 0x4e: "update_time", 0x4f: "title", 0x50: "entity_sound_effect", 0x51: "sound_effect", 0x52: "stop_sound", 0x53: "playerlist_header", 0x54: "nbt_query_response", 0x55: "collect", 0x56: "entity_teleport", 0x57: "advancements", 0x58: "entity_update_attributes", 0x59: "entity_effect", 0x5a: "declare_recipes", 0x5b: "tags"}

func (ret *PlayToClientPacket) Decode(r io.ReadSeeker) (err error) {
	var PlayToClientPacketNameKey int32
	PlayToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(PlayToClientPacketNameMap, PlayToClientPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		var PlayToClientPacketParamsAbilitiesTmp PlayToClientPacketAbilities
		err = PlayToClientPacketParamsAbilitiesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAbilitiesTmp
	case "acknowledge_player_digging":
		var PlayToClientPacketParamsAcknowledgePlayerDiggingTmp PlayToClientPacketAcknowledgePlayerDigging
		err = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp
	case "advancements":
		var PlayToClientPacketParamsAdvancementsTmp PlayToClientPacketAdvancements
		err = PlayToClientPacketParamsAdvancementsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAdvancementsTmp
	case "animation":
		var PlayToClientPacketParamsAnimationTmp PlayToClientPacketAnimation
		err = PlayToClientPacketParamsAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAnimationTmp
	case "attach_entity":
		var PlayToClientPacketParamsAttachEntityTmp PlayToClientPacketAttachEntity
		err = PlayToClientPacketParamsAttachEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAttachEntityTmp
	case "block_action":
		var PlayToClientPacketParamsBlockActionTmp PlayToClientPacketBlockAction
		err = PlayToClientPacketParamsBlockActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockActionTmp
	case "block_break_animation":
		var PlayToClientPacketParamsBlockBreakAnimationTmp PlayToClientPacketBlockBreakAnimation
		err = PlayToClientPacketParamsBlockBreakAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockBreakAnimationTmp
	case "block_change":
		var PlayToClientPacketParamsBlockChangeTmp PlayToClientPacketBlockChange
		err = PlayToClientPacketParamsBlockChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockChangeTmp
	case "boss_bar":
		var PlayToClientPacketParamsBossBarTmp PlayToClientPacketBossBar
		err = PlayToClientPacketParamsBossBarTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBossBarTmp
	case "camera":
		var PlayToClientPacketParamsCameraTmp PlayToClientPacketCamera
		err = PlayToClientPacketParamsCameraTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCameraTmp
	case "chat":
		var PlayToClientPacketParamsChatTmp PlayToClientPacketChat
		err = PlayToClientPacketParamsChatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsChatTmp
	case "close_window":
		var PlayToClientPacketParamsCloseWindowTmp PlayToClientPacketCloseWindow
		err = PlayToClientPacketParamsCloseWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCloseWindowTmp
	case "collect":
		var PlayToClientPacketParamsCollectTmp PlayToClientPacketCollect
		err = PlayToClientPacketParamsCollectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCollectTmp
	case "combat_event":
		var PlayToClientPacketParamsCombatEventTmp PlayToClientPacketCombatEvent
		err = PlayToClientPacketParamsCombatEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCombatEventTmp
	case "craft_progress_bar":
		var PlayToClientPacketParamsCraftProgressBarTmp PlayToClientPacketCraftProgressBar
		err = PlayToClientPacketParamsCraftProgressBarTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCraftProgressBarTmp
	case "craft_recipe_response":
		var PlayToClientPacketParamsCraftRecipeResponseTmp PlayToClientPacketCraftRecipeResponse
		err = PlayToClientPacketParamsCraftRecipeResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCraftRecipeResponseTmp
	case "custom_payload":
		var PlayToClientPacketParamsCustomPayloadTmp PlayToClientPacketCustomPayload
		err = PlayToClientPacketParamsCustomPayloadTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCustomPayloadTmp
	case "declare_commands":
		var PlayToClientPacketParamsDeclareCommandsTmp PlayToClientPacketDeclareCommands
		err = PlayToClientPacketParamsDeclareCommandsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDeclareCommandsTmp
	case "declare_recipes":
		var PlayToClientPacketParamsDeclareRecipesTmp PlayToClientPacketDeclareRecipes
		err = PlayToClientPacketParamsDeclareRecipesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDeclareRecipesTmp
	case "difficulty":
		var PlayToClientPacketParamsDifficultyTmp PlayToClientPacketDifficulty
		err = PlayToClientPacketParamsDifficultyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDifficultyTmp
	case "entity":
		var PlayToClientPacketParamsEntityTmp PlayToClientPacketEntity
		err = PlayToClientPacketParamsEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityTmp
	case "entity_destroy":
		var PlayToClientPacketParamsEntityDestroyTmp PlayToClientPacketEntityDestroy
		err = PlayToClientPacketParamsEntityDestroyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityDestroyTmp
	case "entity_effect":
		var PlayToClientPacketParamsEntityEffectTmp PlayToClientPacketEntityEffect
		err = PlayToClientPacketParamsEntityEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityEffectTmp
	case "entity_equipment":
		var PlayToClientPacketParamsEntityEquipmentTmp PlayToClientPacketEntityEquipment
		err = PlayToClientPacketParamsEntityEquipmentTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityEquipmentTmp
	case "entity_head_rotation":
		var PlayToClientPacketParamsEntityHeadRotationTmp PlayToClientPacketEntityHeadRotation
		err = PlayToClientPacketParamsEntityHeadRotationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityHeadRotationTmp
	case "entity_look":
		var PlayToClientPacketParamsEntityLookTmp PlayToClientPacketEntityLook
		err = PlayToClientPacketParamsEntityLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityLookTmp
	case "entity_metadata":
		var PlayToClientPacketParamsEntityMetadataTmp PlayToClientPacketEntityMetadata
		err = PlayToClientPacketParamsEntityMetadataTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityMetadataTmp
	case "entity_move_look":
		var PlayToClientPacketParamsEntityMoveLookTmp PlayToClientPacketEntityMoveLook
		err = PlayToClientPacketParamsEntityMoveLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityMoveLookTmp
	case "entity_sound_effect":
		var PlayToClientPacketParamsEntitySoundEffectTmp PlayToClientPacketEntitySoundEffect
		err = PlayToClientPacketParamsEntitySoundEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntitySoundEffectTmp
	case "entity_status":
		var PlayToClientPacketParamsEntityStatusTmp PlayToClientPacketEntityStatus
		err = PlayToClientPacketParamsEntityStatusTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityStatusTmp
	case "entity_teleport":
		var PlayToClientPacketParamsEntityTeleportTmp PlayToClientPacketEntityTeleport
		err = PlayToClientPacketParamsEntityTeleportTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityTeleportTmp
	case "entity_update_attributes":
		var PlayToClientPacketParamsEntityUpdateAttributesTmp PlayToClientPacketEntityUpdateAttributes
		err = PlayToClientPacketParamsEntityUpdateAttributesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityUpdateAttributesTmp
	case "entity_velocity":
		var PlayToClientPacketParamsEntityVelocityTmp PlayToClientPacketEntityVelocity
		err = PlayToClientPacketParamsEntityVelocityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityVelocityTmp
	case "experience":
		var PlayToClientPacketParamsExperienceTmp PlayToClientPacketExperience
		err = PlayToClientPacketParamsExperienceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsExperienceTmp
	case "explosion":
		var PlayToClientPacketParamsExplosionTmp PlayToClientPacketExplosion
		err = PlayToClientPacketParamsExplosionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsExplosionTmp
	case "face_player":
		var PlayToClientPacketParamsFacePlayerTmp PlayToClientPacketFacePlayer
		err = PlayToClientPacketParamsFacePlayerTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsFacePlayerTmp
	case "game_state_change":
		var PlayToClientPacketParamsGameStateChangeTmp PlayToClientPacketGameStateChange
		err = PlayToClientPacketParamsGameStateChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsGameStateChangeTmp
	case "held_item_slot":
		var PlayToClientPacketParamsHeldItemSlotTmp PlayToClientPacketHeldItemSlot
		err = PlayToClientPacketParamsHeldItemSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsHeldItemSlotTmp
	case "keep_alive":
		var PlayToClientPacketParamsKeepAliveTmp PlayToClientPacketKeepAlive
		err = PlayToClientPacketParamsKeepAliveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsKeepAliveTmp
	case "kick_disconnect":
		var PlayToClientPacketParamsKickDisconnectTmp PlayToClientPacketKickDisconnect
		err = PlayToClientPacketParamsKickDisconnectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsKickDisconnectTmp
	case "login":
		var PlayToClientPacketParamsLoginTmp PlayToClientPacketLogin
		err = PlayToClientPacketParamsLoginTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsLoginTmp
	case "map":
		var PlayToClientPacketParamsMapTmp PlayToClientPacketMap
		err = PlayToClientPacketParamsMapTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMapTmp
	case "map_chunk":
		var PlayToClientPacketParamsMapChunkTmp PlayToClientPacketMapChunk
		err = PlayToClientPacketParamsMapChunkTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMapChunkTmp
	case "multi_block_change":
		var PlayToClientPacketParamsMultiBlockChangeTmp PlayToClientPacketMultiBlockChange
		err = PlayToClientPacketParamsMultiBlockChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMultiBlockChangeTmp
	case "named_entity_spawn":
		var PlayToClientPacketParamsNamedEntitySpawnTmp PlayToClientPacketNamedEntitySpawn
		err = PlayToClientPacketParamsNamedEntitySpawnTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsNamedEntitySpawnTmp
	case "named_sound_effect":
		var PlayToClientPacketParamsNamedSoundEffectTmp PlayToClientPacketNamedSoundEffect
		err = PlayToClientPacketParamsNamedSoundEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsNamedSoundEffectTmp
	case "nbt_query_response":
		var PlayToClientPacketParamsNbtQueryResponseTmp PlayToClientPacketNbtQueryResponse
		err = PlayToClientPacketParamsNbtQueryResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsNbtQueryResponseTmp
	case "open_book":
		var PlayToClientPacketParamsOpenBookTmp PlayToClientPacketOpenBook
		err = PlayToClientPacketParamsOpenBookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenBookTmp
	case "open_horse_window":
		var PlayToClientPacketParamsOpenHorseWindowTmp PlayToClientPacketOpenHorseWindow
		err = PlayToClientPacketParamsOpenHorseWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenHorseWindowTmp
	case "open_sign_entity":
		var PlayToClientPacketParamsOpenSignEntityTmp PlayToClientPacketOpenSignEntity
		err = PlayToClientPacketParamsOpenSignEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenSignEntityTmp
	case "open_window":
		var PlayToClientPacketParamsOpenWindowTmp PlayToClientPacketOpenWindow
		err = PlayToClientPacketParamsOpenWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenWindowTmp
	case "player_info":
		var PlayToClientPacketParamsPlayerInfoTmp PlayToClientPacketPlayerInfo
		err = PlayToClientPacketParamsPlayerInfoTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerInfoTmp
	case "playerlist_header":
		var PlayToClientPacketParamsPlayerlistHeaderTmp PlayToClientPacketPlayerlistHeader
		err = PlayToClientPacketParamsPlayerlistHeaderTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerlistHeaderTmp
	case "position":
		var PlayToClientPacketParamsPositionTmp PlayToClientPacketPosition
		err = PlayToClientPacketParamsPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPositionTmp
	case "rel_entity_move":
		var PlayToClientPacketParamsRelEntityMoveTmp PlayToClientPacketRelEntityMove
		err = PlayToClientPacketParamsRelEntityMoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRelEntityMoveTmp
	case "remove_entity_effect":
		var PlayToClientPacketParamsRemoveEntityEffectTmp PlayToClientPacketRemoveEntityEffect
		err = PlayToClientPacketParamsRemoveEntityEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRemoveEntityEffectTmp
	case "resource_pack_send":
		var PlayToClientPacketParamsResourcePackSendTmp PlayToClientPacketResourcePackSend
		err = PlayToClientPacketParamsResourcePackSendTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsResourcePackSendTmp
	case "respawn":
		var PlayToClientPacketParamsRespawnTmp PlayToClientPacketRespawn
		err = PlayToClientPacketParamsRespawnTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRespawnTmp
	case "scoreboard_display_objective":
		var PlayToClientPacketParamsScoreboardDisplayObjectiveTmp PlayToClientPacketScoreboardDisplayObjective
		err = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp
	case "scoreboard_objective":
		var PlayToClientPacketParamsScoreboardObjectiveTmp PlayToClientPacketScoreboardObjective
		err = PlayToClientPacketParamsScoreboardObjectiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardObjectiveTmp
	case "scoreboard_score":
		var PlayToClientPacketParamsScoreboardScoreTmp PlayToClientPacketScoreboardScore
		err = PlayToClientPacketParamsScoreboardScoreTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardScoreTmp
	case "select_advancement_tab":
		var PlayToClientPacketParamsSelectAdvancementTabTmp PlayToClientPacketSelectAdvancementTab
		err = PlayToClientPacketParamsSelectAdvancementTabTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSelectAdvancementTabTmp
	case "set_cooldown":
		var PlayToClientPacketParamsSetCooldownTmp PlayToClientPacketSetCooldown
		err = PlayToClientPacketParamsSetCooldownTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetCooldownTmp
	case "set_passengers":
		var PlayToClientPacketParamsSetPassengersTmp PlayToClientPacketSetPassengers
		err = PlayToClientPacketParamsSetPassengersTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetPassengersTmp
	case "set_slot":
		var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot
		err = PlayToClientPacketParamsSetSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetSlotTmp
	case "sound_effect":
		var PlayToClientPacketParamsSoundEffectTmp PlayToClientPacketSoundEffect
		err = PlayToClientPacketParamsSoundEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSoundEffectTmp
	case "spawn_entity":
		var PlayToClientPacketParamsSpawnEntityTmp PlayToClientPacketSpawnEntity
		err = PlayToClientPacketParamsSpawnEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityTmp
	case "spawn_entity_experience_orb":
		var PlayToClientPacketParamsSpawnEntityExperienceOrbTmp PlayToClientPacketSpawnEntityExperienceOrb
		err = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp
	case "spawn_entity_living":
		var PlayToClientPacketParamsSpawnEntityLivingTmp PlayToClientPacketSpawnEntityLiving
		err = PlayToClientPacketParamsSpawnEntityLivingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityLivingTmp
	case "spawn_entity_painting":
		var PlayToClientPacketParamsSpawnEntityPaintingTmp PlayToClientPacketSpawnEntityPainting
		err = PlayToClientPacketParamsSpawnEntityPaintingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityPaintingTmp
	case "spawn_position":
		var PlayToClientPacketParamsSpawnPositionTmp PlayToClientPacketSpawnPosition
		err = PlayToClientPacketParamsSpawnPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnPositionTmp
	case "statistics":
		var PlayToClientPacketParamsStatisticsTmp PlayToClientPacketStatistics
		err = PlayToClientPacketParamsStatisticsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsStatisticsTmp
	case "stop_sound":
		var PlayToClientPacketParamsStopSoundTmp PlayToClientPacketStopSound
		err = PlayToClientPacketParamsStopSoundTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsStopSoundTmp
	case "tab_complete":
		var PlayToClientPacketParamsTabCompleteTmp PlayToClientPacketTabComplete
		err = PlayToClientPacketParamsTabCompleteTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTabCompleteTmp
	case "tags":
		var PlayToClientPacketParamsTagsTmp PlayToClientPacketTags
		err = PlayToClientPacketParamsTagsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTagsTmp
	case "teams":
		var PlayToClientPacketParamsTeamsTmp PlayToClientPacketTeams
		err = PlayToClientPacketParamsTeamsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTeamsTmp
	case "tile_entity_data":
		var PlayToClientPacketParamsTileEntityDataTmp PlayToClientPacketTileEntityData
		err = PlayToClientPacketParamsTileEntityDataTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTileEntityDataTmp
	case "title":
		var PlayToClientPacketParamsTitleTmp PlayToClientPacketTitle
		err = PlayToClientPacketParamsTitleTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTitleTmp
	case "trade_list":
		var PlayToClientPacketParamsTradeListTmp PlayToClientPacketTradeList
		err = PlayToClientPacketParamsTradeListTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTradeListTmp
	case "transaction":
		var PlayToClientPacketParamsTransactionTmp PlayToClientPacketTransaction
		err = PlayToClientPacketParamsTransactionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTransactionTmp
	case "unload_chunk":
		var PlayToClientPacketParamsUnloadChunkTmp PlayToClientPacketUnloadChunk
		err = PlayToClientPacketParamsUnloadChunkTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUnloadChunkTmp
	case "unlock_recipes":
		var PlayToClientPacketParamsUnlockRecipesTmp PlayToClientPacketUnlockRecipes
		err = PlayToClientPacketParamsUnlockRecipesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUnlockRecipesTmp
	case "update_health":
		var PlayToClientPacketParamsUpdateHealthTmp PlayToClientPacketUpdateHealth
		err = PlayToClientPacketParamsUpdateHealthTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateHealthTmp
	case "update_light":
		var PlayToClientPacketParamsUpdateLightTmp PlayToClientPacketUpdateLight
		err = PlayToClientPacketParamsUpdateLightTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateLightTmp
	case "update_time":
		var PlayToClientPacketParamsUpdateTimeTmp PlayToClientPacketUpdateTime
		err = PlayToClientPacketParamsUpdateTimeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateTimeTmp
	case "update_view_distance":
		var PlayToClientPacketParamsUpdateViewDistanceTmp PlayToClientPacketUpdateViewDistance
		err = PlayToClientPacketParamsUpdateViewDistanceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateViewDistanceTmp
	case "update_view_position":
		var PlayToClientPacketParamsUpdateViewPositionTmp PlayToClientPacketUpdateViewPosition
		err = PlayToClientPacketParamsUpdateViewPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateViewPositionTmp
	case "vehicle_move":
		var PlayToClientPacketParamsVehicleMoveTmp PlayToClientPacketVehicleMove
		err = PlayToClientPacketParamsVehicleMoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsVehicleMoveTmp
	case "window_items":
		var PlayToClientPacketParamsWindowItemsTmp PlayToClientPacketWindowItems
		err = PlayToClientPacketParamsWindowItemsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWindowItemsTmp
	case "world_border":
		var PlayToClientPacketParamsWorldBorderTmp PlayToClientPacketWorldBorder
		err = PlayToClientPacketParamsWorldBorderTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldBorderTmp
	case "world_event":
		var PlayToClientPacketParamsWorldEventTmp PlayToClientPacketWorldEvent
		err = PlayToClientPacketParamsWorldEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldEventTmp
	case "world_particles":
		var PlayToClientPacketParamsWorldParticlesTmp PlayToClientPacketWorldParticles
		err = PlayToClientPacketParamsWorldParticlesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldParticlesTmp
	}
	return
}

var PlayToClientPacketNameReverseMap = map[string]int32{"spawn_entity": 0x00, "spawn_entity_experience_orb": 0x01, "spawn_entity_living": 0x02, "spawn_entity_painting": 0x03, "named_entity_spawn": 0x04, "animation": 0x05, "statistics": 0x06, "acknowledge_player_digging": 0x07, "block_break_animation": 0x08, "tile_entity_data": 0x09, "block_action": 0x0a, "block_change": 0x0b, "boss_bar": 0x0c, "difficulty": 0x0d, "chat": 0x0e, "tab_complete": 0x0f, "declare_commands": 0x10, "transaction": 0x11, "close_window": 0x12, "window_items": 0x13, "craft_progress_bar": 0x14, "set_slot": 0x15, "set_cooldown": 0x16, "custom_payload": 0x17, "named_sound_effect": 0x18, "kick_disconnect": 0x19, "entity_status": 0x1a, "explosion": 0x1b, "unload_chunk": 0x1c, "game_state_change": 0x1d, "open_horse_window": 0x1e, "keep_alive": 0x1f, "map_chunk": 0x20, "world_event": 0x21, "world_particles": 0x22, "update_light": 0x23, "login": 0x24, "map": 0x25, "trade_list": 0x26, "rel_entity_move": 0x27, "entity_move_look": 0x28, "entity_look": 0x29, "entity": 0x2a, "vehicle_move": 0x2b, "open_book": 0x2c, "open_window": 0x2d, "open_sign_entity": 0x2e, "craft_recipe_response": 0x2f, "abilities": 0x30, "combat_event": 0x31, "player_info": 0x32, "face_player": 0x33, "position": 0x34, "unlock_recipes": 0x35, "entity_destroy": 0x36, "remove_entity_effect": 0x37, "resource_pack_send": 0x38, "respawn": 0x39, "entity_head_rotation": 0x3a, "multi_block_change": 0x3b, "select_advancement_tab": 0x3c, "world_border": 0x3d, "camera": 0x3e, "held_item_slot": 0x3f, "update_view_position": 0x40, "update_view_distance": 0x41, "spawn_position": 0x42, "scoreboard_display_objective": 0x43, "entity_metadata": 0x44, "attach_entity": 0x45, "entity_velocity": 0x46, "entity_equipment": 0x47, "experience": 0x48, "update_health": 0x49, "scoreboard_objective": 0x4a, "set_passengers": 0x4b, "teams": 0x4c, "scoreboard_score": 0x4d, "update_time": 0x4e, "title": 0x4f, "entity_sound_effect": 0x50, "sound_effect": 0x51, "stop_sound": 0x52, "playerlist_header": 0x53, "nbt_query_response": 0x54, "collect": 0x55, "entity_teleport": 0x56, "advancements": 0x57, "entity_update_attributes": 0x58, "entity_effect": 0x59, "declare_recipes": 0x5a, "tags": 0x5b}

func (ret *PlayToClientPacket) Encode(w io.Writer) (err error) {
	var vPlayToClientPacketName int32
	vPlayToClientPacketName, err = proto_base.ErroringIndex(PlayToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAbilities)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "acknowledge_player_digging":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAcknowledgePlayerDigging)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "advancements":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAdvancements)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "animation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "attach_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAttachEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_action":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_break_animation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockBreakAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "boss_bar":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBossBar)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "camera":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCamera)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "chat":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "close_window":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCloseWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "collect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCollect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "combat_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCombatEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "craft_progress_bar":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftProgressBar)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "craft_recipe_response":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftRecipeResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "custom_payload":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCustomPayload)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "declare_commands":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareCommands)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "declare_recipes":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareRecipes)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "difficulty":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDifficulty)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_destroy":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityDestroy)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_equipment":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEquipment)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_head_rotation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityHeadRotation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_look":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_metadata":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMetadata)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_move_look":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMoveLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_sound_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntitySoundEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_status":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityStatus)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_teleport":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityTeleport)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_update_attributes":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityUpdateAttributes)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_velocity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityVelocity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "experience":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExperience)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "explosion":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExplosion)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "face_player":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketFacePlayer)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "game_state_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameStateChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "held_item_slot":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHeldItemSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "keep_alive":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKeepAlive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "kick_disconnect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKickDisconnect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "login":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketLogin)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "map":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMap)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "map_chunk":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunk)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "multi_block_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMultiBlockChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "named_entity_spawn":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNamedEntitySpawn)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "named_sound_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNamedSoundEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "nbt_query_response":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNbtQueryResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "open_book":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenBook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "open_horse_window":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenHorseWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "open_sign_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenSignEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "open_window":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "player_info":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerInfo)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "playerlist_header":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerlistHeader)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "rel_entity_move":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRelEntityMove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "remove_entity_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRemoveEntityEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "resource_pack_send":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResourcePackSend)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "respawn":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRespawn)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_display_objective":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardDisplayObjective)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_objective":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardObjective)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_score":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardScore)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "select_advancement_tab":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSelectAdvancementTab)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_cooldown":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCooldown)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_passengers":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPassengers)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_slot":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "sound_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSoundEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity_experience_orb":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityExperienceOrb)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity_living":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityLiving)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity_painting":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityPainting)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spawn_position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "statistics":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStatistics)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "stop_sound":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStopSound)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "tab_complete":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTabComplete)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "tags":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTags)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "teams":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTeams)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "tile_entity_data":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTileEntityData)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "title":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTitle)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "trade_list":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTradeList)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "transaction":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTransaction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "unload_chunk":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnloadChunk)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "unlock_recipes":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnlockRecipes)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_health":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateHealth)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_light":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateLight)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_time":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateTime)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_view_distance":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewDistance)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_view_position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "vehicle_move":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketVehicleMove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "window_items":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWindowItems)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "world_border":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorder)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "world_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "world_particles":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldParticles)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
		err = PlayToClientPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketAbilities struct {
	Flags        int8
	FlyingSpeed  float32
	WalkingSpeed float32
}

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

type PlayToClientPacketAcknowledgePlayerDigging struct {
	Location   Position
	Block      int32
	Status     int32
	Successful bool
}

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

type PlayToClientPacketAdvancements struct {
	Reset              bool
	AdvancementMapping []struct {
		Key   string
		Value struct {
			ParentId    *string
			DisplayData *struct {
				Title       string
				Description string
				Icon        Slot
				FrameType   int32
				Flags       struct {
					Unused               uint32
					Hidden               bool
					ShowToast            bool
					HasBackgroundTexture bool
				}
				BackgroundTexture any
				XCord             float32
				YCord             float32
			}
			Criteria []struct {
				Key   string
				Value struct {
				}
			}
			Requirements [][]string
		}
	}
	Identifiers     []string
	ProgressMapping []struct {
		Key   string
		Value []struct {
			CriterionIdentifier string
			CriterionProgress   *int64
		}
	}
}

func (ret *PlayToClientPacketAdvancements) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Reset)
	if err != nil {
		return
	}
	var lPlayToClientPacketAdvancementsAdvancementMapping int32
	lPlayToClientPacketAdvancementsAdvancementMapping, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.AdvancementMapping = []struct {
		Key   string
		Value struct {
			ParentId    *string
			DisplayData *struct {
				Title       string
				Description string
				Icon        Slot
				FrameType   int32
				Flags       struct {
					Unused               uint32
					Hidden               bool
					ShowToast            bool
					HasBackgroundTexture bool
				}
				BackgroundTexture any
				XCord             float32
				YCord             float32
			}
			Criteria []struct {
				Key   string
				Value struct {
				}
			}
			Requirements [][]string
		}
	}{}
	for range lPlayToClientPacketAdvancementsAdvancementMapping {
		var PlayToClientPacketAdvancementsAdvancementMappingElement struct {
			Key   string
			Value struct {
				ParentId    *string
				DisplayData *struct {
					Title       string
					Description string
					Icon        Slot
					FrameType   int32
					Flags       struct {
						Unused               uint32
						Hidden               bool
						ShowToast            bool
						HasBackgroundTexture bool
					}
					BackgroundTexture any
					XCord             float32
					YCord             float32
				}
				Criteria []struct {
					Key   string
					Value struct {
					}
				}
				Requirements [][]string
			}
		}
		PlayToClientPacketAdvancementsAdvancementMappingElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent {
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue string
			PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElement.Value.ParentId = &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue
		}
		var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent {
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue struct {
				Title       string
				Description string
				Icon        Slot
				FrameType   int32
				Flags       struct {
					Unused               uint32
					Hidden               bool
					ShowToast            bool
					HasBackgroundTexture bool
				}
				BackgroundTexture any
				XCord             float32
				YCord             float32
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Title, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Description, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Icon.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.FrameType, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked uint32
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked>>0&1 == 1
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.ShowToast = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked>>1&1 == 1
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Hidden = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked>>2&1 == 1
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Unused = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked >> 3 & 536870911
			switch PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture {
			case true:
				var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp string
				PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp
			default:
				var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp struct {
				}
				PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.XCord)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.YCord)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElement.Value.DisplayData = &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue
		}
		var lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria int32
		lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria = []struct {
			Key   string
			Value struct {
			}
		}{}
		for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueCriteria {
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement struct {
				Key   string
				Value struct {
				}
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement.Key, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Criteria, PlayToClientPacketAdvancementsAdvancementMappingElementValueCriteriaElement)
		}
		var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements int32
		lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = [][]string{}
		for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements {
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement []string
			var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement int32
			lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = []string{}
			for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement {
				var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement string
				PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = append(PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement)
			}
			PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement)
		}
		ret.AdvancementMapping = append(ret.AdvancementMapping, PlayToClientPacketAdvancementsAdvancementMappingElement)
	}
	var lPlayToClientPacketAdvancementsIdentifiers int32
	lPlayToClientPacketAdvancementsIdentifiers, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Identifiers = []string{}
	for range lPlayToClientPacketAdvancementsIdentifiers {
		var PlayToClientPacketAdvancementsIdentifiersElement string
		PlayToClientPacketAdvancementsIdentifiersElement, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Identifiers = append(ret.Identifiers, PlayToClientPacketAdvancementsIdentifiersElement)
	}
	var lPlayToClientPacketAdvancementsProgressMapping int32
	lPlayToClientPacketAdvancementsProgressMapping, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ProgressMapping = []struct {
		Key   string
		Value []struct {
			CriterionIdentifier string
			CriterionProgress   *int64
		}
	}{}
	for range lPlayToClientPacketAdvancementsProgressMapping {
		var PlayToClientPacketAdvancementsProgressMappingElement struct {
			Key   string
			Value []struct {
				CriterionIdentifier string
				CriterionProgress   *int64
			}
		}
		PlayToClientPacketAdvancementsProgressMappingElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var lPlayToClientPacketAdvancementsProgressMappingElementValue int32
		lPlayToClientPacketAdvancementsProgressMappingElementValue, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketAdvancementsProgressMappingElement.Value = []struct {
			CriterionIdentifier string
			CriterionProgress   *int64
		}{}
		for range lPlayToClientPacketAdvancementsProgressMappingElementValue {
			var PlayToClientPacketAdvancementsProgressMappingElementValueElement struct {
				CriterionIdentifier string
				CriterionProgress   *int64
			}
			PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionIdentifier, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent bool
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent)
			if err != nil {
				return
			}
			if PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent {
				var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue int64
				err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue)
				if err != nil {
					return
				}
				PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionProgress = &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue
			}
			PlayToClientPacketAdvancementsProgressMappingElement.Value = append(PlayToClientPacketAdvancementsProgressMappingElement.Value, PlayToClientPacketAdvancementsProgressMappingElementValueElement)
		}
		ret.ProgressMapping = append(ret.ProgressMapping, PlayToClientPacketAdvancementsProgressMappingElement)
	}
	return
}
func (ret *PlayToClientPacketAdvancements) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Reset)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping)))
	if err != nil {
		return
	}
	for iPlayToClientPacketAdvancementsAdvancementMapping := range len(ret.AdvancementMapping) {
		err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Key)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil)
		if err != nil {
			return
		}
		if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil {
			err = proto_base.EncodeString(w, *ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId)
			if err != nil {
				return
			}
		}
		err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil)
		if err != nil {
			return
		}
		if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil {
			err = proto_base.EncodeString(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Title)
			if err != nil {
				return
			}
			err = proto_base.EncodeString(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Description)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataIconEncTmp := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Icon
			err = PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataIconEncTmp.Encode(w)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).FrameType)
			if err != nil {
				return
			}
			var PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked uint32
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture) & 0x1) << 0x0
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.ShowToast) & 0x1) << 0x1
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Hidden) & 0x1) << 0x2
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Unused) & 0x1FFFFFFF) << 0x3
			err = binary.Write(w, binary.BigEndian, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked)
			if err != nil {
				return
			}
			switch (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture {
			case true:
				PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(string)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = proto_base.EncodeString(w, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture)
				if err != nil {
					return
				}
			default:
				_, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
			err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).XCord)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).YCord)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria)))
		if err != nil {
			return
		}
		for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueCriteria := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria) {
			err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Criteria[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueCriteria].Key)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements)))
		if err != nil {
			return
		}
		for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements) {
			err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements])))
			if err != nil {
				return
			}
			for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements]) {
				err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements][iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner])
				if err != nil {
					return
				}
			}
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Identifiers)))
	if err != nil {
		return
	}
	for iPlayToClientPacketAdvancementsIdentifiers := range len(ret.Identifiers) {
		err = proto_base.EncodeString(w, ret.Identifiers[iPlayToClientPacketAdvancementsIdentifiers])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping)))
	if err != nil {
		return
	}
	for iPlayToClientPacketAdvancementsProgressMapping := range len(ret.ProgressMapping) {
		err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value)))
		if err != nil {
			return
		}
		for iPlayToClientPacketAdvancementsProgressMappingInnerValue := range len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value) {
			err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionIdentifier)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil)
			if err != nil {
				return
			}
			if ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil {
				err = binary.Write(w, binary.BigEndian, *ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress)
				if err != nil {
					return
				}
			}
		}
	}
	return
}

type PlayToClientPacketAnimation struct {
	EntityId  int32
	Animation uint8
}

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

type PlayToClientPacketAttachEntity struct {
	EntityId  int32
	VehicleId int32
}

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

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

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

type PlayToClientPacketBlockBreakAnimation struct {
	EntityId     int32
	Location     Position
	DestroyStage int8
}

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

type PlayToClientPacketBlockChange struct {
	Location Position
	Type     int32
}

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

type PlayToClientPacketBossBar struct {
	EntityUUID uuid.UUID
	Action     int32
	Title      any
	Health     any
	Color      any
	Dividers   any
	Flags      any
}

func (ret *PlayToClientPacketBossBar) Decode(r io.ReadSeeker) (err error) {
	_, err = io.ReadFull(r, ret.EntityUUID[:])
	if err != nil {
		return
	}
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarTitle0Tmp string
		PlayToClientPacketBossBarTitle0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Title = PlayToClientPacketBossBarTitle0Tmp
	case 3:
		var PlayToClientPacketBossBarTitle3Tmp string
		PlayToClientPacketBossBarTitle3Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Title = PlayToClientPacketBossBarTitle3Tmp
	default:
		var PlayToClientPacketBossBarTitleTmp struct {
		}
		ret.Title = PlayToClientPacketBossBarTitleTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarHealth0Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth0Tmp)
		if err != nil {
			return
		}
		ret.Health = PlayToClientPacketBossBarHealth0Tmp
	case 2:
		var PlayToClientPacketBossBarHealth2Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth2Tmp)
		if err != nil {
			return
		}
		ret.Health = PlayToClientPacketBossBarHealth2Tmp
	default:
		var PlayToClientPacketBossBarHealthTmp struct {
		}
		ret.Health = PlayToClientPacketBossBarHealthTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarColor0Tmp int32
		PlayToClientPacketBossBarColor0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Color = PlayToClientPacketBossBarColor0Tmp
	case 4:
		var PlayToClientPacketBossBarColor4Tmp int32
		PlayToClientPacketBossBarColor4Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Color = PlayToClientPacketBossBarColor4Tmp
	default:
		var PlayToClientPacketBossBarColorTmp struct {
		}
		ret.Color = PlayToClientPacketBossBarColorTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarDividers0Tmp int32
		PlayToClientPacketBossBarDividers0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Dividers = PlayToClientPacketBossBarDividers0Tmp
	case 4:
		var PlayToClientPacketBossBarDividers4Tmp int32
		PlayToClientPacketBossBarDividers4Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Dividers = PlayToClientPacketBossBarDividers4Tmp
	default:
		var PlayToClientPacketBossBarDividersTmp struct {
		}
		ret.Dividers = PlayToClientPacketBossBarDividersTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarFlags0Tmp uint8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags0Tmp)
		if err != nil {
			return
		}
		ret.Flags = PlayToClientPacketBossBarFlags0Tmp
	case 5:
		var PlayToClientPacketBossBarFlags5Tmp uint8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags5Tmp)
		if err != nil {
			return
		}
		ret.Flags = PlayToClientPacketBossBarFlags5Tmp
	default:
		var PlayToClientPacketBossBarFlagsTmp struct {
		}
		ret.Flags = PlayToClientPacketBossBarFlagsTmp
	}
	return
}
func (ret *PlayToClientPacketBossBar) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.EntityUUID[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarTitle, ok := ret.Title.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketBossBarTitle)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketBossBarTitle, ok := ret.Title.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketBossBarTitle)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Title.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Health.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
		if err != nil {
			return
		}
	case 4:
		PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Color.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
		if err != nil {
			return
		}
	case 4:
		PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Dividers.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
		if err != nil {
			return
		}
	case 5:
		PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Flags.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketCamera struct {
	CameraId int32
}

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

type PlayToClientPacketChat struct {
	Message  string
	Position int8
	Sender   uuid.UUID
}

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
	}
	_, err = io.ReadFull(r, ret.Sender[:])
	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
	}
	_, err = w.Write(ret.Sender[:])
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCloseWindow struct {
	WindowId uint8
}

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

type PlayToClientPacketCollect struct {
	CollectedEntityId int32
	CollectorEntityId int32
	PickupItemCount   int32
}

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

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

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

type PlayToClientPacketCraftProgressBar struct {
	WindowId uint8
	Property int16
	Value    int16
}

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

type PlayToClientPacketCraftRecipeResponse struct {
	WindowId int8
	Recipe   string
}

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

type PlayToClientPacketCustomPayload struct {
	Channel string
	Data    proto_base.RestBuffer
}

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

type PlayToClientPacketDeclareCommands struct {
	Nodes     []CommandNode
	RootIndex int32
}

func (ret *PlayToClientPacketDeclareCommands) Decode(r io.ReadSeeker) (err error) {
	var lPlayToClientPacketDeclareCommandsNodes int32
	lPlayToClientPacketDeclareCommandsNodes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Nodes = []CommandNode{}
	for range lPlayToClientPacketDeclareCommandsNodes {
		var PlayToClientPacketDeclareCommandsNodesElement CommandNode
		err = PlayToClientPacketDeclareCommandsNodesElement.Decode(r)
		if err != nil {
			return
		}
		ret.Nodes = append(ret.Nodes, PlayToClientPacketDeclareCommandsNodesElement)
	}
	ret.RootIndex, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDeclareCommands) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Nodes)))
	if err != nil {
		return
	}
	for iPlayToClientPacketDeclareCommandsNodes := range len(ret.Nodes) {
		PlayToClientPacketDeclareCommandsNodesInnerEncTmp := ret.Nodes[iPlayToClientPacketDeclareCommandsNodes]
		err = PlayToClientPacketDeclareCommandsNodesInnerEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.RootIndex)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDeclareRecipes struct {
	Recipes []struct {
		Type     string
		RecipeId string
		Data     any
	}
}

func (ret *PlayToClientPacketDeclareRecipes) Decode(r io.ReadSeeker) (err error) {
	var lPlayToClientPacketDeclareRecipesRecipes int32
	lPlayToClientPacketDeclareRecipesRecipes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Recipes = []struct {
		Type     string
		RecipeId string
		Data     any
	}{}
	for range lPlayToClientPacketDeclareRecipesRecipes {
		var PlayToClientPacketDeclareRecipesRecipesElement struct {
			Type     string
			RecipeId string
			Data     any
		}
		PlayToClientPacketDeclareRecipesRecipesElement.Type, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		PlayToClientPacketDeclareRecipesRecipesElement.RecipeId, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		switch PlayToClientPacketDeclareRecipesRecipesElement.Type {
		case "minecraft:blasting":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp MinecraftSmeltingFormat
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp
		case "minecraft:campfire_cooking":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp MinecraftSmeltingFormat
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp
		case "minecraft:crafting_shaped":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp struct {
				Width       int32
				Height      int32
				Group       string
				Ingredients [][]Ingredient
				Result      Slot
			}
			PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Width, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Height, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Group, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients int32
			lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Height
			PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients = [][]Ingredient{}
			for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients {
				var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement []Ingredient
				var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement int32
				lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Width
				PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = []Ingredient{}
				for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement {
					var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement Ingredient
					err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement.Decode(r)
					if err != nil {
						return
					}
					PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement)
				}
				PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement)
			}
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Result.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp
		case "minecraft:crafting_shapeless":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp struct {
				Group       string
				Ingredients []Ingredient
				Result      Slot
			}
			PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Group, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients int32
			lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients = []Ingredient{}
			for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients {
				var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement Ingredient
				err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement.Decode(r)
				if err != nil {
					return
				}
				PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement)
			}
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Result.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp
		case "minecraft:crafting_special_armordye":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialArmordyeTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialArmordyeTmp
		case "minecraft:crafting_special_banneraddpattern":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBanneraddpatternTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBanneraddpatternTmp
		case "minecraft:crafting_special_bannerduplicate":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBannerduplicateTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBannerduplicateTmp
		case "minecraft:crafting_special_bookcloning":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBookcloningTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBookcloningTmp
		case "minecraft:crafting_special_firework_rocket":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkRocketTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkRocketTmp
		case "minecraft:crafting_special_firework_star":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarTmp
		case "minecraft:crafting_special_firework_star_fade":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarFadeTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarFadeTmp
		case "minecraft:crafting_special_mapcloning":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapcloningTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapcloningTmp
		case "minecraft:crafting_special_mapextending":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapextendingTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapextendingTmp
		case "minecraft:crafting_special_repairitem":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialRepairitemTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialRepairitemTmp
		case "minecraft:crafting_special_shielddecoration":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShielddecorationTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShielddecorationTmp
		case "minecraft:crafting_special_shulkerboxcoloring":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShulkerboxcoloringTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShulkerboxcoloringTmp
		case "minecraft:crafting_special_suspiciousstew":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialSuspiciousstewTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialSuspiciousstewTmp
		case "minecraft:crafting_special_tippedarrow":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialTippedarrowTmp struct {
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialTippedarrowTmp
		case "minecraft:smelting":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp MinecraftSmeltingFormat
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp
		case "minecraft:smithing":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTmp struct {
				Base     Ingredient
				Addition Ingredient
				Result   Slot
			}
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTmp.Base.Decode(r)
			if err != nil {
				return
			}
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTmp.Addition.Decode(r)
			if err != nil {
				return
			}
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTmp.Result.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTmp
		case "minecraft:smoking":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp MinecraftSmeltingFormat
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp
		case "minecraft:stonecutting":
			var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp struct {
				Group      string
				Ingredient Ingredient
				Result     Slot
			}
			PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Group, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Ingredient.Decode(r)
			if err != nil {
				return
			}
			err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Result.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp
		}
		ret.Recipes = append(ret.Recipes, PlayToClientPacketDeclareRecipesRecipesElement)
	}
	return
}
func (ret *PlayToClientPacketDeclareRecipes) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes)))
	if err != nil {
		return
	}
	for iPlayToClientPacketDeclareRecipesRecipes := range len(ret.Recipes) {
		err = proto_base.EncodeString(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Type)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].RecipeId)
		if err != nil {
			return
		}
		switch ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Type {
		case "minecraft:blasting":
			PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
			if err != nil {
				return
			}
		case "minecraft:campfire_cooking":
			PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
			if err != nil {
				return
			}
		case "minecraft:crafting_shaped":
			PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
				Width       int32
				Height      int32
				Group       string
				Ingredients [][]Ingredient
				Result      Slot
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Width)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Height)
			if err != nil {
				return
			}
			err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
			if err != nil {
				return
			}
			for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients) {
				for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInner := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients]) {
					PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerInnerEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients][iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInner]
					err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerInnerEncTmp.Encode(w)
					if err != nil {
						return
					}
				}
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
			if err != nil {
				return
			}
		case "minecraft:crafting_shapeless":
			PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
				Group       string
				Ingredients []Ingredient
				Result      Slot
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients)))
			if err != nil {
				return
			}
			for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients) {
				PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients]
				err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerEncTmp.Encode(w)
				if err != nil {
					return
				}
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
			if err != nil {
				return
			}
		case "minecraft:crafting_special_armordye":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_banneraddpattern":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_bannerduplicate":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_bookcloning":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_firework_rocket":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_firework_star":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_firework_star_fade":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_mapcloning":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_mapextending":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_repairitem":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_shielddecoration":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_shulkerboxcoloring":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_suspiciousstew":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:crafting_special_tippedarrow":
			_, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		case "minecraft:smelting":
			PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
			if err != nil {
				return
			}
		case "minecraft:smithing":
			PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
				Base     Ingredient
				Addition Ingredient
				Result   Slot
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataBaseEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Base
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataBaseEncTmp.Encode(w)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataAdditionEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Addition
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataAdditionEncTmp.Encode(w)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
			if err != nil {
				return
			}
		case "minecraft:smoking":
			PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
			if err != nil {
				return
			}
		case "minecraft:stonecutting":
			PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
				Group      string
				Ingredient Ingredient
				Result     Slot
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredient
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientEncTmp.Encode(w)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
			err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientPacketDifficulty struct {
	Difficulty       uint8
	DifficultyLocked bool
}

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

type PlayToClientPacketEntity struct {
	EntityId int32
}

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

type PlayToClientPacketEntityDestroy struct {
	EntityIds []int32
}

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

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

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

type PlayToClientPacketEntityEquipment struct {
	EntityId   int32
	Equipments []struct {
		Slot int8
		Item Slot
	}
}

func (ret *PlayToClientPacketEntityEquipment) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Equipments = []struct {
		Slot int8
		Item Slot
	}{}
	for {
		var PlayToClientPacketEntityEquipmentEquipmentsHeader uint8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityEquipmentEquipmentsHeader)
		if err == io.EOF {
			err = nil
			break
		}
		if err != nil {
			return
		}
		_, err = r.Seek(-1, io.SeekCurrent)
		if err != nil {
			return
		}
		PlayToClientPacketEntityEquipmentEquipmentsHasMore := PlayToClientPacketEntityEquipmentEquipmentsHeader&128 != 0
		var PlayToClientPacketEntityEquipmentEquipmentsElement struct {
			Slot int8
			Item Slot
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityEquipmentEquipmentsElement.Slot)
		if err != nil {
			return
		}
		err = PlayToClientPacketEntityEquipmentEquipmentsElement.Item.Decode(r)
		if err != nil {
			return
		}
		ret.Equipments = append(ret.Equipments, PlayToClientPacketEntityEquipmentEquipmentsElement)
		if !PlayToClientPacketEntityEquipmentEquipmentsHasMore {
			break
		}
	}
	return
}
func (ret *PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	for iPlayToClientPacketEntityEquipmentEquipments, PlayToClientPacketEntityEquipmentEquipmentsElem := range ret.Equipments {
		if iPlayToClientPacketEntityEquipmentEquipments != len(ret.Equipments)-1 {
			err = binary.Write(w, binary.BigEndian, int8(uint8(PlayToClientPacketEntityEquipmentEquipmentsElem.Slot)|128))
			if err != nil {
				return
			}
		} else {
			err = binary.Write(w, binary.BigEndian, PlayToClientPacketEntityEquipmentEquipmentsElem.Slot)
			if err != nil {
				return
			}
		}
		PlayToClientPacketEntityEquipmentEquipmentsItemEncTmp := PlayToClientPacketEntityEquipmentEquipmentsElem.Item
		err = PlayToClientPacketEntityEquipmentEquipmentsItemEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketEntityHeadRotation struct {
	EntityId int32
	HeadYaw  int8
}

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

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

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

type PlayToClientPacketEntityMetadata struct {
	EntityId int32
	Metadata EntityMetadata
}

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

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

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

type PlayToClientPacketEntitySoundEffect struct {
	SoundId       int32
	SoundCategory int32
	EntityId      int32
	Volume        float32
	Pitch         float32
}

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

type PlayToClientPacketEntityStatus struct {
	EntityId     int32
	EntityStatus int8
}

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

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

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

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

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

type PlayToClientPacketEntityVelocity struct {
	EntityId int32
	Velocity Vec3i16
}

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

type PlayToClientPacketExperience struct {
	ExperienceBar   float32
	Level           int32
	TotalExperience int32
}

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

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

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

type PlayToClientPacketFacePlayer struct {
	FeetEyes       int32
	X              float64
	Y              float64
	Z              float64
	IsEntity       bool
	EntityId       any
	EntityFeetEyes any
}

func (ret *PlayToClientPacketFacePlayer) Decode(r io.ReadSeeker) (err error) {
	ret.FeetEyes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsEntity)
	if err != nil {
		return
	}
	switch ret.IsEntity {
	case true:
		var PlayToClientPacketFacePlayerEntityIdTrueTmp int32
		PlayToClientPacketFacePlayerEntityIdTrueTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.EntityId = PlayToClientPacketFacePlayerEntityIdTrueTmp
	default:
		var PlayToClientPacketFacePlayerEntityIdTmp struct {
		}
		ret.EntityId = PlayToClientPacketFacePlayerEntityIdTmp
	}
	switch ret.IsEntity {
	case true:
		var PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp string
		PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp
	default:
		var PlayToClientPacketFacePlayerEntityFeetEyesTmp struct {
		}
		ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTmp
	}
	return
}
func (ret *PlayToClientPacketFacePlayer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.FeetEyes)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsEntity)
	if err != nil {
		return
	}
	switch ret.IsEntity {
	case true:
		PlayToClientPacketFacePlayerEntityId, ok := ret.EntityId.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityId)
		if err != nil {
			return
		}
	default:
		_, ok := ret.EntityId.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.IsEntity {
	case true:
		PlayToClientPacketFacePlayerEntityFeetEyes, ok := ret.EntityFeetEyes.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketFacePlayerEntityFeetEyes)
		if err != nil {
			return
		}
	default:
		_, ok := ret.EntityFeetEyes.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketGameStateChange struct {
	Reason   uint8
	GameMode float32
}

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

type PlayToClientPacketHeldItemSlot struct {
	Slot int8
}

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

type PlayToClientPacketKeepAlive struct {
	KeepAliveId int64
}

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

type PlayToClientPacketKickDisconnect struct {
	Reason string
}

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

type PlayToClientPacketLogin struct {
	EntityId            int32
	IsHardcore          bool
	GameMode            uint8
	PreviousGameMode    uint8
	WorldNames          []string
	DimensionCodec      nbt.Tag
	Dimension           nbt.Tag
	WorldName           string
	HashedSeed          int64
	MaxPlayers          int32
	ViewDistance        int32
	ReducedDebugInfo    bool
	EnableRespawnScreen bool
	IsDebug             bool
	IsFlat              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.IsHardcore)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.GameMode)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.PreviousGameMode)
	if err != nil {
		return
	}
	var lPlayToClientPacketLoginWorldNames int32
	lPlayToClientPacketLoginWorldNames, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.WorldNames = []string{}
	for range lPlayToClientPacketLoginWorldNames {
		var PlayToClientPacketLoginWorldNamesElement string
		PlayToClientPacketLoginWorldNamesElement, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.WorldNames = append(ret.WorldNames, PlayToClientPacketLoginWorldNamesElement)
	}
	err = ret.DimensionCodec.Decode(r)
	if err != nil {
		return
	}
	err = ret.Dimension.Decode(r)
	if err != nil {
		return
	}
	ret.WorldName, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HashedSeed)
	if err != nil {
		return
	}
	ret.MaxPlayers, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ViewDistance, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ReducedDebugInfo)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableRespawnScreen)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsDebug)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsFlat)
	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.IsHardcore)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.GameMode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PreviousGameMode)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.WorldNames)))
	if err != nil {
		return
	}
	for iPlayToClientPacketLoginWorldNames := range len(ret.WorldNames) {
		err = proto_base.EncodeString(w, ret.WorldNames[iPlayToClientPacketLoginWorldNames])
		if err != nil {
			return
		}
	}
	PlayToClientPacketLoginDimensionCodecEncTmp := ret.DimensionCodec
	err = PlayToClientPacketLoginDimensionCodecEncTmp.Encode(w)
	if err != nil {
		return
	}
	PlayToClientPacketLoginDimensionEncTmp := ret.Dimension
	err = PlayToClientPacketLoginDimensionEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.WorldName)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HashedSeed)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MaxPlayers)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ViewDistance)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ReducedDebugInfo)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableRespawnScreen)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsDebug)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsFlat)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketMap struct {
	ItemDamage       int32
	Scale            int8
	TrackingPosition bool
	Locked           bool
	Icons            []struct {
		Type        int32
		X           int8
		Z           int8
		Direction   uint8
		DisplayName *string
	}
	Columns int8
	Rows    any
	X       any
	Y       any
	Data    any
}

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

type PlayToClientPacketMapChunk struct {
	X             int32
	Z             int32
	GroundUp      bool
	BitMap        int32
	Heightmaps    nbt.Tag
	Biomes        any
	ChunkData     []byte
	BlockEntities []nbt.Tag
}

func (ret *PlayToClientPacketMapChunk) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.GroundUp)
	if err != nil {
		return
	}
	ret.BitMap, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Heightmaps.Decode(r)
	if err != nil {
		return
	}
	switch ret.GroundUp {
	case false:
		var PlayToClientPacketMapChunkBiomesFalseTmp struct {
		}
		ret.Biomes = PlayToClientPacketMapChunkBiomesFalseTmp
	case true:
		var PlayToClientPacketMapChunkBiomesTrueTmp []int32
		var lPlayToClientPacketMapChunkBiomesTrueTmp int32
		lPlayToClientPacketMapChunkBiomesTrueTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketMapChunkBiomesTrueTmp = []int32{}
		for range lPlayToClientPacketMapChunkBiomesTrueTmp {
			var PlayToClientPacketMapChunkBiomesTrueTmpElement int32
			PlayToClientPacketMapChunkBiomesTrueTmpElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketMapChunkBiomesTrueTmp = append(PlayToClientPacketMapChunkBiomesTrueTmp, PlayToClientPacketMapChunkBiomesTrueTmpElement)
		}
		ret.Biomes = PlayToClientPacketMapChunkBiomesTrueTmp
	}
	var lPlayToClientPacketMapChunkChunkData int32
	lPlayToClientPacketMapChunkChunkData, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ChunkData, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapChunkChunkData)))
	if err != nil {
		return
	}
	var lPlayToClientPacketMapChunkBlockEntities int32
	lPlayToClientPacketMapChunkBlockEntities, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.BlockEntities = []nbt.Tag{}
	for range lPlayToClientPacketMapChunkBlockEntities {
		var PlayToClientPacketMapChunkBlockEntitiesElement nbt.Tag
		err = PlayToClientPacketMapChunkBlockEntitiesElement.Decode(r)
		if err != nil {
			return
		}
		ret.BlockEntities = append(ret.BlockEntities, PlayToClientPacketMapChunkBlockEntitiesElement)
	}
	return
}
func (ret *PlayToClientPacketMapChunk) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.GroundUp)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.BitMap)
	if err != nil {
		return
	}
	PlayToClientPacketMapChunkHeightmapsEncTmp := ret.Heightmaps
	err = PlayToClientPacketMapChunkHeightmapsEncTmp.Encode(w)
	if err != nil {
		return
	}
	switch ret.GroundUp {
	case false:
		_, ok := ret.Biomes.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	case true:
		PlayToClientPacketMapChunkBiomes, ok := ret.Biomes.([]int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketMapChunkBiomes)))
		if err != nil {
			return
		}
		for iPlayToClientPacketMapChunkBiomes := range len(PlayToClientPacketMapChunkBiomes) {
			err = proto_base.EncodeVarInt(w, PlayToClientPacketMapChunkBiomes[iPlayToClientPacketMapChunkBiomes])
			if err != nil {
				return
			}
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.ChunkData)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.ChunkData)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.BlockEntities)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkBlockEntities := range len(ret.BlockEntities) {
		PlayToClientPacketMapChunkBlockEntitiesInnerEncTmp := ret.BlockEntities[iPlayToClientPacketMapChunkBlockEntities]
		err = PlayToClientPacketMapChunkBlockEntitiesInnerEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketMultiBlockChange struct {
	ChunkCoordinates struct {
		X int32
		Z int32
		Y uint32
	}
	NotTrustEdges bool
	Records       []int64
}

func (ret *PlayToClientPacketMultiBlockChange) Decode(r io.ReadSeeker) (err error) {
	var PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked uint64
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked)
	if err != nil {
		return
	}
	ret.ChunkCoordinates.Y = uint32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked >> 0 & 1048575)
	ret.ChunkCoordinates.Z = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked >> 20 & 4194303)
	if ret.ChunkCoordinates.Z >= 1<<21 {
		ret.ChunkCoordinates.Z -= 1 << 22
	}
	ret.ChunkCoordinates.X = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked >> 42 & 4194303)
	if ret.ChunkCoordinates.X >= 1<<21 {
		ret.ChunkCoordinates.X -= 1 << 22
	}
	err = binary.Read(r, binary.BigEndian, &ret.NotTrustEdges)
	if err != nil {
		return
	}
	var lPlayToClientPacketMultiBlockChangeRecords int32
	lPlayToClientPacketMultiBlockChangeRecords, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Records = []int64{}
	for range lPlayToClientPacketMultiBlockChangeRecords {
		var PlayToClientPacketMultiBlockChangeRecordsElement int64
		PlayToClientPacketMultiBlockChangeRecordsElement, err = proto_base.DecodeVarLong(r)
		if err != nil {
			return
		}
		ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement)
	}
	return
}
func (ret *PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) {
	var PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked uint64
	PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.Y) & 0xFFFFF) << 0x0
	PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.Z) & 0x3FFFFF) << 0x14
	PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.X) & 0x3FFFFF) << 0x2A
	err = binary.Write(w, binary.BigEndian, PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.NotTrustEdges)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Records)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) {
		err = proto_base.EncodeVarLong(w, ret.Records[iPlayToClientPacketMultiBlockChangeRecords])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketNamedEntitySpawn struct {
	EntityId   int32
	PlayerUUID uuid.UUID
	X          float64
	Y          float64
	Z          float64
	Yaw        int8
	Pitch      int8
}

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
	}
	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
	}
	return
}

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

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

type PlayToClientPacketNbtQueryResponse struct {
	TransactionId int32
	Nbt           nbt.Tag
}

func (ret *PlayToClientPacketNbtQueryResponse) Decode(r io.ReadSeeker) (err error) {
	ret.TransactionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Nbt.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketNbtQueryResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TransactionId)
	if err != nil {
		return
	}
	PlayToClientPacketNbtQueryResponseNbtEncTmp := ret.Nbt
	err = PlayToClientPacketNbtQueryResponseNbtEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketOpenBook struct {
	Hand int32
}

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

type PlayToClientPacketOpenHorseWindow struct {
	WindowId uint8
	NbSlots  int32
	EntityId int32
}

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

type PlayToClientPacketOpenSignEntity struct {
	Location Position
}

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

type PlayToClientPacketOpenWindow struct {
	WindowId      int32
	InventoryType int32
	WindowTitle   string
}

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

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

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

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

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

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

type PlayToClientPacketPlayerlistHeader struct {
	Header string
	Footer string
}

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

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

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

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

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

type PlayToClientPacketRemoveEntityEffect struct {
	EntityId int32
	EffectId int8
}

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

type PlayToClientPacketResourcePackSend struct {
	Url  string
	Hash string
}

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

type PlayToClientPacketRespawn struct {
	Dimension        nbt.Tag
	WorldName        string
	HashedSeed       int64
	Gamemode         uint8
	PreviousGamemode uint8
	IsDebug          bool
	IsFlat           bool
	CopyMetadata     bool
}

func (ret *PlayToClientPacketRespawn) Decode(r io.ReadSeeker) (err error) {
	err = ret.Dimension.Decode(r)
	if err != nil {
		return
	}
	ret.WorldName, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HashedSeed)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Gamemode)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.PreviousGamemode)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsDebug)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsFlat)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CopyMetadata)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketRespawn) Encode(w io.Writer) (err error) {
	PlayToClientPacketRespawnDimensionEncTmp := ret.Dimension
	err = PlayToClientPacketRespawnDimensionEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.WorldName)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HashedSeed)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Gamemode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PreviousGamemode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsDebug)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsFlat)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CopyMetadata)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketScoreboardDisplayObjective struct {
	Position int8
	Name     string
}

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

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

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

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

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

type PlayToClientPacketSelectAdvancementTab struct {
	Id *string
}

func (ret *PlayToClientPacketSelectAdvancementTab) Decode(r io.ReadSeeker) (err error) {
	var PlayToClientPacketSelectAdvancementTabIdPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketSelectAdvancementTabIdPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketSelectAdvancementTabIdPresent {
		var PlayToClientPacketSelectAdvancementTabIdPresentValue string
		PlayToClientPacketSelectAdvancementTabIdPresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Id = &PlayToClientPacketSelectAdvancementTabIdPresentValue
	}
	return
}
func (ret *PlayToClientPacketSelectAdvancementTab) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Id != nil)
	if err != nil {
		return
	}
	if ret.Id != nil {
		err = proto_base.EncodeString(w, *ret.Id)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketSetCooldown struct {
	ItemID        int32
	CooldownTicks int32
}

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

type PlayToClientPacketSetPassengers struct {
	EntityId   int32
	Passengers []int32
}

func (ret *PlayToClientPacketSetPassengers) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketSetPassengersPassengers int32
	lPlayToClientPacketSetPassengersPassengers, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Passengers = []int32{}
	for range lPlayToClientPacketSetPassengersPassengers {
		var PlayToClientPacketSetPassengersPassengersElement int32
		PlayToClientPacketSetPassengersPassengersElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Passengers = append(ret.Passengers, PlayToClientPacketSetPassengersPassengersElement)
	}
	return
}
func (ret *PlayToClientPacketSetPassengers) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Passengers)))
	if err != nil {
		return
	}
	for iPlayToClientPacketSetPassengersPassengers := range len(ret.Passengers) {
		err = proto_base.EncodeVarInt(w, ret.Passengers[iPlayToClientPacketSetPassengersPassengers])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketSetSlot struct {
	WindowId int8
	Slot     int16
	Item     Slot
}

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

type PlayToClientPacketSoundEffect struct {
	SoundId       int32
	SoundCategory int32
	X             int32
	Y             int32
	Z             int32
	Volume        float32
	Pitch         float32
}

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

type PlayToClientPacketSpawnEntity struct {
	EntityId   int32
	ObjectUUID uuid.UUID
	Type       int32
	X          float64
	Y          float64
	Z          float64
	Pitch      int8
	Yaw        int8
	ObjectData int32
	Velocity   Vec3i16
}

func (ret *PlayToClientPacketSpawnEntity) Decode(r io.ReadSeeker) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	_, err = io.ReadFull(r, ret.ObjectUUID[:])
	if err != nil {
		return
	}
	ret.Type, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ObjectData)
	if err != nil {
		return
	}
	err = ret.Velocity.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSpawnEntity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	_, err = w.Write(ret.ObjectUUID[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Type)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ObjectData)
	if err != nil {
		return
	}
	PlayToClientPacketSpawnEntityVelocityEncTmp := ret.Velocity
	err = PlayToClientPacketSpawnEntityVelocityEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

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

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

type PlayToClientPacketSpawnEntityLiving struct {
	EntityId   int32
	EntityUUID uuid.UUID
	Type       int32
	X          float64
	Y          float64
	Z          float64
	Yaw        int8
	Pitch      int8
	HeadPitch  int8
	Velocity   Vec3i16
}

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

type PlayToClientPacketSpawnEntityPainting struct {
	EntityId   int32
	EntityUUID uuid.UUID
	Title      int32
	Location   Position
	Direction  uint8
}

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

type PlayToClientPacketSpawnPosition struct {
	Location Position
}

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

type PlayToClientPacketStatistics struct {
	Entries []struct {
		CategoryId  int32
		StatisticId int32
		Value       int32
	}
}

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

type PlayToClientPacketStopSound struct {
	Flags  int8
	Source any
	Sound  any
}

func (ret *PlayToClientPacketStopSound) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	switch ret.Flags {
	case 1:
		var PlayToClientPacketStopSoundSource1Tmp int32
		PlayToClientPacketStopSoundSource1Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Source = PlayToClientPacketStopSoundSource1Tmp
	case 3:
		var PlayToClientPacketStopSoundSource3Tmp int32
		PlayToClientPacketStopSoundSource3Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Source = PlayToClientPacketStopSoundSource3Tmp
	default:
		var PlayToClientPacketStopSoundSourceTmp struct {
		}
		ret.Source = PlayToClientPacketStopSoundSourceTmp
	}
	switch ret.Flags {
	case 2:
		var PlayToClientPacketStopSoundSound2Tmp string
		PlayToClientPacketStopSoundSound2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Sound = PlayToClientPacketStopSoundSound2Tmp
	case 3:
		var PlayToClientPacketStopSoundSound3Tmp string
		PlayToClientPacketStopSoundSound3Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Sound = PlayToClientPacketStopSoundSound3Tmp
	default:
		var PlayToClientPacketStopSoundSoundTmp struct {
		}
		ret.Sound = PlayToClientPacketStopSoundSoundTmp
	}
	return
}
func (ret *PlayToClientPacketStopSound) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	switch ret.Flags {
	case 1:
		PlayToClientPacketStopSoundSource, ok := ret.Source.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketStopSoundSource, ok := ret.Source.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Source.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Flags {
	case 2:
		PlayToClientPacketStopSoundSound, ok := ret.Sound.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketStopSoundSound, ok := ret.Sound.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Sound.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketTabComplete struct {
	TransactionId int32
	Start         int32
	Length        int32
	Matches       []struct {
		Match   string
		Tooltip *string
	}
}

func (ret *PlayToClientPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
	ret.TransactionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Start, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Length, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketTabCompleteMatches int32
	lPlayToClientPacketTabCompleteMatches, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Matches = []struct {
		Match   string
		Tooltip *string
	}{}
	for range lPlayToClientPacketTabCompleteMatches {
		var PlayToClientPacketTabCompleteMatchesElement struct {
			Match   string
			Tooltip *string
		}
		PlayToClientPacketTabCompleteMatchesElement.Match, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var PlayToClientPacketTabCompleteMatchesElementTooltipPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTabCompleteMatchesElementTooltipPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketTabCompleteMatchesElementTooltipPresent {
			var PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue string
			PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketTabCompleteMatchesElement.Tooltip = &PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue
		}
		ret.Matches = append(ret.Matches, PlayToClientPacketTabCompleteMatchesElement)
	}
	return
}
func (ret *PlayToClientPacketTabComplete) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TransactionId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Start)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Length)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Matches)))
	if err != nil {
		return
	}
	for iPlayToClientPacketTabCompleteMatches := range len(ret.Matches) {
		err = proto_base.EncodeString(w, ret.Matches[iPlayToClientPacketTabCompleteMatches].Match)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil)
		if err != nil {
			return
		}
		if ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil {
			err = proto_base.EncodeString(w, *ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip)
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientPacketTags struct {
	BlockTags  Tags
	ItemTags   Tags
	FluidTags  Tags
	EntityTags Tags
}

func (ret *PlayToClientPacketTags) Decode(r io.ReadSeeker) (err error) {
	err = ret.BlockTags.Decode(r)
	if err != nil {
		return
	}
	err = ret.ItemTags.Decode(r)
	if err != nil {
		return
	}
	err = ret.FluidTags.Decode(r)
	if err != nil {
		return
	}
	err = ret.EntityTags.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketTags) Encode(w io.Writer) (err error) {
	PlayToClientPacketTagsBlockTagsEncTmp := ret.BlockTags
	err = PlayToClientPacketTagsBlockTagsEncTmp.Encode(w)
	if err != nil {
		return
	}
	PlayToClientPacketTagsItemTagsEncTmp := ret.ItemTags
	err = PlayToClientPacketTagsItemTagsEncTmp.Encode(w)
	if err != nil {
		return
	}
	PlayToClientPacketTagsFluidTagsEncTmp := ret.FluidTags
	err = PlayToClientPacketTagsFluidTagsEncTmp.Encode(w)
	if err != nil {
		return
	}
	PlayToClientPacketTagsEntityTagsEncTmp := ret.EntityTags
	err = PlayToClientPacketTagsEntityTagsEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketTeams struct {
	Team              string
	Mode              int8
	Name              any
	FriendlyFire      any
	NameTagVisibility any
	CollisionRule     any
	Formatting        any
	Prefix            any
	Suffix            any
	Players           any
}

func (ret *PlayToClientPacketTeams) Decode(r io.ReadSeeker) (err error) {
	ret.Team, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Mode)
	if err != nil {
		return
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketTeamsName0Tmp string
		PlayToClientPacketTeamsName0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Name = PlayToClientPacketTeamsName0Tmp
	case 2:
		var PlayToClientPacketTeamsName2Tmp string
		PlayToClientPacketTeamsName2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Name = PlayToClientPacketTeamsName2Tmp
	default:
		var PlayToClientPacketTeamsNameTmp struct {
		}
		ret.Name = PlayToClientPacketTeamsNameTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketTeamsFriendlyFire0Tmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsFriendlyFire0Tmp)
		if err != nil {
			return
		}
		ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFire0Tmp
	case 2:
		var PlayToClientPacketTeamsFriendlyFire2Tmp int8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsFriendlyFire2Tmp)
		if err != nil {
			return
		}
		ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFire2Tmp
	default:
		var PlayToClientPacketTeamsFriendlyFireTmp struct {
		}
		ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFireTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketTeamsNameTagVisibility0Tmp string
		PlayToClientPacketTeamsNameTagVisibility0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibility0Tmp
	case 2:
		var PlayToClientPacketTeamsNameTagVisibility2Tmp string
		PlayToClientPacketTeamsNameTagVisibility2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibility2Tmp
	default:
		var PlayToClientPacketTeamsNameTagVisibilityTmp struct {
		}
		ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibilityTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketTeamsCollisionRule0Tmp string
		PlayToClientPacketTeamsCollisionRule0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.CollisionRule = PlayToClientPacketTeamsCollisionRule0Tmp
	case 2:
		var PlayToClientPacketTeamsCollisionRule2Tmp string
		PlayToClientPacketTeamsCollisionRule2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.CollisionRule = PlayToClientPacketTeamsCollisionRule2Tmp
	default:
		var PlayToClientPacketTeamsCollisionRuleTmp struct {
		}
		ret.CollisionRule = PlayToClientPacketTeamsCollisionRuleTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketTeamsFormatting0Tmp int32
		PlayToClientPacketTeamsFormatting0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Formatting = PlayToClientPacketTeamsFormatting0Tmp
	case 2:
		var PlayToClientPacketTeamsFormatting2Tmp int32
		PlayToClientPacketTeamsFormatting2Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Formatting = PlayToClientPacketTeamsFormatting2Tmp
	default:
		var PlayToClientPacketTeamsFormattingTmp struct {
		}
		ret.Formatting = PlayToClientPacketTeamsFormattingTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketTeamsPrefix0Tmp string
		PlayToClientPacketTeamsPrefix0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Prefix = PlayToClientPacketTeamsPrefix0Tmp
	case 2:
		var PlayToClientPacketTeamsPrefix2Tmp string
		PlayToClientPacketTeamsPrefix2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Prefix = PlayToClientPacketTeamsPrefix2Tmp
	default:
		var PlayToClientPacketTeamsPrefixTmp struct {
		}
		ret.Prefix = PlayToClientPacketTeamsPrefixTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketTeamsSuffix0Tmp string
		PlayToClientPacketTeamsSuffix0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Suffix = PlayToClientPacketTeamsSuffix0Tmp
	case 2:
		var PlayToClientPacketTeamsSuffix2Tmp string
		PlayToClientPacketTeamsSuffix2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Suffix = PlayToClientPacketTeamsSuffix2Tmp
	default:
		var PlayToClientPacketTeamsSuffixTmp struct {
		}
		ret.Suffix = PlayToClientPacketTeamsSuffixTmp
	}
	switch ret.Mode {
	case 0:
		var PlayToClientPacketTeamsPlayers0Tmp []string
		var lPlayToClientPacketTeamsPlayers0Tmp int32
		lPlayToClientPacketTeamsPlayers0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsPlayers0Tmp = []string{}
		for range lPlayToClientPacketTeamsPlayers0Tmp {
			var PlayToClientPacketTeamsPlayers0TmpElement string
			PlayToClientPacketTeamsPlayers0TmpElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketTeamsPlayers0Tmp = append(PlayToClientPacketTeamsPlayers0Tmp, PlayToClientPacketTeamsPlayers0TmpElement)
		}
		ret.Players = PlayToClientPacketTeamsPlayers0Tmp
	case 3:
		var PlayToClientPacketTeamsPlayers3Tmp []string
		var lPlayToClientPacketTeamsPlayers3Tmp int32
		lPlayToClientPacketTeamsPlayers3Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsPlayers3Tmp = []string{}
		for range lPlayToClientPacketTeamsPlayers3Tmp {
			var PlayToClientPacketTeamsPlayers3TmpElement string
			PlayToClientPacketTeamsPlayers3TmpElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketTeamsPlayers3Tmp = append(PlayToClientPacketTeamsPlayers3Tmp, PlayToClientPacketTeamsPlayers3TmpElement)
		}
		ret.Players = PlayToClientPacketTeamsPlayers3Tmp
	case 4:
		var PlayToClientPacketTeamsPlayers4Tmp []string
		var lPlayToClientPacketTeamsPlayers4Tmp int32
		lPlayToClientPacketTeamsPlayers4Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsPlayers4Tmp = []string{}
		for range lPlayToClientPacketTeamsPlayers4Tmp {
			var PlayToClientPacketTeamsPlayers4TmpElement string
			PlayToClientPacketTeamsPlayers4TmpElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketTeamsPlayers4Tmp = append(PlayToClientPacketTeamsPlayers4Tmp, PlayToClientPacketTeamsPlayers4TmpElement)
		}
		ret.Players = PlayToClientPacketTeamsPlayers4Tmp
	default:
		var PlayToClientPacketTeamsPlayersTmp struct {
		}
		ret.Players = PlayToClientPacketTeamsPlayersTmp
	}
	return
}
func (ret *PlayToClientPacketTeams) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Team)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Mode)
	if err != nil {
		return
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketTeamsName, ok := ret.Name.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsName)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketTeamsName, ok := ret.Name.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsName)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Name.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketTeamsFriendlyFire, ok := ret.FriendlyFire.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsFriendlyFire)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketTeamsFriendlyFire, ok := ret.FriendlyFire.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsFriendlyFire)
		if err != nil {
			return
		}
	default:
		_, ok := ret.FriendlyFire.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketTeamsNameTagVisibility, ok := ret.NameTagVisibility.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsNameTagVisibility)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketTeamsNameTagVisibility, ok := ret.NameTagVisibility.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsNameTagVisibility)
		if err != nil {
			return
		}
	default:
		_, ok := ret.NameTagVisibility.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketTeamsCollisionRule, ok := ret.CollisionRule.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsCollisionRule)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketTeamsCollisionRule, ok := ret.CollisionRule.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsCollisionRule)
		if err != nil {
			return
		}
	default:
		_, ok := ret.CollisionRule.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketTeamsFormatting, ok := ret.Formatting.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsFormatting)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketTeamsFormatting, ok := ret.Formatting.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsFormatting)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Formatting.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketTeamsPrefix, ok := ret.Prefix.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsPrefix)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketTeamsPrefix, ok := ret.Prefix.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsPrefix)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Prefix.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketTeamsSuffix, ok := ret.Suffix.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsSuffix)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketTeamsSuffix, ok := ret.Suffix.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTeamsSuffix)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Suffix.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case 0:
		PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
			if err != nil {
				return
			}
		}
	case 3:
		PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
			if err != nil {
				return
			}
		}
	case 4:
		PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
			if err != nil {
				return
			}
		}
	default:
		_, ok := ret.Players.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

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

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

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

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

type PlayToClientPacketTradeList struct {
	WindowId int32
	Trades   []struct {
		InputItem1         Slot
		OutputItem         Slot
		InputItem2         *Slot
		TradeDisabled      bool
		NbTradeUses        int32
		MaximumNbTradeUses int32
		Xp                 int32
		SpecialPrice       int32
		PriceMultiplier    float32
		Demand             int32
	}
	VillagerLevel     int32
	Experience        int32
	IsRegularVillager bool
	CanRestock        bool
}

func (ret *PlayToClientPacketTradeList) Decode(r io.ReadSeeker) (err error) {
	ret.WindowId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketTradeListTrades uint8
	err = binary.Read(r, binary.BigEndian, &lPlayToClientPacketTradeListTrades)
	if err != nil {
		return
	}
	ret.Trades = []struct {
		InputItem1         Slot
		OutputItem         Slot
		InputItem2         *Slot
		TradeDisabled      bool
		NbTradeUses        int32
		MaximumNbTradeUses int32
		Xp                 int32
		SpecialPrice       int32
		PriceMultiplier    float32
		Demand             int32
	}{}
	for range lPlayToClientPacketTradeListTrades {
		var PlayToClientPacketTradeListTradesElement struct {
			InputItem1         Slot
			OutputItem         Slot
			InputItem2         *Slot
			TradeDisabled      bool
			NbTradeUses        int32
			MaximumNbTradeUses int32
			Xp                 int32
			SpecialPrice       int32
			PriceMultiplier    float32
			Demand             int32
		}
		err = PlayToClientPacketTradeListTradesElement.InputItem1.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketTradeListTradesElement.OutputItem.Decode(r)
		if err != nil {
			return
		}
		var PlayToClientPacketTradeListTradesElementInputItem2Present bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElementInputItem2Present)
		if err != nil {
			return
		}
		if PlayToClientPacketTradeListTradesElementInputItem2Present {
			var PlayToClientPacketTradeListTradesElementInputItem2PresentValue Slot
			err = PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketTradeListTradesElement.InputItem2 = &PlayToClientPacketTradeListTradesElementInputItem2PresentValue
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.TradeDisabled)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.NbTradeUses)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.MaximumNbTradeUses)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Xp)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.SpecialPrice)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.PriceMultiplier)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Demand)
		if err != nil {
			return
		}
		ret.Trades = append(ret.Trades, PlayToClientPacketTradeListTradesElement)
	}
	ret.VillagerLevel, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Experience, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsRegularVillager)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CanRestock)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketTradeList) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.WindowId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, uint8(len(ret.Trades)))
	if err != nil {
		return
	}
	for iPlayToClientPacketTradeListTrades := range len(ret.Trades) {
		PlayToClientPacketTradeListTradesInnerInputItem1EncTmp := ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1
		err = PlayToClientPacketTradeListTradesInnerInputItem1EncTmp.Encode(w)
		if err != nil {
			return
		}
		PlayToClientPacketTradeListTradesInnerOutputItemEncTmp := ret.Trades[iPlayToClientPacketTradeListTrades].OutputItem
		err = PlayToClientPacketTradeListTradesInnerOutputItemEncTmp.Encode(w)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil)
		if err != nil {
			return
		}
		if ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil {
			PlayToClientPacketTradeListTradesInnerInputItem2EncTmp := *ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2
			err = PlayToClientPacketTradeListTradesInnerInputItem2EncTmp.Encode(w)
			if err != nil {
				return
			}
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].TradeDisabled)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].NbTradeUses)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].MaximumNbTradeUses)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Xp)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].SpecialPrice)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].PriceMultiplier)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Demand)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.VillagerLevel)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Experience)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsRegularVillager)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CanRestock)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketTransaction struct {
	WindowId int8
	Action   int16
	Accepted bool
}

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

type PlayToClientPacketUnloadChunk struct {
	ChunkX int32
	ChunkZ int32
}

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

type PlayToClientPacketUnlockRecipes struct {
	Action                int32
	CraftingBookOpen      bool
	FilteringCraftable    bool
	SmeltingBookOpen      bool
	FilteringSmeltable    bool
	BlastFurnaceOpen      bool
	FilteringBlastFurnace bool
	SmokerBookOpen        bool
	FilteringSmoker       bool
	Recipes1              []string
	Recipes2              any
}

func (ret *PlayToClientPacketUnlockRecipes) Decode(r io.ReadSeeker) (err error) {
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CraftingBookOpen)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FilteringCraftable)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SmeltingBookOpen)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FilteringSmeltable)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.BlastFurnaceOpen)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FilteringBlastFurnace)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SmokerBookOpen)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FilteringSmoker)
	if err != nil {
		return
	}
	var lPlayToClientPacketUnlockRecipesRecipes1 int32
	lPlayToClientPacketUnlockRecipesRecipes1, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Recipes1 = []string{}
	for range lPlayToClientPacketUnlockRecipesRecipes1 {
		var PlayToClientPacketUnlockRecipesRecipes1Element string
		PlayToClientPacketUnlockRecipesRecipes1Element, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Recipes1 = append(ret.Recipes1, PlayToClientPacketUnlockRecipesRecipes1Element)
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketUnlockRecipesRecipes20Tmp []string
		var lPlayToClientPacketUnlockRecipesRecipes20Tmp int32
		lPlayToClientPacketUnlockRecipesRecipes20Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketUnlockRecipesRecipes20Tmp = []string{}
		for range lPlayToClientPacketUnlockRecipesRecipes20Tmp {
			var PlayToClientPacketUnlockRecipesRecipes20TmpElement string
			PlayToClientPacketUnlockRecipesRecipes20TmpElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketUnlockRecipesRecipes20Tmp = append(PlayToClientPacketUnlockRecipesRecipes20Tmp, PlayToClientPacketUnlockRecipesRecipes20TmpElement)
		}
		ret.Recipes2 = PlayToClientPacketUnlockRecipesRecipes20Tmp
	default:
		var PlayToClientPacketUnlockRecipesRecipes2Tmp struct {
		}
		ret.Recipes2 = PlayToClientPacketUnlockRecipesRecipes2Tmp
	}
	return
}
func (ret *PlayToClientPacketUnlockRecipes) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CraftingBookOpen)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FilteringCraftable)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SmeltingBookOpen)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FilteringSmeltable)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.BlastFurnaceOpen)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FilteringBlastFurnace)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SmokerBookOpen)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FilteringSmoker)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes1)))
	if err != nil {
		return
	}
	for iPlayToClientPacketUnlockRecipesRecipes1 := range len(ret.Recipes1) {
		err = proto_base.EncodeString(w, ret.Recipes1[iPlayToClientPacketUnlockRecipesRecipes1])
		if err != nil {
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketUnlockRecipesRecipes2, ok := ret.Recipes2.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketUnlockRecipesRecipes2)))
		if err != nil {
			return
		}
		for iPlayToClientPacketUnlockRecipesRecipes2 := range len(PlayToClientPacketUnlockRecipesRecipes2) {
			err = proto_base.EncodeString(w, PlayToClientPacketUnlockRecipesRecipes2[iPlayToClientPacketUnlockRecipesRecipes2])
			if err != nil {
				return
			}
		}
	default:
		_, ok := ret.Recipes2.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketUpdateHealth struct {
	Health         float32
	Food           int32
	FoodSaturation float32
}

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

type PlayToClientPacketUpdateLight struct {
	ChunkX              int32
	ChunkZ              int32
	TrustEdges          bool
	SkyLightMask        int32
	BlockLightMask      int32
	EmptySkyLightMask   int32
	EmptyBlockLightMask int32
	Data                proto_base.RestBuffer
}

func (ret *PlayToClientPacketUpdateLight) Decode(r io.ReadSeeker) (err error) {
	ret.ChunkX, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ChunkZ, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.TrustEdges)
	if err != nil {
		return
	}
	ret.SkyLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.BlockLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EmptySkyLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EmptyBlockLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateLight) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ChunkX)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChunkZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.TrustEdges)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.SkyLightMask)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.BlockLightMask)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.EmptySkyLightMask)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.EmptyBlockLightMask)
	if err != nil {
		return
	}
	PlayToClientPacketUpdateLightDataEncTmp := ret.Data
	err = PlayToClientPacketUpdateLightDataEncTmp.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateTime struct {
	Age  int64
	Time int64
}

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

type PlayToClientPacketUpdateViewDistance struct {
	ViewDistance int32
}

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

type PlayToClientPacketUpdateViewPosition struct {
	ChunkX int32
	ChunkZ int32
}

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

type PlayToClientPacketVehicleMove struct {
	X     float64
	Y     float64
	Z     float64
	Yaw   float32
	Pitch float32
}

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

type PlayToClientPacketWindowItems struct {
	WindowId uint8
	Items    []Slot
}

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

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

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

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

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

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

func (ret *PlayToClientPacketWorldParticles) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.ParticleId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.LongDistance)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ParticleData)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Particles)
	if err != nil {
		return
	}
	switch ret.ParticleId {
	case 14:
		var PlayToClientPacketWorldParticlesData14Tmp struct {
			Red   float32
			Green float32
			Blue  float32
			Scale float32
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldParticlesData14Tmp.Red)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldParticlesData14Tmp.Green)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldParticlesData14Tmp.Blue)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketWorldParticlesData14Tmp.Scale)
		if err != nil {
			return
		}
		ret.Data = PlayToClientPacketWorldParticlesData14Tmp
	case 23:
		var PlayToClientPacketWorldParticlesData23Tmp struct {
			BlockState int32
		}
		PlayToClientPacketWorldParticlesData23Tmp.BlockState, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientPacketWorldParticlesData23Tmp
	case 3:
		var PlayToClientPacketWorldParticlesData3Tmp struct {
			BlockState int32
		}
		PlayToClientPacketWorldParticlesData3Tmp.BlockState, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientPacketWorldParticlesData3Tmp
	case 34:
		var PlayToClientPacketWorldParticlesData34Tmp struct {
			Item Slot
		}
		err = PlayToClientPacketWorldParticlesData34Tmp.Item.Decode(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientPacketWorldParticlesData34Tmp
	default:
		var PlayToClientPacketWorldParticlesDataTmp struct {
		}
		ret.Data = PlayToClientPacketWorldParticlesDataTmp
	}
	return
}
func (ret *PlayToClientPacketWorldParticles) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.ParticleId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.LongDistance)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ParticleData)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Particles)
	if err != nil {
		return
	}
	switch ret.ParticleId {
	case 14:
		PlayToClientPacketWorldParticlesData, ok := ret.Data.(struct {
			Red   float32
			Green float32
			Blue  float32
			Scale float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldParticlesData.Red)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldParticlesData.Green)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldParticlesData.Blue)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketWorldParticlesData.Scale)
		if err != nil {
			return
		}
	case 23:
		PlayToClientPacketWorldParticlesData, ok := ret.Data.(struct {
			BlockState int32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData.BlockState)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketWorldParticlesData, ok := ret.Data.(struct {
			BlockState int32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketWorldParticlesData.BlockState)
		if err != nil {
			return
		}
	case 34:
		PlayToClientPacketWorldParticlesData, ok := ret.Data.(struct {
			Item Slot
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToClientPacketWorldParticlesDataItemEncTmp := PlayToClientPacketWorldParticlesData.Item
		err = PlayToClientPacketWorldParticlesDataItemEncTmp.Encode(w)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Data.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToServerPacket struct {
	Name   string
	Params any
}

var PlayToServerPacketNameMap = map[int32]string{0x00: "teleport_confirm", 0x01: "query_block_nbt", 0x02: "set_difficulty", 0x03: "chat", 0x04: "client_command", 0x05: "settings", 0x06: "tab_complete", 0x07: "transaction", 0x08: "enchant_item", 0x09: "window_click", 0x0a: "close_window", 0x0b: "custom_payload", 0x0c: "edit_book", 0x0d: "query_entity_nbt", 0x0e: "use_entity", 0x0f: "generate_structure", 0x10: "keep_alive", 0x11: "lock_difficulty", 0x12: "position", 0x13: "position_look", 0x14: "look", 0x15: "flying", 0x16: "vehicle_move", 0x17: "steer_boat", 0x18: "pick_item", 0x19: "craft_recipe_request", 0x1a: "abilities", 0x1b: "block_dig", 0x1c: "entity_action", 0x1d: "steer_vehicle", 0x1e: "recipe_book", 0x1f: "displayed_recipe", 0x20: "name_item", 0x21: "resource_pack_receive", 0x22: "advancement_tab", 0x23: "select_trade", 0x24: "set_beacon_effect", 0x25: "held_item_slot", 0x26: "update_command_block", 0x27: "update_command_block_minecart", 0x28: "set_creative_slot", 0x29: "update_jigsaw_block", 0x2a: "update_structure_block", 0x2b: "update_sign", 0x2c: "arm_animation", 0x2d: "spectate", 0x2e: "block_place", 0x2f: "use_item"}

func (ret *PlayToServerPacket) Decode(r io.ReadSeeker) (err error) {
	var PlayToServerPacketNameKey int32
	PlayToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(PlayToServerPacketNameMap, PlayToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		var PlayToServerPacketParamsAbilitiesTmp PlayToServerPacketAbilities
		err = PlayToServerPacketParamsAbilitiesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsAbilitiesTmp
	case "advancement_tab":
		var PlayToServerPacketParamsAdvancementTabTmp PlayToServerPacketAdvancementTab
		err = PlayToServerPacketParamsAdvancementTabTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsAdvancementTabTmp
	case "arm_animation":
		var PlayToServerPacketParamsArmAnimationTmp PlayToServerPacketArmAnimation
		err = PlayToServerPacketParamsArmAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsArmAnimationTmp
	case "block_dig":
		var PlayToServerPacketParamsBlockDigTmp PlayToServerPacketBlockDig
		err = PlayToServerPacketParamsBlockDigTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsBlockDigTmp
	case "block_place":
		var PlayToServerPacketParamsBlockPlaceTmp PlayToServerPacketBlockPlace
		err = PlayToServerPacketParamsBlockPlaceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsBlockPlaceTmp
	case "chat":
		var PlayToServerPacketParamsChatTmp PlayToServerPacketChat
		err = PlayToServerPacketParamsChatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsChatTmp
	case "client_command":
		var PlayToServerPacketParamsClientCommandTmp PlayToServerPacketClientCommand
		err = PlayToServerPacketParamsClientCommandTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsClientCommandTmp
	case "close_window":
		var PlayToServerPacketParamsCloseWindowTmp PlayToServerPacketCloseWindow
		err = PlayToServerPacketParamsCloseWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCloseWindowTmp
	case "craft_recipe_request":
		var PlayToServerPacketParamsCraftRecipeRequestTmp PlayToServerPacketCraftRecipeRequest
		err = PlayToServerPacketParamsCraftRecipeRequestTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCraftRecipeRequestTmp
	case "custom_payload":
		var PlayToServerPacketParamsCustomPayloadTmp PlayToServerPacketCustomPayload
		err = PlayToServerPacketParamsCustomPayloadTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCustomPayloadTmp
	case "displayed_recipe":
		var PlayToServerPacketParamsDisplayedRecipeTmp PlayToServerPacketDisplayedRecipe
		err = PlayToServerPacketParamsDisplayedRecipeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsDisplayedRecipeTmp
	case "edit_book":
		var PlayToServerPacketParamsEditBookTmp PlayToServerPacketEditBook
		err = PlayToServerPacketParamsEditBookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsEditBookTmp
	case "enchant_item":
		var PlayToServerPacketParamsEnchantItemTmp PlayToServerPacketEnchantItem
		err = PlayToServerPacketParamsEnchantItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsEnchantItemTmp
	case "entity_action":
		var PlayToServerPacketParamsEntityActionTmp PlayToServerPacketEntityAction
		err = PlayToServerPacketParamsEntityActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsEntityActionTmp
	case "flying":
		var PlayToServerPacketParamsFlyingTmp PlayToServerPacketFlying
		err = PlayToServerPacketParamsFlyingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsFlyingTmp
	case "generate_structure":
		var PlayToServerPacketParamsGenerateStructureTmp PlayToServerPacketGenerateStructure
		err = PlayToServerPacketParamsGenerateStructureTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsGenerateStructureTmp
	case "held_item_slot":
		var PlayToServerPacketParamsHeldItemSlotTmp PlayToServerPacketHeldItemSlot
		err = PlayToServerPacketParamsHeldItemSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsHeldItemSlotTmp
	case "keep_alive":
		var PlayToServerPacketParamsKeepAliveTmp PlayToServerPacketKeepAlive
		err = PlayToServerPacketParamsKeepAliveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsKeepAliveTmp
	case "lock_difficulty":
		var PlayToServerPacketParamsLockDifficultyTmp PlayToServerPacketLockDifficulty
		err = PlayToServerPacketParamsLockDifficultyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsLockDifficultyTmp
	case "look":
		var PlayToServerPacketParamsLookTmp PlayToServerPacketLook
		err = PlayToServerPacketParamsLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsLookTmp
	case "name_item":
		var PlayToServerPacketParamsNameItemTmp PlayToServerPacketNameItem
		err = PlayToServerPacketParamsNameItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsNameItemTmp
	case "pick_item":
		var PlayToServerPacketParamsPickItemTmp PlayToServerPacketPickItem
		err = PlayToServerPacketParamsPickItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPickItemTmp
	case "position":
		var PlayToServerPacketParamsPositionTmp PlayToServerPacketPosition
		err = PlayToServerPacketParamsPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPositionTmp
	case "position_look":
		var PlayToServerPacketParamsPositionLookTmp PlayToServerPacketPositionLook
		err = PlayToServerPacketParamsPositionLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPositionLookTmp
	case "query_block_nbt":
		var PlayToServerPacketParamsQueryBlockNbtTmp PlayToServerPacketQueryBlockNbt
		err = PlayToServerPacketParamsQueryBlockNbtTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsQueryBlockNbtTmp
	case "query_entity_nbt":
		var PlayToServerPacketParamsQueryEntityNbtTmp PlayToServerPacketQueryEntityNbt
		err = PlayToServerPacketParamsQueryEntityNbtTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsQueryEntityNbtTmp
	case "recipe_book":
		var PlayToServerPacketParamsRecipeBookTmp PlayToServerPacketRecipeBook
		err = PlayToServerPacketParamsRecipeBookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsRecipeBookTmp
	case "resource_pack_receive":
		var PlayToServerPacketParamsResourcePackReceiveTmp PlayToServerPacketResourcePackReceive
		err = PlayToServerPacketParamsResourcePackReceiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsResourcePackReceiveTmp
	case "select_trade":
		var PlayToServerPacketParamsSelectTradeTmp PlayToServerPacketSelectTrade
		err = PlayToServerPacketParamsSelectTradeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSelectTradeTmp
	case "set_beacon_effect":
		var PlayToServerPacketParamsSetBeaconEffectTmp PlayToServerPacketSetBeaconEffect
		err = PlayToServerPacketParamsSetBeaconEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetBeaconEffectTmp
	case "set_creative_slot":
		var PlayToServerPacketParamsSetCreativeSlotTmp PlayToServerPacketSetCreativeSlot
		err = PlayToServerPacketParamsSetCreativeSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetCreativeSlotTmp
	case "set_difficulty":
		var PlayToServerPacketParamsSetDifficultyTmp PlayToServerPacketSetDifficulty
		err = PlayToServerPacketParamsSetDifficultyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetDifficultyTmp
	case "settings":
		var PlayToServerPacketParamsSettingsTmp PlayToServerPacketSettings
		err = PlayToServerPacketParamsSettingsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSettingsTmp
	case "spectate":
		var PlayToServerPacketParamsSpectateTmp PlayToServerPacketSpectate
		err = PlayToServerPacketParamsSpectateTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSpectateTmp
	case "steer_boat":
		var PlayToServerPacketParamsSteerBoatTmp PlayToServerPacketSteerBoat
		err = PlayToServerPacketParamsSteerBoatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSteerBoatTmp
	case "steer_vehicle":
		var PlayToServerPacketParamsSteerVehicleTmp PlayToServerPacketSteerVehicle
		err = PlayToServerPacketParamsSteerVehicleTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSteerVehicleTmp
	case "tab_complete":
		var PlayToServerPacketParamsTabCompleteTmp PlayToServerPacketTabComplete
		err = PlayToServerPacketParamsTabCompleteTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTabCompleteTmp
	case "teleport_confirm":
		var PlayToServerPacketParamsTeleportConfirmTmp PlayToServerPacketTeleportConfirm
		err = PlayToServerPacketParamsTeleportConfirmTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTeleportConfirmTmp
	case "transaction":
		var PlayToServerPacketParamsTransactionTmp PlayToServerPacketTransaction
		err = PlayToServerPacketParamsTransactionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTransactionTmp
	case "update_command_block":
		var PlayToServerPacketParamsUpdateCommandBlockTmp PlayToServerPacketUpdateCommandBlock
		err = PlayToServerPacketParamsUpdateCommandBlockTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateCommandBlockTmp
	case "update_command_block_minecart":
		var PlayToServerPacketParamsUpdateCommandBlockMinecartTmp PlayToServerPacketUpdateCommandBlockMinecart
		err = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp
	case "update_jigsaw_block":
		var PlayToServerPacketParamsUpdateJigsawBlockTmp PlayToServerPacketUpdateJigsawBlock
		err = PlayToServerPacketParamsUpdateJigsawBlockTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateJigsawBlockTmp
	case "update_sign":
		var PlayToServerPacketParamsUpdateSignTmp PlayToServerPacketUpdateSign
		err = PlayToServerPacketParamsUpdateSignTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateSignTmp
	case "update_structure_block":
		var PlayToServerPacketParamsUpdateStructureBlockTmp PlayToServerPacketUpdateStructureBlock
		err = PlayToServerPacketParamsUpdateStructureBlockTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateStructureBlockTmp
	case "use_entity":
		var PlayToServerPacketParamsUseEntityTmp PlayToServerPacketUseEntity
		err = PlayToServerPacketParamsUseEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUseEntityTmp
	case "use_item":
		var PlayToServerPacketParamsUseItemTmp PlayToServerPacketUseItem
		err = PlayToServerPacketParamsUseItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUseItemTmp
	case "vehicle_move":
		var PlayToServerPacketParamsVehicleMoveTmp PlayToServerPacketVehicleMove
		err = PlayToServerPacketParamsVehicleMoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsVehicleMoveTmp
	case "window_click":
		var PlayToServerPacketParamsWindowClickTmp PlayToServerPacketWindowClick
		err = PlayToServerPacketParamsWindowClickTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsWindowClickTmp
	}
	return
}

var PlayToServerPacketNameReverseMap = map[string]int32{"teleport_confirm": 0x00, "query_block_nbt": 0x01, "set_difficulty": 0x02, "chat": 0x03, "client_command": 0x04, "settings": 0x05, "tab_complete": 0x06, "transaction": 0x07, "enchant_item": 0x08, "window_click": 0x09, "close_window": 0x0a, "custom_payload": 0x0b, "edit_book": 0x0c, "query_entity_nbt": 0x0d, "use_entity": 0x0e, "generate_structure": 0x0f, "keep_alive": 0x10, "lock_difficulty": 0x11, "position": 0x12, "position_look": 0x13, "look": 0x14, "flying": 0x15, "vehicle_move": 0x16, "steer_boat": 0x17, "pick_item": 0x18, "craft_recipe_request": 0x19, "abilities": 0x1a, "block_dig": 0x1b, "entity_action": 0x1c, "steer_vehicle": 0x1d, "recipe_book": 0x1e, "displayed_recipe": 0x1f, "name_item": 0x20, "resource_pack_receive": 0x21, "advancement_tab": 0x22, "select_trade": 0x23, "set_beacon_effect": 0x24, "held_item_slot": 0x25, "update_command_block": 0x26, "update_command_block_minecart": 0x27, "set_creative_slot": 0x28, "update_jigsaw_block": 0x29, "update_structure_block": 0x2a, "update_sign": 0x2b, "arm_animation": 0x2c, "spectate": 0x2d, "block_place": 0x2e, "use_item": 0x2f}

func (ret *PlayToServerPacket) Encode(w io.Writer) (err error) {
	var vPlayToServerPacketName int32
	vPlayToServerPacketName, err = proto_base.ErroringIndex(PlayToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAbilities)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "advancement_tab":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAdvancementTab)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "arm_animation":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketArmAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_dig":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockDig)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "block_place":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockPlace)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "chat":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "client_command":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketClientCommand)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "close_window":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCloseWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "craft_recipe_request":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftRecipeRequest)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "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 "displayed_recipe":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDisplayedRecipe)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "edit_book":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEditBook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "enchant_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEnchantItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "entity_action":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEntityAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "flying":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketFlying)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "generate_structure":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketGenerateStructure)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "held_item_slot":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketHeldItemSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "keep_alive":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketKeepAlive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "lock_difficulty":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLockDifficulty)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "look":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "name_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketNameItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "pick_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "position":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "position_look":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPositionLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "query_block_nbt":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryBlockNbt)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "query_entity_nbt":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryEntityNbt)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "recipe_book":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketRecipeBook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "resource_pack_receive":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketResourcePackReceive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "select_trade":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectTrade)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_beacon_effect":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetBeaconEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_creative_slot":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetCreativeSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "set_difficulty":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetDifficulty)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "settings":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSettings)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "spectate":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSpectate)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "steer_boat":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerBoat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "steer_vehicle":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerVehicle)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "tab_complete":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTabComplete)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "teleport_confirm":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTeleportConfirm)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "transaction":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTransaction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_command_block":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlock)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_command_block_minecart":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlockMinecart)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_jigsaw_block":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateJigsawBlock)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_sign":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateSign)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "update_structure_block":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateStructureBlock)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "use_entity":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "use_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "vehicle_move":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketVehicleMove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	case "window_click":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketWindowClick)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
		err = PlayToServerPacketParamsEncTmp.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketAbilities struct {
	Flags int8
}

func (ret *PlayToServerPacketAbilities) Decode(r io.ReadSeeker) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	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
	}
	return
}

type PlayToServerPacketAdvancementTab struct {
	Action int32
	TabId  any
}

func (ret *PlayToServerPacketAdvancementTab) Decode(r io.ReadSeeker) (err error) {
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		var PlayToServerPacketAdvancementTabTabId0Tmp string
		PlayToServerPacketAdvancementTabTabId0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.TabId = PlayToServerPacketAdvancementTabTabId0Tmp
	case 1:
		var PlayToServerPacketAdvancementTabTabId1Tmp struct {
		}
		ret.TabId = PlayToServerPacketAdvancementTabTabId1Tmp
	}
	return
}
func (ret *PlayToServerPacketAdvancementTab) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		PlayToServerPacketAdvancementTabTabId, ok := ret.TabId.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToServerPacketAdvancementTabTabId)
		if err != nil {
			return
		}
	case 1:
		_, ok := ret.TabId.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToServerPacketArmAnimation struct {
	Hand int32
}

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

type PlayToServerPacketBlockDig struct {
	Status   int32
	Location Position
	Face     int8
}

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

type PlayToServerPacketBlockPlace struct {
	Hand        int32
	Location    Position
	Direction   int32
	CursorX     float32
	CursorY     float32
	CursorZ     float32
	InsideBlock bool
}

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

type PlayToServerPacketChat struct {
	Message string
}

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

type PlayToServerPacketClientCommand struct {
	ActionId int32
}

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

type PlayToServerPacketCloseWindow struct {
	WindowId uint8
}

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

type PlayToServerPacketCraftRecipeRequest struct {
	WindowId int8
	Recipe   string
	MakeAll  bool
}

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

type 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 PlayToServerPacketDisplayedRecipe struct {
	RecipeId string
}

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

type PlayToServerPacketEditBook struct {
	NewBook Slot
	Signing bool
	Hand    int32
}

func (ret *PlayToServerPacketEditBook) Decode(r io.ReadSeeker) (err error) {
	err = ret.NewBook.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Signing)
	if err != nil {
		return
	}
	ret.Hand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketEditBook) Encode(w io.Writer) (err error) {
	PlayToServerPacketEditBookNewBookEncTmp := ret.NewBook
	err = PlayToServerPacketEditBookNewBookEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Signing)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Hand)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketEnchantItem struct {
	WindowId    int8
	Enchantment int8
}

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

type PlayToServerPacketEntityAction struct {
	EntityId  int32
	ActionId  int32
	JumpBoost int32
}

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

type PlayToServerPacketFlying struct {
	OnGround bool
}

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

type PlayToServerPacketGenerateStructure struct {
	Location    Position
	Levels      int32
	KeepJigsaws bool
}

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

type PlayToServerPacketHeldItemSlot struct {
	SlotId int16
}

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

type PlayToServerPacketKeepAlive struct {
	KeepAliveId int64
}

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

type PlayToServerPacketLockDifficulty struct {
	Locked bool
}

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

type PlayToServerPacketLook struct {
	Yaw      float32
	Pitch    float32
	OnGround bool
}

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

type PlayToServerPacketNameItem struct {
	Name string
}

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

type PlayToServerPacketPickItem struct {
	Slot int32
}

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

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

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

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

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

type PlayToServerPacketQueryBlockNbt struct {
	TransactionId int32
	Location      Position
}

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

type PlayToServerPacketQueryEntityNbt struct {
	TransactionId int32
	EntityId      int32
}

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

type PlayToServerPacketRecipeBook struct {
	BookId       int32
	BookOpen     bool
	FilterActive bool
}

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

type PlayToServerPacketResourcePackReceive struct {
	Result int32
}

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

type PlayToServerPacketSelectTrade struct {
	Slot int32
}

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

type PlayToServerPacketSetBeaconEffect struct {
	PrimaryEffect   int32
	SecondaryEffect int32
}

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

type PlayToServerPacketSetCreativeSlot struct {
	Slot int16
	Item Slot
}

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

type PlayToServerPacketSetDifficulty struct {
	NewDifficulty uint8
}

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

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

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

type PlayToServerPacketSpectate struct {
	Target uuid.UUID
}

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

type PlayToServerPacketSteerBoat struct {
	LeftPaddle  bool
	RightPaddle bool
}

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

type PlayToServerPacketSteerVehicle struct {
	Sideways float32
	Forward  float32
	Jump     uint8
}

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

type PlayToServerPacketTabComplete struct {
	TransactionId int32
	Text          string
}

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

type PlayToServerPacketTeleportConfirm struct {
	TeleportId int32
}

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

type PlayToServerPacketTransaction struct {
	WindowId int8
	Action   int16
	Accepted bool
}

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

type PlayToServerPacketUpdateCommandBlock struct {
	Location Position
	Command  string
	Mode     int32
	Flags    uint8
}

func (ret *PlayToServerPacketUpdateCommandBlock) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Command, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Mode, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUpdateCommandBlock) Encode(w io.Writer) (err error) {
	PlayToServerPacketUpdateCommandBlockLocationEncTmp := ret.Location
	err = PlayToServerPacketUpdateCommandBlockLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Command)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUpdateCommandBlockMinecart struct {
	EntityId    int32
	Command     string
	TrackOutput bool
}

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

type PlayToServerPacketUpdateJigsawBlock struct {
	Location   Position
	Name       string
	Target     string
	Pool       string
	FinalState string
	JointType  string
}

func (ret *PlayToServerPacketUpdateJigsawBlock) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Target, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Pool, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.FinalState, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.JointType, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUpdateJigsawBlock) Encode(w io.Writer) (err error) {
	PlayToServerPacketUpdateJigsawBlockLocationEncTmp := ret.Location
	err = PlayToServerPacketUpdateJigsawBlockLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Target)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Pool)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.FinalState)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.JointType)
	if err != nil {
		return
	}
	return
}

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

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

type PlayToServerPacketUpdateStructureBlock struct {
	Location  Position
	Action    int32
	Mode      int32
	Name      string
	OffsetX   int8
	OffsetY   int8
	OffsetZ   int8
	SizeX     int8
	SizeY     int8
	SizeZ     int8
	Mirror    int32
	Rotation  int32
	Metadata  string
	Integrity float32
	Seed      int64
	Flags     uint8
}

func (ret *PlayToServerPacketUpdateStructureBlock) Decode(r io.ReadSeeker) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Mode, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SizeX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SizeY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SizeZ)
	if err != nil {
		return
	}
	ret.Mirror, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Rotation, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Metadata, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Integrity)
	if err != nil {
		return
	}
	ret.Seed, err = proto_base.DecodeVarLong(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUpdateStructureBlock) Encode(w io.Writer) (err error) {
	PlayToServerPacketUpdateStructureBlockLocationEncTmp := ret.Location
	err = PlayToServerPacketUpdateStructureBlockLocationEncTmp.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mode)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SizeX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SizeY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SizeZ)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mirror)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Rotation)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Metadata)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Integrity)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarLong(w, ret.Seed)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	return
}

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

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

type PlayToServerPacketUseItem struct {
	Hand int32
}

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

type PlayToServerPacketVehicleMove struct {
	X     float64
	Y     float64
	Z     float64
	Yaw   float32
	Pitch float32
}

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

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

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

type StatusToClientPacket struct {
	Name   string
	Params any
}

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

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

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

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

type StatusToClientPacketPing struct {
	Time int64
}

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

type StatusToClientPacketServerInfo struct {
	Response string
}

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

type StatusToServerPacket struct {
	Name   string
	Params any
}

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

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

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

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

type StatusToServerPacketPing struct {
	Time int64
}

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

type StatusToServerPacketPingStart struct {
}

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