// Code generated by strom. DO NOT EDIT. // source: minecraft-data/pc/1.21.9/protocol.json (sha256:de50c20cccb0093133fff3e243efe1fa9ffe2bfb9c67dd2f5c2a747c6935f9d6) // version: v0.6.6-0.20260805202908-e58499ed0924+dirty (go1.26.2) package v1_21_9 import ( "encoding/binary" "io" "git.anygate.cloud/anygatecloud/strom/mc/proto_base" "git.anygate.cloud/anygatecloud/strom/mc/nbt" "github.com/google/uuid" ) type ArmorTrimMaterial struct { AssetBase string OverrideArmorAssets []struct { Key string Value string } Description nbt.Anon } func (ret *ArmorTrimMaterial) Decode(r io.ReadSeeker) (err error) { ret.AssetBase, err = proto_base.DecodeString(r) if err != nil { return } var lArmorTrimMaterialOverrideArmorAssets int32 lArmorTrimMaterialOverrideArmorAssets, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.OverrideArmorAssets = []struct { Key string Value string }{} for range lArmorTrimMaterialOverrideArmorAssets { var ArmorTrimMaterialOverrideArmorAssetsElement struct { Key string Value string } ArmorTrimMaterialOverrideArmorAssetsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } ArmorTrimMaterialOverrideArmorAssetsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.OverrideArmorAssets = append(ret.OverrideArmorAssets, ArmorTrimMaterialOverrideArmorAssetsElement) } err = ret.Description.Decode(r) if err != nil { return } return } func (ret *ArmorTrimMaterial) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.AssetBase) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.OverrideArmorAssets))) if err != nil { return } for iArmorTrimMaterialOverrideArmorAssets := range len(ret.OverrideArmorAssets) { err = proto_base.EncodeString(w, ret.OverrideArmorAssets[iArmorTrimMaterialOverrideArmorAssets].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.OverrideArmorAssets[iArmorTrimMaterialOverrideArmorAssets].Value) if err != nil { return } } ArmorTrimMaterialDescriptionEncTmp := ret.Description err = ArmorTrimMaterialDescriptionEncTmp.Encode(w) if err != nil { return } return } type ArmorTrimPattern struct { AssetId string Description nbt.Anon Decal bool } func (ret *ArmorTrimPattern) Decode(r io.ReadSeeker) (err error) { ret.AssetId, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Description.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Decal) if err != nil { return } return } func (ret *ArmorTrimPattern) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.AssetId) if err != nil { return } ArmorTrimPatternDescriptionEncTmp := ret.Description err = ArmorTrimPatternDescriptionEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Decal) if err != nil { return } return } type BannerPattern struct { AssetId string TranslationKey string } func (ret *BannerPattern) Decode(r io.ReadSeeker) (err error) { ret.AssetId, err = proto_base.DecodeString(r) if err != nil { return } ret.TranslationKey, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *BannerPattern) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.AssetId) if err != nil { return } err = proto_base.EncodeString(w, ret.TranslationKey) if err != nil { return } return } type BannerPatternLayer struct { Pattern any ColorId int32 } func (ret *BannerPatternLayer) Decode(r io.ReadSeeker) (err error) { var BannerPatternLayerPatternId int32 BannerPatternLayerPatternId, err = proto_base.DecodeVarInt(r) if err != nil { return } if BannerPatternLayerPatternId != 0 { ret.Pattern = BannerPatternLayerPatternId } else { var BannerPatternLayerPatternResult BannerPattern err = BannerPatternLayerPatternResult.Decode(r) if err != nil { return } ret.Pattern = BannerPatternLayerPatternResult } ret.ColorId, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *BannerPatternLayer) Encode(w io.Writer) (err error) { switch BannerPatternLayerPatternKnownType := ret.Pattern.(type) { case int32: err = proto_base.EncodeVarInt(w, BannerPatternLayerPatternKnownType) if err != nil { return } case BannerPattern: err = proto_base.EncodeVarInt(w, 0) if err != nil { return } BannerPatternLayerPatternOtherwiseEncTmp := BannerPatternLayerPatternKnownType err = BannerPatternLayerPatternOtherwiseEncTmp.Encode(w) if err != nil { return } default: err = proto_base.BadTypeError } err = proto_base.EncodeVarInt(w, ret.ColorId) if err != nil { return } return } 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 ContainerID struct { Val int32 } func (ret *ContainerID) Decode(r io.ReadSeeker) (err error) { ret.Val, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *ContainerID) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Val) if err != nil { return } return } type DataComponentMatchers struct { ExactMatchers ExactComponentMatcher PartialMatchers []int32 } func (ret *DataComponentMatchers) Decode(r io.ReadSeeker) (err error) { err = ret.ExactMatchers.Decode(r) if err != nil { return } var lDataComponentMatchersPartialMatchers int32 lDataComponentMatchersPartialMatchers, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.PartialMatchers = []int32{} for range lDataComponentMatchersPartialMatchers { var DataComponentMatchersPartialMatchersElement int32 DataComponentMatchersPartialMatchersElement, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.PartialMatchers = append(ret.PartialMatchers, DataComponentMatchersPartialMatchersElement) } return } func (ret *DataComponentMatchers) Encode(w io.Writer) (err error) { DataComponentMatchersExactMatchersEncTmp := ret.ExactMatchers err = DataComponentMatchersExactMatchersEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.PartialMatchers))) if err != nil { return } for iDataComponentMatchersPartialMatchers := range len(ret.PartialMatchers) { err = proto_base.EncodeVarInt(w, ret.PartialMatchers[iDataComponentMatchersPartialMatchers]) if err != nil { return } } return } type DebugStructureInfo struct { BoundingBoxMin Position BoundingBoxMax Position Pieces []struct { BoundingBoxMin Position BoundingBoxMax Position IsStart bool } } func (ret *DebugStructureInfo) Decode(r io.ReadSeeker) (err error) { err = ret.BoundingBoxMin.Decode(r) if err != nil { return } err = ret.BoundingBoxMax.Decode(r) if err != nil { return } var lDebugStructureInfoPieces int32 lDebugStructureInfoPieces, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Pieces = []struct { BoundingBoxMin Position BoundingBoxMax Position IsStart bool }{} for range lDebugStructureInfoPieces { var DebugStructureInfoPiecesElement struct { BoundingBoxMin Position BoundingBoxMax Position IsStart bool } err = DebugStructureInfoPiecesElement.BoundingBoxMin.Decode(r) if err != nil { return } err = DebugStructureInfoPiecesElement.BoundingBoxMax.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &DebugStructureInfoPiecesElement.IsStart) if err != nil { return } ret.Pieces = append(ret.Pieces, DebugStructureInfoPiecesElement) } return } func (ret *DebugStructureInfo) Encode(w io.Writer) (err error) { DebugStructureInfoBoundingBoxMinEncTmp := ret.BoundingBoxMin err = DebugStructureInfoBoundingBoxMinEncTmp.Encode(w) if err != nil { return } DebugStructureInfoBoundingBoxMaxEncTmp := ret.BoundingBoxMax err = DebugStructureInfoBoundingBoxMaxEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Pieces))) if err != nil { return } for iDebugStructureInfoPieces := range len(ret.Pieces) { DebugStructureInfoPiecesInnerBoundingBoxMinEncTmp := ret.Pieces[iDebugStructureInfoPieces].BoundingBoxMin err = DebugStructureInfoPiecesInnerBoundingBoxMinEncTmp.Encode(w) if err != nil { return } DebugStructureInfoPiecesInnerBoundingBoxMaxEncTmp := ret.Pieces[iDebugStructureInfoPieces].BoundingBoxMax err = DebugStructureInfoPiecesInnerBoundingBoxMaxEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Pieces[iDebugStructureInfoPieces].IsStart) if err != nil { return } } return } type DebugSubscriptionDataType struct { Val string } var DebugSubscriptionDataTypeMap = map[int32]string{0: "DedicatedServerTickTime", 1: "Bees", 10: "VillageSections", 11: "Raids", 12: "Structures", 13: "GameEventListeners", 14: "NeighborUpdates", 15: "GameEvents", 2: "Brains", 3: "Breezes", 4: "GoalSelectors", 5: "EntityPaths", 6: "EntityBlockIntersections", 7: "BeeHives", 8: "Pois", 9: "RedstoneWireOrientations"} func (ret *DebugSubscriptionDataType) Decode(r io.ReadSeeker) (err error) { var DebugSubscriptionDataTypeKey int32 DebugSubscriptionDataTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Val, err = proto_base.ErroringIndex(DebugSubscriptionDataTypeMap, DebugSubscriptionDataTypeKey) if err != nil { return } return } var DebugSubscriptionDataTypeReverseMap = map[string]int32{"DedicatedServerTickTime": 0, "Bees": 1, "VillageSections": 10, "Raids": 11, "Structures": 12, "GameEventListeners": 13, "NeighborUpdates": 14, "GameEvents": 15, "Brains": 2, "Breezes": 3, "GoalSelectors": 4, "EntityPaths": 5, "EntityBlockIntersections": 6, "BeeHives": 7, "Pois": 8, "RedstoneWireOrientations": 9} func (ret *DebugSubscriptionDataType) Encode(w io.Writer) (err error) { var vDebugSubscriptionDataType int32 vDebugSubscriptionDataType, err = proto_base.ErroringIndex(DebugSubscriptionDataTypeReverseMap, ret.Val) if err != nil { return } err = proto_base.EncodeVarInt(w, vDebugSubscriptionDataType) if err != nil { return } return } type DebugSubscriptionEvent struct { Type DebugSubscriptionDataType Value any } func (ret *DebugSubscriptionEvent) Decode(r io.ReadSeeker) (err error) { err = proto_base.ToDoError return } func (ret *DebugSubscriptionEvent) Encode(w io.Writer) (err error) { err = proto_base.ToDoError return } type DebugSubscriptionUpdate struct { Type DebugSubscriptionDataType Anon any } func (ret *DebugSubscriptionUpdate) Decode(r io.ReadSeeker) (err error) { err = proto_base.ToDoError return } func (ret *DebugSubscriptionUpdate) Encode(w io.Writer) (err error) { err = proto_base.ToDoError return } type EntityMetadataPaintingVariant struct { Width int32 Height int32 AssetId string Title *nbt.Anon Author *nbt.Anon } func (ret *EntityMetadataPaintingVariant) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Width) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Height) if err != nil { return } ret.AssetId, err = proto_base.DecodeString(r) if err != nil { return } var EntityMetadataPaintingVariantTitlePresent bool err = binary.Read(r, binary.BigEndian, &EntityMetadataPaintingVariantTitlePresent) if err != nil { return } if EntityMetadataPaintingVariantTitlePresent { var EntityMetadataPaintingVariantTitlePresentValue nbt.Anon err = EntityMetadataPaintingVariantTitlePresentValue.Decode(r) if err != nil { return } ret.Title = &EntityMetadataPaintingVariantTitlePresentValue } var EntityMetadataPaintingVariantAuthorPresent bool err = binary.Read(r, binary.BigEndian, &EntityMetadataPaintingVariantAuthorPresent) if err != nil { return } if EntityMetadataPaintingVariantAuthorPresent { var EntityMetadataPaintingVariantAuthorPresentValue nbt.Anon err = EntityMetadataPaintingVariantAuthorPresentValue.Decode(r) if err != nil { return } ret.Author = &EntityMetadataPaintingVariantAuthorPresentValue } return } func (ret *EntityMetadataPaintingVariant) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Width) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Height) if err != nil { return } err = proto_base.EncodeString(w, ret.AssetId) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Title != nil) if err != nil { return } if ret.Title != nil { EntityMetadataPaintingVariantTitleEncTmp := *ret.Title err = EntityMetadataPaintingVariantTitleEncTmp.Encode(w) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.Author != nil) if err != nil { return } if ret.Author != nil { EntityMetadataPaintingVariantAuthorEncTmp := *ret.Author err = EntityMetadataPaintingVariantAuthorEncTmp.Encode(w) if err != nil { return } } return } type ExactComponentMatcher struct { Val []SlotComponent } func (ret *ExactComponentMatcher) Decode(r io.ReadSeeker) (err error) { var lExactComponentMatcher int32 lExactComponentMatcher, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Val = []SlotComponent{} for range lExactComponentMatcher { var ExactComponentMatcherElement SlotComponent err = ExactComponentMatcherElement.Decode(r) if err != nil { return } ret.Val = append(ret.Val, ExactComponentMatcherElement) } return } func (ret *ExactComponentMatcher) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Val))) if err != nil { return } for iExactComponentMatcher := range len(ret.Val) { ExactComponentMatcherInnerEncTmp := ret.Val[iExactComponentMatcher] err = ExactComponentMatcherInnerEncTmp.Encode(w) if err != nil { return } } return } type GameProfile struct { Uuid uuid.UUID Name string Properties []GameProfileProperty } func (ret *GameProfile) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Name, err = proto_base.DecodeString(r) if err != nil { return } var lGameProfileProperties int32 lGameProfileProperties, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Properties = []GameProfileProperty{} for range lGameProfileProperties { var GameProfilePropertiesElement GameProfileProperty err = GameProfilePropertiesElement.Decode(r) if err != nil { return } ret.Properties = append(ret.Properties, GameProfilePropertiesElement) } return } func (ret *GameProfile) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Name) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Properties))) if err != nil { return } for iGameProfileProperties := range len(ret.Properties) { GameProfilePropertiesInnerEncTmp := ret.Properties[iGameProfileProperties] err = GameProfilePropertiesInnerEncTmp.Encode(w) if err != nil { return } } return } type GameProfileProperty struct { Name string Value string Signature *string } func (ret *GameProfileProperty) Decode(r io.ReadSeeker) (err error) { ret.Name, err = proto_base.DecodeString(r) if err != nil { return } ret.Value, err = proto_base.DecodeString(r) if err != nil { return } var GameProfilePropertySignaturePresent bool err = binary.Read(r, binary.BigEndian, &GameProfilePropertySignaturePresent) if err != nil { return } if GameProfilePropertySignaturePresent { var GameProfilePropertySignaturePresentValue string GameProfilePropertySignaturePresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Signature = &GameProfilePropertySignaturePresentValue } return } func (ret *GameProfileProperty) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Name) if err != nil { return } err = proto_base.EncodeString(w, ret.Value) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Signature != nil) if err != nil { return } if ret.Signature != nil { err = proto_base.EncodeString(w, *ret.Signature) if err != nil { return } } return } type GlobalPos struct { DimensionName string Location Position } func (ret *GlobalPos) Decode(r io.ReadSeeker) (err error) { ret.DimensionName, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Location.Decode(r) if err != nil { return } return } func (ret *GlobalPos) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.DimensionName) if err != nil { return } GlobalPosLocationEncTmp := ret.Location err = GlobalPosLocationEncTmp.Encode(w) if err != nil { return } return } type HashedSlot struct { ItemId int32 ItemCount int32 Components []struct { Type SlotComponentType Hash int32 } RemoveComponents []struct { Type SlotComponentType } } func (ret *HashedSlot) Decode(r io.ReadSeeker) (err error) { ret.ItemId, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ItemCount, err = proto_base.DecodeVarInt(r) if err != nil { return } var lHashedSlotComponents int32 lHashedSlotComponents, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Components = []struct { Type SlotComponentType Hash int32 }{} for range lHashedSlotComponents { var HashedSlotComponentsElement struct { Type SlotComponentType Hash int32 } err = HashedSlotComponentsElement.Type.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &HashedSlotComponentsElement.Hash) if err != nil { return } ret.Components = append(ret.Components, HashedSlotComponentsElement) } var lHashedSlotRemoveComponents int32 lHashedSlotRemoveComponents, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.RemoveComponents = []struct { Type SlotComponentType }{} for range lHashedSlotRemoveComponents { var HashedSlotRemoveComponentsElement struct { Type SlotComponentType } err = HashedSlotRemoveComponentsElement.Type.Decode(r) if err != nil { return } ret.RemoveComponents = append(ret.RemoveComponents, HashedSlotRemoveComponentsElement) } return } func (ret *HashedSlot) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.ItemId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.ItemCount) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Components))) if err != nil { return } for iHashedSlotComponents := range len(ret.Components) { HashedSlotComponentsInnerTypeEncTmp := ret.Components[iHashedSlotComponents].Type err = HashedSlotComponentsInnerTypeEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Components[iHashedSlotComponents].Hash) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.RemoveComponents))) if err != nil { return } for iHashedSlotRemoveComponents := range len(ret.RemoveComponents) { HashedSlotRemoveComponentsInnerTypeEncTmp := ret.RemoveComponents[iHashedSlotRemoveComponents].Type err = HashedSlotRemoveComponentsInnerTypeEncTmp.Encode(w) if err != nil { return } } return } type IDSet struct { Val any } func (ret *IDSet) Decode(r io.ReadSeeker) (err error) { var IDSetId int32 IDSetId, err = proto_base.DecodeVarInt(r) if err != nil { return } if IDSetId != 0 { ret.Val = IDSetId } else { var IDSetResult string IDSetResult, err = proto_base.DecodeString(r) if err != nil { return } ret.Val = IDSetResult } return } func (ret *IDSet) Encode(w io.Writer) (err error) { switch IDSetKnownType := ret.Val.(type) { case string: err = proto_base.EncodeVarInt(w, 0) if err != nil { return } err = proto_base.EncodeString(w, IDSetKnownType) if err != nil { return } case int32: err = proto_base.EncodeVarInt(w, IDSetKnownType) if err != nil { return } default: err = proto_base.BadTypeError } return } type InstrumentData struct { SoundEvent ItemSoundHolder UseDuration float32 Range float32 Description nbt.Anon } func (ret *InstrumentData) Decode(r io.ReadSeeker) (err error) { err = ret.SoundEvent.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.UseDuration) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Range) if err != nil { return } err = ret.Description.Decode(r) if err != nil { return } return } func (ret *InstrumentData) Encode(w io.Writer) (err error) { InstrumentDataSoundEventEncTmp := ret.SoundEvent err = InstrumentDataSoundEventEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.UseDuration) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Range) if err != nil { return } InstrumentDataDescriptionEncTmp := ret.Description err = InstrumentDataDescriptionEncTmp.Encode(w) if err != nil { return } return } type ItemBlockPredicate struct { BlockSet *any Properties *[]ItemBlockProperty Nbt nbt.Anon Components DataComponentMatchers } func (ret *ItemBlockPredicate) Decode(r io.ReadSeeker) (err error) { var ItemBlockPredicateBlockSetPresent bool err = binary.Read(r, binary.BigEndian, &ItemBlockPredicateBlockSetPresent) if err != nil { return } if ItemBlockPredicateBlockSetPresent { var ItemBlockPredicateBlockSetPresentValue any var ItemBlockPredicateBlockSetId int32 ItemBlockPredicateBlockSetId, err = proto_base.DecodeVarInt(r) if err != nil { return } if ItemBlockPredicateBlockSetId != 0 { ItemBlockPredicateBlockSetPresentValue = ItemBlockPredicateBlockSetId } else { var ItemBlockPredicateBlockSetResult string ItemBlockPredicateBlockSetResult, err = proto_base.DecodeString(r) if err != nil { return } ItemBlockPredicateBlockSetPresentValue = ItemBlockPredicateBlockSetResult } ret.BlockSet = &ItemBlockPredicateBlockSetPresentValue } var ItemBlockPredicatePropertiesPresent bool err = binary.Read(r, binary.BigEndian, &ItemBlockPredicatePropertiesPresent) if err != nil { return } if ItemBlockPredicatePropertiesPresent { var ItemBlockPredicatePropertiesPresentValue []ItemBlockProperty var lItemBlockPredicateProperties int32 lItemBlockPredicateProperties, err = proto_base.DecodeVarInt(r) if err != nil { return } ItemBlockPredicatePropertiesPresentValue = []ItemBlockProperty{} for range lItemBlockPredicateProperties { var ItemBlockPredicatePropertiesElement ItemBlockProperty err = ItemBlockPredicatePropertiesElement.Decode(r) if err != nil { return } ItemBlockPredicatePropertiesPresentValue = append(ItemBlockPredicatePropertiesPresentValue, ItemBlockPredicatePropertiesElement) } ret.Properties = &ItemBlockPredicatePropertiesPresentValue } err = ret.Nbt.Decode(r) if err != nil { return } err = ret.Components.Decode(r) if err != nil { return } return } func (ret *ItemBlockPredicate) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.BlockSet != nil) if err != nil { return } if ret.BlockSet != nil { switch ItemBlockPredicateBlockSetKnownType := (*ret.BlockSet).(type) { case string: err = proto_base.EncodeVarInt(w, 0) if err != nil { return } err = proto_base.EncodeString(w, ItemBlockPredicateBlockSetKnownType) if err != nil { return } case int32: err = proto_base.EncodeVarInt(w, ItemBlockPredicateBlockSetKnownType) if err != nil { return } default: err = proto_base.BadTypeError } } err = binary.Write(w, binary.BigEndian, ret.Properties != nil) if err != nil { return } if ret.Properties != nil { err = proto_base.EncodeVarInt(w, int32(len(*ret.Properties))) if err != nil { return } for iItemBlockPredicateProperties := range len(*ret.Properties) { ItemBlockPredicatePropertiesInnerEncTmp := (*ret.Properties)[iItemBlockPredicateProperties] err = ItemBlockPredicatePropertiesInnerEncTmp.Encode(w) if err != nil { return } } } ItemBlockPredicateNbtEncTmp := ret.Nbt err = ItemBlockPredicateNbtEncTmp.Encode(w) if err != nil { return } ItemBlockPredicateComponentsEncTmp := ret.Components err = ItemBlockPredicateComponentsEncTmp.Encode(w) if err != nil { return } return } type ItemBlockProperty struct { Name string IsExactMatch bool Value any } func (ret *ItemBlockProperty) Decode(r io.ReadSeeker) (err error) { ret.Name, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.IsExactMatch) if err != nil { return } switch ret.IsExactMatch { case false: var ItemBlockPropertyValueFalseTmp struct { MinValue string MaxValue string } ItemBlockPropertyValueFalseTmp.MinValue, err = proto_base.DecodeString(r) if err != nil { return } ItemBlockPropertyValueFalseTmp.MaxValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Value = ItemBlockPropertyValueFalseTmp case true: var ItemBlockPropertyValueTrueTmp struct { ExactValue string } ItemBlockPropertyValueTrueTmp.ExactValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Value = ItemBlockPropertyValueTrueTmp } return } func (ret *ItemBlockProperty) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Name) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.IsExactMatch) if err != nil { return } switch ret.IsExactMatch { case false: ItemBlockPropertyValue, ok := ret.Value.(struct { MinValue string MaxValue string }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, ItemBlockPropertyValue.MinValue) if err != nil { return } err = proto_base.EncodeString(w, ItemBlockPropertyValue.MaxValue) if err != nil { return } case true: ItemBlockPropertyValue, ok := ret.Value.(struct { ExactValue string }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, ItemBlockPropertyValue.ExactValue) if err != nil { return } } return } type ItemBookPage struct { Content string FilteredContent *string } func (ret *ItemBookPage) Decode(r io.ReadSeeker) (err error) { ret.Content, err = proto_base.DecodeString(r) if err != nil { return } var ItemBookPageFilteredContentPresent bool err = binary.Read(r, binary.BigEndian, &ItemBookPageFilteredContentPresent) if err != nil { return } if ItemBookPageFilteredContentPresent { var ItemBookPageFilteredContentPresentValue string ItemBookPageFilteredContentPresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.FilteredContent = &ItemBookPageFilteredContentPresentValue } return } func (ret *ItemBookPage) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Content) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.FilteredContent != nil) if err != nil { return } if ret.FilteredContent != nil { err = proto_base.EncodeString(w, *ret.FilteredContent) if err != nil { return } } return } type ItemConsumeEffect struct { Type string Anon any } var ItemConsumeEffectTypeMap = map[int32]string{0: "apply_effects", 1: "remove_effects", 2: "clear_all_effects", 3: "teleport_randomly", 4: "play_sound"} func (ret *ItemConsumeEffect) Decode(r io.ReadSeeker) (err error) { var ItemConsumeEffectTypeKey int32 ItemConsumeEffectTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Type, err = proto_base.ErroringIndex(ItemConsumeEffectTypeMap, ItemConsumeEffectTypeKey) if err != nil { return } switch ret.Type { case "apply_effects": var ItemConsumeEffectAnonApplyEffectsTmp struct { Effects []ItemPotionEffect Probability float32 } var lItemConsumeEffectAnonApplyEffectsTmpEffects int32 lItemConsumeEffectAnonApplyEffectsTmpEffects, err = proto_base.DecodeVarInt(r) if err != nil { return } ItemConsumeEffectAnonApplyEffectsTmp.Effects = []ItemPotionEffect{} for range lItemConsumeEffectAnonApplyEffectsTmpEffects { var ItemConsumeEffectAnonApplyEffectsTmpEffectsElement ItemPotionEffect err = ItemConsumeEffectAnonApplyEffectsTmpEffectsElement.Decode(r) if err != nil { return } ItemConsumeEffectAnonApplyEffectsTmp.Effects = append(ItemConsumeEffectAnonApplyEffectsTmp.Effects, ItemConsumeEffectAnonApplyEffectsTmpEffectsElement) } err = binary.Read(r, binary.BigEndian, &ItemConsumeEffectAnonApplyEffectsTmp.Probability) if err != nil { return } ret.Anon = ItemConsumeEffectAnonApplyEffectsTmp case "clear_all_effects": var ItemConsumeEffectAnonClearAllEffectsTmp struct { } ret.Anon = ItemConsumeEffectAnonClearAllEffectsTmp case "play_sound": var ItemConsumeEffectAnonPlaySoundTmp struct { Sound ItemSoundHolder } err = ItemConsumeEffectAnonPlaySoundTmp.Sound.Decode(r) if err != nil { return } ret.Anon = ItemConsumeEffectAnonPlaySoundTmp case "remove_effects": var ItemConsumeEffectAnonRemoveEffectsTmp struct { Effects IDSet } err = ItemConsumeEffectAnonRemoveEffectsTmp.Effects.Decode(r) if err != nil { return } ret.Anon = ItemConsumeEffectAnonRemoveEffectsTmp case "teleport_randomly": var ItemConsumeEffectAnonTeleportRandomlyTmp struct { Diameter float32 } err = binary.Read(r, binary.BigEndian, &ItemConsumeEffectAnonTeleportRandomlyTmp.Diameter) if err != nil { return } ret.Anon = ItemConsumeEffectAnonTeleportRandomlyTmp } return } var ItemConsumeEffectTypeReverseMap = map[string]int32{"apply_effects": 0, "remove_effects": 1, "clear_all_effects": 2, "teleport_randomly": 3, "play_sound": 4} func (ret *ItemConsumeEffect) Encode(w io.Writer) (err error) { var vItemConsumeEffectType int32 vItemConsumeEffectType, err = proto_base.ErroringIndex(ItemConsumeEffectTypeReverseMap, ret.Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vItemConsumeEffectType) if err != nil { return } switch ret.Type { case "apply_effects": ItemConsumeEffectAnon, ok := ret.Anon.(struct { Effects []ItemPotionEffect Probability float32 }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, int32(len(ItemConsumeEffectAnon.Effects))) if err != nil { return } for iItemConsumeEffectAnonEffects := range len(ItemConsumeEffectAnon.Effects) { ItemConsumeEffectAnonEffectsInnerEncTmp := ItemConsumeEffectAnon.Effects[iItemConsumeEffectAnonEffects] err = ItemConsumeEffectAnonEffectsInnerEncTmp.Encode(w) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ItemConsumeEffectAnon.Probability) if err != nil { return } case "clear_all_effects": _, ok := ret.Anon.(struct { }) if !ok { err = proto_base.BadTypeError return } case "play_sound": ItemConsumeEffectAnon, ok := ret.Anon.(struct { Sound ItemSoundHolder }) if !ok { err = proto_base.BadTypeError return } ItemConsumeEffectAnonSoundEncTmp := ItemConsumeEffectAnon.Sound err = ItemConsumeEffectAnonSoundEncTmp.Encode(w) if err != nil { return } case "remove_effects": ItemConsumeEffectAnon, ok := ret.Anon.(struct { Effects IDSet }) if !ok { err = proto_base.BadTypeError return } ItemConsumeEffectAnonEffectsEncTmp := ItemConsumeEffectAnon.Effects err = ItemConsumeEffectAnonEffectsEncTmp.Encode(w) if err != nil { return } case "teleport_randomly": ItemConsumeEffectAnon, ok := ret.Anon.(struct { Diameter float32 }) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ItemConsumeEffectAnon.Diameter) if err != nil { return } } return } type ItemEffectDetail struct { Amplifier int32 Duration int32 Ambient bool ShowParticles bool ShowIcon bool HiddenEffect *ItemEffectDetail } func (ret *ItemEffectDetail) Decode(r io.ReadSeeker) (err error) { ret.Amplifier, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Duration, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Ambient) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.ShowParticles) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.ShowIcon) if err != nil { return } var ItemEffectDetailHiddenEffectPresent bool err = binary.Read(r, binary.BigEndian, &ItemEffectDetailHiddenEffectPresent) if err != nil { return } if ItemEffectDetailHiddenEffectPresent { var ItemEffectDetailHiddenEffectPresentValue ItemEffectDetail err = ItemEffectDetailHiddenEffectPresentValue.Decode(r) if err != nil { return } ret.HiddenEffect = &ItemEffectDetailHiddenEffectPresentValue } return } func (ret *ItemEffectDetail) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Amplifier) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Duration) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Ambient) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.ShowParticles) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.ShowIcon) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.HiddenEffect != nil) if err != nil { return } if ret.HiddenEffect != nil { ItemEffectDetailHiddenEffectEncTmp := *ret.HiddenEffect err = ItemEffectDetailHiddenEffectEncTmp.Encode(w) if err != nil { return } } return } type ItemFireworkExplosion struct { Shape string Colors []int32 FadeColors []int32 HasTrail bool HasTwinkle bool } var ItemFireworkExplosionShapeMap = map[int32]string{0: "small_ball", 1: "large_ball", 2: "star", 3: "creeper", 4: "burst"} func (ret *ItemFireworkExplosion) Decode(r io.ReadSeeker) (err error) { var ItemFireworkExplosionShapeKey int32 ItemFireworkExplosionShapeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Shape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeMap, ItemFireworkExplosionShapeKey) if err != nil { return } var lItemFireworkExplosionColors int32 lItemFireworkExplosionColors, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Colors = []int32{} for range lItemFireworkExplosionColors { var ItemFireworkExplosionColorsElement int32 err = binary.Read(r, binary.BigEndian, &ItemFireworkExplosionColorsElement) if err != nil { return } ret.Colors = append(ret.Colors, ItemFireworkExplosionColorsElement) } var lItemFireworkExplosionFadeColors int32 lItemFireworkExplosionFadeColors, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.FadeColors = []int32{} for range lItemFireworkExplosionFadeColors { var ItemFireworkExplosionFadeColorsElement int32 err = binary.Read(r, binary.BigEndian, &ItemFireworkExplosionFadeColorsElement) if err != nil { return } ret.FadeColors = append(ret.FadeColors, ItemFireworkExplosionFadeColorsElement) } err = binary.Read(r, binary.BigEndian, &ret.HasTrail) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.HasTwinkle) if err != nil { return } return } var ItemFireworkExplosionShapeReverseMap = map[string]int32{"small_ball": 0, "large_ball": 1, "star": 2, "creeper": 3, "burst": 4} func (ret *ItemFireworkExplosion) Encode(w io.Writer) (err error) { var vItemFireworkExplosionShape int32 vItemFireworkExplosionShape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeReverseMap, ret.Shape) if err != nil { return } err = proto_base.EncodeVarInt(w, vItemFireworkExplosionShape) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Colors))) if err != nil { return } for iItemFireworkExplosionColors := range len(ret.Colors) { err = binary.Write(w, binary.BigEndian, ret.Colors[iItemFireworkExplosionColors]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.FadeColors))) if err != nil { return } for iItemFireworkExplosionFadeColors := range len(ret.FadeColors) { err = binary.Write(w, binary.BigEndian, ret.FadeColors[iItemFireworkExplosionFadeColors]) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.HasTrail) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.HasTwinkle) if err != nil { return } return } type ItemPotionEffect struct { Id int32 Details ItemEffectDetail } func (ret *ItemPotionEffect) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeVarInt(r) if err != nil { return } err = ret.Details.Decode(r) if err != nil { return } return } func (ret *ItemPotionEffect) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Id) if err != nil { return } ItemPotionEffectDetailsEncTmp := ret.Details err = ItemPotionEffectDetailsEncTmp.Encode(w) if err != nil { return } return } type ItemSoundEvent struct { SoundName string FixedRange *float32 } func (ret *ItemSoundEvent) Decode(r io.ReadSeeker) (err error) { ret.SoundName, err = proto_base.DecodeString(r) if err != nil { return } var ItemSoundEventFixedRangePresent bool err = binary.Read(r, binary.BigEndian, &ItemSoundEventFixedRangePresent) if err != nil { return } if ItemSoundEventFixedRangePresent { var ItemSoundEventFixedRangePresentValue float32 err = binary.Read(r, binary.BigEndian, &ItemSoundEventFixedRangePresentValue) if err != nil { return } ret.FixedRange = &ItemSoundEventFixedRangePresentValue } return } func (ret *ItemSoundEvent) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.SoundName) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.FixedRange != nil) if err != nil { return } if ret.FixedRange != nil { err = binary.Write(w, binary.BigEndian, *ret.FixedRange) if err != nil { return } } return } type ItemSoundHolder struct { Val any } func (ret *ItemSoundHolder) Decode(r io.ReadSeeker) (err error) { var ItemSoundHolderId int32 ItemSoundHolderId, err = proto_base.DecodeVarInt(r) if err != nil { return } if ItemSoundHolderId != 0 { ret.Val = ItemSoundHolderId } else { var ItemSoundHolderResult ItemSoundEvent err = ItemSoundHolderResult.Decode(r) if err != nil { return } ret.Val = ItemSoundHolderResult } return } func (ret *ItemSoundHolder) Encode(w io.Writer) (err error) { switch ItemSoundHolderKnownType := ret.Val.(type) { case int32: err = proto_base.EncodeVarInt(w, ItemSoundHolderKnownType) if err != nil { return } case ItemSoundEvent: err = proto_base.EncodeVarInt(w, 0) if err != nil { return } ItemSoundHolderOtherwiseEncTmp := ItemSoundHolderKnownType err = ItemSoundHolderOtherwiseEncTmp.Encode(w) if err != nil { return } default: err = proto_base.BadTypeError } return } type ItemWrittenBookPage struct { Content nbt.Anon FilteredContent nbt.Anon } func (ret *ItemWrittenBookPage) Decode(r io.ReadSeeker) (err error) { err = ret.Content.Decode(r) if err != nil { return } err = ret.FilteredContent.Decode(r) if err != nil { return } return } func (ret *ItemWrittenBookPage) Encode(w io.Writer) (err error) { ItemWrittenBookPageContentEncTmp := ret.Content err = ItemWrittenBookPageContentEncTmp.Encode(w) if err != nil { return } ItemWrittenBookPageFilteredContentEncTmp := ret.FilteredContent err = ItemWrittenBookPageFilteredContentEncTmp.Encode(w) if err != nil { return } return } type JukeboxSongData struct { SoundEvent ItemSoundHolder Description nbt.Anon LengthInSeconds float32 ComparatorOutput int32 } func (ret *JukeboxSongData) Decode(r io.ReadSeeker) (err error) { err = ret.SoundEvent.Decode(r) if err != nil { return } err = ret.Description.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.LengthInSeconds) if err != nil { return } ret.ComparatorOutput, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *JukeboxSongData) Encode(w io.Writer) (err error) { JukeboxSongDataSoundEventEncTmp := ret.SoundEvent err = JukeboxSongDataSoundEventEncTmp.Encode(w) if err != nil { return } JukeboxSongDataDescriptionEncTmp := ret.Description err = JukeboxSongDataDescriptionEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.LengthInSeconds) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.ComparatorOutput) if err != nil { return } return } type Node struct { Position Vec3i32 WalkedDistance float32 CostMalus float32 Closed bool Type string F float32 } var NodeTypeMap = map[int32]string{0: "blocked", 1: "open", 10: "water_border", 11: "rail", 12: "unpassable_rail", 13: "danger_fire", 14: "damage_fire", 15: "danger_other", 16: "damage_other", 17: "door_open", 18: "door_wood_closed", 19: "door_iron_closed", 2: "walkable", 20: "breach", 21: "leaves", 22: "sticky_honey", 23: "cocoa", 24: "damage_cautious", 25: "danger_trapdoor", 3: "walkable_door", 4: "trapdoor", 5: "powder_snow", 6: "danger_powder_snow", 7: "fence", 8: "lava", 9: "water"} func (ret *Node) Decode(r io.ReadSeeker) (err error) { err = ret.Position.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.WalkedDistance) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.CostMalus) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Closed) if err != nil { return } var NodeTypeKey int32 NodeTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Type, err = proto_base.ErroringIndex(NodeTypeMap, NodeTypeKey) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.F) if err != nil { return } return } var NodeTypeReverseMap = map[string]int32{"blocked": 0, "open": 1, "water_border": 10, "rail": 11, "unpassable_rail": 12, "danger_fire": 13, "damage_fire": 14, "danger_other": 15, "damage_other": 16, "door_open": 17, "door_wood_closed": 18, "door_iron_closed": 19, "walkable": 2, "breach": 20, "leaves": 21, "sticky_honey": 22, "cocoa": 23, "damage_cautious": 24, "danger_trapdoor": 25, "walkable_door": 3, "trapdoor": 4, "powder_snow": 5, "danger_powder_snow": 6, "fence": 7, "lava": 8, "water": 9} func (ret *Node) Encode(w io.Writer) (err error) { NodePositionEncTmp := ret.Position err = NodePositionEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.WalkedDistance) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.CostMalus) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Closed) if err != nil { return } var vNodeType int32 vNodeType, err = proto_base.ErroringIndex(NodeTypeReverseMap, ret.Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vNodeType) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.F) if err != nil { return } return } type PartialResolvableProfile struct { Name *string Uuid *uuid.UUID Properties []GameProfileProperty } func (ret *PartialResolvableProfile) Decode(r io.ReadSeeker) (err error) { var PartialResolvableProfileNamePresent bool err = binary.Read(r, binary.BigEndian, &PartialResolvableProfileNamePresent) if err != nil { return } if PartialResolvableProfileNamePresent { var PartialResolvableProfileNamePresentValue string PartialResolvableProfileNamePresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Name = &PartialResolvableProfileNamePresentValue } var PartialResolvableProfileUuidPresent bool err = binary.Read(r, binary.BigEndian, &PartialResolvableProfileUuidPresent) if err != nil { return } if PartialResolvableProfileUuidPresent { var PartialResolvableProfileUuidPresentValue uuid.UUID _, err = io.ReadFull(r, PartialResolvableProfileUuidPresentValue[:]) if err != nil { return } ret.Uuid = &PartialResolvableProfileUuidPresentValue } var lPartialResolvableProfileProperties int32 lPartialResolvableProfileProperties, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Properties = []GameProfileProperty{} for range lPartialResolvableProfileProperties { var PartialResolvableProfilePropertiesElement GameProfileProperty err = PartialResolvableProfilePropertiesElement.Decode(r) if err != nil { return } ret.Properties = append(ret.Properties, PartialResolvableProfilePropertiesElement) } return } func (ret *PartialResolvableProfile) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Name != nil) if err != nil { return } if ret.Name != nil { err = proto_base.EncodeString(w, *ret.Name) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.Properties))) if err != nil { return } for iPartialResolvableProfileProperties := range len(ret.Properties) { PartialResolvableProfilePropertiesInnerEncTmp := ret.Properties[iPartialResolvableProfileProperties] err = PartialResolvableProfilePropertiesInnerEncTmp.Encode(w) if err != nil { return } } return } type Particle struct { Type string Data any } var ParticleTypeMap = map[int32]string{0: "angry_villager", 1: "block", 10: "falling_lava", 100: "wax_off", 101: "electric_spark", 102: "scrape", 103: "shriek", 104: "egg_crack", 105: "dust_plume", 106: "trial_spawner_detected_player", 107: "trial_spawner_detected_player_ominous", 108: "vault_connection", 109: "dust_pillar", 11: "landing_lava", 110: "ominous_spawning", 111: "raid_omen", 112: "trial_omen", 113: "block_crumble", 114: "firefly", 12: "dripping_water", 13: "falling_water", 14: "dust", 15: "dust_color_transition", 16: "effect", 17: "elder_guardian", 18: "enchanted_hit", 19: "enchant", 2: "block_marker", 20: "end_rod", 21: "entity_effect", 22: "explosion_emitter", 23: "explosion", 24: "gust", 25: "small_gust", 26: "gust_emitter_large", 27: "gust_emitter_small", 28: "sonic_boom", 29: "falling_dust", 3: "bubble", 30: "firework", 31: "fishing", 32: "flame", 33: "infested", 34: "cherry_leaves", 35: "pale_oak_leaves", 36: "tinted_leaves", 37: "sculk_soul", 38: "sculk_charge", 39: "sculk_charge_pop", 4: "cloud", 40: "soul_fire_flame", 41: "soul", 42: "flash", 43: "happy_villager", 44: "composter", 45: "heart", 46: "instant_effect", 47: "item", 48: "vibration", 49: "trail", 5: "copper_fire_flame", 50: "item_slime", 51: "item_cobweb", 52: "item_snowball", 53: "large_smoke", 54: "lava", 55: "mycelium", 56: "note", 57: "poof", 58: "portal", 59: "rain", 6: "crit", 60: "smoke", 61: "white_smoke", 62: "sneeze", 63: "spit", 64: "squid_ink", 65: "sweep_attack", 66: "totem_of_undying", 67: "underwater", 68: "splash", 69: "witch", 7: "damage_indicator", 70: "bubble_pop", 71: "current_down", 72: "bubble_column_up", 73: "nautilus", 74: "dolphin", 75: "campfire_cosy_smoke", 76: "campfire_signal_smoke", 77: "dripping_honey", 78: "falling_honey", 79: "landing_honey", 8: "dragon_breath", 80: "falling_nectar", 81: "falling_spore_blossom", 82: "ash", 83: "crimson_spore", 84: "warped_spore", 85: "spore_blossom_air", 86: "dripping_obsidian_tear", 87: "falling_obsidian_tear", 88: "landing_obsidian_tear", 89: "reverse_portal", 9: "dripping_lava", 90: "white_ash", 91: "small_flame", 92: "snowflake", 93: "dripping_dripstone_lava", 94: "falling_dripstone_lava", 95: "dripping_dripstone_water", 96: "falling_dripstone_water", 97: "glow_squid_ink", 98: "glow", 99: "wax_on"} var ParticleDataVibrationTmpPositionTypeMap = map[int32]string{0: "block", 1: "entity"} func (ret *Particle) Decode(r io.ReadSeeker) (err error) { var ParticleTypeKey int32 ParticleTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Type, err = proto_base.ErroringIndex(ParticleTypeMap, ParticleTypeKey) if err != nil { return } switch ret.Type { case "block": var ParticleDataBlockTmp int32 ParticleDataBlockTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = ParticleDataBlockTmp case "block_crumble": var ParticleDataBlockCrumbleTmp int32 ParticleDataBlockCrumbleTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = ParticleDataBlockCrumbleTmp case "block_marker": var ParticleDataBlockMarkerTmp int32 ParticleDataBlockMarkerTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = ParticleDataBlockMarkerTmp case "dragon_breath": var ParticleDataDragonBreathTmp struct { Power float32 } err = binary.Read(r, binary.BigEndian, &ParticleDataDragonBreathTmp.Power) if err != nil { return } ret.Data = ParticleDataDragonBreathTmp case "dust": var ParticleDataDustTmp struct { Red float32 Green float32 Blue float32 Scale float32 } err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Red) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Green) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Blue) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Scale) if err != nil { return } ret.Data = ParticleDataDustTmp case "dust_color_transition": var ParticleDataDustColorTransitionTmp struct { FromRed float32 FromGreen float32 FromBlue float32 Scale float32 ToRed float32 ToGreen float32 ToBlue float32 } err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromRed) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromGreen) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromBlue) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.Scale) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToRed) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToGreen) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToBlue) if err != nil { return } ret.Data = ParticleDataDustColorTransitionTmp case "dust_pillar": var ParticleDataDustPillarTmp int32 ParticleDataDustPillarTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = ParticleDataDustPillarTmp case "effect": var ParticleDataEffectTmp struct { Color int32 Power float32 } err = binary.Read(r, binary.BigEndian, &ParticleDataEffectTmp.Color) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataEffectTmp.Power) if err != nil { return } ret.Data = ParticleDataEffectTmp case "entity_effect": var ParticleDataEntityEffectTmp int32 err = binary.Read(r, binary.BigEndian, &ParticleDataEntityEffectTmp) if err != nil { return } ret.Data = ParticleDataEntityEffectTmp case "falling_dust": var ParticleDataFallingDustTmp int32 ParticleDataFallingDustTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = ParticleDataFallingDustTmp case "firefly": var ParticleDataFireflyTmp struct { } ret.Data = ParticleDataFireflyTmp case "flash": var ParticleDataFlashTmp int32 err = binary.Read(r, binary.BigEndian, &ParticleDataFlashTmp) if err != nil { return } ret.Data = ParticleDataFlashTmp case "instant_effect": var ParticleDataInstantEffectTmp struct { Color int32 Power float32 } err = binary.Read(r, binary.BigEndian, &ParticleDataInstantEffectTmp.Color) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataInstantEffectTmp.Power) if err != nil { return } ret.Data = ParticleDataInstantEffectTmp case "item": var ParticleDataItemTmp Slot err = ParticleDataItemTmp.Decode(r) if err != nil { return } ret.Data = ParticleDataItemTmp case "sculk_charge": var ParticleDataSculkChargeTmp float32 err = binary.Read(r, binary.BigEndian, &ParticleDataSculkChargeTmp) if err != nil { return } ret.Data = ParticleDataSculkChargeTmp case "shriek": var ParticleDataShriekTmp int32 ParticleDataShriekTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = ParticleDataShriekTmp case "tinted_leaves": var ParticleDataTintedLeavesTmp int32 err = binary.Read(r, binary.BigEndian, &ParticleDataTintedLeavesTmp) if err != nil { return } ret.Data = ParticleDataTintedLeavesTmp case "trail": var ParticleDataTrailTmp struct { Target Vec3f64 Color uint8 } err = ParticleDataTrailTmp.Target.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataTrailTmp.Color) if err != nil { return } ret.Data = ParticleDataTrailTmp case "vibration": var ParticleDataVibrationTmp struct { PositionType string Position any Ticks int32 } var ParticleDataVibrationTmpPositionTypeKey int32 ParticleDataVibrationTmpPositionTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ParticleDataVibrationTmp.PositionType, err = proto_base.ErroringIndex(ParticleDataVibrationTmpPositionTypeMap, ParticleDataVibrationTmpPositionTypeKey) if err != nil { return } switch ParticleDataVibrationTmp.PositionType { case "block": var ParticleDataVibrationTmpPositionBlockTmp Position err = ParticleDataVibrationTmpPositionBlockTmp.Decode(r) if err != nil { return } ParticleDataVibrationTmp.Position = ParticleDataVibrationTmpPositionBlockTmp case "entity": var ParticleDataVibrationTmpPositionEntityTmp struct { EntityId int32 EntityEyeHeight float32 } ParticleDataVibrationTmpPositionEntityTmp.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ParticleDataVibrationTmpPositionEntityTmp.EntityEyeHeight) if err != nil { return } ParticleDataVibrationTmp.Position = ParticleDataVibrationTmpPositionEntityTmp } ParticleDataVibrationTmp.Ticks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = ParticleDataVibrationTmp } return } var ParticleTypeReverseMap = map[string]int32{"angry_villager": 0, "block": 1, "falling_lava": 10, "wax_off": 100, "electric_spark": 101, "scrape": 102, "shriek": 103, "egg_crack": 104, "dust_plume": 105, "trial_spawner_detected_player": 106, "trial_spawner_detected_player_ominous": 107, "vault_connection": 108, "dust_pillar": 109, "landing_lava": 11, "ominous_spawning": 110, "raid_omen": 111, "trial_omen": 112, "block_crumble": 113, "firefly": 114, "dripping_water": 12, "falling_water": 13, "dust": 14, "dust_color_transition": 15, "effect": 16, "elder_guardian": 17, "enchanted_hit": 18, "enchant": 19, "block_marker": 2, "end_rod": 20, "entity_effect": 21, "explosion_emitter": 22, "explosion": 23, "gust": 24, "small_gust": 25, "gust_emitter_large": 26, "gust_emitter_small": 27, "sonic_boom": 28, "falling_dust": 29, "bubble": 3, "firework": 30, "fishing": 31, "flame": 32, "infested": 33, "cherry_leaves": 34, "pale_oak_leaves": 35, "tinted_leaves": 36, "sculk_soul": 37, "sculk_charge": 38, "sculk_charge_pop": 39, "cloud": 4, "soul_fire_flame": 40, "soul": 41, "flash": 42, "happy_villager": 43, "composter": 44, "heart": 45, "instant_effect": 46, "item": 47, "vibration": 48, "trail": 49, "copper_fire_flame": 5, "item_slime": 50, "item_cobweb": 51, "item_snowball": 52, "large_smoke": 53, "lava": 54, "mycelium": 55, "note": 56, "poof": 57, "portal": 58, "rain": 59, "crit": 6, "smoke": 60, "white_smoke": 61, "sneeze": 62, "spit": 63, "squid_ink": 64, "sweep_attack": 65, "totem_of_undying": 66, "underwater": 67, "splash": 68, "witch": 69, "damage_indicator": 7, "bubble_pop": 70, "current_down": 71, "bubble_column_up": 72, "nautilus": 73, "dolphin": 74, "campfire_cosy_smoke": 75, "campfire_signal_smoke": 76, "dripping_honey": 77, "falling_honey": 78, "landing_honey": 79, "dragon_breath": 8, "falling_nectar": 80, "falling_spore_blossom": 81, "ash": 82, "crimson_spore": 83, "warped_spore": 84, "spore_blossom_air": 85, "dripping_obsidian_tear": 86, "falling_obsidian_tear": 87, "landing_obsidian_tear": 88, "reverse_portal": 89, "dripping_lava": 9, "white_ash": 90, "small_flame": 91, "snowflake": 92, "dripping_dripstone_lava": 93, "falling_dripstone_lava": 94, "dripping_dripstone_water": 95, "falling_dripstone_water": 96, "glow_squid_ink": 97, "glow": 98, "wax_on": 99} var ParticleDataPositionTypeReverseMap = map[string]int32{"block": 0, "entity": 1} func (ret *Particle) Encode(w io.Writer) (err error) { var vParticleType int32 vParticleType, err = proto_base.ErroringIndex(ParticleTypeReverseMap, ret.Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vParticleType) if err != nil { return } switch ret.Type { case "block": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ParticleData) if err != nil { return } case "block_crumble": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ParticleData) if err != nil { return } case "block_marker": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ParticleData) if err != nil { return } case "dragon_breath": ParticleData, ok := ret.Data.(struct { Power float32 }) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ParticleData.Power) if err != nil { return } case "dust": 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 "dust_color_transition": ParticleData, ok := ret.Data.(struct { FromRed float32 FromGreen float32 FromBlue float32 Scale float32 ToRed float32 ToGreen float32 ToBlue float32 }) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ParticleData.FromRed) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.FromGreen) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.FromBlue) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.Scale) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.ToRed) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.ToGreen) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.ToBlue) if err != nil { return } case "dust_pillar": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ParticleData) if err != nil { return } case "effect": ParticleData, ok := ret.Data.(struct { Color int32 Power float32 }) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ParticleData.Color) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.Power) if err != nil { return } case "entity_effect": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ParticleData) if err != nil { return } case "falling_dust": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ParticleData) if err != nil { return } case "firefly": _, ok := ret.Data.(struct { }) if !ok { err = proto_base.BadTypeError return } case "flash": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ParticleData) if err != nil { return } case "instant_effect": ParticleData, ok := ret.Data.(struct { Color int32 Power float32 }) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ParticleData.Color) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.Power) if err != nil { return } case "item": ParticleData, ok := ret.Data.(Slot) if !ok { err = proto_base.BadTypeError return } ParticleDataEncTmp := ParticleData err = ParticleDataEncTmp.Encode(w) if err != nil { return } case "sculk_charge": ParticleData, ok := ret.Data.(float32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ParticleData) if err != nil { return } case "shriek": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ParticleData) if err != nil { return } case "tinted_leaves": ParticleData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ParticleData) if err != nil { return } case "trail": ParticleData, ok := ret.Data.(struct { Target Vec3f64 Color uint8 }) if !ok { err = proto_base.BadTypeError return } ParticleDataTargetEncTmp := ParticleData.Target err = ParticleDataTargetEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleData.Color) if err != nil { return } case "vibration": ParticleData, ok := ret.Data.(struct { PositionType string Position any Ticks int32 }) if !ok { err = proto_base.BadTypeError return } var vParticleDataPositionType int32 vParticleDataPositionType, err = proto_base.ErroringIndex(ParticleDataPositionTypeReverseMap, ParticleData.PositionType) if err != nil { return } err = proto_base.EncodeVarInt(w, vParticleDataPositionType) if err != nil { return } switch ParticleData.PositionType { case "block": ParticleDataPosition, ok := ParticleData.Position.(Position) if !ok { err = proto_base.BadTypeError return } ParticleDataPositionEncTmp := ParticleDataPosition err = ParticleDataPositionEncTmp.Encode(w) if err != nil { return } case "entity": ParticleDataPosition, ok := ParticleData.Position.(struct { EntityId int32 EntityEyeHeight float32 }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ParticleDataPosition.EntityId) if err != nil { return } err = binary.Write(w, binary.BigEndian, ParticleDataPosition.EntityEyeHeight) if err != nil { return } } err = proto_base.EncodeVarInt(w, ParticleData.Ticks) if err != nil { return } } return } type Path struct { Reached bool NextNodeIndex int32 Target Position Nodes []Node DebugData PathDebugData } func (ret *Path) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Reached) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.NextNodeIndex) if err != nil { return } err = ret.Target.Decode(r) if err != nil { return } var lPathNodes int32 lPathNodes, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Nodes = []Node{} for range lPathNodes { var PathNodesElement Node err = PathNodesElement.Decode(r) if err != nil { return } ret.Nodes = append(ret.Nodes, PathNodesElement) } err = ret.DebugData.Decode(r) if err != nil { return } return } func (ret *Path) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Reached) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.NextNodeIndex) if err != nil { return } PathTargetEncTmp := ret.Target err = PathTargetEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Nodes))) if err != nil { return } for iPathNodes := range len(ret.Nodes) { PathNodesInnerEncTmp := ret.Nodes[iPathNodes] err = PathNodesInnerEncTmp.Encode(w) if err != nil { return } } PathDebugDataEncTmp := ret.DebugData err = PathDebugDataEncTmp.Encode(w) if err != nil { return } return } type PathDebugData struct { OpenSet []Node ClosedSet []Node TargetNodes []Node } func (ret *PathDebugData) Decode(r io.ReadSeeker) (err error) { var lPathDebugDataOpenSet int32 lPathDebugDataOpenSet, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.OpenSet = []Node{} for range lPathDebugDataOpenSet { var PathDebugDataOpenSetElement Node err = PathDebugDataOpenSetElement.Decode(r) if err != nil { return } ret.OpenSet = append(ret.OpenSet, PathDebugDataOpenSetElement) } var lPathDebugDataClosedSet int32 lPathDebugDataClosedSet, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ClosedSet = []Node{} for range lPathDebugDataClosedSet { var PathDebugDataClosedSetElement Node err = PathDebugDataClosedSetElement.Decode(r) if err != nil { return } ret.ClosedSet = append(ret.ClosedSet, PathDebugDataClosedSetElement) } var lPathDebugDataTargetNodes int32 lPathDebugDataTargetNodes, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.TargetNodes = []Node{} for range lPathDebugDataTargetNodes { var PathDebugDataTargetNodesElement Node err = PathDebugDataTargetNodesElement.Decode(r) if err != nil { return } ret.TargetNodes = append(ret.TargetNodes, PathDebugDataTargetNodesElement) } return } func (ret *PathDebugData) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.OpenSet))) if err != nil { return } for iPathDebugDataOpenSet := range len(ret.OpenSet) { PathDebugDataOpenSetInnerEncTmp := ret.OpenSet[iPathDebugDataOpenSet] err = PathDebugDataOpenSetInnerEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.ClosedSet))) if err != nil { return } for iPathDebugDataClosedSet := range len(ret.ClosedSet) { PathDebugDataClosedSetInnerEncTmp := ret.ClosedSet[iPathDebugDataClosedSet] err = PathDebugDataClosedSetInnerEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.TargetNodes))) if err != nil { return } for iPathDebugDataTargetNodes := range len(ret.TargetNodes) { PathDebugDataTargetNodesInnerEncTmp := ret.TargetNodes[iPathDebugDataTargetNodes] err = PathDebugDataTargetNodesInnerEncTmp.Encode(w) if err != nil { return } } return } type PlayerSkinPatch struct { Body *string Cape *string Elytra *string Model *string } var PlayerSkinPatchModelMap = map[int32]string{0: "wide", 1: "slim"} func (ret *PlayerSkinPatch) Decode(r io.ReadSeeker) (err error) { var PlayerSkinPatchBodyPresent bool err = binary.Read(r, binary.BigEndian, &PlayerSkinPatchBodyPresent) if err != nil { return } if PlayerSkinPatchBodyPresent { var PlayerSkinPatchBodyPresentValue string PlayerSkinPatchBodyPresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Body = &PlayerSkinPatchBodyPresentValue } var PlayerSkinPatchCapePresent bool err = binary.Read(r, binary.BigEndian, &PlayerSkinPatchCapePresent) if err != nil { return } if PlayerSkinPatchCapePresent { var PlayerSkinPatchCapePresentValue string PlayerSkinPatchCapePresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Cape = &PlayerSkinPatchCapePresentValue } var PlayerSkinPatchElytraPresent bool err = binary.Read(r, binary.BigEndian, &PlayerSkinPatchElytraPresent) if err != nil { return } if PlayerSkinPatchElytraPresent { var PlayerSkinPatchElytraPresentValue string PlayerSkinPatchElytraPresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Elytra = &PlayerSkinPatchElytraPresentValue } var PlayerSkinPatchModelPresent bool err = binary.Read(r, binary.BigEndian, &PlayerSkinPatchModelPresent) if err != nil { return } if PlayerSkinPatchModelPresent { var PlayerSkinPatchModelPresentValue string var PlayerSkinPatchModelKey int32 PlayerSkinPatchModelKey, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayerSkinPatchModelPresentValue, err = proto_base.ErroringIndex(PlayerSkinPatchModelMap, PlayerSkinPatchModelKey) if err != nil { return } ret.Model = &PlayerSkinPatchModelPresentValue } return } var PlayerSkinPatchModelReverseMap = map[string]int32{"wide": 0, "slim": 1} func (ret *PlayerSkinPatch) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Body != nil) if err != nil { return } if ret.Body != nil { err = proto_base.EncodeString(w, *ret.Body) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.Cape != nil) if err != nil { return } if ret.Cape != nil { err = proto_base.EncodeString(w, *ret.Cape) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.Elytra != nil) if err != nil { return } if ret.Elytra != nil { err = proto_base.EncodeString(w, *ret.Elytra) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.Model != nil) if err != nil { return } if ret.Model != nil { var vPlayerSkinPatchModel int32 vPlayerSkinPatchModel, err = proto_base.ErroringIndex(PlayerSkinPatchModelReverseMap, *ret.Model) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayerSkinPatchModel) if err != nil { return } } return } type ResolvableProfile struct { Type string Anon any SkinPatch PlayerSkinPatch } var ResolvableProfileTypeMap = map[int32]string{0: "partial", 1: "complete"} func (ret *ResolvableProfile) Decode(r io.ReadSeeker) (err error) { var ResolvableProfileTypeKey int32 ResolvableProfileTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Type, err = proto_base.ErroringIndex(ResolvableProfileTypeMap, ResolvableProfileTypeKey) if err != nil { return } switch ret.Type { case "complete": var ResolvableProfileAnonCompleteTmp GameProfile err = ResolvableProfileAnonCompleteTmp.Decode(r) if err != nil { return } ret.Anon = ResolvableProfileAnonCompleteTmp case "partial": var ResolvableProfileAnonPartialTmp PartialResolvableProfile err = ResolvableProfileAnonPartialTmp.Decode(r) if err != nil { return } ret.Anon = ResolvableProfileAnonPartialTmp } err = ret.SkinPatch.Decode(r) if err != nil { return } return } var ResolvableProfileTypeReverseMap = map[string]int32{"partial": 0, "complete": 1} func (ret *ResolvableProfile) Encode(w io.Writer) (err error) { var vResolvableProfileType int32 vResolvableProfileType, err = proto_base.ErroringIndex(ResolvableProfileTypeReverseMap, ret.Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vResolvableProfileType) if err != nil { return } switch ret.Type { case "complete": ResolvableProfileAnon, ok := ret.Anon.(GameProfile) if !ok { err = proto_base.BadTypeError return } ResolvableProfileAnonEncTmp := ResolvableProfileAnon err = ResolvableProfileAnonEncTmp.Encode(w) if err != nil { return } case "partial": ResolvableProfileAnon, ok := ret.Anon.(PartialResolvableProfile) if !ok { err = proto_base.BadTypeError return } ResolvableProfileAnonEncTmp := ResolvableProfileAnon err = ResolvableProfileAnonEncTmp.Encode(w) if err != nil { return } } ResolvableProfileSkinPatchEncTmp := ret.SkinPatch err = ResolvableProfileSkinPatchEncTmp.Encode(w) if err != nil { return } return } type RespawnData struct { GlobalPos GlobalPos Yaw float32 Pitch float32 } func (ret *RespawnData) Decode(r io.ReadSeeker) (err error) { err = ret.GlobalPos.Decode(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 } return } func (ret *RespawnData) Encode(w io.Writer) (err error) { RespawnDataGlobalPosEncTmp := ret.GlobalPos err = RespawnDataGlobalPosEncTmp.Encode(w) 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 ServerLinkType struct { Val string } var ServerLinkTypeMap = map[int32]string{0: "bug_report", 1: "community_guidelines", 2: "support", 3: "status", 4: "feedback", 5: "community", 6: "website", 7: "forums", 8: "news", 9: "announcements"} func (ret *ServerLinkType) Decode(r io.ReadSeeker) (err error) { var ServerLinkTypeKey int32 ServerLinkTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Val, err = proto_base.ErroringIndex(ServerLinkTypeMap, ServerLinkTypeKey) if err != nil { return } return } var ServerLinkTypeReverseMap = map[string]int32{"bug_report": 0, "community_guidelines": 1, "support": 2, "status": 3, "feedback": 4, "community": 5, "website": 6, "forums": 7, "news": 8, "announcements": 9} func (ret *ServerLinkType) Encode(w io.Writer) (err error) { var vServerLinkType int32 vServerLinkType, err = proto_base.ErroringIndex(ServerLinkTypeReverseMap, ret.Val) if err != nil { return } err = proto_base.EncodeVarInt(w, vServerLinkType) if err != nil { return } return } type Slot struct { ItemCount int32 Anon any } func (ret *Slot) Decode(r io.ReadSeeker) (err error) { ret.ItemCount, err = proto_base.DecodeVarInt(r) if err != nil { return } switch ret.ItemCount { case 0: var SlotAnon0Tmp struct { } ret.Anon = SlotAnon0Tmp default: var SlotAnonTmp struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } } SlotAnonTmp.ItemId, err = proto_base.DecodeVarInt(r) if err != nil { return } SlotAnonTmp.AddedComponentCount, err = proto_base.DecodeVarInt(r) if err != nil { return } SlotAnonTmp.RemovedComponentCount, err = proto_base.DecodeVarInt(r) if err != nil { return } var lSlotAnonComponents int32 lSlotAnonComponents = SlotAnonTmp.AddedComponentCount SlotAnonTmp.Components = []SlotComponent{} for range lSlotAnonComponents { var SlotAnonComponentsElement SlotComponent err = SlotAnonComponentsElement.Decode(r) if err != nil { return } SlotAnonTmp.Components = append(SlotAnonTmp.Components, SlotAnonComponentsElement) } var lSlotAnonRemoveComponents int32 lSlotAnonRemoveComponents = SlotAnonTmp.RemovedComponentCount SlotAnonTmp.RemoveComponents = []struct { Type SlotComponentType }{} for range lSlotAnonRemoveComponents { var SlotAnonRemoveComponentsElement struct { Type SlotComponentType } err = SlotAnonRemoveComponentsElement.Type.Decode(r) if err != nil { return } SlotAnonTmp.RemoveComponents = append(SlotAnonTmp.RemoveComponents, SlotAnonRemoveComponentsElement) } ret.Anon = SlotAnonTmp } return } func (ret *Slot) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.ItemCount) if err != nil { return } switch ret.ItemCount { case 0: _, ok := ret.Anon.(struct { }) if !ok { err = proto_base.BadTypeError return } default: _, ok := ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } }).ItemId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } }).AddedComponentCount) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } }).RemovedComponentCount) if err != nil { return } for iSlotAnonComponents := range len(ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } }).Components) { SlotAnonComponentsInnerEncTmp := ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } }).Components[iSlotAnonComponents] err = SlotAnonComponentsInnerEncTmp.Encode(w) if err != nil { return } } for iSlotAnonRemoveComponents := range len(ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } }).RemoveComponents) { SlotAnonRemoveComponentsInnerTypeEncTmp := ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []SlotComponent RemoveComponents []struct { Type SlotComponentType } }).RemoveComponents[iSlotAnonRemoveComponents].Type err = SlotAnonRemoveComponentsInnerTypeEncTmp.Encode(w) if err != nil { return } } } return } type SlotComponent struct { Type SlotComponentType Data any } func (ret *SlotComponent) Decode(r io.ReadSeeker) (err error) { err = proto_base.ToDoError return } func (ret *SlotComponent) Encode(w io.Writer) (err error) { err = proto_base.ToDoError return } type SlotComponentType struct { Val string } var SlotComponentTypeMap = map[int32]string{0: "custom_data", 1: "max_stack_size", 10: "enchantments", 11: "can_place_on", 12: "can_break", 13: "attribute_modifiers", 14: "custom_model_data", 15: "tooltip_display", 16: "repair_cost", 17: "creative_slot_lock", 18: "enchantment_glint_override", 19: "intangible_projectile", 2: "max_damage", 20: "food", 21: "consumable", 22: "use_remainder", 23: "use_cooldown", 24: "damage_resistant", 25: "tool", 26: "weapon", 27: "enchantable", 28: "equippable", 29: "repairable", 3: "damage", 30: "glider", 31: "tooltip_style", 32: "death_protection", 33: "blocks_attacks", 34: "stored_enchantments", 35: "dyed_color", 36: "map_color", 37: "map_id", 38: "map_decorations", 39: "map_post_processing", 4: "unbreakable", 40: "charged_projectiles", 41: "bundle_contents", 42: "potion_contents", 43: "potion_duration_scale", 44: "suspicious_stew_effects", 45: "writable_book_content", 46: "written_book_content", 47: "trim", 48: "debug_stick_state", 49: "entity_data", 5: "custom_name", 50: "bucket_entity_data", 51: "block_entity_data", 52: "instrument", 53: "provides_trim_material", 54: "ominous_bottle_amplifier", 55: "jukebox_playable", 56: "provides_banner_patterns", 57: "recipes", 58: "lodestone_tracker", 59: "firework_explosion", 6: "item_name", 60: "fireworks", 61: "profile", 62: "note_block_sound", 63: "banner_patterns", 64: "base_color", 65: "pot_decorations", 66: "container", 67: "block_state", 68: "bees", 69: "lock", 7: "item_model", 70: "container_loot", 71: "break_sound", 72: "villager/variant", 73: "wolf/variant", 74: "wolf/sound_variant", 75: "wolf/collar", 76: "fox/variant", 77: "salmon/size", 78: "parrot/variant", 79: "tropical_fish/pattern", 8: "lore", 80: "tropical_fish/base_color", 81: "tropical_fish/pattern_color", 82: "mooshroom/variant", 83: "rabbit/variant", 84: "pig/variant", 85: "cow/variant", 86: "chicken/variant", 87: "frog/variant", 88: "horse/variant", 89: "painting/variant", 9: "rarity", 90: "llama/variant", 91: "axolotl/variant", 92: "cat/variant", 93: "cat/collar", 94: "sheep/color", 95: "shulker/color"} func (ret *SlotComponentType) Decode(r io.ReadSeeker) (err error) { var SlotComponentTypeKey int32 SlotComponentTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Val, err = proto_base.ErroringIndex(SlotComponentTypeMap, SlotComponentTypeKey) if err != nil { return } return } var SlotComponentTypeReverseMap = map[string]int32{"custom_data": 0, "max_stack_size": 1, "enchantments": 10, "can_place_on": 11, "can_break": 12, "attribute_modifiers": 13, "custom_model_data": 14, "tooltip_display": 15, "repair_cost": 16, "creative_slot_lock": 17, "enchantment_glint_override": 18, "intangible_projectile": 19, "max_damage": 2, "food": 20, "consumable": 21, "use_remainder": 22, "use_cooldown": 23, "damage_resistant": 24, "tool": 25, "weapon": 26, "enchantable": 27, "equippable": 28, "repairable": 29, "damage": 3, "glider": 30, "tooltip_style": 31, "death_protection": 32, "blocks_attacks": 33, "stored_enchantments": 34, "dyed_color": 35, "map_color": 36, "map_id": 37, "map_decorations": 38, "map_post_processing": 39, "unbreakable": 4, "charged_projectiles": 40, "bundle_contents": 41, "potion_contents": 42, "potion_duration_scale": 43, "suspicious_stew_effects": 44, "writable_book_content": 45, "written_book_content": 46, "trim": 47, "debug_stick_state": 48, "entity_data": 49, "custom_name": 5, "bucket_entity_data": 50, "block_entity_data": 51, "instrument": 52, "provides_trim_material": 53, "ominous_bottle_amplifier": 54, "jukebox_playable": 55, "provides_banner_patterns": 56, "recipes": 57, "lodestone_tracker": 58, "firework_explosion": 59, "item_name": 6, "fireworks": 60, "profile": 61, "note_block_sound": 62, "banner_patterns": 63, "base_color": 64, "pot_decorations": 65, "container": 66, "block_state": 67, "bees": 68, "lock": 69, "item_model": 7, "container_loot": 70, "break_sound": 71, "villager/variant": 72, "wolf/variant": 73, "wolf/sound_variant": 74, "wolf/collar": 75, "fox/variant": 76, "salmon/size": 77, "parrot/variant": 78, "tropical_fish/pattern": 79, "lore": 8, "tropical_fish/base_color": 80, "tropical_fish/pattern_color": 81, "mooshroom/variant": 82, "rabbit/variant": 83, "pig/variant": 84, "cow/variant": 85, "chicken/variant": 86, "frog/variant": 87, "horse/variant": 88, "painting/variant": 89, "rarity": 9, "llama/variant": 90, "axolotl/variant": 91, "cat/variant": 92, "cat/collar": 93, "sheep/color": 94, "shulker/color": 95} func (ret *SlotComponentType) Encode(w io.Writer) (err error) { var vSlotComponentType int32 vSlotComponentType, err = proto_base.ErroringIndex(SlotComponentTypeReverseMap, ret.Val) if err != nil { return } err = proto_base.EncodeVarInt(w, vSlotComponentType) if err != nil { return } return } type UntrustedSlot struct { ItemCount int32 Anon any } func (ret *UntrustedSlot) Decode(r io.ReadSeeker) (err error) { ret.ItemCount, err = proto_base.DecodeVarInt(r) if err != nil { return } switch ret.ItemCount { case 0: var UntrustedSlotAnon0Tmp struct { } ret.Anon = UntrustedSlotAnon0Tmp default: var UntrustedSlotAnonTmp struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } } UntrustedSlotAnonTmp.ItemId, err = proto_base.DecodeVarInt(r) if err != nil { return } UntrustedSlotAnonTmp.AddedComponentCount, err = proto_base.DecodeVarInt(r) if err != nil { return } UntrustedSlotAnonTmp.RemovedComponentCount, err = proto_base.DecodeVarInt(r) if err != nil { return } var lUntrustedSlotAnonComponents int32 lUntrustedSlotAnonComponents = UntrustedSlotAnonTmp.AddedComponentCount UntrustedSlotAnonTmp.Components = []UntrustedSlotComponent{} for range lUntrustedSlotAnonComponents { var UntrustedSlotAnonComponentsElement UntrustedSlotComponent err = UntrustedSlotAnonComponentsElement.Decode(r) if err != nil { return } UntrustedSlotAnonTmp.Components = append(UntrustedSlotAnonTmp.Components, UntrustedSlotAnonComponentsElement) } var lUntrustedSlotAnonRemoveComponents int32 lUntrustedSlotAnonRemoveComponents = UntrustedSlotAnonTmp.RemovedComponentCount UntrustedSlotAnonTmp.RemoveComponents = []struct { Type SlotComponentType }{} for range lUntrustedSlotAnonRemoveComponents { var UntrustedSlotAnonRemoveComponentsElement struct { Type SlotComponentType } err = UntrustedSlotAnonRemoveComponentsElement.Type.Decode(r) if err != nil { return } UntrustedSlotAnonTmp.RemoveComponents = append(UntrustedSlotAnonTmp.RemoveComponents, UntrustedSlotAnonRemoveComponentsElement) } ret.Anon = UntrustedSlotAnonTmp } return } func (ret *UntrustedSlot) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.ItemCount) if err != nil { return } switch ret.ItemCount { case 0: _, ok := ret.Anon.(struct { }) if !ok { err = proto_base.BadTypeError return } default: _, ok := ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } }).ItemId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } }).AddedComponentCount) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } }).RemovedComponentCount) if err != nil { return } for iUntrustedSlotAnonComponents := range len(ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } }).Components) { UntrustedSlotAnonComponentsInnerEncTmp := ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } }).Components[iUntrustedSlotAnonComponents] err = UntrustedSlotAnonComponentsInnerEncTmp.Encode(w) if err != nil { return } } for iUntrustedSlotAnonRemoveComponents := range len(ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } }).RemoveComponents) { UntrustedSlotAnonRemoveComponentsInnerTypeEncTmp := ret.Anon.(struct { ItemId int32 AddedComponentCount int32 RemovedComponentCount int32 Components []UntrustedSlotComponent RemoveComponents []struct { Type SlotComponentType } }).RemoveComponents[iUntrustedSlotAnonRemoveComponents].Type err = UntrustedSlotAnonRemoveComponentsInnerTypeEncTmp.Encode(w) if err != nil { return } } } return } type UntrustedSlotComponent struct { Type SlotComponentType Data ByteArray } func (ret *UntrustedSlotComponent) Decode(r io.ReadSeeker) (err error) { err = ret.Type.Decode(r) if err != nil { return } err = ret.Data.Decode(r) if err != nil { return } return } func (ret *UntrustedSlotComponent) Encode(w io.Writer) (err error) { UntrustedSlotComponentTypeEncTmp := ret.Type err = UntrustedSlotComponentTypeEncTmp.Encode(w) if err != nil { return } UntrustedSlotComponentDataEncTmp := ret.Data err = UntrustedSlotComponentDataEncTmp.Encode(w) if err != nil { return } return } type ChatSession struct { Val *struct { Uuid uuid.UUID PublicKey struct { ExpireTime int64 KeyBytes []byte KeySignature []byte } } } func (ret *ChatSession) Decode(r io.ReadSeeker) (err error) { var ChatSessionPresent bool err = binary.Read(r, binary.BigEndian, &ChatSessionPresent) if err != nil { return } if ChatSessionPresent { var ChatSessionPresentValue struct { Uuid uuid.UUID PublicKey struct { ExpireTime int64 KeyBytes []byte KeySignature []byte } } _, err = io.ReadFull(r, ChatSessionPresentValue.Uuid[:]) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ChatSessionPresentValue.PublicKey.ExpireTime) if err != nil { return } var lChatSessionPublicKeyKeyBytes int32 lChatSessionPublicKeyKeyBytes, err = proto_base.DecodeVarInt(r) if err != nil { return } ChatSessionPresentValue.PublicKey.KeyBytes, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeyBytes))) if err != nil { return } var lChatSessionPublicKeyKeySignature int32 lChatSessionPublicKeyKeySignature, err = proto_base.DecodeVarInt(r) if err != nil { return } ChatSessionPresentValue.PublicKey.KeySignature, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeySignature))) if err != nil { return } ret.Val = &ChatSessionPresentValue } return } func (ret *ChatSession) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Val != nil) if err != nil { return } if ret.Val != nil { _, err = w.Write((*ret.Val).Uuid[:]) if err != nil { return } err = binary.Write(w, binary.BigEndian, (*ret.Val).PublicKey.ExpireTime) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len((*ret.Val).PublicKey.KeyBytes))) if err != nil { return } _, err = w.Write((*ret.Val).PublicKey.KeyBytes) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len((*ret.Val).PublicKey.KeySignature))) if err != nil { return } _, err = w.Write((*ret.Val).PublicKey.KeySignature) if err != nil { return } } return } type ChunkBlockEntity struct { Anon struct { X uint8 Z uint8 } Y int16 Type int32 NbtData nbt.Anon } func (ret *ChunkBlockEntity) Decode(r io.ReadSeeker) (err error) { var ChunkBlockEntityAnonPacked uint8 err = binary.Read(r, binary.BigEndian, &ChunkBlockEntityAnonPacked) if err != nil { return } ret.Anon.Z = ChunkBlockEntityAnonPacked >> 0 & 15 ret.Anon.X = ChunkBlockEntityAnonPacked >> 4 & 15 err = binary.Read(r, binary.BigEndian, &ret.Y) if err != nil { return } ret.Type, err = proto_base.DecodeVarInt(r) if err != nil { return } err = ret.NbtData.Decode(r) if err != nil { return } return } func (ret *ChunkBlockEntity) Encode(w io.Writer) (err error) { var ChunkBlockEntityAnonPacked uint8 ChunkBlockEntityAnonPacked |= (uint8(ret.Anon.Z) & 0xF) << 0x0 ChunkBlockEntityAnonPacked |= (uint8(ret.Anon.X) & 0xF) << 0x4 err = binary.Write(w, binary.BigEndian, ChunkBlockEntityAnonPacked) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Y) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Type) if err != nil { return } ChunkBlockEntityNbtDataEncTmp := ret.NbtData err = ChunkBlockEntityNbtDataEncTmp.Encode(w) if err != nil { return } return } type CommandNode struct { Flags struct { AllowsRestricted bool HasCustomSuggestions bool HasRedirectNode bool HasCommand bool CommandNodeType uint8 } Children []int32 RedirectNode any ExtraNodeData any } var CommandNodeExtraNodeData2TmpParserMap = map[int32]string{0: "brigadier:bool", 1: "brigadier:float", 10: "minecraft:vec3", 11: "minecraft:vec2", 12: "minecraft:block_state", 13: "minecraft:block_predicate", 14: "minecraft:item_stack", 15: "minecraft:item_predicate", 16: "minecraft:color", 17: "minecraft:hex_color", 18: "minecraft:component", 19: "minecraft:style", 2: "brigadier:double", 20: "minecraft:message", 21: "minecraft:nbt", 22: "minecraft:nbt_tag", 23: "minecraft:nbt_path", 24: "minecraft:objective", 25: "minecraft:objective_criteria", 26: "minecraft:operation", 27: "minecraft:particle", 28: "minecraft:angle", 29: "minecraft:rotation", 3: "brigadier:integer", 30: "minecraft:scoreboard_slot", 31: "minecraft:score_holder", 32: "minecraft:swizzle", 33: "minecraft:team", 34: "minecraft:item_slot", 35: "minecraft:item_slots", 36: "minecraft:resource_location", 37: "minecraft:function", 38: "minecraft:entity_anchor", 39: "minecraft:int_range", 4: "brigadier:long", 40: "minecraft:float_range", 41: "minecraft:dimension", 42: "minecraft:gamemode", 43: "minecraft:time", 44: "minecraft:resource_or_tag", 45: "minecraft:resource_or_tag_key", 46: "minecraft:resource", 47: "minecraft:resource_key", 48: "minecraft:resource_selector", 49: "minecraft:template_mirror", 5: "brigadier:string", 50: "minecraft:template_rotation", 51: "minecraft:heightmap", 52: "minecraft:loot_table", 53: "minecraft:loot_predicate", 54: "minecraft:loot_modifier", 55: "minecraft:dialog", 56: "minecraft:uuid", 6: "minecraft:entity", 7: "minecraft:game_profile", 8: "minecraft:block_pos", 9: "minecraft:column_pos"} 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.AllowsRestricted = CommandNodeFlagsPacked>>5&1 == 1 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 } var CommandNodeExtraNodeData2TmpParserKey int32 CommandNodeExtraNodeData2TmpParserKey, err = proto_base.DecodeVarInt(r) if err != nil { return } CommandNodeExtraNodeData2Tmp.Parser, err = proto_base.ErroringIndex(CommandNodeExtraNodeData2TmpParserMap, CommandNodeExtraNodeData2TmpParserKey) 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:dialog": var CommandNodeExtraNodeData2TmpPropertiesMinecraftDialogTmp struct { } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftDialogTmp 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: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:gamemode": var CommandNodeExtraNodeData2TmpPropertiesMinecraftGamemodeTmp struct { } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftGamemodeTmp case "minecraft:heightmap": var CommandNodeExtraNodeData2TmpPropertiesMinecraftHeightmapTmp struct { } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftHeightmapTmp case "minecraft:hex_color": var CommandNodeExtraNodeData2TmpPropertiesMinecraftHexColorTmp struct { } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftHexColorTmp case "minecraft:int_range": var CommandNodeExtraNodeData2TmpPropertiesMinecraftIntRangeTmp struct { } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftIntRangeTmp 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:nbt": var CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtTmp struct { } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtTmp 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:resource": var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp struct { Registry string } CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp.Registry, err = proto_base.DecodeString(r) if err != nil { return } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp case "minecraft:resource_key": var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceKeyTmp struct { Registry string } CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceKeyTmp.Registry, err = proto_base.DecodeString(r) if err != nil { return } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceKeyTmp 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:resource_or_tag_key": var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagKeyTmp struct { Registry string } CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagKeyTmp.Registry, err = proto_base.DecodeString(r) if err != nil { return } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagKeyTmp case "minecraft:resource_selector": var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceSelectorTmp struct { Registry string } CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceSelectorTmp.Registry, err = proto_base.DecodeString(r) if err != nil { return } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceSelectorTmp 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:template_mirror": var CommandNodeExtraNodeData2TmpPropertiesMinecraftTemplateMirrorTmp struct { } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftTemplateMirrorTmp case "minecraft:template_rotation": var CommandNodeExtraNodeData2TmpPropertiesMinecraftTemplateRotationTmp struct { } CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftTemplateRotationTmp case "minecraft:time": var CommandNodeExtraNodeData2TmpPropertiesMinecraftTimeTmp struct { Min int32 } err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesMinecraftTimeTmp.Min) if err != nil { return } 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 CommandNodeExtraNodeDataParserReverseMap = map[string]int32{"brigadier:bool": 0, "brigadier:float": 1, "minecraft:vec3": 10, "minecraft:vec2": 11, "minecraft:block_state": 12, "minecraft:block_predicate": 13, "minecraft:item_stack": 14, "minecraft:item_predicate": 15, "minecraft:color": 16, "minecraft:hex_color": 17, "minecraft:component": 18, "minecraft:style": 19, "brigadier:double": 2, "minecraft:message": 20, "minecraft:nbt": 21, "minecraft:nbt_tag": 22, "minecraft:nbt_path": 23, "minecraft:objective": 24, "minecraft:objective_criteria": 25, "minecraft:operation": 26, "minecraft:particle": 27, "minecraft:angle": 28, "minecraft:rotation": 29, "brigadier:integer": 3, "minecraft:scoreboard_slot": 30, "minecraft:score_holder": 31, "minecraft:swizzle": 32, "minecraft:team": 33, "minecraft:item_slot": 34, "minecraft:item_slots": 35, "minecraft:resource_location": 36, "minecraft:function": 37, "minecraft:entity_anchor": 38, "minecraft:int_range": 39, "brigadier:long": 4, "minecraft:float_range": 40, "minecraft:dimension": 41, "minecraft:gamemode": 42, "minecraft:time": 43, "minecraft:resource_or_tag": 44, "minecraft:resource_or_tag_key": 45, "minecraft:resource": 46, "minecraft:resource_key": 47, "minecraft:resource_selector": 48, "minecraft:template_mirror": 49, "brigadier:string": 5, "minecraft:template_rotation": 50, "minecraft:heightmap": 51, "minecraft:loot_table": 52, "minecraft:loot_predicate": 53, "minecraft:loot_modifier": 54, "minecraft:dialog": 55, "minecraft:uuid": 56, "minecraft:entity": 6, "minecraft:game_profile": 7, "minecraft:block_pos": 8, "minecraft:column_pos": 9} 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 |= (proto_base.Bool2uint8(ret.Flags.AllowsRestricted) & 0x1) << 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 } var vCommandNodeExtraNodeDataParser int32 vCommandNodeExtraNodeDataParser, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataParserReverseMap, CommandNodeExtraNodeData.Parser) if err != nil { return } err = proto_base.EncodeVarInt(w, vCommandNodeExtraNodeDataParser) 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:dialog": _, 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: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:gamemode": _, ok := CommandNodeExtraNodeData.Properties.(struct { }) if !ok { err = proto_base.BadTypeError return } case "minecraft:heightmap": _, ok := CommandNodeExtraNodeData.Properties.(struct { }) if !ok { err = proto_base.BadTypeError return } case "minecraft:hex_color": _, 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_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:nbt": _, 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: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_key": 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:resource_or_tag_key": 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_selector": 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:template_mirror": _, ok := CommandNodeExtraNodeData.Properties.(struct { }) if !ok { err = proto_base.BadTypeError return } case "minecraft:template_rotation": _, ok := CommandNodeExtraNodeData.Properties.(struct { }) if !ok { err = proto_base.BadTypeError return } case "minecraft:time": CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { Min int32 }) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Min) if err != nil { 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]EntityMetadataEntry } func (ret *EntityMetadata) Decode(r io.ReadSeeker) (err error) { ret.Val = make(map[uint8]EntityMetadataEntry) 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 EntityMetadataEntry err = entry.Decode(r) if err != nil { return } ret.Val[id] = entry } return } func (ret *EntityMetadata) Encode(w io.Writer) (err error) { for _, v := range ret.Val { EntityMetadataEncTmp := v err = EntityMetadataEncTmp.Encode(w) if err != nil { return } } err = binary.Write(w, binary.BigEndian, uint8(255)) if err != nil { return } return } type EntityMetadataEntry struct { Key uint8 Type string Value any } var EntityMetadataEntryTypeMap = map[int32]string{0: "byte", 1: "int", 10: "block_pos", 11: "optional_block_pos", 12: "direction", 13: "optional_uuid", 14: "block_state", 15: "optional_block_state", 16: "particle", 17: "particles", 18: "villager_data", 19: "optional_unsigned_int", 2: "long", 20: "pose", 21: "cat_variant", 22: "cow_variant", 23: "wolf_variant", 24: "wolf_sound_variant", 25: "frog_variant", 26: "pig_variant", 27: "chicken_variant", 28: "optional_global_pos", 29: "painting_variant", 3: "float", 30: "sniffer_state", 31: "armadillo_state", 32: "copper_golem_state", 33: "weathering_copper_golem_state", 34: "vector3", 35: "quaternion", 36: "resolvable_profile", 4: "string", 5: "component", 6: "optional_component", 7: "item_stack", 8: "boolean", 9: "rotations"} func (ret *EntityMetadataEntry) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Key) if err != nil { return } var EntityMetadataEntryTypeKey int32 EntityMetadataEntryTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Type, err = proto_base.ErroringIndex(EntityMetadataEntryTypeMap, EntityMetadataEntryTypeKey) if err != nil { return } switch ret.Type { case "armadillo_state": var EntityMetadataEntryValueArmadilloStateTmp int32 EntityMetadataEntryValueArmadilloStateTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueArmadilloStateTmp case "block_pos": var EntityMetadataEntryValueBlockPosTmp Position err = EntityMetadataEntryValueBlockPosTmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueBlockPosTmp case "block_state": var EntityMetadataEntryValueBlockStateTmp int32 EntityMetadataEntryValueBlockStateTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueBlockStateTmp case "boolean": var EntityMetadataEntryValueBooleanTmp bool err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueBooleanTmp) if err != nil { return } ret.Value = EntityMetadataEntryValueBooleanTmp case "byte": var EntityMetadataEntryValueByteTmp int8 err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueByteTmp) if err != nil { return } ret.Value = EntityMetadataEntryValueByteTmp case "cat_variant": var EntityMetadataEntryValueCatVariantTmp int32 EntityMetadataEntryValueCatVariantTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueCatVariantTmp case "chicken_variant": var EntityMetadataEntryValueChickenVariantTmp int32 EntityMetadataEntryValueChickenVariantTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueChickenVariantTmp case "component": var EntityMetadataEntryValueComponentTmp nbt.Anon err = EntityMetadataEntryValueComponentTmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueComponentTmp case "copper_golem_state": var EntityMetadataEntryValueCopperGolemStateTmp int32 EntityMetadataEntryValueCopperGolemStateTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueCopperGolemStateTmp case "cow_variant": var EntityMetadataEntryValueCowVariantTmp int32 EntityMetadataEntryValueCowVariantTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueCowVariantTmp case "direction": var EntityMetadataEntryValueDirectionTmp int32 EntityMetadataEntryValueDirectionTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueDirectionTmp case "float": var EntityMetadataEntryValueFloatTmp float32 err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueFloatTmp) if err != nil { return } ret.Value = EntityMetadataEntryValueFloatTmp case "frog_variant": var EntityMetadataEntryValueFrogVariantTmp int32 EntityMetadataEntryValueFrogVariantTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueFrogVariantTmp case "int": var EntityMetadataEntryValueIntTmp int32 EntityMetadataEntryValueIntTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueIntTmp case "item_stack": var EntityMetadataEntryValueItemStackTmp Slot err = EntityMetadataEntryValueItemStackTmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueItemStackTmp case "long": var EntityMetadataEntryValueLongTmp int64 EntityMetadataEntryValueLongTmp, err = proto_base.DecodeVarLong(r) if err != nil { return } ret.Value = EntityMetadataEntryValueLongTmp case "optional_block_pos": var EntityMetadataEntryValueOptionalBlockPosTmp *Position var EntityMetadataEntryValueOptionalBlockPosTmpPresent bool err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueOptionalBlockPosTmpPresent) if err != nil { return } if EntityMetadataEntryValueOptionalBlockPosTmpPresent { var EntityMetadataEntryValueOptionalBlockPosTmpPresentValue Position err = EntityMetadataEntryValueOptionalBlockPosTmpPresentValue.Decode(r) if err != nil { return } EntityMetadataEntryValueOptionalBlockPosTmp = &EntityMetadataEntryValueOptionalBlockPosTmpPresentValue } ret.Value = EntityMetadataEntryValueOptionalBlockPosTmp case "optional_block_state": var EntityMetadataEntryValueOptionalBlockStateTmp Optvarint err = EntityMetadataEntryValueOptionalBlockStateTmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueOptionalBlockStateTmp case "optional_component": var EntityMetadataEntryValueOptionalComponentTmp *nbt.Anon var EntityMetadataEntryValueOptionalComponentTmpPresent bool err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueOptionalComponentTmpPresent) if err != nil { return } if EntityMetadataEntryValueOptionalComponentTmpPresent { var EntityMetadataEntryValueOptionalComponentTmpPresentValue nbt.Anon err = EntityMetadataEntryValueOptionalComponentTmpPresentValue.Decode(r) if err != nil { return } EntityMetadataEntryValueOptionalComponentTmp = &EntityMetadataEntryValueOptionalComponentTmpPresentValue } ret.Value = EntityMetadataEntryValueOptionalComponentTmp case "optional_global_pos": var EntityMetadataEntryValueOptionalGlobalPosTmp *GlobalPos var EntityMetadataEntryValueOptionalGlobalPosTmpPresent bool err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueOptionalGlobalPosTmpPresent) if err != nil { return } if EntityMetadataEntryValueOptionalGlobalPosTmpPresent { var EntityMetadataEntryValueOptionalGlobalPosTmpPresentValue GlobalPos err = EntityMetadataEntryValueOptionalGlobalPosTmpPresentValue.Decode(r) if err != nil { return } EntityMetadataEntryValueOptionalGlobalPosTmp = &EntityMetadataEntryValueOptionalGlobalPosTmpPresentValue } ret.Value = EntityMetadataEntryValueOptionalGlobalPosTmp case "optional_unsigned_int": var EntityMetadataEntryValueOptionalUnsignedIntTmp Optvarint err = EntityMetadataEntryValueOptionalUnsignedIntTmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueOptionalUnsignedIntTmp case "optional_uuid": var EntityMetadataEntryValueOptionalUuidTmp *uuid.UUID var EntityMetadataEntryValueOptionalUuidTmpPresent bool err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueOptionalUuidTmpPresent) if err != nil { return } if EntityMetadataEntryValueOptionalUuidTmpPresent { var EntityMetadataEntryValueOptionalUuidTmpPresentValue uuid.UUID _, err = io.ReadFull(r, EntityMetadataEntryValueOptionalUuidTmpPresentValue[:]) if err != nil { return } EntityMetadataEntryValueOptionalUuidTmp = &EntityMetadataEntryValueOptionalUuidTmpPresentValue } ret.Value = EntityMetadataEntryValueOptionalUuidTmp case "painting_variant": var EntityMetadataEntryValuePaintingVariantTmp any var EntityMetadataEntryValuePaintingVariantTmpId int32 EntityMetadataEntryValuePaintingVariantTmpId, err = proto_base.DecodeVarInt(r) if err != nil { return } if EntityMetadataEntryValuePaintingVariantTmpId != 0 { EntityMetadataEntryValuePaintingVariantTmp = EntityMetadataEntryValuePaintingVariantTmpId } else { var EntityMetadataEntryValuePaintingVariantTmpResult EntityMetadataPaintingVariant err = EntityMetadataEntryValuePaintingVariantTmpResult.Decode(r) if err != nil { return } EntityMetadataEntryValuePaintingVariantTmp = EntityMetadataEntryValuePaintingVariantTmpResult } ret.Value = EntityMetadataEntryValuePaintingVariantTmp case "particle": var EntityMetadataEntryValueParticleTmp Particle err = EntityMetadataEntryValueParticleTmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueParticleTmp case "particles": var EntityMetadataEntryValueParticlesTmp []Particle var lEntityMetadataEntryValueParticlesTmp int32 lEntityMetadataEntryValueParticlesTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } EntityMetadataEntryValueParticlesTmp = []Particle{} for range lEntityMetadataEntryValueParticlesTmp { var EntityMetadataEntryValueParticlesTmpElement Particle err = EntityMetadataEntryValueParticlesTmpElement.Decode(r) if err != nil { return } EntityMetadataEntryValueParticlesTmp = append(EntityMetadataEntryValueParticlesTmp, EntityMetadataEntryValueParticlesTmpElement) } ret.Value = EntityMetadataEntryValueParticlesTmp case "pig_variant": var EntityMetadataEntryValuePigVariantTmp int32 EntityMetadataEntryValuePigVariantTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValuePigVariantTmp case "pose": var EntityMetadataEntryValuePoseTmp int32 EntityMetadataEntryValuePoseTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValuePoseTmp case "quaternion": var EntityMetadataEntryValueQuaternionTmp Vec4f err = EntityMetadataEntryValueQuaternionTmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueQuaternionTmp case "resolvable_profile": var EntityMetadataEntryValueResolvableProfileTmp ResolvableProfile err = EntityMetadataEntryValueResolvableProfileTmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueResolvableProfileTmp case "rotations": var EntityMetadataEntryValueRotationsTmp struct { Pitch float32 Yaw float32 Roll float32 } err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Pitch) if err != nil { return } err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Yaw) if err != nil { return } err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Roll) if err != nil { return } ret.Value = EntityMetadataEntryValueRotationsTmp case "sniffer_state": var EntityMetadataEntryValueSnifferStateTmp int32 EntityMetadataEntryValueSnifferStateTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueSnifferStateTmp case "string": var EntityMetadataEntryValueStringTmp string EntityMetadataEntryValueStringTmp, err = proto_base.DecodeString(r) if err != nil { return } ret.Value = EntityMetadataEntryValueStringTmp case "vector3": var EntityMetadataEntryValueVector3Tmp Vec3f err = EntityMetadataEntryValueVector3Tmp.Decode(r) if err != nil { return } ret.Value = EntityMetadataEntryValueVector3Tmp case "villager_data": var EntityMetadataEntryValueVillagerDataTmp struct { VillagerType int32 VillagerProfession int32 Level int32 } EntityMetadataEntryValueVillagerDataTmp.VillagerType, err = proto_base.DecodeVarInt(r) if err != nil { return } EntityMetadataEntryValueVillagerDataTmp.VillagerProfession, err = proto_base.DecodeVarInt(r) if err != nil { return } EntityMetadataEntryValueVillagerDataTmp.Level, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueVillagerDataTmp case "weathering_copper_golem_state": var EntityMetadataEntryValueWeatheringCopperGolemStateTmp int32 EntityMetadataEntryValueWeatheringCopperGolemStateTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueWeatheringCopperGolemStateTmp case "wolf_sound_variant": var EntityMetadataEntryValueWolfSoundVariantTmp int32 EntityMetadataEntryValueWolfSoundVariantTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueWolfSoundVariantTmp case "wolf_variant": var EntityMetadataEntryValueWolfVariantTmp int32 EntityMetadataEntryValueWolfVariantTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Value = EntityMetadataEntryValueWolfVariantTmp } return } var EntityMetadataEntryTypeReverseMap = map[string]int32{"byte": 0, "int": 1, "block_pos": 10, "optional_block_pos": 11, "direction": 12, "optional_uuid": 13, "block_state": 14, "optional_block_state": 15, "particle": 16, "particles": 17, "villager_data": 18, "optional_unsigned_int": 19, "long": 2, "pose": 20, "cat_variant": 21, "cow_variant": 22, "wolf_variant": 23, "wolf_sound_variant": 24, "frog_variant": 25, "pig_variant": 26, "chicken_variant": 27, "optional_global_pos": 28, "painting_variant": 29, "float": 3, "sniffer_state": 30, "armadillo_state": 31, "copper_golem_state": 32, "weathering_copper_golem_state": 33, "vector3": 34, "quaternion": 35, "resolvable_profile": 36, "string": 4, "component": 5, "optional_component": 6, "item_stack": 7, "boolean": 8, "rotations": 9} func (ret *EntityMetadataEntry) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Key) if err != nil { return } var vEntityMetadataEntryType int32 vEntityMetadataEntryType, err = proto_base.ErroringIndex(EntityMetadataEntryTypeReverseMap, ret.Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vEntityMetadataEntryType) if err != nil { return } switch ret.Type { case "armadillo_state": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "block_pos": EntityMetadataEntryValue, ok := ret.Value.(Position) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "block_state": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "boolean": EntityMetadataEntryValue, ok := ret.Value.(bool) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue) if err != nil { return } case "byte": EntityMetadataEntryValue, ok := ret.Value.(int8) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue) if err != nil { return } case "cat_variant": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "chicken_variant": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "component": EntityMetadataEntryValue, ok := ret.Value.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "copper_golem_state": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "cow_variant": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "direction": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "float": EntityMetadataEntryValue, ok := ret.Value.(float32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue) if err != nil { return } case "frog_variant": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "int": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "item_stack": EntityMetadataEntryValue, ok := ret.Value.(Slot) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "long": EntityMetadataEntryValue, ok := ret.Value.(int64) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarLong(w, EntityMetadataEntryValue) if err != nil { return } case "optional_block_pos": EntityMetadataEntryValue, ok := ret.Value.(*Position) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil) if err != nil { return } if EntityMetadataEntryValue != nil { EntityMetadataEntryValueEncTmp := *EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } } case "optional_block_state": EntityMetadataEntryValue, ok := ret.Value.(Optvarint) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "optional_component": EntityMetadataEntryValue, ok := ret.Value.(*nbt.Anon) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil) if err != nil { return } if EntityMetadataEntryValue != nil { EntityMetadataEntryValueEncTmp := *EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } } case "optional_global_pos": EntityMetadataEntryValue, ok := ret.Value.(*GlobalPos) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil) if err != nil { return } if EntityMetadataEntryValue != nil { EntityMetadataEntryValueEncTmp := *EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } } case "optional_unsigned_int": EntityMetadataEntryValue, ok := ret.Value.(Optvarint) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "optional_uuid": EntityMetadataEntryValue, ok := ret.Value.(*uuid.UUID) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil) if err != nil { return } if EntityMetadataEntryValue != nil { _, err = w.Write((*EntityMetadataEntryValue)[:]) if err != nil { return } } case "painting_variant": EntityMetadataEntryValue, ok := ret.Value.(any) if !ok { err = proto_base.BadTypeError return } switch EntityMetadataEntryValueKnownType := EntityMetadataEntryValue.(type) { case int32: err = proto_base.EncodeVarInt(w, EntityMetadataEntryValueKnownType) if err != nil { return } case EntityMetadataPaintingVariant: err = proto_base.EncodeVarInt(w, 0) if err != nil { return } EntityMetadataEntryValueOtherwiseEncTmp := EntityMetadataEntryValueKnownType err = EntityMetadataEntryValueOtherwiseEncTmp.Encode(w) if err != nil { return } default: err = proto_base.BadTypeError } case "particle": EntityMetadataEntryValue, ok := ret.Value.(Particle) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "particles": EntityMetadataEntryValue, ok := ret.Value.([]Particle) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, int32(len(EntityMetadataEntryValue))) if err != nil { return } for iEntityMetadataEntryValue := range len(EntityMetadataEntryValue) { EntityMetadataEntryValueInnerEncTmp := EntityMetadataEntryValue[iEntityMetadataEntryValue] err = EntityMetadataEntryValueInnerEncTmp.Encode(w) if err != nil { return } } case "pig_variant": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "pose": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "quaternion": EntityMetadataEntryValue, ok := ret.Value.(Vec4f) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "resolvable_profile": EntityMetadataEntryValue, ok := ret.Value.(ResolvableProfile) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "rotations": EntityMetadataEntryValue, ok := ret.Value.(struct { Pitch float32 Yaw float32 Roll float32 }) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Pitch) if err != nil { return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Yaw) if err != nil { return } err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Roll) if err != nil { return } case "sniffer_state": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "string": EntityMetadataEntryValue, ok := ret.Value.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, EntityMetadataEntryValue) if err != nil { return } case "vector3": EntityMetadataEntryValue, ok := ret.Value.(Vec3f) if !ok { err = proto_base.BadTypeError return } EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue err = EntityMetadataEntryValueEncTmp.Encode(w) if err != nil { return } case "villager_data": EntityMetadataEntryValue, ok := ret.Value.(struct { VillagerType int32 VillagerProfession int32 Level int32 }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.VillagerType) if err != nil { return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.VillagerProfession) if err != nil { return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.Level) if err != nil { return } case "weathering_copper_golem_state": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "wolf_sound_variant": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } case "wolf_variant": EntityMetadataEntryValue, ok := ret.Value.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) if err != nil { return } } return } type GameProfileNameProp struct { Name string Properties []GameProfileProperty } func (ret *GameProfileNameProp) Decode(r io.ReadSeeker) (err error) { ret.Name, err = proto_base.DecodeString(r) if err != nil { return } var lGameProfileNamePropProperties int32 lGameProfileNamePropProperties, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Properties = []GameProfileProperty{} for range lGameProfileNamePropProperties { var GameProfileNamePropPropertiesElement GameProfileProperty err = GameProfileNamePropPropertiesElement.Decode(r) if err != nil { return } ret.Properties = append(ret.Properties, GameProfileNamePropPropertiesElement) } return } func (ret *GameProfileNameProp) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Name) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Properties))) if err != nil { return } for iGameProfileNamePropProperties := range len(ret.Properties) { GameProfileNamePropPropertiesInnerEncTmp := ret.Properties[iGameProfileNamePropProperties] err = GameProfileNamePropPropertiesInnerEncTmp.Encode(w) if err != nil { return } } 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 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 PackedChunkPos struct { Z int32 X int32 } func (ret *PackedChunkPos) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Z) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.X) if err != nil { return } return } func (ret *PackedChunkPos) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Z) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.X) if err != nil { return } 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 PreviousMessages struct { Val []struct { Id int32 Signature any } } func (ret *PreviousMessages) Decode(r io.ReadSeeker) (err error) { var lPreviousMessages int32 lPreviousMessages, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Val = []struct { Id int32 Signature any }{} for range lPreviousMessages { var PreviousMessagesElement struct { Id int32 Signature any } PreviousMessagesElement.Id, err = proto_base.DecodeVarInt(r) if err != nil { return } switch PreviousMessagesElement.Id { case 0: var PreviousMessagesElementSignature0Tmp [256]byte _, err = r.Read(PreviousMessagesElementSignature0Tmp[:]) if err != nil { return } PreviousMessagesElement.Signature = PreviousMessagesElementSignature0Tmp default: var PreviousMessagesElementSignatureTmp struct { } PreviousMessagesElement.Signature = PreviousMessagesElementSignatureTmp } ret.Val = append(ret.Val, PreviousMessagesElement) } return } func (ret *PreviousMessages) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Val))) if err != nil { return } for iPreviousMessages := range len(ret.Val) { err = proto_base.EncodeVarInt(w, ret.Val[iPreviousMessages].Id) if err != nil { return } switch ret.Val[iPreviousMessages].Id { case 0: PreviousMessagesInnerSignature, ok := ret.Val[iPreviousMessages].Signature.([256]byte) if !ok { err = proto_base.BadTypeError return } arr := PreviousMessagesInnerSignature _, err = w.Write(arr[:]) if err != nil { return } default: _, ok := ret.Val[iPreviousMessages].Signature.(struct { }) if !ok { err = proto_base.BadTypeError return } } } return } type SoundSource struct { Val string } var SoundSourceMap = map[int32]string{0: "master", 1: "music", 10: "ui", 2: "record", 3: "weather", 4: "block", 5: "hostile", 6: "neutral", 7: "player", 8: "ambient", 9: "voice"} func (ret *SoundSource) Decode(r io.ReadSeeker) (err error) { var SoundSourceKey int32 SoundSourceKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Val, err = proto_base.ErroringIndex(SoundSourceMap, SoundSourceKey) if err != nil { return } return } var SoundSourceReverseMap = map[string]int32{"master": 0, "music": 1, "ui": 10, "record": 2, "weather": 3, "block": 4, "hostile": 5, "neutral": 6, "player": 7, "ambient": 8, "voice": 9} func (ret *SoundSource) Encode(w io.Writer) (err error) { var vSoundSource int32 vSoundSource, err = proto_base.ErroringIndex(SoundSourceReverseMap, ret.Val) if err != nil { return } err = proto_base.EncodeVarInt(w, vSoundSource) 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 Vec2f struct { X float32 Y float32 } func (ret *Vec2f) 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 } return } func (ret *Vec2f) 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 } return } type Vec3f struct { X float32 Y float32 Z float32 } func (ret *Vec3f) 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 *Vec3f) 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 Vec3f64 struct { X float64 Y float64 Z float64 } func (ret *Vec3f64) 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 *Vec3f64) 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 Vec3i struct { X int32 Y int32 Z int32 } func (ret *Vec3i) Decode(r io.ReadSeeker) (err error) { ret.X, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Y, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Z, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *Vec3i) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.X) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Y) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Z) if err != nil { return } return } type Vec3i32 struct { X int32 Y int32 Z int32 } func (ret *Vec3i32) 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 *Vec3i32) 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 Vec4f struct { X float32 Y float32 Z float32 W float32 } func (ret *Vec4f) 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.W) if err != nil { return } return } func (ret *Vec4f) 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.W) if err != nil { return } return } type ConfigurationToClientPacket struct { Name string Params any } var ConfigurationToClientPacketNameMap = map[int32]string{0x00: "cookie_request", 0x01: "custom_payload", 0x02: "disconnect", 0x03: "finish_configuration", 0x04: "keep_alive", 0x05: "ping", 0x06: "reset_chat", 0x07: "registry_data", 0x08: "remove_resource_pack", 0x09: "add_resource_pack", 0x0a: "store_cookie", 0x0b: "transfer", 0x0c: "feature_flags", 0x0d: "tags", 0x0e: "select_known_packs", 0x0f: "custom_report_details", 0x10: "server_links", 0x11: "clear_dialog", 0x12: "show_dialog", 0x13: "code_of_conduct"} func (ret *ConfigurationToClientPacket) Decode(r io.ReadSeeker) (err error) { var ConfigurationToClientPacketNameKey int32 ConfigurationToClientPacketNameKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Name, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameMap, ConfigurationToClientPacketNameKey) if err != nil { return } switch ret.Name { case "add_resource_pack": var ConfigurationToClientPacketParamsAddResourcePackTmp ConfigurationToClientPacketCommonAddResourcePack err = ConfigurationToClientPacketParamsAddResourcePackTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsAddResourcePackTmp case "clear_dialog": var ConfigurationToClientPacketParamsClearDialogTmp ConfigurationToClientPacketCommonClearDialog err = ConfigurationToClientPacketParamsClearDialogTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsClearDialogTmp case "code_of_conduct": var ConfigurationToClientPacketParamsCodeOfConductTmp ConfigurationToClientPacketCodeOfConduct err = ConfigurationToClientPacketParamsCodeOfConductTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsCodeOfConductTmp case "cookie_request": var ConfigurationToClientPacketParamsCookieRequestTmp ConfigurationToClientPacketCommonCookieRequest err = ConfigurationToClientPacketParamsCookieRequestTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsCookieRequestTmp case "custom_payload": var ConfigurationToClientPacketParamsCustomPayloadTmp ConfigurationToClientPacketCustomPayload err = ConfigurationToClientPacketParamsCustomPayloadTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsCustomPayloadTmp case "custom_report_details": var ConfigurationToClientPacketParamsCustomReportDetailsTmp ConfigurationToClientPacketCommonCustomReportDetails err = ConfigurationToClientPacketParamsCustomReportDetailsTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsCustomReportDetailsTmp case "disconnect": var ConfigurationToClientPacketParamsDisconnectTmp ConfigurationToClientPacketDisconnect err = ConfigurationToClientPacketParamsDisconnectTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsDisconnectTmp case "feature_flags": var ConfigurationToClientPacketParamsFeatureFlagsTmp ConfigurationToClientPacketFeatureFlags err = ConfigurationToClientPacketParamsFeatureFlagsTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsFeatureFlagsTmp case "finish_configuration": var ConfigurationToClientPacketParamsFinishConfigurationTmp ConfigurationToClientPacketFinishConfiguration err = ConfigurationToClientPacketParamsFinishConfigurationTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsFinishConfigurationTmp case "keep_alive": var ConfigurationToClientPacketParamsKeepAliveTmp ConfigurationToClientPacketKeepAlive err = ConfigurationToClientPacketParamsKeepAliveTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsKeepAliveTmp case "ping": var ConfigurationToClientPacketParamsPingTmp ConfigurationToClientPacketPing err = ConfigurationToClientPacketParamsPingTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsPingTmp case "registry_data": var ConfigurationToClientPacketParamsRegistryDataTmp ConfigurationToClientPacketRegistryData err = ConfigurationToClientPacketParamsRegistryDataTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsRegistryDataTmp case "remove_resource_pack": var ConfigurationToClientPacketParamsRemoveResourcePackTmp ConfigurationToClientPacketCommonRemoveResourcePack err = ConfigurationToClientPacketParamsRemoveResourcePackTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsRemoveResourcePackTmp case "reset_chat": var ConfigurationToClientPacketParamsResetChatTmp ConfigurationToClientPacketResetChat err = ConfigurationToClientPacketParamsResetChatTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsResetChatTmp case "select_known_packs": var ConfigurationToClientPacketParamsSelectKnownPacksTmp ConfigurationToClientPacketCommonSelectKnownPacks err = ConfigurationToClientPacketParamsSelectKnownPacksTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsSelectKnownPacksTmp case "server_links": var ConfigurationToClientPacketParamsServerLinksTmp ConfigurationToClientPacketCommonServerLinks err = ConfigurationToClientPacketParamsServerLinksTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsServerLinksTmp case "show_dialog": var ConfigurationToClientPacketParamsShowDialogTmp ConfigurationToClientPacketShowDialog err = ConfigurationToClientPacketParamsShowDialogTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsShowDialogTmp case "store_cookie": var ConfigurationToClientPacketParamsStoreCookieTmp ConfigurationToClientPacketCommonStoreCookie err = ConfigurationToClientPacketParamsStoreCookieTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsStoreCookieTmp case "tags": var ConfigurationToClientPacketParamsTagsTmp ConfigurationToClientPacketTags err = ConfigurationToClientPacketParamsTagsTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsTagsTmp case "transfer": var ConfigurationToClientPacketParamsTransferTmp ConfigurationToClientPacketCommonTransfer err = ConfigurationToClientPacketParamsTransferTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToClientPacketParamsTransferTmp } return } var ConfigurationToClientPacketNameReverseMap = map[string]int32{"cookie_request": 0x00, "custom_payload": 0x01, "disconnect": 0x02, "finish_configuration": 0x03, "keep_alive": 0x04, "ping": 0x05, "reset_chat": 0x06, "registry_data": 0x07, "remove_resource_pack": 0x08, "add_resource_pack": 0x09, "store_cookie": 0x0a, "transfer": 0x0b, "feature_flags": 0x0c, "tags": 0x0d, "select_known_packs": 0x0e, "custom_report_details": 0x0f, "server_links": 0x10, "clear_dialog": 0x11, "show_dialog": 0x12, "code_of_conduct": 0x13} func (ret *ConfigurationToClientPacket) Encode(w io.Writer) (err error) { var vConfigurationToClientPacketName int32 vConfigurationToClientPacketName, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameReverseMap, ret.Name) if err != nil { return } err = proto_base.EncodeVarInt(w, vConfigurationToClientPacketName) if err != nil { return } switch ret.Name { case "add_resource_pack": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonAddResourcePack) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "clear_dialog": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonClearDialog) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "code_of_conduct": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCodeOfConduct) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "cookie_request": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonCookieRequest) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "custom_payload": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCustomPayload) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "custom_report_details": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonCustomReportDetails) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "disconnect": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketDisconnect) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "feature_flags": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFeatureFlags) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "finish_configuration": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFinishConfiguration) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "keep_alive": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketKeepAlive) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "ping": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketPing) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "registry_data": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketRegistryData) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "remove_resource_pack": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonRemoveResourcePack) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "reset_chat": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketResetChat) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "select_known_packs": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonSelectKnownPacks) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "server_links": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonServerLinks) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "show_dialog": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketShowDialog) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "store_cookie": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonStoreCookie) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "tags": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketTags) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "transfer": ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonTransfer) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams err = ConfigurationToClientPacketParamsEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToClientPacketCodeOfConduct struct { Contents string } func (ret *ConfigurationToClientPacketCodeOfConduct) Decode(r io.ReadSeeker) (err error) { ret.Contents, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *ConfigurationToClientPacketCodeOfConduct) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Contents) if err != nil { return } return } type ConfigurationToClientPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *ConfigurationToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent { var ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *ConfigurationToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { ConfigurationToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = ConfigurationToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToClientPacketCommonClearDialog struct { } func (ret *ConfigurationToClientPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *ConfigurationToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type ConfigurationToClientPacketCommonCookieRequest struct { Cookie string } func (ret *ConfigurationToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *ConfigurationToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type ConfigurationToClientPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *ConfigurationToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var ConfigurationToClientPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonCookieResponseValuePresent) if err != nil { return } if ConfigurationToClientPacketCommonCookieResponseValuePresent { var ConfigurationToClientPacketCommonCookieResponseValuePresentValue ByteArray err = ConfigurationToClientPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &ConfigurationToClientPacketCommonCookieResponseValuePresentValue } return } func (ret *ConfigurationToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { ConfigurationToClientPacketCommonCookieResponseValueEncTmp := *ret.Value err = ConfigurationToClientPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToClientPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *ConfigurationToClientPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var ConfigurationToClientPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonCustomClickActionNbtPresent) if err != nil { return } if ConfigurationToClientPacketCommonCustomClickActionNbtPresent { var ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue } return } func (ret *ConfigurationToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { ConfigurationToClientPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = ConfigurationToClientPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToClientPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *ConfigurationToClientPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lConfigurationToClientPacketCommonCustomReportDetailsDetails int32 lConfigurationToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lConfigurationToClientPacketCommonCustomReportDetailsDetails { var ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *ConfigurationToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iConfigurationToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iConfigurationToClientPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iConfigurationToClientPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type ConfigurationToClientPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *ConfigurationToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent { var ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *ConfigurationToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type ConfigurationToClientPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *ConfigurationToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lConfigurationToClientPacketCommonSelectKnownPacksPacks int32 lConfigurationToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lConfigurationToClientPacketCommonSelectKnownPacksPacks { var ConfigurationToClientPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, ConfigurationToClientPacketCommonSelectKnownPacksPacksElement) } return } func (ret *ConfigurationToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iConfigurationToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type ConfigurationToClientPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *ConfigurationToClientPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lConfigurationToClientPacketCommonServerLinksLinks int32 lConfigurationToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lConfigurationToClientPacketCommonServerLinksLinks { var ConfigurationToClientPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType { case true: var ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } ConfigurationToClientPacketCommonServerLinksLinksElement.KnownType = ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType { case false: var ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } ConfigurationToClientPacketCommonServerLinksLinksElement.UnknownType = ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } ConfigurationToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, ConfigurationToClientPacketCommonServerLinksLinksElement) } return } func (ret *ConfigurationToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iConfigurationToClientPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType { case true: ConfigurationToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp := ConfigurationToClientPacketCommonServerLinksLinksInnerKnownType err = ConfigurationToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType { case false: ConfigurationToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } ConfigurationToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := ConfigurationToClientPacketCommonServerLinksLinksInnerUnknownType err = ConfigurationToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type ConfigurationToClientPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var ConfigurationToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *ConfigurationToClientPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var ConfigurationToClientPacketCommonSettingsParticleStatusKey int32 ConfigurationToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(ConfigurationToClientPacketCommonSettingsParticleStatusMap, ConfigurationToClientPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var ConfigurationToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *ConfigurationToClientPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vConfigurationToClientPacketCommonSettingsParticleStatus int32 vConfigurationToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(ConfigurationToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vConfigurationToClientPacketCommonSettingsParticleStatus) if err != nil { return } return } type ConfigurationToClientPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *ConfigurationToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *ConfigurationToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } ConfigurationToClientPacketCommonStoreCookieValueEncTmp := ret.Value err = ConfigurationToClientPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type ConfigurationToClientPacketCommonTransfer struct { Host string Port int32 } func (ret *ConfigurationToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *ConfigurationToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) if err != nil { return } return } type ConfigurationToClientPacketCustomPayload struct { Channel string Data proto_base.RestBuffer } func (ret *ConfigurationToClientPacketCustomPayload) 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 *ConfigurationToClientPacketCustomPayload) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Channel) if err != nil { return } ConfigurationToClientPacketCustomPayloadDataEncTmp := ret.Data err = ConfigurationToClientPacketCustomPayloadDataEncTmp.Encode(w) if err != nil { return } return } type ConfigurationToClientPacketDisconnect struct { Reason nbt.Anon } func (ret *ConfigurationToClientPacketDisconnect) Decode(r io.ReadSeeker) (err error) { err = ret.Reason.Decode(r) if err != nil { return } return } func (ret *ConfigurationToClientPacketDisconnect) Encode(w io.Writer) (err error) { ConfigurationToClientPacketDisconnectReasonEncTmp := ret.Reason err = ConfigurationToClientPacketDisconnectReasonEncTmp.Encode(w) if err != nil { return } return } type ConfigurationToClientPacketFeatureFlags struct { Features []string } func (ret *ConfigurationToClientPacketFeatureFlags) Decode(r io.ReadSeeker) (err error) { var lConfigurationToClientPacketFeatureFlagsFeatures int32 lConfigurationToClientPacketFeatureFlagsFeatures, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Features = []string{} for range lConfigurationToClientPacketFeatureFlagsFeatures { var ConfigurationToClientPacketFeatureFlagsFeaturesElement string ConfigurationToClientPacketFeatureFlagsFeaturesElement, err = proto_base.DecodeString(r) if err != nil { return } ret.Features = append(ret.Features, ConfigurationToClientPacketFeatureFlagsFeaturesElement) } return } func (ret *ConfigurationToClientPacketFeatureFlags) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Features))) if err != nil { return } for iConfigurationToClientPacketFeatureFlagsFeatures := range len(ret.Features) { err = proto_base.EncodeString(w, ret.Features[iConfigurationToClientPacketFeatureFlagsFeatures]) if err != nil { return } } return } type ConfigurationToClientPacketFinishConfiguration struct { } func (ret *ConfigurationToClientPacketFinishConfiguration) Decode(r io.ReadSeeker) (err error) { return } func (ret *ConfigurationToClientPacketFinishConfiguration) Encode(w io.Writer) (err error) { return } type ConfigurationToClientPacketKeepAlive struct { KeepAliveId int64 } func (ret *ConfigurationToClientPacketKeepAlive) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId) if err != nil { return } return } func (ret *ConfigurationToClientPacketKeepAlive) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.KeepAliveId) if err != nil { return } return } type ConfigurationToClientPacketPing struct { Id int32 } func (ret *ConfigurationToClientPacketPing) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Id) if err != nil { return } return } func (ret *ConfigurationToClientPacketPing) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Id) if err != nil { return } return } type ConfigurationToClientPacketRegistryData struct { Id string Entries []struct { Key string Value *nbt.Anon } } func (ret *ConfigurationToClientPacketRegistryData) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var lConfigurationToClientPacketRegistryDataEntries int32 lConfigurationToClientPacketRegistryDataEntries, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Entries = []struct { Key string Value *nbt.Anon }{} for range lConfigurationToClientPacketRegistryDataEntries { var ConfigurationToClientPacketRegistryDataEntriesElement struct { Key string Value *nbt.Anon } ConfigurationToClientPacketRegistryDataEntriesElement.Key, err = proto_base.DecodeString(r) if err != nil { return } var ConfigurationToClientPacketRegistryDataEntriesElementValuePresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketRegistryDataEntriesElementValuePresent) if err != nil { return } if ConfigurationToClientPacketRegistryDataEntriesElementValuePresent { var ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue nbt.Anon err = ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue.Decode(r) if err != nil { return } ConfigurationToClientPacketRegistryDataEntriesElement.Value = &ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue } ret.Entries = append(ret.Entries, ConfigurationToClientPacketRegistryDataEntriesElement) } return } func (ret *ConfigurationToClientPacketRegistryData) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Entries))) if err != nil { return } for iConfigurationToClientPacketRegistryDataEntries := range len(ret.Entries) { err = proto_base.EncodeString(w, ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value != nil) if err != nil { return } if ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value != nil { ConfigurationToClientPacketRegistryDataEntriesInnerValueEncTmp := *ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value err = ConfigurationToClientPacketRegistryDataEntriesInnerValueEncTmp.Encode(w) if err != nil { return } } } return } type ConfigurationToClientPacketResetChat struct { } func (ret *ConfigurationToClientPacketResetChat) Decode(r io.ReadSeeker) (err error) { return } func (ret *ConfigurationToClientPacketResetChat) Encode(w io.Writer) (err error) { return } type ConfigurationToClientPacketShowDialog struct { Dialog nbt.Anon } func (ret *ConfigurationToClientPacketShowDialog) Decode(r io.ReadSeeker) (err error) { err = ret.Dialog.Decode(r) if err != nil { return } return } func (ret *ConfigurationToClientPacketShowDialog) Encode(w io.Writer) (err error) { ConfigurationToClientPacketShowDialogDialogEncTmp := ret.Dialog err = ConfigurationToClientPacketShowDialogDialogEncTmp.Encode(w) if err != nil { return } return } type ConfigurationToClientPacketTags struct { Tags []struct { TagType string Tags Tags } } func (ret *ConfigurationToClientPacketTags) Decode(r io.ReadSeeker) (err error) { var lConfigurationToClientPacketTagsTags int32 lConfigurationToClientPacketTagsTags, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Tags = []struct { TagType string Tags Tags }{} for range lConfigurationToClientPacketTagsTags { var ConfigurationToClientPacketTagsTagsElement struct { TagType string Tags Tags } ConfigurationToClientPacketTagsTagsElement.TagType, err = proto_base.DecodeString(r) if err != nil { return } err = ConfigurationToClientPacketTagsTagsElement.Tags.Decode(r) if err != nil { return } ret.Tags = append(ret.Tags, ConfigurationToClientPacketTagsTagsElement) } return } func (ret *ConfigurationToClientPacketTags) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Tags))) if err != nil { return } for iConfigurationToClientPacketTagsTags := range len(ret.Tags) { err = proto_base.EncodeString(w, ret.Tags[iConfigurationToClientPacketTagsTags].TagType) if err != nil { return } ConfigurationToClientPacketTagsTagsInnerTagsEncTmp := ret.Tags[iConfigurationToClientPacketTagsTags].Tags err = ConfigurationToClientPacketTagsTagsInnerTagsEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToServerPacket struct { Name string Params any } var ConfigurationToServerPacketNameMap = map[int32]string{0x00: "settings", 0x01: "cookie_response", 0x02: "custom_payload", 0x03: "finish_configuration", 0x04: "keep_alive", 0x05: "pong", 0x06: "resource_pack_receive", 0x07: "select_known_packs", 0x08: "custom_click_action", 0x09: "accept_code_of_conduct"} func (ret *ConfigurationToServerPacket) Decode(r io.ReadSeeker) (err error) { var ConfigurationToServerPacketNameKey int32 ConfigurationToServerPacketNameKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Name, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameMap, ConfigurationToServerPacketNameKey) if err != nil { return } switch ret.Name { case "accept_code_of_conduct": var ConfigurationToServerPacketParamsAcceptCodeOfConductTmp ConfigurationToServerPacketAcceptCodeOfConduct err = ConfigurationToServerPacketParamsAcceptCodeOfConductTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsAcceptCodeOfConductTmp case "cookie_response": var ConfigurationToServerPacketParamsCookieResponseTmp ConfigurationToServerPacketCommonCookieResponse err = ConfigurationToServerPacketParamsCookieResponseTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsCookieResponseTmp case "custom_click_action": var ConfigurationToServerPacketParamsCustomClickActionTmp ConfigurationToServerPacketCommonCustomClickAction err = ConfigurationToServerPacketParamsCustomClickActionTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsCustomClickActionTmp case "custom_payload": var ConfigurationToServerPacketParamsCustomPayloadTmp ConfigurationToServerPacketCustomPayload err = ConfigurationToServerPacketParamsCustomPayloadTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsCustomPayloadTmp case "finish_configuration": var ConfigurationToServerPacketParamsFinishConfigurationTmp ConfigurationToServerPacketFinishConfiguration err = ConfigurationToServerPacketParamsFinishConfigurationTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsFinishConfigurationTmp case "keep_alive": var ConfigurationToServerPacketParamsKeepAliveTmp ConfigurationToServerPacketKeepAlive err = ConfigurationToServerPacketParamsKeepAliveTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsKeepAliveTmp case "pong": var ConfigurationToServerPacketParamsPongTmp ConfigurationToServerPacketPong err = ConfigurationToServerPacketParamsPongTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsPongTmp case "resource_pack_receive": var ConfigurationToServerPacketParamsResourcePackReceiveTmp ConfigurationToServerPacketResourcePackReceive err = ConfigurationToServerPacketParamsResourcePackReceiveTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsResourcePackReceiveTmp case "select_known_packs": var ConfigurationToServerPacketParamsSelectKnownPacksTmp ConfigurationToServerPacketCommonSelectKnownPacks err = ConfigurationToServerPacketParamsSelectKnownPacksTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsSelectKnownPacksTmp case "settings": var ConfigurationToServerPacketParamsSettingsTmp ConfigurationToServerPacketCommonSettings err = ConfigurationToServerPacketParamsSettingsTmp.Decode(r) if err != nil { return } ret.Params = ConfigurationToServerPacketParamsSettingsTmp } return } var ConfigurationToServerPacketNameReverseMap = map[string]int32{"settings": 0x00, "cookie_response": 0x01, "custom_payload": 0x02, "finish_configuration": 0x03, "keep_alive": 0x04, "pong": 0x05, "resource_pack_receive": 0x06, "select_known_packs": 0x07, "custom_click_action": 0x08, "accept_code_of_conduct": 0x09} func (ret *ConfigurationToServerPacket) Encode(w io.Writer) (err error) { var vConfigurationToServerPacketName int32 vConfigurationToServerPacketName, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameReverseMap, ret.Name) if err != nil { return } err = proto_base.EncodeVarInt(w, vConfigurationToServerPacketName) if err != nil { return } switch ret.Name { case "accept_code_of_conduct": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketAcceptCodeOfConduct) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "cookie_response": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonCookieResponse) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "custom_click_action": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonCustomClickAction) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "custom_payload": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCustomPayload) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "finish_configuration": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketFinishConfiguration) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "keep_alive": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketKeepAlive) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "pong": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketPong) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "resource_pack_receive": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketResourcePackReceive) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "select_known_packs": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonSelectKnownPacks) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "settings": ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonSettings) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams err = ConfigurationToServerPacketParamsEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToServerPacketAcceptCodeOfConduct struct { } func (ret *ConfigurationToServerPacketAcceptCodeOfConduct) Decode(r io.ReadSeeker) (err error) { return } func (ret *ConfigurationToServerPacketAcceptCodeOfConduct) Encode(w io.Writer) (err error) { return } type ConfigurationToServerPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *ConfigurationToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent { var ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *ConfigurationToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { ConfigurationToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = ConfigurationToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToServerPacketCommonClearDialog struct { } func (ret *ConfigurationToServerPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *ConfigurationToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type ConfigurationToServerPacketCommonCookieRequest struct { Cookie string } func (ret *ConfigurationToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *ConfigurationToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type ConfigurationToServerPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *ConfigurationToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var ConfigurationToServerPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonCookieResponseValuePresent) if err != nil { return } if ConfigurationToServerPacketCommonCookieResponseValuePresent { var ConfigurationToServerPacketCommonCookieResponseValuePresentValue ByteArray err = ConfigurationToServerPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &ConfigurationToServerPacketCommonCookieResponseValuePresentValue } return } func (ret *ConfigurationToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { ConfigurationToServerPacketCommonCookieResponseValueEncTmp := *ret.Value err = ConfigurationToServerPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToServerPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *ConfigurationToServerPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var ConfigurationToServerPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonCustomClickActionNbtPresent) if err != nil { return } if ConfigurationToServerPacketCommonCustomClickActionNbtPresent { var ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue } return } func (ret *ConfigurationToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { ConfigurationToServerPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = ConfigurationToServerPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type ConfigurationToServerPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *ConfigurationToServerPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lConfigurationToServerPacketCommonCustomReportDetailsDetails int32 lConfigurationToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lConfigurationToServerPacketCommonCustomReportDetailsDetails { var ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *ConfigurationToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iConfigurationToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iConfigurationToServerPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iConfigurationToServerPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type ConfigurationToServerPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *ConfigurationToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent { var ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *ConfigurationToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type ConfigurationToServerPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *ConfigurationToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lConfigurationToServerPacketCommonSelectKnownPacksPacks int32 lConfigurationToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lConfigurationToServerPacketCommonSelectKnownPacksPacks { var ConfigurationToServerPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, ConfigurationToServerPacketCommonSelectKnownPacksPacksElement) } return } func (ret *ConfigurationToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iConfigurationToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type ConfigurationToServerPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *ConfigurationToServerPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lConfigurationToServerPacketCommonServerLinksLinks int32 lConfigurationToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lConfigurationToServerPacketCommonServerLinksLinks { var ConfigurationToServerPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType { case true: var ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } ConfigurationToServerPacketCommonServerLinksLinksElement.KnownType = ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType { case false: var ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } ConfigurationToServerPacketCommonServerLinksLinksElement.UnknownType = ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } ConfigurationToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, ConfigurationToServerPacketCommonServerLinksLinksElement) } return } func (ret *ConfigurationToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iConfigurationToServerPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType { case true: ConfigurationToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp := ConfigurationToServerPacketCommonServerLinksLinksInnerKnownType err = ConfigurationToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType { case false: ConfigurationToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } ConfigurationToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := ConfigurationToServerPacketCommonServerLinksLinksInnerUnknownType err = ConfigurationToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type ConfigurationToServerPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var ConfigurationToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *ConfigurationToServerPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var ConfigurationToServerPacketCommonSettingsParticleStatusKey int32 ConfigurationToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(ConfigurationToServerPacketCommonSettingsParticleStatusMap, ConfigurationToServerPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var ConfigurationToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *ConfigurationToServerPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vConfigurationToServerPacketCommonSettingsParticleStatus int32 vConfigurationToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(ConfigurationToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vConfigurationToServerPacketCommonSettingsParticleStatus) if err != nil { return } return } type ConfigurationToServerPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *ConfigurationToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *ConfigurationToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } ConfigurationToServerPacketCommonStoreCookieValueEncTmp := ret.Value err = ConfigurationToServerPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type ConfigurationToServerPacketCommonTransfer struct { Host string Port int32 } func (ret *ConfigurationToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *ConfigurationToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) if err != nil { return } return } type ConfigurationToServerPacketCustomPayload struct { Channel string Data proto_base.RestBuffer } func (ret *ConfigurationToServerPacketCustomPayload) 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 *ConfigurationToServerPacketCustomPayload) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Channel) if err != nil { return } ConfigurationToServerPacketCustomPayloadDataEncTmp := ret.Data err = ConfigurationToServerPacketCustomPayloadDataEncTmp.Encode(w) if err != nil { return } return } type ConfigurationToServerPacketFinishConfiguration struct { } func (ret *ConfigurationToServerPacketFinishConfiguration) Decode(r io.ReadSeeker) (err error) { return } func (ret *ConfigurationToServerPacketFinishConfiguration) Encode(w io.Writer) (err error) { return } type ConfigurationToServerPacketKeepAlive struct { KeepAliveId int64 } func (ret *ConfigurationToServerPacketKeepAlive) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId) if err != nil { return } return } func (ret *ConfigurationToServerPacketKeepAlive) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.KeepAliveId) if err != nil { return } return } type ConfigurationToServerPacketPong struct { Id int32 } func (ret *ConfigurationToServerPacketPong) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Id) if err != nil { return } return } func (ret *ConfigurationToServerPacketPong) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Id) if err != nil { return } return } type ConfigurationToServerPacketResourcePackReceive struct { Uuid uuid.UUID Result int32 } func (ret *ConfigurationToServerPacketResourcePackReceive) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Result, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *ConfigurationToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Result) 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 HandshakingToClientPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *HandshakingToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent { var HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *HandshakingToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { HandshakingToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = HandshakingToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type HandshakingToClientPacketCommonClearDialog struct { } func (ret *HandshakingToClientPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *HandshakingToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type HandshakingToClientPacketCommonCookieRequest struct { Cookie string } func (ret *HandshakingToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *HandshakingToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type HandshakingToClientPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *HandshakingToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var HandshakingToClientPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonCookieResponseValuePresent) if err != nil { return } if HandshakingToClientPacketCommonCookieResponseValuePresent { var HandshakingToClientPacketCommonCookieResponseValuePresentValue ByteArray err = HandshakingToClientPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &HandshakingToClientPacketCommonCookieResponseValuePresentValue } return } func (ret *HandshakingToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { HandshakingToClientPacketCommonCookieResponseValueEncTmp := *ret.Value err = HandshakingToClientPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type HandshakingToClientPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *HandshakingToClientPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var HandshakingToClientPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonCustomClickActionNbtPresent) if err != nil { return } if HandshakingToClientPacketCommonCustomClickActionNbtPresent { var HandshakingToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = HandshakingToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &HandshakingToClientPacketCommonCustomClickActionNbtPresentValue } return } func (ret *HandshakingToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { HandshakingToClientPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = HandshakingToClientPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type HandshakingToClientPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *HandshakingToClientPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lHandshakingToClientPacketCommonCustomReportDetailsDetails int32 lHandshakingToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lHandshakingToClientPacketCommonCustomReportDetailsDetails { var HandshakingToClientPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } HandshakingToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } HandshakingToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, HandshakingToClientPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *HandshakingToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iHandshakingToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iHandshakingToClientPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iHandshakingToClientPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type HandshakingToClientPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *HandshakingToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var HandshakingToClientPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if HandshakingToClientPacketCommonRemoveResourcePackUuidPresent { var HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *HandshakingToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type HandshakingToClientPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *HandshakingToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lHandshakingToClientPacketCommonSelectKnownPacksPacks int32 lHandshakingToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lHandshakingToClientPacketCommonSelectKnownPacksPacks { var HandshakingToClientPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, HandshakingToClientPacketCommonSelectKnownPacksPacksElement) } return } func (ret *HandshakingToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iHandshakingToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type HandshakingToClientPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *HandshakingToClientPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lHandshakingToClientPacketCommonServerLinksLinks int32 lHandshakingToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lHandshakingToClientPacketCommonServerLinksLinks { var HandshakingToClientPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType { case true: var HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } HandshakingToClientPacketCommonServerLinksLinksElement.KnownType = HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType { case false: var HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } HandshakingToClientPacketCommonServerLinksLinksElement.UnknownType = HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } HandshakingToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, HandshakingToClientPacketCommonServerLinksLinksElement) } return } func (ret *HandshakingToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iHandshakingToClientPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType { case true: HandshakingToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } HandshakingToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp := HandshakingToClientPacketCommonServerLinksLinksInnerKnownType err = HandshakingToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType { case false: HandshakingToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } HandshakingToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := HandshakingToClientPacketCommonServerLinksLinksInnerUnknownType err = HandshakingToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type HandshakingToClientPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var HandshakingToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *HandshakingToClientPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var HandshakingToClientPacketCommonSettingsParticleStatusKey int32 HandshakingToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(HandshakingToClientPacketCommonSettingsParticleStatusMap, HandshakingToClientPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var HandshakingToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *HandshakingToClientPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vHandshakingToClientPacketCommonSettingsParticleStatus int32 vHandshakingToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(HandshakingToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vHandshakingToClientPacketCommonSettingsParticleStatus) if err != nil { return } return } type HandshakingToClientPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *HandshakingToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *HandshakingToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } HandshakingToClientPacketCommonStoreCookieValueEncTmp := ret.Value err = HandshakingToClientPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type HandshakingToClientPacketCommonTransfer struct { Host string Port int32 } func (ret *HandshakingToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *HandshakingToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) 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 HandshakingToServerPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *HandshakingToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent { var HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *HandshakingToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { HandshakingToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = HandshakingToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type HandshakingToServerPacketCommonClearDialog struct { } func (ret *HandshakingToServerPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *HandshakingToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type HandshakingToServerPacketCommonCookieRequest struct { Cookie string } func (ret *HandshakingToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *HandshakingToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type HandshakingToServerPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *HandshakingToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var HandshakingToServerPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonCookieResponseValuePresent) if err != nil { return } if HandshakingToServerPacketCommonCookieResponseValuePresent { var HandshakingToServerPacketCommonCookieResponseValuePresentValue ByteArray err = HandshakingToServerPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &HandshakingToServerPacketCommonCookieResponseValuePresentValue } return } func (ret *HandshakingToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { HandshakingToServerPacketCommonCookieResponseValueEncTmp := *ret.Value err = HandshakingToServerPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type HandshakingToServerPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *HandshakingToServerPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var HandshakingToServerPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonCustomClickActionNbtPresent) if err != nil { return } if HandshakingToServerPacketCommonCustomClickActionNbtPresent { var HandshakingToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = HandshakingToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &HandshakingToServerPacketCommonCustomClickActionNbtPresentValue } return } func (ret *HandshakingToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { HandshakingToServerPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = HandshakingToServerPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type HandshakingToServerPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *HandshakingToServerPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lHandshakingToServerPacketCommonCustomReportDetailsDetails int32 lHandshakingToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lHandshakingToServerPacketCommonCustomReportDetailsDetails { var HandshakingToServerPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } HandshakingToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } HandshakingToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, HandshakingToServerPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *HandshakingToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iHandshakingToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iHandshakingToServerPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iHandshakingToServerPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type HandshakingToServerPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *HandshakingToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var HandshakingToServerPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if HandshakingToServerPacketCommonRemoveResourcePackUuidPresent { var HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *HandshakingToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type HandshakingToServerPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *HandshakingToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lHandshakingToServerPacketCommonSelectKnownPacksPacks int32 lHandshakingToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lHandshakingToServerPacketCommonSelectKnownPacksPacks { var HandshakingToServerPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, HandshakingToServerPacketCommonSelectKnownPacksPacksElement) } return } func (ret *HandshakingToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iHandshakingToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type HandshakingToServerPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *HandshakingToServerPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lHandshakingToServerPacketCommonServerLinksLinks int32 lHandshakingToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lHandshakingToServerPacketCommonServerLinksLinks { var HandshakingToServerPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType { case true: var HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } HandshakingToServerPacketCommonServerLinksLinksElement.KnownType = HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType { case false: var HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } HandshakingToServerPacketCommonServerLinksLinksElement.UnknownType = HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } HandshakingToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, HandshakingToServerPacketCommonServerLinksLinksElement) } return } func (ret *HandshakingToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iHandshakingToServerPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType { case true: HandshakingToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } HandshakingToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp := HandshakingToServerPacketCommonServerLinksLinksInnerKnownType err = HandshakingToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType { case false: HandshakingToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } HandshakingToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := HandshakingToServerPacketCommonServerLinksLinksInnerUnknownType err = HandshakingToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type HandshakingToServerPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var HandshakingToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *HandshakingToServerPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var HandshakingToServerPacketCommonSettingsParticleStatusKey int32 HandshakingToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(HandshakingToServerPacketCommonSettingsParticleStatusMap, HandshakingToServerPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var HandshakingToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *HandshakingToServerPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vHandshakingToServerPacketCommonSettingsParticleStatus int32 vHandshakingToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(HandshakingToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vHandshakingToServerPacketCommonSettingsParticleStatus) if err != nil { return } return } type HandshakingToServerPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *HandshakingToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *HandshakingToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } HandshakingToServerPacketCommonStoreCookieValueEncTmp := ret.Value err = HandshakingToServerPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type HandshakingToServerPacketCommonTransfer struct { Host string Port int32 } func (ret *HandshakingToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *HandshakingToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) 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", 0x05: "cookie_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 "cookie_request": var LoginToClientPacketParamsCookieRequestTmp LoginToClientPacketCommonCookieRequest err = LoginToClientPacketParamsCookieRequestTmp.Decode(r) if err != nil { return } ret.Params = LoginToClientPacketParamsCookieRequestTmp 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, "cookie_request": 0x05} 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 "cookie_request": LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCommonCookieRequest) 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 LoginToClientPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *LoginToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var LoginToClientPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if LoginToClientPacketCommonAddResourcePackPromptMessagePresent { var LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *LoginToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { LoginToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = LoginToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type LoginToClientPacketCommonClearDialog struct { } func (ret *LoginToClientPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *LoginToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type LoginToClientPacketCommonCookieRequest struct { Cookie string } func (ret *LoginToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *LoginToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type LoginToClientPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *LoginToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var LoginToClientPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonCookieResponseValuePresent) if err != nil { return } if LoginToClientPacketCommonCookieResponseValuePresent { var LoginToClientPacketCommonCookieResponseValuePresentValue ByteArray err = LoginToClientPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &LoginToClientPacketCommonCookieResponseValuePresentValue } return } func (ret *LoginToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { LoginToClientPacketCommonCookieResponseValueEncTmp := *ret.Value err = LoginToClientPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type LoginToClientPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *LoginToClientPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var LoginToClientPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonCustomClickActionNbtPresent) if err != nil { return } if LoginToClientPacketCommonCustomClickActionNbtPresent { var LoginToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = LoginToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &LoginToClientPacketCommonCustomClickActionNbtPresentValue } return } func (ret *LoginToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { LoginToClientPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = LoginToClientPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type LoginToClientPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *LoginToClientPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lLoginToClientPacketCommonCustomReportDetailsDetails int32 lLoginToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lLoginToClientPacketCommonCustomReportDetailsDetails { var LoginToClientPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } LoginToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } LoginToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, LoginToClientPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *LoginToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iLoginToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iLoginToClientPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iLoginToClientPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type LoginToClientPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *LoginToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var LoginToClientPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if LoginToClientPacketCommonRemoveResourcePackUuidPresent { var LoginToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, LoginToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &LoginToClientPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *LoginToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type LoginToClientPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *LoginToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lLoginToClientPacketCommonSelectKnownPacksPacks int32 lLoginToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lLoginToClientPacketCommonSelectKnownPacksPacks { var LoginToClientPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } LoginToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } LoginToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } LoginToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, LoginToClientPacketCommonSelectKnownPacksPacksElement) } return } func (ret *LoginToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iLoginToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type LoginToClientPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *LoginToClientPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lLoginToClientPacketCommonServerLinksLinks int32 lLoginToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lLoginToClientPacketCommonServerLinksLinks { var LoginToClientPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch LoginToClientPacketCommonServerLinksLinksElement.HasKnownType { case true: var LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } LoginToClientPacketCommonServerLinksLinksElement.KnownType = LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch LoginToClientPacketCommonServerLinksLinksElement.HasKnownType { case false: var LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } LoginToClientPacketCommonServerLinksLinksElement.UnknownType = LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } LoginToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, LoginToClientPacketCommonServerLinksLinksElement) } return } func (ret *LoginToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iLoginToClientPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType { case true: LoginToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iLoginToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } LoginToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp := LoginToClientPacketCommonServerLinksLinksInnerKnownType err = LoginToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType { case false: LoginToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iLoginToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } LoginToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := LoginToClientPacketCommonServerLinksLinksInnerUnknownType err = LoginToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iLoginToClientPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type LoginToClientPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var LoginToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *LoginToClientPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var LoginToClientPacketCommonSettingsParticleStatusKey int32 LoginToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(LoginToClientPacketCommonSettingsParticleStatusMap, LoginToClientPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var LoginToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *LoginToClientPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vLoginToClientPacketCommonSettingsParticleStatus int32 vLoginToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(LoginToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vLoginToClientPacketCommonSettingsParticleStatus) if err != nil { return } return } type LoginToClientPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *LoginToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *LoginToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } LoginToClientPacketCommonStoreCookieValueEncTmp := ret.Value err = LoginToClientPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type LoginToClientPacketCommonTransfer struct { Host string Port int32 } func (ret *LoginToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *LoginToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) 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 ShouldAuthenticate bool } 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 } err = binary.Read(r, binary.BigEndian, &ret.ShouldAuthenticate) 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 } err = binary.Write(w, binary.BigEndian, ret.ShouldAuthenticate) 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 Properties []struct { Name string Value string Signature *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 } var lLoginToClientPacketSuccessProperties int32 lLoginToClientPacketSuccessProperties, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Properties = []struct { Name string Value string Signature *string }{} for range lLoginToClientPacketSuccessProperties { var LoginToClientPacketSuccessPropertiesElement struct { Name string Value string Signature *string } LoginToClientPacketSuccessPropertiesElement.Name, err = proto_base.DecodeString(r) if err != nil { return } LoginToClientPacketSuccessPropertiesElement.Value, err = proto_base.DecodeString(r) if err != nil { return } var LoginToClientPacketSuccessPropertiesElementSignaturePresent bool err = binary.Read(r, binary.BigEndian, &LoginToClientPacketSuccessPropertiesElementSignaturePresent) if err != nil { return } if LoginToClientPacketSuccessPropertiesElementSignaturePresent { var LoginToClientPacketSuccessPropertiesElementSignaturePresentValue string LoginToClientPacketSuccessPropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r) if err != nil { return } LoginToClientPacketSuccessPropertiesElement.Signature = &LoginToClientPacketSuccessPropertiesElementSignaturePresentValue } ret.Properties = append(ret.Properties, LoginToClientPacketSuccessPropertiesElement) } 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 } err = proto_base.EncodeVarInt(w, int32(len(ret.Properties))) if err != nil { return } for iLoginToClientPacketSuccessProperties := range len(ret.Properties) { err = proto_base.EncodeString(w, ret.Properties[iLoginToClientPacketSuccessProperties].Name) if err != nil { return } err = proto_base.EncodeString(w, ret.Properties[iLoginToClientPacketSuccessProperties].Value) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Properties[iLoginToClientPacketSuccessProperties].Signature != nil) if err != nil { return } if ret.Properties[iLoginToClientPacketSuccessProperties].Signature != nil { err = proto_base.EncodeString(w, *ret.Properties[iLoginToClientPacketSuccessProperties].Signature) 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", 0x03: "login_acknowledged", 0x04: "cookie_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 "cookie_response": var LoginToServerPacketParamsCookieResponseTmp LoginToServerPacketCommonCookieResponse err = LoginToServerPacketParamsCookieResponseTmp.Decode(r) if err != nil { return } ret.Params = LoginToServerPacketParamsCookieResponseTmp case "encryption_begin": var LoginToServerPacketParamsEncryptionBeginTmp LoginToServerPacketEncryptionBegin err = LoginToServerPacketParamsEncryptionBeginTmp.Decode(r) if err != nil { return } ret.Params = LoginToServerPacketParamsEncryptionBeginTmp case "login_acknowledged": var LoginToServerPacketParamsLoginAcknowledgedTmp LoginToServerPacketLoginAcknowledged err = LoginToServerPacketParamsLoginAcknowledgedTmp.Decode(r) if err != nil { return } ret.Params = LoginToServerPacketParamsLoginAcknowledgedTmp 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, "login_acknowledged": 0x03, "cookie_response": 0x04} 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 "cookie_response": LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketCommonCookieResponse) if !ok { err = proto_base.BadTypeError return } LoginToServerPacketParamsEncTmp := LoginToServerPacketParams err = LoginToServerPacketParamsEncTmp.Encode(w) if err != nil { return } 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_acknowledged": LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginAcknowledged) 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 LoginToServerPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *LoginToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var LoginToServerPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if LoginToServerPacketCommonAddResourcePackPromptMessagePresent { var LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *LoginToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { LoginToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = LoginToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type LoginToServerPacketCommonClearDialog struct { } func (ret *LoginToServerPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *LoginToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type LoginToServerPacketCommonCookieRequest struct { Cookie string } func (ret *LoginToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *LoginToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type LoginToServerPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *LoginToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var LoginToServerPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonCookieResponseValuePresent) if err != nil { return } if LoginToServerPacketCommonCookieResponseValuePresent { var LoginToServerPacketCommonCookieResponseValuePresentValue ByteArray err = LoginToServerPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &LoginToServerPacketCommonCookieResponseValuePresentValue } return } func (ret *LoginToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { LoginToServerPacketCommonCookieResponseValueEncTmp := *ret.Value err = LoginToServerPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type LoginToServerPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *LoginToServerPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var LoginToServerPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonCustomClickActionNbtPresent) if err != nil { return } if LoginToServerPacketCommonCustomClickActionNbtPresent { var LoginToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = LoginToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &LoginToServerPacketCommonCustomClickActionNbtPresentValue } return } func (ret *LoginToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { LoginToServerPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = LoginToServerPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type LoginToServerPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *LoginToServerPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lLoginToServerPacketCommonCustomReportDetailsDetails int32 lLoginToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lLoginToServerPacketCommonCustomReportDetailsDetails { var LoginToServerPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } LoginToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } LoginToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, LoginToServerPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *LoginToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iLoginToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iLoginToServerPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iLoginToServerPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type LoginToServerPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *LoginToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var LoginToServerPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if LoginToServerPacketCommonRemoveResourcePackUuidPresent { var LoginToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, LoginToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &LoginToServerPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *LoginToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type LoginToServerPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *LoginToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lLoginToServerPacketCommonSelectKnownPacksPacks int32 lLoginToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lLoginToServerPacketCommonSelectKnownPacksPacks { var LoginToServerPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } LoginToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } LoginToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } LoginToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, LoginToServerPacketCommonSelectKnownPacksPacksElement) } return } func (ret *LoginToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iLoginToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type LoginToServerPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *LoginToServerPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lLoginToServerPacketCommonServerLinksLinks int32 lLoginToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lLoginToServerPacketCommonServerLinksLinks { var LoginToServerPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch LoginToServerPacketCommonServerLinksLinksElement.HasKnownType { case true: var LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } LoginToServerPacketCommonServerLinksLinksElement.KnownType = LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch LoginToServerPacketCommonServerLinksLinksElement.HasKnownType { case false: var LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } LoginToServerPacketCommonServerLinksLinksElement.UnknownType = LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } LoginToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, LoginToServerPacketCommonServerLinksLinksElement) } return } func (ret *LoginToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iLoginToServerPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType { case true: LoginToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iLoginToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } LoginToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp := LoginToServerPacketCommonServerLinksLinksInnerKnownType err = LoginToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType { case false: LoginToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iLoginToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } LoginToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := LoginToServerPacketCommonServerLinksLinksInnerUnknownType err = LoginToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iLoginToServerPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type LoginToServerPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var LoginToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *LoginToServerPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var LoginToServerPacketCommonSettingsParticleStatusKey int32 LoginToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(LoginToServerPacketCommonSettingsParticleStatusMap, LoginToServerPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var LoginToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *LoginToServerPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vLoginToServerPacketCommonSettingsParticleStatus int32 vLoginToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(LoginToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vLoginToServerPacketCommonSettingsParticleStatus) if err != nil { return } return } type LoginToServerPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *LoginToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *LoginToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } LoginToServerPacketCommonStoreCookieValueEncTmp := ret.Value err = LoginToServerPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type LoginToServerPacketCommonTransfer struct { Host string Port int32 } func (ret *LoginToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *LoginToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) 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 LoginToServerPacketLoginAcknowledged struct { } func (ret *LoginToServerPacketLoginAcknowledged) Decode(r io.ReadSeeker) (err error) { return } func (ret *LoginToServerPacketLoginAcknowledged) Encode(w io.Writer) (err error) { 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 PlayerUUID uuid.UUID } func (ret *LoginToServerPacketLoginStart) Decode(r io.ReadSeeker) (err error) { ret.Username, err = proto_base.DecodeString(r) if err != nil { return } _, err = io.ReadFull(r, ret.PlayerUUID[:]) 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 } _, err = w.Write(ret.PlayerUUID[:]) if err != nil { return } return } type PlayToClientChatType struct { TranslationKey string Parameters []PlayToClientChatTypeParameterType Style nbt.Anon } func (ret *PlayToClientChatType) Decode(r io.ReadSeeker) (err error) { ret.TranslationKey, err = proto_base.DecodeString(r) if err != nil { return } var lPlayToClientChatTypeParameters int32 lPlayToClientChatTypeParameters, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Parameters = []PlayToClientChatTypeParameterType{} for range lPlayToClientChatTypeParameters { var PlayToClientChatTypeParametersElement PlayToClientChatTypeParameterType err = PlayToClientChatTypeParametersElement.Decode(r) if err != nil { return } ret.Parameters = append(ret.Parameters, PlayToClientChatTypeParametersElement) } err = ret.Style.Decode(r) if err != nil { return } return } func (ret *PlayToClientChatType) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.TranslationKey) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Parameters))) if err != nil { return } for iPlayToClientChatTypeParameters := range len(ret.Parameters) { PlayToClientChatTypeParametersInnerEncTmp := ret.Parameters[iPlayToClientChatTypeParameters] err = PlayToClientChatTypeParametersInnerEncTmp.Encode(w) if err != nil { return } } PlayToClientChatTypeStyleEncTmp := ret.Style err = PlayToClientChatTypeStyleEncTmp.Encode(w) if err != nil { return } return } type PlayToClientChatTypeParameterType struct { Val string } var PlayToClientChatTypeParameterTypeMap = map[int32]string{0: "content", 1: "sender", 2: "target"} func (ret *PlayToClientChatTypeParameterType) Decode(r io.ReadSeeker) (err error) { var PlayToClientChatTypeParameterTypeKey int32 PlayToClientChatTypeParameterTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Val, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeMap, PlayToClientChatTypeParameterTypeKey) if err != nil { return } return } var PlayToClientChatTypeParameterTypeReverseMap = map[string]int32{"content": 0, "sender": 1, "target": 2} func (ret *PlayToClientChatTypeParameterType) Encode(w io.Writer) (err error) { var vPlayToClientChatTypeParameterType int32 vPlayToClientChatTypeParameterType, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeReverseMap, ret.Val) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientChatTypeParameterType) if err != nil { return } return } type PlayToClientChatTypes struct { Chat PlayToClientChatType Narration PlayToClientChatType } func (ret *PlayToClientChatTypes) Decode(r io.ReadSeeker) (err error) { err = ret.Chat.Decode(r) if err != nil { return } err = ret.Narration.Decode(r) if err != nil { return } return } func (ret *PlayToClientChatTypes) Encode(w io.Writer) (err error) { PlayToClientChatTypesChatEncTmp := ret.Chat err = PlayToClientChatTypesChatEncTmp.Encode(w) if err != nil { return } PlayToClientChatTypesNarrationEncTmp := ret.Narration err = PlayToClientChatTypesNarrationEncTmp.Encode(w) if err != nil { return } return } type PlayToClientChatTypesHolder struct { Val any } func (ret *PlayToClientChatTypesHolder) Decode(r io.ReadSeeker) (err error) { var PlayToClientChatTypesHolderId int32 PlayToClientChatTypesHolderId, err = proto_base.DecodeVarInt(r) if err != nil { return } if PlayToClientChatTypesHolderId != 0 { ret.Val = PlayToClientChatTypesHolderId } else { var PlayToClientChatTypesHolderResult PlayToClientChatTypes err = PlayToClientChatTypesHolderResult.Decode(r) if err != nil { return } ret.Val = PlayToClientChatTypesHolderResult } return } func (ret *PlayToClientChatTypesHolder) Encode(w io.Writer) (err error) { switch PlayToClientChatTypesHolderKnownType := ret.Val.(type) { case int32: err = proto_base.EncodeVarInt(w, PlayToClientChatTypesHolderKnownType) if err != nil { return } case PlayToClientChatTypes: err = proto_base.EncodeVarInt(w, 0) if err != nil { return } PlayToClientChatTypesHolderOtherwiseEncTmp := PlayToClientChatTypesHolderKnownType err = PlayToClientChatTypesHolderOtherwiseEncTmp.Encode(w) if err != nil { return } default: err = proto_base.BadTypeError } return } type PlayToClientExplosionParticleEntry struct { Data PlayToClientExplosionParticleInfo Weight int32 } func (ret *PlayToClientExplosionParticleEntry) Decode(r io.ReadSeeker) (err error) { err = ret.Data.Decode(r) if err != nil { return } ret.Weight, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientExplosionParticleEntry) Encode(w io.Writer) (err error) { PlayToClientExplosionParticleEntryDataEncTmp := ret.Data err = PlayToClientExplosionParticleEntryDataEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Weight) if err != nil { return } return } type PlayToClientExplosionParticleInfo struct { Particle Particle Scaling float32 Speed float32 } func (ret *PlayToClientExplosionParticleInfo) Decode(r io.ReadSeeker) (err error) { err = ret.Particle.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Scaling) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Speed) if err != nil { return } return } func (ret *PlayToClientExplosionParticleInfo) Encode(w io.Writer) (err error) { PlayToClientExplosionParticleInfoParticleEncTmp := ret.Particle err = PlayToClientExplosionParticleInfoParticleEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Scaling) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Speed) if err != nil { return } return } type PlayToClientPositionUpdateRelatives struct { Val uint32 } func (ret *PlayToClientPositionUpdateRelatives) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Val) if err != nil { return } return } func (ret *PlayToClientPositionUpdateRelatives) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Val) if err != nil { return } return } type PlayToClientRecipeBookSetting struct { Open bool Filtering bool } func (ret *PlayToClientRecipeBookSetting) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Open) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Filtering) if err != nil { return } return } func (ret *PlayToClientRecipeBookSetting) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Open) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Filtering) if err != nil { return } return } type PlayToClientRecipeDisplay struct { Type string Data any } var PlayToClientRecipeDisplayTypeMap = map[int32]string{0: "crafting_shapeless", 1: "crafting_shaped", 2: "furnace", 3: "stonecutter", 4: "smithing"} func (ret *PlayToClientRecipeDisplay) Decode(r io.ReadSeeker) (err error) { var PlayToClientRecipeDisplayTypeKey int32 PlayToClientRecipeDisplayTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Type, err = proto_base.ErroringIndex(PlayToClientRecipeDisplayTypeMap, PlayToClientRecipeDisplayTypeKey) if err != nil { return } switch ret.Type { case "crafting_shaped": var PlayToClientRecipeDisplayDataCraftingShapedTmp struct { Width int32 Height int32 Ingredients []PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay } PlayToClientRecipeDisplayDataCraftingShapedTmp.Width, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientRecipeDisplayDataCraftingShapedTmp.Height, err = proto_base.DecodeVarInt(r) if err != nil { return } var lPlayToClientRecipeDisplayDataCraftingShapedTmpIngredients int32 lPlayToClientRecipeDisplayDataCraftingShapedTmpIngredients, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients = []PlayToClientSlotDisplay{} for range lPlayToClientRecipeDisplayDataCraftingShapedTmpIngredients { var PlayToClientRecipeDisplayDataCraftingShapedTmpIngredientsElement PlayToClientSlotDisplay err = PlayToClientRecipeDisplayDataCraftingShapedTmpIngredientsElement.Decode(r) if err != nil { return } PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients = append(PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients, PlayToClientRecipeDisplayDataCraftingShapedTmpIngredientsElement) } err = PlayToClientRecipeDisplayDataCraftingShapedTmp.Result.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataCraftingShapedTmp.CraftingStation.Decode(r) if err != nil { return } ret.Data = PlayToClientRecipeDisplayDataCraftingShapedTmp case "crafting_shapeless": var PlayToClientRecipeDisplayDataCraftingShapelessTmp struct { Ingredients []PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay } var lPlayToClientRecipeDisplayDataCraftingShapelessTmpIngredients int32 lPlayToClientRecipeDisplayDataCraftingShapelessTmpIngredients, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients = []PlayToClientSlotDisplay{} for range lPlayToClientRecipeDisplayDataCraftingShapelessTmpIngredients { var PlayToClientRecipeDisplayDataCraftingShapelessTmpIngredientsElement PlayToClientSlotDisplay err = PlayToClientRecipeDisplayDataCraftingShapelessTmpIngredientsElement.Decode(r) if err != nil { return } PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients = append(PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients, PlayToClientRecipeDisplayDataCraftingShapelessTmpIngredientsElement) } err = PlayToClientRecipeDisplayDataCraftingShapelessTmp.Result.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataCraftingShapelessTmp.CraftingStation.Decode(r) if err != nil { return } ret.Data = PlayToClientRecipeDisplayDataCraftingShapelessTmp case "furnace": var PlayToClientRecipeDisplayDataFurnaceTmp struct { Ingredient PlayToClientSlotDisplay Fuel PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay Duration int32 Experience float32 } err = PlayToClientRecipeDisplayDataFurnaceTmp.Ingredient.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataFurnaceTmp.Fuel.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataFurnaceTmp.Result.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataFurnaceTmp.CraftingStation.Decode(r) if err != nil { return } PlayToClientRecipeDisplayDataFurnaceTmp.Duration, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientRecipeDisplayDataFurnaceTmp.Experience) if err != nil { return } ret.Data = PlayToClientRecipeDisplayDataFurnaceTmp case "smithing": var PlayToClientRecipeDisplayDataSmithingTmp struct { Template PlayToClientSlotDisplay Base PlayToClientSlotDisplay Addition PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay } err = PlayToClientRecipeDisplayDataSmithingTmp.Template.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataSmithingTmp.Base.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataSmithingTmp.Addition.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataSmithingTmp.Result.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataSmithingTmp.CraftingStation.Decode(r) if err != nil { return } ret.Data = PlayToClientRecipeDisplayDataSmithingTmp case "stonecutter": var PlayToClientRecipeDisplayDataStonecutterTmp struct { Ingredient PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay } err = PlayToClientRecipeDisplayDataStonecutterTmp.Ingredient.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataStonecutterTmp.Result.Decode(r) if err != nil { return } err = PlayToClientRecipeDisplayDataStonecutterTmp.CraftingStation.Decode(r) if err != nil { return } ret.Data = PlayToClientRecipeDisplayDataStonecutterTmp } return } var PlayToClientRecipeDisplayTypeReverseMap = map[string]int32{"crafting_shapeless": 0, "crafting_shaped": 1, "furnace": 2, "stonecutter": 3, "smithing": 4} func (ret *PlayToClientRecipeDisplay) Encode(w io.Writer) (err error) { var vPlayToClientRecipeDisplayType int32 vPlayToClientRecipeDisplayType, err = proto_base.ErroringIndex(PlayToClientRecipeDisplayTypeReverseMap, ret.Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientRecipeDisplayType) if err != nil { return } switch ret.Type { case "crafting_shaped": PlayToClientRecipeDisplayData, ok := ret.Data.(struct { Width int32 Height int32 Ingredients []PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Width) if err != nil { return } err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Height) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(PlayToClientRecipeDisplayData.Ingredients))) if err != nil { return } for iPlayToClientRecipeDisplayDataIngredients := range len(PlayToClientRecipeDisplayData.Ingredients) { PlayToClientRecipeDisplayDataIngredientsInnerEncTmp := PlayToClientRecipeDisplayData.Ingredients[iPlayToClientRecipeDisplayDataIngredients] err = PlayToClientRecipeDisplayDataIngredientsInnerEncTmp.Encode(w) if err != nil { return } } PlayToClientRecipeDisplayDataResultEncTmp := PlayToClientRecipeDisplayData.Result err = PlayToClientRecipeDisplayDataResultEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataCraftingStationEncTmp := PlayToClientRecipeDisplayData.CraftingStation err = PlayToClientRecipeDisplayDataCraftingStationEncTmp.Encode(w) if err != nil { return } case "crafting_shapeless": PlayToClientRecipeDisplayData, ok := ret.Data.(struct { Ingredients []PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, int32(len(PlayToClientRecipeDisplayData.Ingredients))) if err != nil { return } for iPlayToClientRecipeDisplayDataIngredients := range len(PlayToClientRecipeDisplayData.Ingredients) { PlayToClientRecipeDisplayDataIngredientsInnerEncTmp := PlayToClientRecipeDisplayData.Ingredients[iPlayToClientRecipeDisplayDataIngredients] err = PlayToClientRecipeDisplayDataIngredientsInnerEncTmp.Encode(w) if err != nil { return } } PlayToClientRecipeDisplayDataResultEncTmp := PlayToClientRecipeDisplayData.Result err = PlayToClientRecipeDisplayDataResultEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataCraftingStationEncTmp := PlayToClientRecipeDisplayData.CraftingStation err = PlayToClientRecipeDisplayDataCraftingStationEncTmp.Encode(w) if err != nil { return } case "furnace": PlayToClientRecipeDisplayData, ok := ret.Data.(struct { Ingredient PlayToClientSlotDisplay Fuel PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay Duration int32 Experience float32 }) if !ok { err = proto_base.BadTypeError return } PlayToClientRecipeDisplayDataIngredientEncTmp := PlayToClientRecipeDisplayData.Ingredient err = PlayToClientRecipeDisplayDataIngredientEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataFuelEncTmp := PlayToClientRecipeDisplayData.Fuel err = PlayToClientRecipeDisplayDataFuelEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataResultEncTmp := PlayToClientRecipeDisplayData.Result err = PlayToClientRecipeDisplayDataResultEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataCraftingStationEncTmp := PlayToClientRecipeDisplayData.CraftingStation err = PlayToClientRecipeDisplayDataCraftingStationEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Duration) if err != nil { return } err = binary.Write(w, binary.BigEndian, PlayToClientRecipeDisplayData.Experience) if err != nil { return } case "smithing": PlayToClientRecipeDisplayData, ok := ret.Data.(struct { Template PlayToClientSlotDisplay Base PlayToClientSlotDisplay Addition PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay }) if !ok { err = proto_base.BadTypeError return } PlayToClientRecipeDisplayDataTemplateEncTmp := PlayToClientRecipeDisplayData.Template err = PlayToClientRecipeDisplayDataTemplateEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataBaseEncTmp := PlayToClientRecipeDisplayData.Base err = PlayToClientRecipeDisplayDataBaseEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataAdditionEncTmp := PlayToClientRecipeDisplayData.Addition err = PlayToClientRecipeDisplayDataAdditionEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataResultEncTmp := PlayToClientRecipeDisplayData.Result err = PlayToClientRecipeDisplayDataResultEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataCraftingStationEncTmp := PlayToClientRecipeDisplayData.CraftingStation err = PlayToClientRecipeDisplayDataCraftingStationEncTmp.Encode(w) if err != nil { return } case "stonecutter": PlayToClientRecipeDisplayData, ok := ret.Data.(struct { Ingredient PlayToClientSlotDisplay Result PlayToClientSlotDisplay CraftingStation PlayToClientSlotDisplay }) if !ok { err = proto_base.BadTypeError return } PlayToClientRecipeDisplayDataIngredientEncTmp := PlayToClientRecipeDisplayData.Ingredient err = PlayToClientRecipeDisplayDataIngredientEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataResultEncTmp := PlayToClientRecipeDisplayData.Result err = PlayToClientRecipeDisplayDataResultEncTmp.Encode(w) if err != nil { return } PlayToClientRecipeDisplayDataCraftingStationEncTmp := PlayToClientRecipeDisplayData.CraftingStation err = PlayToClientRecipeDisplayDataCraftingStationEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientSlotDisplay struct { Type string Data any } var PlayToClientSlotDisplayTypeMap = map[int32]string{0: "empty", 1: "any_fuel", 2: "item", 3: "item_stack", 4: "tag", 5: "smithing_trim", 6: "with_remainder", 7: "composite"} func (ret *PlayToClientSlotDisplay) Decode(r io.ReadSeeker) (err error) { var PlayToClientSlotDisplayTypeKey int32 PlayToClientSlotDisplayTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Type, err = proto_base.ErroringIndex(PlayToClientSlotDisplayTypeMap, PlayToClientSlotDisplayTypeKey) if err != nil { return } switch ret.Type { case "any_fuel": var PlayToClientSlotDisplayDataAnyFuelTmp struct { } ret.Data = PlayToClientSlotDisplayDataAnyFuelTmp case "composite": var PlayToClientSlotDisplayDataCompositeTmp []PlayToClientSlotDisplay var lPlayToClientSlotDisplayDataCompositeTmp int32 lPlayToClientSlotDisplayDataCompositeTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientSlotDisplayDataCompositeTmp = []PlayToClientSlotDisplay{} for range lPlayToClientSlotDisplayDataCompositeTmp { var PlayToClientSlotDisplayDataCompositeTmpElement PlayToClientSlotDisplay err = PlayToClientSlotDisplayDataCompositeTmpElement.Decode(r) if err != nil { return } PlayToClientSlotDisplayDataCompositeTmp = append(PlayToClientSlotDisplayDataCompositeTmp, PlayToClientSlotDisplayDataCompositeTmpElement) } ret.Data = PlayToClientSlotDisplayDataCompositeTmp case "empty": var PlayToClientSlotDisplayDataEmptyTmp struct { } ret.Data = PlayToClientSlotDisplayDataEmptyTmp case "item": var PlayToClientSlotDisplayDataItemTmp int32 PlayToClientSlotDisplayDataItemTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = PlayToClientSlotDisplayDataItemTmp case "item_stack": var PlayToClientSlotDisplayDataItemStackTmp Slot err = PlayToClientSlotDisplayDataItemStackTmp.Decode(r) if err != nil { return } ret.Data = PlayToClientSlotDisplayDataItemStackTmp case "smithing_trim": var PlayToClientSlotDisplayDataSmithingTrimTmp struct { Base PlayToClientSlotDisplay Material PlayToClientSlotDisplay Pattern any } err = PlayToClientSlotDisplayDataSmithingTrimTmp.Base.Decode(r) if err != nil { return } err = PlayToClientSlotDisplayDataSmithingTrimTmp.Material.Decode(r) if err != nil { return } var PlayToClientSlotDisplayDataSmithingTrimTmpPatternId int32 PlayToClientSlotDisplayDataSmithingTrimTmpPatternId, err = proto_base.DecodeVarInt(r) if err != nil { return } if PlayToClientSlotDisplayDataSmithingTrimTmpPatternId != 0 { PlayToClientSlotDisplayDataSmithingTrimTmp.Pattern = PlayToClientSlotDisplayDataSmithingTrimTmpPatternId } else { var PlayToClientSlotDisplayDataSmithingTrimTmpPatternResult ArmorTrimPattern err = PlayToClientSlotDisplayDataSmithingTrimTmpPatternResult.Decode(r) if err != nil { return } PlayToClientSlotDisplayDataSmithingTrimTmp.Pattern = PlayToClientSlotDisplayDataSmithingTrimTmpPatternResult } ret.Data = PlayToClientSlotDisplayDataSmithingTrimTmp case "tag": var PlayToClientSlotDisplayDataTagTmp string PlayToClientSlotDisplayDataTagTmp, err = proto_base.DecodeString(r) if err != nil { return } ret.Data = PlayToClientSlotDisplayDataTagTmp case "with_remainder": var PlayToClientSlotDisplayDataWithRemainderTmp struct { Input PlayToClientSlotDisplay Remainder PlayToClientSlotDisplay } err = PlayToClientSlotDisplayDataWithRemainderTmp.Input.Decode(r) if err != nil { return } err = PlayToClientSlotDisplayDataWithRemainderTmp.Remainder.Decode(r) if err != nil { return } ret.Data = PlayToClientSlotDisplayDataWithRemainderTmp } return } var PlayToClientSlotDisplayTypeReverseMap = map[string]int32{"empty": 0, "any_fuel": 1, "item": 2, "item_stack": 3, "tag": 4, "smithing_trim": 5, "with_remainder": 6, "composite": 7} func (ret *PlayToClientSlotDisplay) Encode(w io.Writer) (err error) { var vPlayToClientSlotDisplayType int32 vPlayToClientSlotDisplayType, err = proto_base.ErroringIndex(PlayToClientSlotDisplayTypeReverseMap, ret.Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientSlotDisplayType) if err != nil { return } switch ret.Type { case "any_fuel": _, ok := ret.Data.(struct { }) if !ok { err = proto_base.BadTypeError return } case "composite": PlayToClientSlotDisplayData, ok := ret.Data.([]PlayToClientSlotDisplay) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, int32(len(PlayToClientSlotDisplayData))) if err != nil { return } for iPlayToClientSlotDisplayData := range len(PlayToClientSlotDisplayData) { PlayToClientSlotDisplayDataInnerEncTmp := PlayToClientSlotDisplayData[iPlayToClientSlotDisplayData] err = PlayToClientSlotDisplayDataInnerEncTmp.Encode(w) if err != nil { return } } case "empty": _, ok := ret.Data.(struct { }) if !ok { err = proto_base.BadTypeError return } case "item": PlayToClientSlotDisplayData, ok := ret.Data.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, PlayToClientSlotDisplayData) if err != nil { return } case "item_stack": PlayToClientSlotDisplayData, ok := ret.Data.(Slot) if !ok { err = proto_base.BadTypeError return } PlayToClientSlotDisplayDataEncTmp := PlayToClientSlotDisplayData err = PlayToClientSlotDisplayDataEncTmp.Encode(w) if err != nil { return } case "smithing_trim": PlayToClientSlotDisplayData, ok := ret.Data.(struct { Base PlayToClientSlotDisplay Material PlayToClientSlotDisplay Pattern any }) if !ok { err = proto_base.BadTypeError return } PlayToClientSlotDisplayDataBaseEncTmp := PlayToClientSlotDisplayData.Base err = PlayToClientSlotDisplayDataBaseEncTmp.Encode(w) if err != nil { return } PlayToClientSlotDisplayDataMaterialEncTmp := PlayToClientSlotDisplayData.Material err = PlayToClientSlotDisplayDataMaterialEncTmp.Encode(w) if err != nil { return } switch PlayToClientSlotDisplayDataPatternKnownType := PlayToClientSlotDisplayData.Pattern.(type) { case int32: err = proto_base.EncodeVarInt(w, PlayToClientSlotDisplayDataPatternKnownType) if err != nil { return } case ArmorTrimPattern: err = proto_base.EncodeVarInt(w, 0) if err != nil { return } PlayToClientSlotDisplayDataPatternOtherwiseEncTmp := PlayToClientSlotDisplayDataPatternKnownType err = PlayToClientSlotDisplayDataPatternOtherwiseEncTmp.Encode(w) if err != nil { return } default: err = proto_base.BadTypeError } case "tag": PlayToClientSlotDisplayData, ok := ret.Data.(string) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientSlotDisplayData) if err != nil { return } case "with_remainder": PlayToClientSlotDisplayData, ok := ret.Data.(struct { Input PlayToClientSlotDisplay Remainder PlayToClientSlotDisplay }) if !ok { err = proto_base.BadTypeError return } PlayToClientSlotDisplayDataInputEncTmp := PlayToClientSlotDisplayData.Input err = PlayToClientSlotDisplayDataInputEncTmp.Encode(w) if err != nil { return } PlayToClientSlotDisplayDataRemainderEncTmp := PlayToClientSlotDisplayData.Remainder err = PlayToClientSlotDisplayDataRemainderEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientSpawnInfo struct { Dimension int32 Name string HashedSeed int64 Gamemode string PreviousGamemode uint8 IsDebug bool IsFlat bool Death *GlobalPos PortalCooldown int32 SeaLevel int32 } var PlayToClientSpawnInfoGamemodeMap = map[int8]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"} func (ret *PlayToClientSpawnInfo) Decode(r io.ReadSeeker) (err error) { ret.Dimension, 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.HashedSeed) if err != nil { return } var PlayToClientSpawnInfoGamemodeKey int8 err = binary.Read(r, binary.BigEndian, &PlayToClientSpawnInfoGamemodeKey) if err != nil { return } ret.Gamemode, err = proto_base.ErroringIndex(PlayToClientSpawnInfoGamemodeMap, PlayToClientSpawnInfoGamemodeKey) 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 } var PlayToClientSpawnInfoDeathPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientSpawnInfoDeathPresent) if err != nil { return } if PlayToClientSpawnInfoDeathPresent { var PlayToClientSpawnInfoDeathPresentValue GlobalPos err = PlayToClientSpawnInfoDeathPresentValue.Decode(r) if err != nil { return } ret.Death = &PlayToClientSpawnInfoDeathPresentValue } ret.PortalCooldown, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SeaLevel, err = proto_base.DecodeVarInt(r) if err != nil { return } return } var PlayToClientSpawnInfoGamemodeReverseMap = map[string]int8{"survival": 0, "creative": 1, "adventure": 2, "spectator": 3} func (ret *PlayToClientSpawnInfo) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Dimension) if err != nil { return } err = proto_base.EncodeString(w, ret.Name) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.HashedSeed) if err != nil { return } var vPlayToClientSpawnInfoGamemode int8 vPlayToClientSpawnInfoGamemode, err = proto_base.ErroringIndex(PlayToClientSpawnInfoGamemodeReverseMap, ret.Gamemode) if err != nil { return } err = binary.Write(w, binary.BigEndian, vPlayToClientSpawnInfoGamemode) 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.Death != nil) if err != nil { return } if ret.Death != nil { PlayToClientSpawnInfoDeathEncTmp := *ret.Death err = PlayToClientSpawnInfoDeathEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeVarInt(w, ret.PortalCooldown) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.SeaLevel) if err != nil { return } return } type PlayToClientPacket struct { Name string Params any } var PlayToClientPacketNameMap = map[int32]string{0x00: "bundle_delimiter", 0x01: "spawn_entity", 0x02: "animation", 0x03: "statistics", 0x04: "acknowledge_player_digging", 0x05: "block_break_animation", 0x06: "tile_entity_data", 0x07: "block_action", 0x08: "block_change", 0x09: "boss_bar", 0x0a: "difficulty", 0x0b: "chunk_batch_finished", 0x0c: "chunk_batch_start", 0x0d: "chunk_biomes", 0x0e: "clear_titles", 0x0f: "tab_complete", 0x10: "declare_commands", 0x11: "close_window", 0x12: "window_items", 0x13: "craft_progress_bar", 0x14: "set_slot", 0x15: "cookie_request", 0x16: "set_cooldown", 0x17: "chat_suggestions", 0x18: "custom_payload", 0x19: "damage_event", 0x1a: "debug_block_value", 0x1b: "debug_chunk_value", 0x1c: "debug_entity_value", 0x1d: "debug_event", 0x1e: "debug_sample", 0x1f: "hide_message", 0x20: "kick_disconnect", 0x21: "profileless_chat", 0x22: "entity_status", 0x23: "sync_entity_position", 0x24: "explosion", 0x25: "unload_chunk", 0x26: "game_state_change", 0x27: "game_test_highlight_pos", 0x28: "open_horse_window", 0x29: "hurt_animation", 0x2a: "initialize_world_border", 0x2b: "keep_alive", 0x2c: "map_chunk", 0x2d: "world_event", 0x2e: "world_particles", 0x2f: "update_light", 0x30: "login", 0x31: "map", 0x32: "trade_list", 0x33: "rel_entity_move", 0x34: "entity_move_look", 0x35: "move_minecart", 0x36: "entity_look", 0x37: "vehicle_move", 0x38: "open_book", 0x39: "open_window", 0x3a: "open_sign_entity", 0x3b: "ping", 0x3c: "ping_response", 0x3d: "craft_recipe_response", 0x3e: "abilities", 0x3f: "player_chat", 0x40: "end_combat_event", 0x41: "enter_combat_event", 0x42: "death_combat_event", 0x43: "player_remove", 0x44: "player_info", 0x45: "face_player", 0x46: "position", 0x47: "player_rotation", 0x48: "recipe_book_add", 0x49: "recipe_book_remove", 0x4a: "recipe_book_settings", 0x4b: "entity_destroy", 0x4c: "remove_entity_effect", 0x4d: "reset_score", 0x4e: "remove_resource_pack", 0x4f: "add_resource_pack", 0x50: "respawn", 0x51: "entity_head_rotation", 0x52: "multi_block_change", 0x53: "select_advancement_tab", 0x54: "server_data", 0x55: "action_bar", 0x56: "world_border_center", 0x57: "world_border_lerp_size", 0x58: "world_border_size", 0x59: "world_border_warning_delay", 0x5a: "world_border_warning_reach", 0x5b: "camera", 0x5c: "update_view_position", 0x5d: "update_view_distance", 0x5e: "set_cursor_item", 0x5f: "spawn_position", 0x60: "scoreboard_display_objective", 0x61: "entity_metadata", 0x62: "attach_entity", 0x63: "entity_velocity", 0x64: "entity_equipment", 0x65: "experience", 0x66: "update_health", 0x67: "held_item_slot", 0x68: "scoreboard_objective", 0x69: "set_passengers", 0x6a: "set_player_inventory", 0x6b: "teams", 0x6c: "scoreboard_score", 0x6d: "simulation_distance", 0x6e: "set_title_subtitle", 0x6f: "update_time", 0x70: "set_title_text", 0x71: "set_title_time", 0x72: "entity_sound_effect", 0x73: "sound_effect", 0x74: "start_configuration", 0x75: "stop_sound", 0x76: "store_cookie", 0x77: "system_chat", 0x78: "playerlist_header", 0x79: "nbt_query_response", 0x7a: "collect", 0x7b: "entity_teleport", 0x7c: "test_instance_block_status", 0x7d: "set_ticking_state", 0x7e: "step_tick", 0x7f: "transfer", 0x80: "advancements", 0x81: "entity_update_attributes", 0x82: "entity_effect", 0x83: "declare_recipes", 0x84: "tags", 0x85: "set_projectile_power", 0x86: "custom_report_details", 0x87: "server_links", 0x88: "tracked_waypoint", 0x89: "clear_dialog", 0x8a: "show_dialog"} 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 "action_bar": var PlayToClientPacketParamsActionBarTmp PlayToClientPacketActionBar err = PlayToClientPacketParamsActionBarTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsActionBarTmp case "add_resource_pack": var PlayToClientPacketParamsAddResourcePackTmp PlayToClientPacketCommonAddResourcePack err = PlayToClientPacketParamsAddResourcePackTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsAddResourcePackTmp 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 "bundle_delimiter": var PlayToClientPacketParamsBundleDelimiterTmp PlayToClientPacketBundleDelimiter err = PlayToClientPacketParamsBundleDelimiterTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsBundleDelimiterTmp case "camera": var PlayToClientPacketParamsCameraTmp PlayToClientPacketCamera err = PlayToClientPacketParamsCameraTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsCameraTmp case "chat_suggestions": var PlayToClientPacketParamsChatSuggestionsTmp PlayToClientPacketChatSuggestions err = PlayToClientPacketParamsChatSuggestionsTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsChatSuggestionsTmp case "chunk_batch_finished": var PlayToClientPacketParamsChunkBatchFinishedTmp PlayToClientPacketChunkBatchFinished err = PlayToClientPacketParamsChunkBatchFinishedTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsChunkBatchFinishedTmp case "chunk_batch_start": var PlayToClientPacketParamsChunkBatchStartTmp PlayToClientPacketChunkBatchStart err = PlayToClientPacketParamsChunkBatchStartTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsChunkBatchStartTmp case "chunk_biomes": var PlayToClientPacketParamsChunkBiomesTmp PlayToClientPacketChunkBiomes err = PlayToClientPacketParamsChunkBiomesTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsChunkBiomesTmp case "clear_dialog": var PlayToClientPacketParamsClearDialogTmp PlayToClientPacketCommonClearDialog err = PlayToClientPacketParamsClearDialogTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsClearDialogTmp case "clear_titles": var PlayToClientPacketParamsClearTitlesTmp PlayToClientPacketClearTitles err = PlayToClientPacketParamsClearTitlesTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsClearTitlesTmp 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 "cookie_request": var PlayToClientPacketParamsCookieRequestTmp PlayToClientPacketCommonCookieRequest err = PlayToClientPacketParamsCookieRequestTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsCookieRequestTmp 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 "custom_report_details": var PlayToClientPacketParamsCustomReportDetailsTmp PlayToClientPacketCommonCustomReportDetails err = PlayToClientPacketParamsCustomReportDetailsTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsCustomReportDetailsTmp case "damage_event": var PlayToClientPacketParamsDamageEventTmp PlayToClientPacketDamageEvent err = PlayToClientPacketParamsDamageEventTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsDamageEventTmp case "death_combat_event": var PlayToClientPacketParamsDeathCombatEventTmp PlayToClientPacketDeathCombatEvent err = PlayToClientPacketParamsDeathCombatEventTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsDeathCombatEventTmp case "debug_block_value": var PlayToClientPacketParamsDebugBlockValueTmp PlayToClientPacketDebugBlockValue err = PlayToClientPacketParamsDebugBlockValueTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsDebugBlockValueTmp case "debug_chunk_value": var PlayToClientPacketParamsDebugChunkValueTmp PlayToClientPacketDebugChunkValue err = PlayToClientPacketParamsDebugChunkValueTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsDebugChunkValueTmp case "debug_entity_value": var PlayToClientPacketParamsDebugEntityValueTmp PlayToClientPacketDebugEntityValue err = PlayToClientPacketParamsDebugEntityValueTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsDebugEntityValueTmp case "debug_event": var PlayToClientPacketParamsDebugEventTmp PlayToClientPacketDebugEvent err = PlayToClientPacketParamsDebugEventTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsDebugEventTmp case "debug_sample": var PlayToClientPacketParamsDebugSampleTmp PlayToClientPacketDebugSample err = PlayToClientPacketParamsDebugSampleTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsDebugSampleTmp 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 "end_combat_event": var PlayToClientPacketParamsEndCombatEventTmp PlayToClientPacketEndCombatEvent err = PlayToClientPacketParamsEndCombatEventTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsEndCombatEventTmp case "enter_combat_event": var PlayToClientPacketParamsEnterCombatEventTmp PlayToClientPacketEnterCombatEvent err = PlayToClientPacketParamsEnterCombatEventTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsEnterCombatEventTmp 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 "game_test_highlight_pos": var PlayToClientPacketParamsGameTestHighlightPosTmp PlayToClientPacketGameTestHighlightPos err = PlayToClientPacketParamsGameTestHighlightPosTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsGameTestHighlightPosTmp case "held_item_slot": var PlayToClientPacketParamsHeldItemSlotTmp PlayToClientPacketHeldItemSlot err = PlayToClientPacketParamsHeldItemSlotTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsHeldItemSlotTmp case "hide_message": var PlayToClientPacketParamsHideMessageTmp PlayToClientPacketHideMessage err = PlayToClientPacketParamsHideMessageTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsHideMessageTmp case "hurt_animation": var PlayToClientPacketParamsHurtAnimationTmp PlayToClientPacketHurtAnimation err = PlayToClientPacketParamsHurtAnimationTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsHurtAnimationTmp case "initialize_world_border": var PlayToClientPacketParamsInitializeWorldBorderTmp PlayToClientPacketInitializeWorldBorder err = PlayToClientPacketParamsInitializeWorldBorderTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsInitializeWorldBorderTmp 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 "move_minecart": var PlayToClientPacketParamsMoveMinecartTmp PlayToClientPacketMoveMinecart err = PlayToClientPacketParamsMoveMinecartTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsMoveMinecartTmp case "multi_block_change": var PlayToClientPacketParamsMultiBlockChangeTmp PlayToClientPacketMultiBlockChange err = PlayToClientPacketParamsMultiBlockChangeTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsMultiBlockChangeTmp 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 "ping": var PlayToClientPacketParamsPingTmp PlayToClientPacketPing err = PlayToClientPacketParamsPingTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsPingTmp case "ping_response": var PlayToClientPacketParamsPingResponseTmp PlayToClientPacketPingResponse err = PlayToClientPacketParamsPingResponseTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsPingResponseTmp case "player_chat": var PlayToClientPacketParamsPlayerChatTmp PlayToClientPacketPlayerChat err = PlayToClientPacketParamsPlayerChatTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsPlayerChatTmp case "player_info": var PlayToClientPacketParamsPlayerInfoTmp PlayToClientPacketPlayerInfo err = PlayToClientPacketParamsPlayerInfoTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsPlayerInfoTmp case "player_remove": var PlayToClientPacketParamsPlayerRemoveTmp PlayToClientPacketPlayerRemove err = PlayToClientPacketParamsPlayerRemoveTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsPlayerRemoveTmp case "player_rotation": var PlayToClientPacketParamsPlayerRotationTmp PlayToClientPacketPlayerRotation err = PlayToClientPacketParamsPlayerRotationTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsPlayerRotationTmp 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 "profileless_chat": var PlayToClientPacketParamsProfilelessChatTmp PlayToClientPacketProfilelessChat err = PlayToClientPacketParamsProfilelessChatTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsProfilelessChatTmp case "recipe_book_add": var PlayToClientPacketParamsRecipeBookAddTmp PlayToClientPacketRecipeBookAdd err = PlayToClientPacketParamsRecipeBookAddTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsRecipeBookAddTmp case "recipe_book_remove": var PlayToClientPacketParamsRecipeBookRemoveTmp PlayToClientPacketRecipeBookRemove err = PlayToClientPacketParamsRecipeBookRemoveTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsRecipeBookRemoveTmp case "recipe_book_settings": var PlayToClientPacketParamsRecipeBookSettingsTmp PlayToClientPacketRecipeBookSettings err = PlayToClientPacketParamsRecipeBookSettingsTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsRecipeBookSettingsTmp 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 "remove_resource_pack": var PlayToClientPacketParamsRemoveResourcePackTmp PlayToClientPacketCommonRemoveResourcePack err = PlayToClientPacketParamsRemoveResourcePackTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsRemoveResourcePackTmp case "reset_score": var PlayToClientPacketParamsResetScoreTmp PlayToClientPacketResetScore err = PlayToClientPacketParamsResetScoreTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsResetScoreTmp 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 "server_data": var PlayToClientPacketParamsServerDataTmp PlayToClientPacketServerData err = PlayToClientPacketParamsServerDataTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsServerDataTmp case "server_links": var PlayToClientPacketParamsServerLinksTmp PlayToClientPacketCommonServerLinks err = PlayToClientPacketParamsServerLinksTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsServerLinksTmp case "set_cooldown": var PlayToClientPacketParamsSetCooldownTmp PlayToClientPacketSetCooldown err = PlayToClientPacketParamsSetCooldownTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetCooldownTmp case "set_cursor_item": var PlayToClientPacketParamsSetCursorItemTmp PlayToClientPacketSetCursorItem err = PlayToClientPacketParamsSetCursorItemTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetCursorItemTmp case "set_passengers": var PlayToClientPacketParamsSetPassengersTmp PlayToClientPacketSetPassengers err = PlayToClientPacketParamsSetPassengersTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetPassengersTmp case "set_player_inventory": var PlayToClientPacketParamsSetPlayerInventoryTmp PlayToClientPacketSetPlayerInventory err = PlayToClientPacketParamsSetPlayerInventoryTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetPlayerInventoryTmp case "set_projectile_power": var PlayToClientPacketParamsSetProjectilePowerTmp PlayToClientPacketSetProjectilePower err = PlayToClientPacketParamsSetProjectilePowerTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetProjectilePowerTmp case "set_slot": var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot err = PlayToClientPacketParamsSetSlotTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetSlotTmp case "set_ticking_state": var PlayToClientPacketParamsSetTickingStateTmp PlayToClientPacketSetTickingState err = PlayToClientPacketParamsSetTickingStateTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetTickingStateTmp case "set_title_subtitle": var PlayToClientPacketParamsSetTitleSubtitleTmp PlayToClientPacketSetTitleSubtitle err = PlayToClientPacketParamsSetTitleSubtitleTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetTitleSubtitleTmp case "set_title_text": var PlayToClientPacketParamsSetTitleTextTmp PlayToClientPacketSetTitleText err = PlayToClientPacketParamsSetTitleTextTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetTitleTextTmp case "set_title_time": var PlayToClientPacketParamsSetTitleTimeTmp PlayToClientPacketSetTitleTime err = PlayToClientPacketParamsSetTitleTimeTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSetTitleTimeTmp case "show_dialog": var PlayToClientPacketParamsShowDialogTmp PlayToClientPacketShowDialog err = PlayToClientPacketParamsShowDialogTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsShowDialogTmp case "simulation_distance": var PlayToClientPacketParamsSimulationDistanceTmp PlayToClientPacketSimulationDistance err = PlayToClientPacketParamsSimulationDistanceTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSimulationDistanceTmp 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_position": var PlayToClientPacketParamsSpawnPositionTmp PlayToClientPacketSpawnPosition err = PlayToClientPacketParamsSpawnPositionTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSpawnPositionTmp case "start_configuration": var PlayToClientPacketParamsStartConfigurationTmp PlayToClientPacketStartConfiguration err = PlayToClientPacketParamsStartConfigurationTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsStartConfigurationTmp case "statistics": var PlayToClientPacketParamsStatisticsTmp PlayToClientPacketStatistics err = PlayToClientPacketParamsStatisticsTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsStatisticsTmp case "step_tick": var PlayToClientPacketParamsStepTickTmp PlayToClientPacketStepTick err = PlayToClientPacketParamsStepTickTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsStepTickTmp case "stop_sound": var PlayToClientPacketParamsStopSoundTmp PlayToClientPacketStopSound err = PlayToClientPacketParamsStopSoundTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsStopSoundTmp case "store_cookie": var PlayToClientPacketParamsStoreCookieTmp PlayToClientPacketCommonStoreCookie err = PlayToClientPacketParamsStoreCookieTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsStoreCookieTmp case "sync_entity_position": var PlayToClientPacketParamsSyncEntityPositionTmp PlayToClientPacketSyncEntityPosition err = PlayToClientPacketParamsSyncEntityPositionTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSyncEntityPositionTmp case "system_chat": var PlayToClientPacketParamsSystemChatTmp PlayToClientPacketSystemChat err = PlayToClientPacketParamsSystemChatTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsSystemChatTmp 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 "test_instance_block_status": var PlayToClientPacketParamsTestInstanceBlockStatusTmp PlayToClientPacketTestInstanceBlockStatus err = PlayToClientPacketParamsTestInstanceBlockStatusTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsTestInstanceBlockStatusTmp case "tile_entity_data": var PlayToClientPacketParamsTileEntityDataTmp PlayToClientPacketTileEntityData err = PlayToClientPacketParamsTileEntityDataTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsTileEntityDataTmp case "tracked_waypoint": var PlayToClientPacketParamsTrackedWaypointTmp PlayToClientPacketTrackedWaypoint err = PlayToClientPacketParamsTrackedWaypointTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsTrackedWaypointTmp case "trade_list": var PlayToClientPacketParamsTradeListTmp PlayToClientPacketTradeList err = PlayToClientPacketParamsTradeListTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsTradeListTmp case "transfer": var PlayToClientPacketParamsTransferTmp PlayToClientPacketCommonTransfer err = PlayToClientPacketParamsTransferTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsTransferTmp case "unload_chunk": var PlayToClientPacketParamsUnloadChunkTmp PlayToClientPacketUnloadChunk err = PlayToClientPacketParamsUnloadChunkTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsUnloadChunkTmp 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_center": var PlayToClientPacketParamsWorldBorderCenterTmp PlayToClientPacketWorldBorderCenter err = PlayToClientPacketParamsWorldBorderCenterTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsWorldBorderCenterTmp case "world_border_lerp_size": var PlayToClientPacketParamsWorldBorderLerpSizeTmp PlayToClientPacketWorldBorderLerpSize err = PlayToClientPacketParamsWorldBorderLerpSizeTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsWorldBorderLerpSizeTmp case "world_border_size": var PlayToClientPacketParamsWorldBorderSizeTmp PlayToClientPacketWorldBorderSize err = PlayToClientPacketParamsWorldBorderSizeTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsWorldBorderSizeTmp case "world_border_warning_delay": var PlayToClientPacketParamsWorldBorderWarningDelayTmp PlayToClientPacketWorldBorderWarningDelay err = PlayToClientPacketParamsWorldBorderWarningDelayTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsWorldBorderWarningDelayTmp case "world_border_warning_reach": var PlayToClientPacketParamsWorldBorderWarningReachTmp PlayToClientPacketWorldBorderWarningReach err = PlayToClientPacketParamsWorldBorderWarningReachTmp.Decode(r) if err != nil { return } ret.Params = PlayToClientPacketParamsWorldBorderWarningReachTmp 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{"bundle_delimiter": 0x00, "spawn_entity": 0x01, "animation": 0x02, "statistics": 0x03, "acknowledge_player_digging": 0x04, "block_break_animation": 0x05, "tile_entity_data": 0x06, "block_action": 0x07, "block_change": 0x08, "boss_bar": 0x09, "difficulty": 0x0a, "chunk_batch_finished": 0x0b, "chunk_batch_start": 0x0c, "chunk_biomes": 0x0d, "clear_titles": 0x0e, "tab_complete": 0x0f, "declare_commands": 0x10, "close_window": 0x11, "window_items": 0x12, "craft_progress_bar": 0x13, "set_slot": 0x14, "cookie_request": 0x15, "set_cooldown": 0x16, "chat_suggestions": 0x17, "custom_payload": 0x18, "damage_event": 0x19, "debug_block_value": 0x1a, "debug_chunk_value": 0x1b, "debug_entity_value": 0x1c, "debug_event": 0x1d, "debug_sample": 0x1e, "hide_message": 0x1f, "kick_disconnect": 0x20, "profileless_chat": 0x21, "entity_status": 0x22, "sync_entity_position": 0x23, "explosion": 0x24, "unload_chunk": 0x25, "game_state_change": 0x26, "game_test_highlight_pos": 0x27, "open_horse_window": 0x28, "hurt_animation": 0x29, "initialize_world_border": 0x2a, "keep_alive": 0x2b, "map_chunk": 0x2c, "world_event": 0x2d, "world_particles": 0x2e, "update_light": 0x2f, "login": 0x30, "map": 0x31, "trade_list": 0x32, "rel_entity_move": 0x33, "entity_move_look": 0x34, "move_minecart": 0x35, "entity_look": 0x36, "vehicle_move": 0x37, "open_book": 0x38, "open_window": 0x39, "open_sign_entity": 0x3a, "ping": 0x3b, "ping_response": 0x3c, "craft_recipe_response": 0x3d, "abilities": 0x3e, "player_chat": 0x3f, "end_combat_event": 0x40, "enter_combat_event": 0x41, "death_combat_event": 0x42, "player_remove": 0x43, "player_info": 0x44, "face_player": 0x45, "position": 0x46, "player_rotation": 0x47, "recipe_book_add": 0x48, "recipe_book_remove": 0x49, "recipe_book_settings": 0x4a, "entity_destroy": 0x4b, "remove_entity_effect": 0x4c, "reset_score": 0x4d, "remove_resource_pack": 0x4e, "add_resource_pack": 0x4f, "respawn": 0x50, "entity_head_rotation": 0x51, "multi_block_change": 0x52, "select_advancement_tab": 0x53, "server_data": 0x54, "action_bar": 0x55, "world_border_center": 0x56, "world_border_lerp_size": 0x57, "world_border_size": 0x58, "world_border_warning_delay": 0x59, "world_border_warning_reach": 0x5a, "camera": 0x5b, "update_view_position": 0x5c, "update_view_distance": 0x5d, "set_cursor_item": 0x5e, "spawn_position": 0x5f, "scoreboard_display_objective": 0x60, "entity_metadata": 0x61, "attach_entity": 0x62, "entity_velocity": 0x63, "entity_equipment": 0x64, "experience": 0x65, "update_health": 0x66, "held_item_slot": 0x67, "scoreboard_objective": 0x68, "set_passengers": 0x69, "set_player_inventory": 0x6a, "teams": 0x6b, "scoreboard_score": 0x6c, "simulation_distance": 0x6d, "set_title_subtitle": 0x6e, "update_time": 0x6f, "set_title_text": 0x70, "set_title_time": 0x71, "entity_sound_effect": 0x72, "sound_effect": 0x73, "start_configuration": 0x74, "stop_sound": 0x75, "store_cookie": 0x76, "system_chat": 0x77, "playerlist_header": 0x78, "nbt_query_response": 0x79, "collect": 0x7a, "entity_teleport": 0x7b, "test_instance_block_status": 0x7c, "set_ticking_state": 0x7d, "step_tick": 0x7e, "transfer": 0x7f, "advancements": 0x80, "entity_update_attributes": 0x81, "entity_effect": 0x82, "declare_recipes": 0x83, "tags": 0x84, "set_projectile_power": 0x85, "custom_report_details": 0x86, "server_links": 0x87, "tracked_waypoint": 0x88, "clear_dialog": 0x89, "show_dialog": 0x8a} 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 "action_bar": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketActionBar) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "add_resource_pack": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonAddResourcePack) 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 "bundle_delimiter": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBundleDelimiter) 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_suggestions": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChatSuggestions) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "chunk_batch_finished": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchFinished) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "chunk_batch_start": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchStart) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "chunk_biomes": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBiomes) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "clear_dialog": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonClearDialog) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "clear_titles": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketClearTitles) 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 "cookie_request": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonCookieRequest) 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 "custom_report_details": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonCustomReportDetails) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "damage_event": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDamageEvent) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "death_combat_event": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeathCombatEvent) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "debug_block_value": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugBlockValue) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "debug_chunk_value": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugChunkValue) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "debug_entity_value": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugEntityValue) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "debug_event": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugEvent) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "debug_sample": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugSample) 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 "end_combat_event": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEndCombatEvent) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "enter_combat_event": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEnterCombatEvent) 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 "game_test_highlight_pos": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameTestHighlightPos) 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 "hide_message": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHideMessage) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "hurt_animation": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHurtAnimation) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "initialize_world_border": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketInitializeWorldBorder) 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 "move_minecart": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMoveMinecart) 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 "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 "ping": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPing) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "ping_response": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPingResponse) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "player_chat": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerChat) 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 "player_remove": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRemove) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "player_rotation": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRotation) 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 "profileless_chat": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketProfilelessChat) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "recipe_book_add": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookAdd) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "recipe_book_remove": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookRemove) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "recipe_book_settings": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookSettings) 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 "remove_resource_pack": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonRemoveResourcePack) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "reset_score": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResetScore) 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 "server_data": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketServerData) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "server_links": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonServerLinks) 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_cursor_item": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCursorItem) 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_player_inventory": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPlayerInventory) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "set_projectile_power": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetProjectilePower) 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 "set_ticking_state": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTickingState) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "set_title_subtitle": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleSubtitle) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "set_title_text": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleText) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "set_title_time": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleTime) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "show_dialog": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketShowDialog) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "simulation_distance": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSimulationDistance) 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_position": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "start_configuration": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStartConfiguration) 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 "step_tick": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStepTick) 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 "store_cookie": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonStoreCookie) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "sync_entity_position": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSyncEntityPosition) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "system_chat": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSystemChat) 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 "test_instance_block_status": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTestInstanceBlockStatus) 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 "tracked_waypoint": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTrackedWaypoint) 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 "transfer": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonTransfer) 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 "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_center": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderCenter) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "world_border_lerp_size": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderLerpSize) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "world_border_size": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderSize) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "world_border_warning_delay": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningDelay) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketParamsEncTmp := PlayToClientPacketParams err = PlayToClientPacketParamsEncTmp.Encode(w) if err != nil { return } case "world_border_warning_reach": PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningReach) 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 { SequenceId int32 } func (ret *PlayToClientPacketAcknowledgePlayerDigging) Decode(r io.ReadSeeker) (err error) { ret.SequenceId, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketAcknowledgePlayerDigging) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.SequenceId) if err != nil { return } return } type PlayToClientPacketActionBar struct { Text nbt.Anon } func (ret *PlayToClientPacketActionBar) Decode(r io.ReadSeeker) (err error) { err = ret.Text.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketActionBar) Encode(w io.Writer) (err error) { PlayToClientPacketActionBarTextEncTmp := ret.Text err = PlayToClientPacketActionBarTextEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketAdvancements struct { Reset bool AdvancementMapping []struct { Key string Value struct { ParentId *string DisplayData *struct { Title nbt.Anon Description nbt.Anon Icon Slot FrameType int32 Flags struct { Unused uint32 Hidden bool ShowToast bool HasBackgroundTexture bool } BackgroundTexture any XCord float32 YCord float32 } Requirements [][]string SendsTelemtryData bool } } Identifiers []string ProgressMapping []struct { Key string Value []struct { CriterionIdentifier string CriterionProgress *int64 } } ShowAdvancements bool } 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 nbt.Anon Description nbt.Anon Icon Slot FrameType int32 Flags struct { Unused uint32 Hidden bool ShowToast bool HasBackgroundTexture bool } BackgroundTexture any XCord float32 YCord float32 } Requirements [][]string SendsTelemtryData bool } }{} for range lPlayToClientPacketAdvancementsAdvancementMapping { var PlayToClientPacketAdvancementsAdvancementMappingElement struct { Key string Value struct { ParentId *string DisplayData *struct { Title nbt.Anon Description nbt.Anon Icon Slot FrameType int32 Flags struct { Unused uint32 Hidden bool ShowToast bool HasBackgroundTexture bool } BackgroundTexture any XCord float32 YCord float32 } Requirements [][]string SendsTelemtryData bool } } 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 nbt.Anon Description nbt.Anon Icon Slot FrameType int32 Flags struct { Unused uint32 Hidden bool ShowToast bool HasBackgroundTexture bool } BackgroundTexture any XCord float32 YCord float32 } err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Title.Decode(r) if err != nil { return } err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Description.Decode(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 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) } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElement.Value.SendsTelemtryData) if err != nil { return } 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) } err = binary.Read(r, binary.BigEndian, &ret.ShowAdvancements) if err != nil { return } 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 { PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataTitleEncTmp := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Title err = PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataTitleEncTmp.Encode(w) if err != nil { return } PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataDescriptionEncTmp := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Description err = PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataDescriptionEncTmp.Encode(w) 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.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 = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.SendsTelemtryData) 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 } } } } err = binary.Write(w, binary.BigEndian, ret.ShowAdvancements) 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 nbt.Anon err = PlayToClientPacketBossBarTitle0Tmp.Decode(r) if err != nil { return } ret.Title = PlayToClientPacketBossBarTitle0Tmp case 3: var PlayToClientPacketBossBarTitle3Tmp nbt.Anon err = PlayToClientPacketBossBarTitle3Tmp.Decode(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.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketBossBarTitleEncTmp := PlayToClientPacketBossBarTitle err = PlayToClientPacketBossBarTitleEncTmp.Encode(w) if err != nil { return } case 3: PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketBossBarTitleEncTmp := PlayToClientPacketBossBarTitle err = PlayToClientPacketBossBarTitleEncTmp.Encode(w) 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 PlayToClientPacketBundleDelimiter struct { } func (ret *PlayToClientPacketBundleDelimiter) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToClientPacketBundleDelimiter) Encode(w io.Writer) (err error) { 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 PlayToClientPacketChatSuggestions struct { Action int32 Entries []string } func (ret *PlayToClientPacketChatSuggestions) Decode(r io.ReadSeeker) (err error) { ret.Action, err = proto_base.DecodeVarInt(r) if err != nil { return } var lPlayToClientPacketChatSuggestionsEntries int32 lPlayToClientPacketChatSuggestionsEntries, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Entries = []string{} for range lPlayToClientPacketChatSuggestionsEntries { var PlayToClientPacketChatSuggestionsEntriesElement string PlayToClientPacketChatSuggestionsEntriesElement, err = proto_base.DecodeString(r) if err != nil { return } ret.Entries = append(ret.Entries, PlayToClientPacketChatSuggestionsEntriesElement) } return } func (ret *PlayToClientPacketChatSuggestions) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Action) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Entries))) if err != nil { return } for iPlayToClientPacketChatSuggestionsEntries := range len(ret.Entries) { err = proto_base.EncodeString(w, ret.Entries[iPlayToClientPacketChatSuggestionsEntries]) if err != nil { return } } return } type PlayToClientPacketChunkBatchFinished struct { BatchSize int32 } func (ret *PlayToClientPacketChunkBatchFinished) Decode(r io.ReadSeeker) (err error) { ret.BatchSize, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketChunkBatchFinished) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.BatchSize) if err != nil { return } return } type PlayToClientPacketChunkBatchStart struct { } func (ret *PlayToClientPacketChunkBatchStart) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToClientPacketChunkBatchStart) Encode(w io.Writer) (err error) { return } type PlayToClientPacketChunkBiomes struct { Biomes []struct { Position PackedChunkPos Data ByteArray } } func (ret *PlayToClientPacketChunkBiomes) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketChunkBiomesBiomes int32 lPlayToClientPacketChunkBiomesBiomes, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Biomes = []struct { Position PackedChunkPos Data ByteArray }{} for range lPlayToClientPacketChunkBiomesBiomes { var PlayToClientPacketChunkBiomesBiomesElement struct { Position PackedChunkPos Data ByteArray } err = PlayToClientPacketChunkBiomesBiomesElement.Position.Decode(r) if err != nil { return } err = PlayToClientPacketChunkBiomesBiomesElement.Data.Decode(r) if err != nil { return } ret.Biomes = append(ret.Biomes, PlayToClientPacketChunkBiomesBiomesElement) } return } func (ret *PlayToClientPacketChunkBiomes) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Biomes))) if err != nil { return } for iPlayToClientPacketChunkBiomesBiomes := range len(ret.Biomes) { PlayToClientPacketChunkBiomesBiomesInnerPositionEncTmp := ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Position err = PlayToClientPacketChunkBiomesBiomesInnerPositionEncTmp.Encode(w) if err != nil { return } PlayToClientPacketChunkBiomesBiomesInnerDataEncTmp := ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Data err = PlayToClientPacketChunkBiomesBiomesInnerDataEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketClearTitles struct { Reset bool } func (ret *PlayToClientPacketClearTitles) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Reset) if err != nil { return } return } func (ret *PlayToClientPacketClearTitles) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Reset) if err != nil { return } return } type PlayToClientPacketCloseWindow struct { WindowId ContainerID } func (ret *PlayToClientPacketCloseWindow) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketCloseWindow) Encode(w io.Writer) (err error) { PlayToClientPacketCloseWindowWindowIdEncTmp := ret.WindowId err = PlayToClientPacketCloseWindowWindowIdEncTmp.Encode(w) 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 PlayToClientPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *PlayToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var PlayToClientPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if PlayToClientPacketCommonAddResourcePackPromptMessagePresent { var PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *PlayToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { PlayToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = PlayToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketCommonClearDialog struct { } func (ret *PlayToClientPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type PlayToClientPacketCommonCookieRequest struct { Cookie string } func (ret *PlayToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *PlayToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type PlayToClientPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *PlayToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var PlayToClientPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonCookieResponseValuePresent) if err != nil { return } if PlayToClientPacketCommonCookieResponseValuePresent { var PlayToClientPacketCommonCookieResponseValuePresentValue ByteArray err = PlayToClientPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &PlayToClientPacketCommonCookieResponseValuePresentValue } return } func (ret *PlayToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { PlayToClientPacketCommonCookieResponseValueEncTmp := *ret.Value err = PlayToClientPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *PlayToClientPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var PlayToClientPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonCustomClickActionNbtPresent) if err != nil { return } if PlayToClientPacketCommonCustomClickActionNbtPresent { var PlayToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = PlayToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &PlayToClientPacketCommonCustomClickActionNbtPresentValue } return } func (ret *PlayToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { PlayToClientPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = PlayToClientPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *PlayToClientPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketCommonCustomReportDetailsDetails int32 lPlayToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lPlayToClientPacketCommonCustomReportDetailsDetails { var PlayToClientPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } PlayToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, PlayToClientPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *PlayToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iPlayToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iPlayToClientPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iPlayToClientPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type PlayToClientPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *PlayToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var PlayToClientPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if PlayToClientPacketCommonRemoveResourcePackUuidPresent { var PlayToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, PlayToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &PlayToClientPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *PlayToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type PlayToClientPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *PlayToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketCommonSelectKnownPacksPacks int32 lPlayToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lPlayToClientPacketCommonSelectKnownPacksPacks { var PlayToClientPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } PlayToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, PlayToClientPacketCommonSelectKnownPacksPacksElement) } return } func (ret *PlayToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iPlayToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type PlayToClientPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *PlayToClientPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketCommonServerLinksLinks int32 lPlayToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lPlayToClientPacketCommonServerLinksLinks { var PlayToClientPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch PlayToClientPacketCommonServerLinksLinksElement.HasKnownType { case true: var PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } PlayToClientPacketCommonServerLinksLinksElement.KnownType = PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch PlayToClientPacketCommonServerLinksLinksElement.HasKnownType { case false: var PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } PlayToClientPacketCommonServerLinksLinksElement.UnknownType = PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } PlayToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, PlayToClientPacketCommonServerLinksLinksElement) } return } func (ret *PlayToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iPlayToClientPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType { case true: PlayToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iPlayToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp := PlayToClientPacketCommonServerLinksLinksInnerKnownType err = PlayToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType { case false: PlayToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iPlayToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := PlayToClientPacketCommonServerLinksLinksInnerUnknownType err = PlayToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iPlayToClientPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type PlayToClientPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var PlayToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *PlayToClientPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var PlayToClientPacketCommonSettingsParticleStatusKey int32 PlayToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(PlayToClientPacketCommonSettingsParticleStatusMap, PlayToClientPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var PlayToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *PlayToClientPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vPlayToClientPacketCommonSettingsParticleStatus int32 vPlayToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(PlayToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketCommonSettingsParticleStatus) if err != nil { return } return } type PlayToClientPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *PlayToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } PlayToClientPacketCommonStoreCookieValueEncTmp := ret.Value err = PlayToClientPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketCommonTransfer struct { Host string Port int32 } func (ret *PlayToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) if err != nil { return } return } type PlayToClientPacketCraftProgressBar struct { WindowId ContainerID Property int16 Value int16 } func (ret *PlayToClientPacketCraftProgressBar) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) 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) { PlayToClientPacketCraftProgressBarWindowIdEncTmp := ret.WindowId err = PlayToClientPacketCraftProgressBarWindowIdEncTmp.Encode(w) 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 ContainerID RecipeDisplay PlayToClientRecipeDisplay } func (ret *PlayToClientPacketCraftRecipeResponse) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) if err != nil { return } err = ret.RecipeDisplay.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketCraftRecipeResponse) Encode(w io.Writer) (err error) { PlayToClientPacketCraftRecipeResponseWindowIdEncTmp := ret.WindowId err = PlayToClientPacketCraftRecipeResponseWindowIdEncTmp.Encode(w) if err != nil { return } PlayToClientPacketCraftRecipeResponseRecipeDisplayEncTmp := ret.RecipeDisplay err = PlayToClientPacketCraftRecipeResponseRecipeDisplayEncTmp.Encode(w) 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 PlayToClientPacketDamageEvent struct { EntityId int32 SourceTypeId int32 SourceCauseId int32 SourceDirectId int32 SourcePosition *Vec3f64 } func (ret *PlayToClientPacketDamageEvent) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SourceTypeId, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SourceCauseId, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SourceDirectId, err = proto_base.DecodeVarInt(r) if err != nil { return } var PlayToClientPacketDamageEventSourcePositionPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDamageEventSourcePositionPresent) if err != nil { return } if PlayToClientPacketDamageEventSourcePositionPresent { var PlayToClientPacketDamageEventSourcePositionPresentValue Vec3f64 err = PlayToClientPacketDamageEventSourcePositionPresentValue.Decode(r) if err != nil { return } ret.SourcePosition = &PlayToClientPacketDamageEventSourcePositionPresentValue } return } func (ret *PlayToClientPacketDamageEvent) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.EntityId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.SourceTypeId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.SourceCauseId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.SourceDirectId) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.SourcePosition != nil) if err != nil { return } if ret.SourcePosition != nil { PlayToClientPacketDamageEventSourcePositionEncTmp := *ret.SourcePosition err = PlayToClientPacketDamageEventSourcePositionEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketDeathCombatEvent struct { PlayerId int32 Message nbt.Anon } func (ret *PlayToClientPacketDeathCombatEvent) Decode(r io.ReadSeeker) (err error) { ret.PlayerId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = ret.Message.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketDeathCombatEvent) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.PlayerId) if err != nil { return } PlayToClientPacketDeathCombatEventMessageEncTmp := ret.Message err = PlayToClientPacketDeathCombatEventMessageEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketDebugBlockValue struct { BlockPos Position Update DebugSubscriptionUpdate } func (ret *PlayToClientPacketDebugBlockValue) Decode(r io.ReadSeeker) (err error) { err = ret.BlockPos.Decode(r) if err != nil { return } err = ret.Update.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketDebugBlockValue) Encode(w io.Writer) (err error) { PlayToClientPacketDebugBlockValueBlockPosEncTmp := ret.BlockPos err = PlayToClientPacketDebugBlockValueBlockPosEncTmp.Encode(w) if err != nil { return } PlayToClientPacketDebugBlockValueUpdateEncTmp := ret.Update err = PlayToClientPacketDebugBlockValueUpdateEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketDebugChunkValue struct { ChunkPos PackedChunkPos Update DebugSubscriptionUpdate } func (ret *PlayToClientPacketDebugChunkValue) Decode(r io.ReadSeeker) (err error) { err = ret.ChunkPos.Decode(r) if err != nil { return } err = ret.Update.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketDebugChunkValue) Encode(w io.Writer) (err error) { PlayToClientPacketDebugChunkValueChunkPosEncTmp := ret.ChunkPos err = PlayToClientPacketDebugChunkValueChunkPosEncTmp.Encode(w) if err != nil { return } PlayToClientPacketDebugChunkValueUpdateEncTmp := ret.Update err = PlayToClientPacketDebugChunkValueUpdateEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketDebugEntityValue struct { EntityId int32 Update DebugSubscriptionUpdate } func (ret *PlayToClientPacketDebugEntityValue) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = ret.Update.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketDebugEntityValue) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.EntityId) if err != nil { return } PlayToClientPacketDebugEntityValueUpdateEncTmp := ret.Update err = PlayToClientPacketDebugEntityValueUpdateEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketDebugEvent struct { Event DebugSubscriptionEvent } func (ret *PlayToClientPacketDebugEvent) Decode(r io.ReadSeeker) (err error) { err = ret.Event.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketDebugEvent) Encode(w io.Writer) (err error) { PlayToClientPacketDebugEventEventEncTmp := ret.Event err = PlayToClientPacketDebugEventEventEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketDebugSample struct { Sample []int64 Type int32 } func (ret *PlayToClientPacketDebugSample) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketDebugSampleSample int32 lPlayToClientPacketDebugSampleSample, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Sample = []int64{} for range lPlayToClientPacketDebugSampleSample { var PlayToClientPacketDebugSampleSampleElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDebugSampleSampleElement) if err != nil { return } ret.Sample = append(ret.Sample, PlayToClientPacketDebugSampleSampleElement) } ret.Type, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketDebugSample) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Sample))) if err != nil { return } for iPlayToClientPacketDebugSampleSample := range len(ret.Sample) { err = binary.Write(w, binary.BigEndian, ret.Sample[iPlayToClientPacketDebugSampleSample]) if err != nil { return } } err = proto_base.EncodeVarInt(w, ret.Type) 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 { Name string Items []int32 } StoneCutterRecipes []struct { Input IDSet SlotDisplay PlayToClientSlotDisplay } } 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 { Name string Items []int32 }{} for range lPlayToClientPacketDeclareRecipesRecipes { var PlayToClientPacketDeclareRecipesRecipesElement struct { Name string Items []int32 } PlayToClientPacketDeclareRecipesRecipesElement.Name, err = proto_base.DecodeString(r) if err != nil { return } var lPlayToClientPacketDeclareRecipesRecipesElementItems int32 lPlayToClientPacketDeclareRecipesRecipesElementItems, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketDeclareRecipesRecipesElement.Items = []int32{} for range lPlayToClientPacketDeclareRecipesRecipesElementItems { var PlayToClientPacketDeclareRecipesRecipesElementItemsElement int32 PlayToClientPacketDeclareRecipesRecipesElementItemsElement, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketDeclareRecipesRecipesElement.Items = append(PlayToClientPacketDeclareRecipesRecipesElement.Items, PlayToClientPacketDeclareRecipesRecipesElementItemsElement) } ret.Recipes = append(ret.Recipes, PlayToClientPacketDeclareRecipesRecipesElement) } var lPlayToClientPacketDeclareRecipesStoneCutterRecipes int32 lPlayToClientPacketDeclareRecipesStoneCutterRecipes, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.StoneCutterRecipes = []struct { Input IDSet SlotDisplay PlayToClientSlotDisplay }{} for range lPlayToClientPacketDeclareRecipesStoneCutterRecipes { var PlayToClientPacketDeclareRecipesStoneCutterRecipesElement struct { Input IDSet SlotDisplay PlayToClientSlotDisplay } err = PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.Input.Decode(r) if err != nil { return } err = PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.SlotDisplay.Decode(r) if err != nil { return } ret.StoneCutterRecipes = append(ret.StoneCutterRecipes, PlayToClientPacketDeclareRecipesStoneCutterRecipesElement) } 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].Name) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items))) if err != nil { return } for iPlayToClientPacketDeclareRecipesRecipesInnerItems := range len(ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items) { err = proto_base.EncodeVarInt(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items[iPlayToClientPacketDeclareRecipesRecipesInnerItems]) if err != nil { return } } } err = proto_base.EncodeVarInt(w, int32(len(ret.StoneCutterRecipes))) if err != nil { return } for iPlayToClientPacketDeclareRecipesStoneCutterRecipes := range len(ret.StoneCutterRecipes) { PlayToClientPacketDeclareRecipesStoneCutterRecipesInnerInputEncTmp := ret.StoneCutterRecipes[iPlayToClientPacketDeclareRecipesStoneCutterRecipes].Input err = PlayToClientPacketDeclareRecipesStoneCutterRecipesInnerInputEncTmp.Encode(w) if err != nil { return } PlayToClientPacketDeclareRecipesStoneCutterRecipesInnerSlotDisplayEncTmp := ret.StoneCutterRecipes[iPlayToClientPacketDeclareRecipesStoneCutterRecipes].SlotDisplay err = PlayToClientPacketDeclareRecipesStoneCutterRecipesInnerSlotDisplayEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketDifficulty struct { Difficulty string DifficultyLocked bool } var PlayToClientPacketDifficultyDifficultyMap = map[int32]string{0: "peaceful", 1: "easy", 2: "normal", 3: "hard"} func (ret *PlayToClientPacketDifficulty) Decode(r io.ReadSeeker) (err error) { var PlayToClientPacketDifficultyDifficultyKey int32 PlayToClientPacketDifficultyDifficultyKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Difficulty, err = proto_base.ErroringIndex(PlayToClientPacketDifficultyDifficultyMap, PlayToClientPacketDifficultyDifficultyKey) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.DifficultyLocked) if err != nil { return } return } var PlayToClientPacketDifficultyDifficultyReverseMap = map[string]int32{"peaceful": 0, "easy": 1, "normal": 2, "hard": 3} func (ret *PlayToClientPacketDifficulty) Encode(w io.Writer) (err error) { var vPlayToClientPacketDifficultyDifficulty int32 vPlayToClientPacketDifficultyDifficulty, err = proto_base.ErroringIndex(PlayToClientPacketDifficultyDifficultyReverseMap, ret.Difficulty) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketDifficultyDifficulty) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.DifficultyLocked) if err != nil { return } return } type PlayToClientPacketEndCombatEvent struct { Duration int32 } func (ret *PlayToClientPacketEndCombatEvent) Decode(r io.ReadSeeker) (err error) { ret.Duration, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketEndCombatEvent) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Duration) if err != nil { return } return } type PlayToClientPacketEnterCombatEvent struct { } func (ret *PlayToClientPacketEnterCombatEvent) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToClientPacketEnterCombatEvent) Encode(w io.Writer) (err error) { 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 int32 Amplifier int32 Duration int32 Flags uint8 } func (ret *PlayToClientPacketEntityEffect) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.EffectId, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Amplifier, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Duration, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Flags) 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 = proto_base.EncodeVarInt(w, ret.EffectId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Amplifier) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Duration) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Flags) 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 { Sound ItemSoundHolder SoundCategory SoundSource EntityId int32 Volume float32 Pitch float32 Seed int64 } func (ret *PlayToClientPacketEntitySoundEffect) Decode(r io.ReadSeeker) (err error) { err = ret.Sound.Decode(r) if err != nil { return } err = ret.SoundCategory.Decode(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 } err = binary.Read(r, binary.BigEndian, &ret.Seed) if err != nil { return } return } func (ret *PlayToClientPacketEntitySoundEffect) Encode(w io.Writer) (err error) { PlayToClientPacketEntitySoundEffectSoundEncTmp := ret.Sound err = PlayToClientPacketEntitySoundEffectSoundEncTmp.Encode(w) if err != nil { return } PlayToClientPacketEntitySoundEffectSoundCategoryEncTmp := ret.SoundCategory err = PlayToClientPacketEntitySoundEffectSoundCategoryEncTmp.Encode(w) 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 } err = binary.Write(w, binary.BigEndian, ret.Seed) 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 string Amount float64 Operation int8 } } } var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap = map[int32]string{0: "generic.armor", 1: "generic.armor_toughness", 10: "player.entity_interaction_range", 11: "generic.fall_damage_multiplier", 12: "generic.flying_speed", 13: "generic.follow_range", 14: "generic.gravity", 15: "generic.jump_strength", 16: "generic.knockback_resistance", 17: "generic.luck", 18: "generic.max_absorption", 19: "generic.max_health", 2: "generic.attack_damage", 20: "generic.movement_speed", 21: "generic.safe_fall_distance", 22: "generic.scale", 23: "zombie.spawn_reinforcements", 24: "generic.step_height", 25: "submerged_mining_speed", 26: "sweeping_damage_ratio", 27: "tempt_range", 28: "water_movement_efficiency", 29: "waypoint_transmit_range", 3: "generic.attack_knockback", 30: "waypoint_receive_range", 4: "generic.attack_speed", 5: "player.block_break_speed", 6: "player.block_interaction_range", 7: "burning_time", 8: "camera_distance", 9: "explosion_knockback_resistance"} func (ret *PlayToClientPacketEntityUpdateAttributes) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } var lPlayToClientPacketEntityUpdateAttributesProperties int32 lPlayToClientPacketEntityUpdateAttributesProperties, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Properties = []struct { Key string Value float64 Modifiers []struct { Uuid string Amount float64 Operation int8 } }{} for range lPlayToClientPacketEntityUpdateAttributesProperties { var PlayToClientPacketEntityUpdateAttributesPropertiesElement struct { Key string Value float64 Modifiers []struct { Uuid string Amount float64 Operation int8 } } var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey int32 PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketEntityUpdateAttributesPropertiesElement.Key, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap, PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey) 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 string Amount float64 Operation int8 }{} for range lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers { var PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement struct { Uuid string Amount float64 Operation int8 } PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Uuid, err = proto_base.DecodeString(r) 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 } var PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap = map[string]int32{"generic.armor": 0, "generic.armor_toughness": 1, "player.entity_interaction_range": 10, "generic.fall_damage_multiplier": 11, "generic.flying_speed": 12, "generic.follow_range": 13, "generic.gravity": 14, "generic.jump_strength": 15, "generic.knockback_resistance": 16, "generic.luck": 17, "generic.max_absorption": 18, "generic.max_health": 19, "generic.attack_damage": 2, "generic.movement_speed": 20, "generic.safe_fall_distance": 21, "generic.scale": 22, "zombie.spawn_reinforcements": 23, "generic.step_height": 24, "submerged_mining_speed": 25, "sweeping_damage_ratio": 26, "tempt_range": 27, "water_movement_efficiency": 28, "waypoint_transmit_range": 29, "generic.attack_knockback": 3, "waypoint_receive_range": 30, "generic.attack_speed": 4, "player.block_break_speed": 5, "player.block_interaction_range": 6, "burning_time": 7, "camera_distance": 8, "explosion_knockback_resistance": 9} func (ret *PlayToClientPacketEntityUpdateAttributes) 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.Properties))) if err != nil { return } for iPlayToClientPacketEntityUpdateAttributesProperties := range len(ret.Properties) { var vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey int32 vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Key) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey) 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 = proto_base.EncodeString(w, 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 proto_base.LpVec3d } 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 { Center Vec3f64 Radius float32 BlockCount int32 PlayerKnockback *Vec3f64 ExplosionParticle Particle Sound ItemSoundHolder BlockParticles []PlayToClientExplosionParticleEntry } func (ret *PlayToClientPacketExplosion) Decode(r io.ReadSeeker) (err error) { err = ret.Center.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Radius) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.BlockCount) if err != nil { return } var PlayToClientPacketExplosionPlayerKnockbackPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionPlayerKnockbackPresent) if err != nil { return } if PlayToClientPacketExplosionPlayerKnockbackPresent { var PlayToClientPacketExplosionPlayerKnockbackPresentValue Vec3f64 err = PlayToClientPacketExplosionPlayerKnockbackPresentValue.Decode(r) if err != nil { return } ret.PlayerKnockback = &PlayToClientPacketExplosionPlayerKnockbackPresentValue } err = ret.ExplosionParticle.Decode(r) if err != nil { return } err = ret.Sound.Decode(r) if err != nil { return } var lPlayToClientPacketExplosionBlockParticles int32 lPlayToClientPacketExplosionBlockParticles, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.BlockParticles = []PlayToClientExplosionParticleEntry{} for range lPlayToClientPacketExplosionBlockParticles { var PlayToClientPacketExplosionBlockParticlesElement PlayToClientExplosionParticleEntry err = PlayToClientPacketExplosionBlockParticlesElement.Decode(r) if err != nil { return } ret.BlockParticles = append(ret.BlockParticles, PlayToClientPacketExplosionBlockParticlesElement) } return } func (ret *PlayToClientPacketExplosion) Encode(w io.Writer) (err error) { PlayToClientPacketExplosionCenterEncTmp := ret.Center err = PlayToClientPacketExplosionCenterEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Radius) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.BlockCount) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PlayerKnockback != nil) if err != nil { return } if ret.PlayerKnockback != nil { PlayToClientPacketExplosionPlayerKnockbackEncTmp := *ret.PlayerKnockback err = PlayToClientPacketExplosionPlayerKnockbackEncTmp.Encode(w) if err != nil { return } } PlayToClientPacketExplosionExplosionParticleEncTmp := ret.ExplosionParticle err = PlayToClientPacketExplosionExplosionParticleEncTmp.Encode(w) if err != nil { return } PlayToClientPacketExplosionSoundEncTmp := ret.Sound err = PlayToClientPacketExplosionSoundEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.BlockParticles))) if err != nil { return } for iPlayToClientPacketExplosionBlockParticles := range len(ret.BlockParticles) { PlayToClientPacketExplosionBlockParticlesInnerEncTmp := ret.BlockParticles[iPlayToClientPacketExplosionBlockParticles] err = PlayToClientPacketExplosionBlockParticlesInnerEncTmp.Encode(w) 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 int32 PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp, err = proto_base.DecodeVarInt(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.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityFeetEyes) if err != nil { return } default: _, ok := ret.EntityFeetEyes.(struct { }) if !ok { err = proto_base.BadTypeError return } } return } type PlayToClientPacketGameStateChange struct { Reason string GameMode float32 } var PlayToClientPacketGameStateChangeReasonMap = map[uint8]string{0: "no_respawn_block_available", 1: "start_raining", 10: "guardian_elder_effect", 11: "immediate_respawn", 12: "limited_crafting", 13: "level_chunks_load_start", 2: "stop_raining", 3: "change_game_mode", 4: "win_game", 5: "demo_event", 6: "play_arrow_hit_sound", 7: "rain_level_change", 8: "thunder_level_change", 9: "puffer_fish_sting"} func (ret *PlayToClientPacketGameStateChange) Decode(r io.ReadSeeker) (err error) { var PlayToClientPacketGameStateChangeReasonKey uint8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketGameStateChangeReasonKey) if err != nil { return } ret.Reason, err = proto_base.ErroringIndex(PlayToClientPacketGameStateChangeReasonMap, PlayToClientPacketGameStateChangeReasonKey) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.GameMode) if err != nil { return } return } var PlayToClientPacketGameStateChangeReasonReverseMap = map[string]uint8{"no_respawn_block_available": 0, "start_raining": 1, "guardian_elder_effect": 10, "immediate_respawn": 11, "limited_crafting": 12, "level_chunks_load_start": 13, "stop_raining": 2, "change_game_mode": 3, "win_game": 4, "demo_event": 5, "play_arrow_hit_sound": 6, "rain_level_change": 7, "thunder_level_change": 8, "puffer_fish_sting": 9} func (ret *PlayToClientPacketGameStateChange) Encode(w io.Writer) (err error) { var vPlayToClientPacketGameStateChangeReason uint8 vPlayToClientPacketGameStateChangeReason, err = proto_base.ErroringIndex(PlayToClientPacketGameStateChangeReasonReverseMap, ret.Reason) if err != nil { return } err = binary.Write(w, binary.BigEndian, vPlayToClientPacketGameStateChangeReason) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.GameMode) if err != nil { return } return } type PlayToClientPacketGameTestHighlightPos struct { AbsolutePos Position RelativePos Position } func (ret *PlayToClientPacketGameTestHighlightPos) Decode(r io.ReadSeeker) (err error) { err = ret.AbsolutePos.Decode(r) if err != nil { return } err = ret.RelativePos.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketGameTestHighlightPos) Encode(w io.Writer) (err error) { PlayToClientPacketGameTestHighlightPosAbsolutePosEncTmp := ret.AbsolutePos err = PlayToClientPacketGameTestHighlightPosAbsolutePosEncTmp.Encode(w) if err != nil { return } PlayToClientPacketGameTestHighlightPosRelativePosEncTmp := ret.RelativePos err = PlayToClientPacketGameTestHighlightPosRelativePosEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketHeldItemSlot struct { Slot int32 } func (ret *PlayToClientPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) { ret.Slot, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketHeldItemSlot) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Slot) if err != nil { return } return } type PlayToClientPacketHideMessage struct { Id int32 Signature any } func (ret *PlayToClientPacketHideMessage) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeVarInt(r) if err != nil { return } switch ret.Id { case 0: var PlayToClientPacketHideMessageSignature0Tmp [256]byte _, err = r.Read(PlayToClientPacketHideMessageSignature0Tmp[:]) if err != nil { return } ret.Signature = PlayToClientPacketHideMessageSignature0Tmp default: var PlayToClientPacketHideMessageSignatureTmp struct { } ret.Signature = PlayToClientPacketHideMessageSignatureTmp } return } func (ret *PlayToClientPacketHideMessage) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Id) if err != nil { return } switch ret.Id { case 0: PlayToClientPacketHideMessageSignature, ok := ret.Signature.([256]byte) if !ok { err = proto_base.BadTypeError return } arr := PlayToClientPacketHideMessageSignature _, err = w.Write(arr[:]) if err != nil { return } default: _, ok := ret.Signature.(struct { }) if !ok { err = proto_base.BadTypeError return } } return } type PlayToClientPacketHurtAnimation struct { EntityId int32 Yaw float32 } func (ret *PlayToClientPacketHurtAnimation) 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 } return } func (ret *PlayToClientPacketHurtAnimation) 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 } return } type PlayToClientPacketInitializeWorldBorder struct { X float64 Z float64 OldDiameter float64 NewDiameter float64 Speed int32 PortalTeleportBoundary int32 WarningBlocks int32 WarningTime int32 } func (ret *PlayToClientPacketInitializeWorldBorder) 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.OldDiameter) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.NewDiameter) if err != nil { return } ret.Speed, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.PortalTeleportBoundary, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.WarningBlocks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.WarningTime, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketInitializeWorldBorder) 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.OldDiameter) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.NewDiameter) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Speed) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.PortalTeleportBoundary) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.WarningBlocks) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.WarningTime) 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 nbt.Anon } func (ret *PlayToClientPacketKickDisconnect) Decode(r io.ReadSeeker) (err error) { err = ret.Reason.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketKickDisconnect) Encode(w io.Writer) (err error) { PlayToClientPacketKickDisconnectReasonEncTmp := ret.Reason err = PlayToClientPacketKickDisconnectReasonEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketLogin struct { EntityId int32 IsHardcore bool WorldNames []string MaxPlayers int32 ViewDistance int32 SimulationDistance int32 ReducedDebugInfo bool EnableRespawnScreen bool DoLimitedCrafting bool WorldState PlayToClientSpawnInfo EnforcesSecureChat 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 } 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) } ret.MaxPlayers, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ViewDistance, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SimulationDistance, 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.DoLimitedCrafting) if err != nil { return } err = ret.WorldState.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnforcesSecureChat) 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 = 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 } } err = proto_base.EncodeVarInt(w, ret.MaxPlayers) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.ViewDistance) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.SimulationDistance) 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.DoLimitedCrafting) if err != nil { return } PlayToClientPacketLoginWorldStateEncTmp := ret.WorldState err = PlayToClientPacketLoginWorldStateEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnforcesSecureChat) if err != nil { return } return } type PlayToClientPacketMap struct { ItemDamage int32 Scale int8 Locked bool Icons *[]struct { Type int32 X int8 Z int8 Direction uint8 DisplayName *nbt.Anon } Columns uint8 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.Locked) if err != nil { return } var PlayToClientPacketMapIconsPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsPresent) if err != nil { return } if PlayToClientPacketMapIconsPresent { var PlayToClientPacketMapIconsPresentValue []struct { Type int32 X int8 Z int8 Direction uint8 DisplayName *nbt.Anon } var lPlayToClientPacketMapIcons int32 lPlayToClientPacketMapIcons, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketMapIconsPresentValue = []struct { Type int32 X int8 Z int8 Direction uint8 DisplayName *nbt.Anon }{} for range lPlayToClientPacketMapIcons { var PlayToClientPacketMapIconsElement struct { Type int32 X int8 Z int8 Direction uint8 DisplayName *nbt.Anon } 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 nbt.Anon err = PlayToClientPacketMapIconsElementDisplayNamePresentValue.Decode(r) if err != nil { return } PlayToClientPacketMapIconsElement.DisplayName = &PlayToClientPacketMapIconsElementDisplayNamePresentValue } PlayToClientPacketMapIconsPresentValue = append(PlayToClientPacketMapIconsPresentValue, PlayToClientPacketMapIconsElement) } ret.Icons = &PlayToClientPacketMapIconsPresentValue } 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 uint8 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 uint8 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 uint8 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.Locked) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Icons != nil) if err != nil { return } if ret.Icons != nil { 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 { PlayToClientPacketMapIconsInnerDisplayNameEncTmp := *(*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName err = PlayToClientPacketMapIconsInnerDisplayNameEncTmp.Encode(w) 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.(uint8) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ret.Rows.(uint8)) if err != nil { return } } switch ret.Columns { case 0: _, ok := ret.X.(struct { }) if !ok { err = proto_base.BadTypeError return } default: _, ok := ret.X.(uint8) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ret.X.(uint8)) if err != nil { return } } switch ret.Columns { case 0: _, ok := ret.Y.(struct { }) if !ok { err = proto_base.BadTypeError return } default: _, ok := ret.Y.(uint8) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, ret.Y.(uint8)) 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 Heightmaps []struct { Type string Data []int64 } ChunkData ByteArray BlockEntities []ChunkBlockEntity SkyLightMask []int64 BlockLightMask []int64 EmptySkyLightMask []int64 EmptyBlockLightMask []int64 SkyLight [][]uint8 BlockLight [][]uint8 } var PlayToClientPacketMapChunkHeightmapsElementTypeMap = map[int32]string{0: "world_surface_wg", 1: "world_surface", 2: "ocean_floor_wg", 3: "ocean_floor", 4: "motion_blocking", 5: "motion_blocking_no_leaves"} 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 } var lPlayToClientPacketMapChunkHeightmaps int32 lPlayToClientPacketMapChunkHeightmaps, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Heightmaps = []struct { Type string Data []int64 }{} for range lPlayToClientPacketMapChunkHeightmaps { var PlayToClientPacketMapChunkHeightmapsElement struct { Type string Data []int64 } var PlayToClientPacketMapChunkHeightmapsElementTypeKey int32 PlayToClientPacketMapChunkHeightmapsElementTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketMapChunkHeightmapsElement.Type, err = proto_base.ErroringIndex(PlayToClientPacketMapChunkHeightmapsElementTypeMap, PlayToClientPacketMapChunkHeightmapsElementTypeKey) if err != nil { return } var lPlayToClientPacketMapChunkHeightmapsElementData int32 lPlayToClientPacketMapChunkHeightmapsElementData, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketMapChunkHeightmapsElement.Data = []int64{} for range lPlayToClientPacketMapChunkHeightmapsElementData { var PlayToClientPacketMapChunkHeightmapsElementDataElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkHeightmapsElementDataElement) if err != nil { return } PlayToClientPacketMapChunkHeightmapsElement.Data = append(PlayToClientPacketMapChunkHeightmapsElement.Data, PlayToClientPacketMapChunkHeightmapsElementDataElement) } ret.Heightmaps = append(ret.Heightmaps, PlayToClientPacketMapChunkHeightmapsElement) } err = ret.ChunkData.Decode(r) if err != nil { return } var lPlayToClientPacketMapChunkBlockEntities int32 lPlayToClientPacketMapChunkBlockEntities, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.BlockEntities = []ChunkBlockEntity{} for range lPlayToClientPacketMapChunkBlockEntities { var PlayToClientPacketMapChunkBlockEntitiesElement ChunkBlockEntity err = PlayToClientPacketMapChunkBlockEntitiesElement.Decode(r) if err != nil { return } ret.BlockEntities = append(ret.BlockEntities, PlayToClientPacketMapChunkBlockEntitiesElement) } var lPlayToClientPacketMapChunkSkyLightMask int32 lPlayToClientPacketMapChunkSkyLightMask, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SkyLightMask = []int64{} for range lPlayToClientPacketMapChunkSkyLightMask { var PlayToClientPacketMapChunkSkyLightMaskElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkSkyLightMaskElement) if err != nil { return } ret.SkyLightMask = append(ret.SkyLightMask, PlayToClientPacketMapChunkSkyLightMaskElement) } var lPlayToClientPacketMapChunkBlockLightMask int32 lPlayToClientPacketMapChunkBlockLightMask, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.BlockLightMask = []int64{} for range lPlayToClientPacketMapChunkBlockLightMask { var PlayToClientPacketMapChunkBlockLightMaskElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBlockLightMaskElement) if err != nil { return } ret.BlockLightMask = append(ret.BlockLightMask, PlayToClientPacketMapChunkBlockLightMaskElement) } var lPlayToClientPacketMapChunkEmptySkyLightMask int32 lPlayToClientPacketMapChunkEmptySkyLightMask, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.EmptySkyLightMask = []int64{} for range lPlayToClientPacketMapChunkEmptySkyLightMask { var PlayToClientPacketMapChunkEmptySkyLightMaskElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkEmptySkyLightMaskElement) if err != nil { return } ret.EmptySkyLightMask = append(ret.EmptySkyLightMask, PlayToClientPacketMapChunkEmptySkyLightMaskElement) } var lPlayToClientPacketMapChunkEmptyBlockLightMask int32 lPlayToClientPacketMapChunkEmptyBlockLightMask, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.EmptyBlockLightMask = []int64{} for range lPlayToClientPacketMapChunkEmptyBlockLightMask { var PlayToClientPacketMapChunkEmptyBlockLightMaskElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkEmptyBlockLightMaskElement) if err != nil { return } ret.EmptyBlockLightMask = append(ret.EmptyBlockLightMask, PlayToClientPacketMapChunkEmptyBlockLightMaskElement) } var lPlayToClientPacketMapChunkSkyLight int32 lPlayToClientPacketMapChunkSkyLight, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SkyLight = [][]uint8{} for range lPlayToClientPacketMapChunkSkyLight { var PlayToClientPacketMapChunkSkyLightElement []uint8 var lPlayToClientPacketMapChunkSkyLightElement int32 lPlayToClientPacketMapChunkSkyLightElement, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketMapChunkSkyLightElement = []uint8{} for range lPlayToClientPacketMapChunkSkyLightElement { var PlayToClientPacketMapChunkSkyLightElementElement uint8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkSkyLightElementElement) if err != nil { return } PlayToClientPacketMapChunkSkyLightElement = append(PlayToClientPacketMapChunkSkyLightElement, PlayToClientPacketMapChunkSkyLightElementElement) } ret.SkyLight = append(ret.SkyLight, PlayToClientPacketMapChunkSkyLightElement) } var lPlayToClientPacketMapChunkBlockLight int32 lPlayToClientPacketMapChunkBlockLight, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.BlockLight = [][]uint8{} for range lPlayToClientPacketMapChunkBlockLight { var PlayToClientPacketMapChunkBlockLightElement []uint8 var lPlayToClientPacketMapChunkBlockLightElement int32 lPlayToClientPacketMapChunkBlockLightElement, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketMapChunkBlockLightElement = []uint8{} for range lPlayToClientPacketMapChunkBlockLightElement { var PlayToClientPacketMapChunkBlockLightElementElement uint8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBlockLightElementElement) if err != nil { return } PlayToClientPacketMapChunkBlockLightElement = append(PlayToClientPacketMapChunkBlockLightElement, PlayToClientPacketMapChunkBlockLightElementElement) } ret.BlockLight = append(ret.BlockLight, PlayToClientPacketMapChunkBlockLightElement) } return } var PlayToClientPacketMapChunkHeightmapsInnerTypeReverseMap = map[string]int32{"world_surface_wg": 0, "world_surface": 1, "ocean_floor_wg": 2, "ocean_floor": 3, "motion_blocking": 4, "motion_blocking_no_leaves": 5} 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 = proto_base.EncodeVarInt(w, int32(len(ret.Heightmaps))) if err != nil { return } for iPlayToClientPacketMapChunkHeightmaps := range len(ret.Heightmaps) { var vPlayToClientPacketMapChunkHeightmapsInnerType int32 vPlayToClientPacketMapChunkHeightmapsInnerType, err = proto_base.ErroringIndex(PlayToClientPacketMapChunkHeightmapsInnerTypeReverseMap, ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketMapChunkHeightmapsInnerType) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data))) if err != nil { return } for iPlayToClientPacketMapChunkHeightmapsInnerData := range len(ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data) { err = binary.Write(w, binary.BigEndian, ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data[iPlayToClientPacketMapChunkHeightmapsInnerData]) if err != nil { return } } } PlayToClientPacketMapChunkChunkDataEncTmp := ret.ChunkData err = PlayToClientPacketMapChunkChunkDataEncTmp.Encode(w) 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 } } err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLightMask))) if err != nil { return } for iPlayToClientPacketMapChunkSkyLightMask := range len(ret.SkyLightMask) { err = binary.Write(w, binary.BigEndian, ret.SkyLightMask[iPlayToClientPacketMapChunkSkyLightMask]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLightMask))) if err != nil { return } for iPlayToClientPacketMapChunkBlockLightMask := range len(ret.BlockLightMask) { err = binary.Write(w, binary.BigEndian, ret.BlockLightMask[iPlayToClientPacketMapChunkBlockLightMask]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.EmptySkyLightMask))) if err != nil { return } for iPlayToClientPacketMapChunkEmptySkyLightMask := range len(ret.EmptySkyLightMask) { err = binary.Write(w, binary.BigEndian, ret.EmptySkyLightMask[iPlayToClientPacketMapChunkEmptySkyLightMask]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.EmptyBlockLightMask))) if err != nil { return } for iPlayToClientPacketMapChunkEmptyBlockLightMask := range len(ret.EmptyBlockLightMask) { err = binary.Write(w, binary.BigEndian, ret.EmptyBlockLightMask[iPlayToClientPacketMapChunkEmptyBlockLightMask]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight))) if err != nil { return } for iPlayToClientPacketMapChunkSkyLight := range len(ret.SkyLight) { err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight]))) if err != nil { return } for iPlayToClientPacketMapChunkSkyLightInner := range len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight]) { err = binary.Write(w, binary.BigEndian, ret.SkyLight[iPlayToClientPacketMapChunkSkyLight][iPlayToClientPacketMapChunkSkyLightInner]) if err != nil { return } } } err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight))) if err != nil { return } for iPlayToClientPacketMapChunkBlockLight := range len(ret.BlockLight) { err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight]))) if err != nil { return } for iPlayToClientPacketMapChunkBlockLightInner := range len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight]) { err = binary.Write(w, binary.BigEndian, ret.BlockLight[iPlayToClientPacketMapChunkBlockLight][iPlayToClientPacketMapChunkBlockLightInner]) if err != nil { return } } } return } type PlayToClientPacketMoveMinecart struct { EntityId int32 Steps []struct { Position Vec3f Velocity Vec3f Yaw float32 Pitch float32 Weight float32 } } func (ret *PlayToClientPacketMoveMinecart) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } var lPlayToClientPacketMoveMinecartSteps int32 lPlayToClientPacketMoveMinecartSteps, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Steps = []struct { Position Vec3f Velocity Vec3f Yaw float32 Pitch float32 Weight float32 }{} for range lPlayToClientPacketMoveMinecartSteps { var PlayToClientPacketMoveMinecartStepsElement struct { Position Vec3f Velocity Vec3f Yaw float32 Pitch float32 Weight float32 } err = PlayToClientPacketMoveMinecartStepsElement.Position.Decode(r) if err != nil { return } err = PlayToClientPacketMoveMinecartStepsElement.Velocity.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Yaw) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Pitch) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Weight) if err != nil { return } ret.Steps = append(ret.Steps, PlayToClientPacketMoveMinecartStepsElement) } return } func (ret *PlayToClientPacketMoveMinecart) 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.Steps))) if err != nil { return } for iPlayToClientPacketMoveMinecartSteps := range len(ret.Steps) { PlayToClientPacketMoveMinecartStepsInnerPositionEncTmp := ret.Steps[iPlayToClientPacketMoveMinecartSteps].Position err = PlayToClientPacketMoveMinecartStepsInnerPositionEncTmp.Encode(w) if err != nil { return } PlayToClientPacketMoveMinecartStepsInnerVelocityEncTmp := ret.Steps[iPlayToClientPacketMoveMinecartSteps].Velocity err = PlayToClientPacketMoveMinecartStepsInnerVelocityEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Yaw) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Pitch) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Weight) if err != nil { return } } return } type PlayToClientPacketMultiBlockChange struct { ChunkCoordinates struct { X int32 Z int32 Y int32 } Records []int32 } 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 = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked >> 0 & 1048575) if ret.ChunkCoordinates.Y >= 1<<19 { ret.ChunkCoordinates.Y -= 1 << 20 } 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 } var lPlayToClientPacketMultiBlockChangeRecords int32 lPlayToClientPacketMultiBlockChangeRecords, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Records = []int32{} for range lPlayToClientPacketMultiBlockChangeRecords { var PlayToClientPacketMultiBlockChangeRecordsElement int32 PlayToClientPacketMultiBlockChangeRecordsElement, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement) } return } func (ret *PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) { 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 = proto_base.EncodeVarInt(w, int32(len(ret.Records))) if err != nil { return } for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) { err = proto_base.EncodeVarInt(w, ret.Records[iPlayToClientPacketMultiBlockChangeRecords]) if err != nil { return } } return } type PlayToClientPacketNbtQueryResponse struct { TransactionId int32 Nbt nbt.Anon } 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 ContainerID NbSlots int32 EntityId int32 } func (ret *PlayToClientPacketOpenHorseWindow) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) 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) { PlayToClientPacketOpenHorseWindowWindowIdEncTmp := ret.WindowId err = PlayToClientPacketOpenHorseWindowWindowIdEncTmp.Encode(w) 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 IsFrontText bool } func (ret *PlayToClientPacketOpenSignEntity) Decode(r io.ReadSeeker) (err error) { err = ret.Location.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.IsFrontText) 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 } err = binary.Write(w, binary.BigEndian, ret.IsFrontText) if err != nil { return } return } type PlayToClientPacketOpenWindow struct { WindowId int32 InventoryType int32 WindowTitle nbt.Anon } 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 } err = ret.WindowTitle.Decode(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 } PlayToClientPacketOpenWindowWindowTitleEncTmp := ret.WindowTitle err = PlayToClientPacketOpenWindowWindowTitleEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketPing struct { Id int32 } func (ret *PlayToClientPacketPing) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Id) if err != nil { return } return } func (ret *PlayToClientPacketPing) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Id) if err != nil { return } return } type PlayToClientPacketPingResponse struct { Id int64 } func (ret *PlayToClientPacketPingResponse) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Id) if err != nil { return } return } func (ret *PlayToClientPacketPingResponse) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Id) if err != nil { return } return } type PlayToClientPacketPlayerChat struct { GlobalIndex int32 SenderUuid uuid.UUID Index int32 Signature *[256]byte PlainMessage string Timestamp int64 Salt int64 PreviousMessages PreviousMessages UnsignedChatContent *nbt.Anon FilterType int32 FilterTypeMask any Type PlayToClientChatTypesHolder NetworkName nbt.Anon NetworkTargetName *nbt.Anon } func (ret *PlayToClientPacketPlayerChat) Decode(r io.ReadSeeker) (err error) { ret.GlobalIndex, err = proto_base.DecodeVarInt(r) if err != nil { return } _, err = io.ReadFull(r, ret.SenderUuid[:]) if err != nil { return } ret.Index, err = proto_base.DecodeVarInt(r) if err != nil { return } var PlayToClientPacketPlayerChatSignaturePresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatSignaturePresent) if err != nil { return } if PlayToClientPacketPlayerChatSignaturePresent { var PlayToClientPacketPlayerChatSignaturePresentValue [256]byte _, err = r.Read(PlayToClientPacketPlayerChatSignaturePresentValue[:]) if err != nil { return } ret.Signature = &PlayToClientPacketPlayerChatSignaturePresentValue } ret.PlainMessage, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Timestamp) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Salt) if err != nil { return } err = ret.PreviousMessages.Decode(r) if err != nil { return } var PlayToClientPacketPlayerChatUnsignedChatContentPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatUnsignedChatContentPresent) if err != nil { return } if PlayToClientPacketPlayerChatUnsignedChatContentPresent { var PlayToClientPacketPlayerChatUnsignedChatContentPresentValue nbt.Anon err = PlayToClientPacketPlayerChatUnsignedChatContentPresentValue.Decode(r) if err != nil { return } ret.UnsignedChatContent = &PlayToClientPacketPlayerChatUnsignedChatContentPresentValue } ret.FilterType, err = proto_base.DecodeVarInt(r) if err != nil { return } switch ret.FilterType { case 2: var PlayToClientPacketPlayerChatFilterTypeMask2Tmp []int64 var lPlayToClientPacketPlayerChatFilterTypeMask2Tmp int32 lPlayToClientPacketPlayerChatFilterTypeMask2Tmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketPlayerChatFilterTypeMask2Tmp = []int64{} for range lPlayToClientPacketPlayerChatFilterTypeMask2Tmp { var PlayToClientPacketPlayerChatFilterTypeMask2TmpElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatFilterTypeMask2TmpElement) if err != nil { return } PlayToClientPacketPlayerChatFilterTypeMask2Tmp = append(PlayToClientPacketPlayerChatFilterTypeMask2Tmp, PlayToClientPacketPlayerChatFilterTypeMask2TmpElement) } ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMask2Tmp default: var PlayToClientPacketPlayerChatFilterTypeMaskTmp struct { } ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMaskTmp } err = ret.Type.Decode(r) if err != nil { return } err = ret.NetworkName.Decode(r) if err != nil { return } var PlayToClientPacketPlayerChatNetworkTargetNamePresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatNetworkTargetNamePresent) if err != nil { return } if PlayToClientPacketPlayerChatNetworkTargetNamePresent { var PlayToClientPacketPlayerChatNetworkTargetNamePresentValue nbt.Anon err = PlayToClientPacketPlayerChatNetworkTargetNamePresentValue.Decode(r) if err != nil { return } ret.NetworkTargetName = &PlayToClientPacketPlayerChatNetworkTargetNamePresentValue } return } func (ret *PlayToClientPacketPlayerChat) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.GlobalIndex) if err != nil { return } _, err = w.Write(ret.SenderUuid[:]) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Index) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Signature != nil) if err != nil { return } if ret.Signature != nil { arr := *ret.Signature _, err = w.Write(arr[:]) if err != nil { return } } err = proto_base.EncodeString(w, ret.PlainMessage) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Timestamp) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Salt) if err != nil { return } PlayToClientPacketPlayerChatPreviousMessagesEncTmp := ret.PreviousMessages err = PlayToClientPacketPlayerChatPreviousMessagesEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.UnsignedChatContent != nil) if err != nil { return } if ret.UnsignedChatContent != nil { PlayToClientPacketPlayerChatUnsignedChatContentEncTmp := *ret.UnsignedChatContent err = PlayToClientPacketPlayerChatUnsignedChatContentEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeVarInt(w, ret.FilterType) if err != nil { return } switch ret.FilterType { case 2: PlayToClientPacketPlayerChatFilterTypeMask, ok := ret.FilterTypeMask.([]int64) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketPlayerChatFilterTypeMask))) if err != nil { return } for iPlayToClientPacketPlayerChatFilterTypeMask := range len(PlayToClientPacketPlayerChatFilterTypeMask) { err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerChatFilterTypeMask[iPlayToClientPacketPlayerChatFilterTypeMask]) if err != nil { return } } default: _, ok := ret.FilterTypeMask.(struct { }) if !ok { err = proto_base.BadTypeError return } } PlayToClientPacketPlayerChatTypeEncTmp := ret.Type err = PlayToClientPacketPlayerChatTypeEncTmp.Encode(w) if err != nil { return } PlayToClientPacketPlayerChatNetworkNameEncTmp := ret.NetworkName err = PlayToClientPacketPlayerChatNetworkNameEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.NetworkTargetName != nil) if err != nil { return } if ret.NetworkTargetName != nil { PlayToClientPacketPlayerChatNetworkTargetNameEncTmp := *ret.NetworkTargetName err = PlayToClientPacketPlayerChatNetworkTargetNameEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketPlayerInfo struct { Action uint8 Data []struct { Uuid uuid.UUID Player any ChatSession any Gamemode any Listed any Latency any DisplayName any ListPriority any ShowHat any } } func (ret *PlayToClientPacketPlayerInfo) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Action) if err != nil { return } var lPlayToClientPacketPlayerInfoData int32 lPlayToClientPacketPlayerInfoData, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Data = []struct { Uuid uuid.UUID Player any ChatSession any Gamemode any Listed any Latency any DisplayName any ListPriority any ShowHat any }{} for range lPlayToClientPacketPlayerInfoData { var PlayToClientPacketPlayerInfoDataElement struct { Uuid uuid.UUID Player any ChatSession any Gamemode any Listed any Latency any DisplayName any ListPriority any ShowHat any } _, err = io.ReadFull(r, PlayToClientPacketPlayerInfoDataElement.Uuid[:]) if err != nil { return } switch ret.Action&0x1 != 0 { case true: var PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp GameProfileNameProp err = PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp.Decode(r) if err != nil { return } PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp default: var PlayToClientPacketPlayerInfoDataElementPlayerTmp struct { } PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTmp } switch ret.Action&0x2 != 0 { case true: var PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp ChatSession err = PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp.Decode(r) if err != nil { return } PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp default: var PlayToClientPacketPlayerInfoDataElementChatSessionTmp struct { } PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTmp } switch ret.Action&0x4 != 0 { case true: var PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp int32 PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp default: var PlayToClientPacketPlayerInfoDataElementGamemodeTmp struct { } PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTmp } switch ret.Action&0x8 != 0 { case true: var PlayToClientPacketPlayerInfoDataElementListedTrueTmp int32 PlayToClientPacketPlayerInfoDataElementListedTrueTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTrueTmp default: var PlayToClientPacketPlayerInfoDataElementListedTmp struct { } PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTmp } switch ret.Action&0x10 != 0 { case true: var PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp int32 PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp default: var PlayToClientPacketPlayerInfoDataElementLatencyTmp struct { } PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTmp } switch ret.Action&0x20 != 0 { case true: var PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp *nbt.Anon var PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresent) if err != nil { return } if PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresent { var PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresentValue nbt.Anon err = PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresentValue.Decode(r) if err != nil { return } PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp = &PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresentValue } PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp default: var PlayToClientPacketPlayerInfoDataElementDisplayNameTmp struct { } PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTmp } switch ret.Action&0x80 != 0 { case true: var PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp int32 PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketPlayerInfoDataElement.ListPriority = PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp default: var PlayToClientPacketPlayerInfoDataElementListPriorityTmp struct { } PlayToClientPacketPlayerInfoDataElement.ListPriority = PlayToClientPacketPlayerInfoDataElementListPriorityTmp } switch ret.Action&0x40 != 0 { case true: var PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp) if err != nil { return } PlayToClientPacketPlayerInfoDataElement.ShowHat = PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp default: var PlayToClientPacketPlayerInfoDataElementShowHatTmp struct { } PlayToClientPacketPlayerInfoDataElement.ShowHat = PlayToClientPacketPlayerInfoDataElementShowHatTmp } ret.Data = append(ret.Data, PlayToClientPacketPlayerInfoDataElement) } return } func (ret *PlayToClientPacketPlayerInfo) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Action) 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&0x1 != 0 { case true: PlayToClientPacketPlayerInfoDataInnerPlayer, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(GameProfileNameProp) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketPlayerInfoDataInnerPlayerEncTmp := PlayToClientPacketPlayerInfoDataInnerPlayer err = PlayToClientPacketPlayerInfoDataInnerPlayerEncTmp.Encode(w) if err != nil { return } default: _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action&0x2 != 0 { case true: PlayToClientPacketPlayerInfoDataInnerChatSession, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(ChatSession) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketPlayerInfoDataInnerChatSessionEncTmp := PlayToClientPacketPlayerInfoDataInnerChatSession err = PlayToClientPacketPlayerInfoDataInnerChatSessionEncTmp.Encode(w) if err != nil { return } default: _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action&0x4 != 0 { case true: PlayToClientPacketPlayerInfoDataInnerGamemode, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerGamemode) if err != nil { return } default: _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action&0x8 != 0 { case true: PlayToClientPacketPlayerInfoDataInnerListed, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerListed) if err != nil { return } default: _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action&0x10 != 0 { case true: PlayToClientPacketPlayerInfoDataInnerLatency, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerLatency) if err != nil { return } default: _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action&0x20 != 0 { case true: PlayToClientPacketPlayerInfoDataInnerDisplayName, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(*nbt.Anon) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerDisplayName != nil) if err != nil { return } if PlayToClientPacketPlayerInfoDataInnerDisplayName != nil { PlayToClientPacketPlayerInfoDataInnerDisplayNameEncTmp := *PlayToClientPacketPlayerInfoDataInnerDisplayName err = PlayToClientPacketPlayerInfoDataInnerDisplayNameEncTmp.Encode(w) if err != nil { return } } default: _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action&0x80 != 0 { case true: PlayToClientPacketPlayerInfoDataInnerListPriority, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(int32) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerListPriority) if err != nil { return } default: _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action&0x40 != 0 { case true: PlayToClientPacketPlayerInfoDataInnerShowHat, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ShowHat.(bool) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerShowHat) if err != nil { return } default: _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ShowHat.(struct { }) if !ok { err = proto_base.BadTypeError return } } } return } type PlayToClientPacketPlayerRemove struct { Players []uuid.UUID } func (ret *PlayToClientPacketPlayerRemove) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketPlayerRemovePlayers int32 lPlayToClientPacketPlayerRemovePlayers, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Players = []uuid.UUID{} for range lPlayToClientPacketPlayerRemovePlayers { var PlayToClientPacketPlayerRemovePlayersElement uuid.UUID _, err = io.ReadFull(r, PlayToClientPacketPlayerRemovePlayersElement[:]) if err != nil { return } ret.Players = append(ret.Players, PlayToClientPacketPlayerRemovePlayersElement) } return } func (ret *PlayToClientPacketPlayerRemove) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Players))) if err != nil { return } for iPlayToClientPacketPlayerRemovePlayers := range len(ret.Players) { _, err = w.Write(ret.Players[iPlayToClientPacketPlayerRemovePlayers][:]) if err != nil { return } } return } type PlayToClientPacketPlayerRotation struct { Yaw float32 RelativeYaw bool Pitch float32 RelativePitch bool } func (ret *PlayToClientPacketPlayerRotation) 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.RelativeYaw) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Pitch) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.RelativePitch) if err != nil { return } return } func (ret *PlayToClientPacketPlayerRotation) 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.RelativeYaw) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Pitch) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.RelativePitch) if err != nil { return } return } type PlayToClientPacketPlayerlistHeader struct { Header nbt.Anon Footer nbt.Anon } func (ret *PlayToClientPacketPlayerlistHeader) Decode(r io.ReadSeeker) (err error) { err = ret.Header.Decode(r) if err != nil { return } err = ret.Footer.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketPlayerlistHeader) Encode(w io.Writer) (err error) { PlayToClientPacketPlayerlistHeaderHeaderEncTmp := ret.Header err = PlayToClientPacketPlayerlistHeaderHeaderEncTmp.Encode(w) if err != nil { return } PlayToClientPacketPlayerlistHeaderFooterEncTmp := ret.Footer err = PlayToClientPacketPlayerlistHeaderFooterEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketPosition struct { TeleportId int32 X float64 Y float64 Z float64 Dx float64 Dy float64 Dz float64 Yaw float32 Pitch float32 Flags PlayToClientPositionUpdateRelatives } func (ret *PlayToClientPacketPosition) Decode(r io.ReadSeeker) (err error) { ret.TeleportId, 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.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 = ret.Flags.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketPosition) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.TeleportId) 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.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 } PlayToClientPacketPositionFlagsEncTmp := ret.Flags err = PlayToClientPacketPositionFlagsEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketProfilelessChat struct { Message nbt.Anon Type PlayToClientChatTypesHolder Name nbt.Anon Target *nbt.Anon } func (ret *PlayToClientPacketProfilelessChat) Decode(r io.ReadSeeker) (err error) { err = ret.Message.Decode(r) if err != nil { return } err = ret.Type.Decode(r) if err != nil { return } err = ret.Name.Decode(r) if err != nil { return } var PlayToClientPacketProfilelessChatTargetPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketProfilelessChatTargetPresent) if err != nil { return } if PlayToClientPacketProfilelessChatTargetPresent { var PlayToClientPacketProfilelessChatTargetPresentValue nbt.Anon err = PlayToClientPacketProfilelessChatTargetPresentValue.Decode(r) if err != nil { return } ret.Target = &PlayToClientPacketProfilelessChatTargetPresentValue } return } func (ret *PlayToClientPacketProfilelessChat) Encode(w io.Writer) (err error) { PlayToClientPacketProfilelessChatMessageEncTmp := ret.Message err = PlayToClientPacketProfilelessChatMessageEncTmp.Encode(w) if err != nil { return } PlayToClientPacketProfilelessChatTypeEncTmp := ret.Type err = PlayToClientPacketProfilelessChatTypeEncTmp.Encode(w) if err != nil { return } PlayToClientPacketProfilelessChatNameEncTmp := ret.Name err = PlayToClientPacketProfilelessChatNameEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Target != nil) if err != nil { return } if ret.Target != nil { PlayToClientPacketProfilelessChatTargetEncTmp := *ret.Target err = PlayToClientPacketProfilelessChatTargetEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketRecipeBookAdd struct { Entries []struct { Recipe struct { DisplayId int32 Display PlayToClientRecipeDisplay Group Optvarint Category string CraftingRequirements *[]IDSet } Flags uint8 } Replace bool } var PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryMap = map[int32]string{0: "crafting_building_blocks", 1: "crafting_redstone", 10: "stonecutter", 11: "smithing", 12: "campfire", 2: "crafting_equipment", 3: "crafting_misc", 4: "furnace_food", 5: "furnace_blocks", 6: "furnace_misc", 7: "blast_furnace_blocks", 8: "blast_furnace_misc", 9: "smoker_food"} func (ret *PlayToClientPacketRecipeBookAdd) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketRecipeBookAddEntries int32 lPlayToClientPacketRecipeBookAddEntries, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Entries = []struct { Recipe struct { DisplayId int32 Display PlayToClientRecipeDisplay Group Optvarint Category string CraftingRequirements *[]IDSet } Flags uint8 }{} for range lPlayToClientPacketRecipeBookAddEntries { var PlayToClientPacketRecipeBookAddEntriesElement struct { Recipe struct { DisplayId int32 Display PlayToClientRecipeDisplay Group Optvarint Category string CraftingRequirements *[]IDSet } Flags uint8 } PlayToClientPacketRecipeBookAddEntriesElement.Recipe.DisplayId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Display.Decode(r) if err != nil { return } err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Group.Decode(r) if err != nil { return } var PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey int32 PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Category, err = proto_base.ErroringIndex(PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryMap, PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey) if err != nil { return } var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent) if err != nil { return } if PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent { var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue []IDSet var lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements int32 lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue = []IDSet{} for range lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements { var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement IDSet err = PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement.Decode(r) if err != nil { return } PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue = append(PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue, PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement) } PlayToClientPacketRecipeBookAddEntriesElement.Recipe.CraftingRequirements = &PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketRecipeBookAddEntriesElement.Flags) if err != nil { return } ret.Entries = append(ret.Entries, PlayToClientPacketRecipeBookAddEntriesElement) } err = binary.Read(r, binary.BigEndian, &ret.Replace) if err != nil { return } return } var PlayToClientPacketRecipeBookAddEntriesInnerRecipeCategoryReverseMap = map[string]int32{"crafting_building_blocks": 0, "crafting_redstone": 1, "stonecutter": 10, "smithing": 11, "campfire": 12, "crafting_equipment": 2, "crafting_misc": 3, "furnace_food": 4, "furnace_blocks": 5, "furnace_misc": 6, "blast_furnace_blocks": 7, "blast_furnace_misc": 8, "smoker_food": 9} func (ret *PlayToClientPacketRecipeBookAdd) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Entries))) if err != nil { return } for iPlayToClientPacketRecipeBookAddEntries := range len(ret.Entries) { err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.DisplayId) if err != nil { return } PlayToClientPacketRecipeBookAddEntriesInnerRecipeDisplayEncTmp := ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Display err = PlayToClientPacketRecipeBookAddEntriesInnerRecipeDisplayEncTmp.Encode(w) if err != nil { return } PlayToClientPacketRecipeBookAddEntriesInnerRecipeGroupEncTmp := ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Group err = PlayToClientPacketRecipeBookAddEntriesInnerRecipeGroupEncTmp.Encode(w) if err != nil { return } var vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory int32 vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory, err = proto_base.ErroringIndex(PlayToClientPacketRecipeBookAddEntriesInnerRecipeCategoryReverseMap, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Category) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements != nil) if err != nil { return } if ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements != nil { err = proto_base.EncodeVarInt(w, int32(len(*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements))) if err != nil { return } for iPlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirements := range len(*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements) { PlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirementsInnerEncTmp := (*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements)[iPlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirements] err = PlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirementsInnerEncTmp.Encode(w) if err != nil { return } } } err = binary.Write(w, binary.BigEndian, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Flags) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.Replace) if err != nil { return } return } type PlayToClientPacketRecipeBookRemove struct { RecipeIds []int32 } func (ret *PlayToClientPacketRecipeBookRemove) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketRecipeBookRemoveRecipeIds int32 lPlayToClientPacketRecipeBookRemoveRecipeIds, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.RecipeIds = []int32{} for range lPlayToClientPacketRecipeBookRemoveRecipeIds { var PlayToClientPacketRecipeBookRemoveRecipeIdsElement int32 PlayToClientPacketRecipeBookRemoveRecipeIdsElement, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.RecipeIds = append(ret.RecipeIds, PlayToClientPacketRecipeBookRemoveRecipeIdsElement) } return } func (ret *PlayToClientPacketRecipeBookRemove) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.RecipeIds))) if err != nil { return } for iPlayToClientPacketRecipeBookRemoveRecipeIds := range len(ret.RecipeIds) { err = proto_base.EncodeVarInt(w, ret.RecipeIds[iPlayToClientPacketRecipeBookRemoveRecipeIds]) if err != nil { return } } return } type PlayToClientPacketRecipeBookSettings struct { Crafting PlayToClientRecipeBookSetting Furnace PlayToClientRecipeBookSetting Blast PlayToClientRecipeBookSetting Smoker PlayToClientRecipeBookSetting } func (ret *PlayToClientPacketRecipeBookSettings) Decode(r io.ReadSeeker) (err error) { err = ret.Crafting.Decode(r) if err != nil { return } err = ret.Furnace.Decode(r) if err != nil { return } err = ret.Blast.Decode(r) if err != nil { return } err = ret.Smoker.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketRecipeBookSettings) Encode(w io.Writer) (err error) { PlayToClientPacketRecipeBookSettingsCraftingEncTmp := ret.Crafting err = PlayToClientPacketRecipeBookSettingsCraftingEncTmp.Encode(w) if err != nil { return } PlayToClientPacketRecipeBookSettingsFurnaceEncTmp := ret.Furnace err = PlayToClientPacketRecipeBookSettingsFurnaceEncTmp.Encode(w) if err != nil { return } PlayToClientPacketRecipeBookSettingsBlastEncTmp := ret.Blast err = PlayToClientPacketRecipeBookSettingsBlastEncTmp.Encode(w) if err != nil { return } PlayToClientPacketRecipeBookSettingsSmokerEncTmp := ret.Smoker err = PlayToClientPacketRecipeBookSettingsSmokerEncTmp.Encode(w) 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 int32 } func (ret *PlayToClientPacketRemoveEntityEffect) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.EffectId, err = proto_base.DecodeVarInt(r) 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 = proto_base.EncodeVarInt(w, ret.EffectId) if err != nil { return } return } type PlayToClientPacketResetScore struct { EntityName string ObjectiveName *string } func (ret *PlayToClientPacketResetScore) Decode(r io.ReadSeeker) (err error) { ret.EntityName, err = proto_base.DecodeString(r) if err != nil { return } var PlayToClientPacketResetScoreObjectiveNamePresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketResetScoreObjectiveNamePresent) if err != nil { return } if PlayToClientPacketResetScoreObjectiveNamePresent { var PlayToClientPacketResetScoreObjectiveNamePresentValue string PlayToClientPacketResetScoreObjectiveNamePresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.ObjectiveName = &PlayToClientPacketResetScoreObjectiveNamePresentValue } return } func (ret *PlayToClientPacketResetScore) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.EntityName) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.ObjectiveName != nil) if err != nil { return } if ret.ObjectiveName != nil { err = proto_base.EncodeString(w, *ret.ObjectiveName) if err != nil { return } } return } type PlayToClientPacketRespawn struct { WorldState PlayToClientSpawnInfo CopyMetadata uint8 } func (ret *PlayToClientPacketRespawn) Decode(r io.ReadSeeker) (err error) { err = ret.WorldState.Decode(r) 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) { PlayToClientPacketRespawnWorldStateEncTmp := ret.WorldState err = PlayToClientPacketRespawnWorldStateEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.CopyMetadata) if err != nil { return } return } type PlayToClientPacketScoreboardDisplayObjective struct { Position int32 Name string } func (ret *PlayToClientPacketScoreboardDisplayObjective) Decode(r io.ReadSeeker) (err error) { ret.Position, err = proto_base.DecodeVarInt(r) 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 = proto_base.EncodeVarInt(w, 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 NumberFormat any Styling 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 nbt.Anon err = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp.Decode(r) if err != nil { return } ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp case 2: var PlayToClientPacketScoreboardObjectiveDisplayText2Tmp nbt.Anon err = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp.Decode(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 } switch ret.Action { case 0: var PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp *int32 var PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresent) if err != nil { return } if PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresent { var PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresentValue int32 PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresentValue, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp = &PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresentValue } ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp case 2: var PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp *int32 var PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresent) if err != nil { return } if PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresent { var PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresentValue int32 PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresentValue, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp = &PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresentValue } ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp default: var PlayToClientPacketScoreboardObjectiveNumberFormatTmp struct { } ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormatTmp } switch ret.Action { case 0: var PlayToClientPacketScoreboardObjectiveStyling0Tmp any switch ret.NumberFormat { case 1: var PlayToClientPacketScoreboardObjectiveStyling0Tmp1Tmp nbt.Anon err = PlayToClientPacketScoreboardObjectiveStyling0Tmp1Tmp.Decode(r) if err != nil { return } PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling0Tmp1Tmp case 2: var PlayToClientPacketScoreboardObjectiveStyling0Tmp2Tmp nbt.Anon err = PlayToClientPacketScoreboardObjectiveStyling0Tmp2Tmp.Decode(r) if err != nil { return } PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling0Tmp2Tmp default: var PlayToClientPacketScoreboardObjectiveStyling0TmpTmp struct { } PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling0TmpTmp } ret.Styling = PlayToClientPacketScoreboardObjectiveStyling0Tmp case 2: var PlayToClientPacketScoreboardObjectiveStyling2Tmp any switch ret.NumberFormat { case 1: var PlayToClientPacketScoreboardObjectiveStyling2Tmp1Tmp nbt.Anon err = PlayToClientPacketScoreboardObjectiveStyling2Tmp1Tmp.Decode(r) if err != nil { return } PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling2Tmp1Tmp case 2: var PlayToClientPacketScoreboardObjectiveStyling2Tmp2Tmp nbt.Anon err = PlayToClientPacketScoreboardObjectiveStyling2Tmp2Tmp.Decode(r) if err != nil { return } PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling2Tmp2Tmp default: var PlayToClientPacketScoreboardObjectiveStyling2TmpTmp struct { } PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling2TmpTmp } ret.Styling = PlayToClientPacketScoreboardObjectiveStyling2Tmp default: var PlayToClientPacketScoreboardObjectiveStylingTmp struct { } ret.Styling = PlayToClientPacketScoreboardObjectiveStylingTmp } 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.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketScoreboardObjectiveDisplayTextEncTmp := PlayToClientPacketScoreboardObjectiveDisplayText err = PlayToClientPacketScoreboardObjectiveDisplayTextEncTmp.Encode(w) if err != nil { return } case 2: PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketScoreboardObjectiveDisplayTextEncTmp := PlayToClientPacketScoreboardObjectiveDisplayText err = PlayToClientPacketScoreboardObjectiveDisplayTextEncTmp.Encode(w) 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 } } switch ret.Action { case 0: PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*int32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil) if err != nil { return } if PlayToClientPacketScoreboardObjectiveNumberFormat != nil { err = proto_base.EncodeVarInt(w, *PlayToClientPacketScoreboardObjectiveNumberFormat) if err != nil { return } } case 2: PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*int32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil) if err != nil { return } if PlayToClientPacketScoreboardObjectiveNumberFormat != nil { err = proto_base.EncodeVarInt(w, *PlayToClientPacketScoreboardObjectiveNumberFormat) if err != nil { return } } default: _, ok := ret.NumberFormat.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Action { case 0: PlayToClientPacketScoreboardObjectiveStyling, ok := ret.Styling.(any) if !ok { err = proto_base.BadTypeError return } switch ret.NumberFormat { case 1: PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketScoreboardObjectiveStylingEncTmp := PlayToClientPacketScoreboardObjectiveStyling err = PlayToClientPacketScoreboardObjectiveStylingEncTmp.Encode(w) if err != nil { return } case 2: PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketScoreboardObjectiveStylingEncTmp := PlayToClientPacketScoreboardObjectiveStyling err = PlayToClientPacketScoreboardObjectiveStylingEncTmp.Encode(w) if err != nil { return } default: _, ok := PlayToClientPacketScoreboardObjectiveStyling.(struct { }) if !ok { err = proto_base.BadTypeError return } } case 2: PlayToClientPacketScoreboardObjectiveStyling, ok := ret.Styling.(any) if !ok { err = proto_base.BadTypeError return } switch ret.NumberFormat { case 1: PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketScoreboardObjectiveStylingEncTmp := PlayToClientPacketScoreboardObjectiveStyling err = PlayToClientPacketScoreboardObjectiveStylingEncTmp.Encode(w) if err != nil { return } case 2: PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketScoreboardObjectiveStylingEncTmp := PlayToClientPacketScoreboardObjectiveStyling err = PlayToClientPacketScoreboardObjectiveStylingEncTmp.Encode(w) if err != nil { return } default: _, ok := PlayToClientPacketScoreboardObjectiveStyling.(struct { }) if !ok { err = proto_base.BadTypeError return } } default: _, ok := ret.Styling.(struct { }) if !ok { err = proto_base.BadTypeError return } } return } type PlayToClientPacketScoreboardScore struct { ItemName string ScoreName string Value int32 DisplayName *nbt.Anon NumberFormat *int32 Styling any } func (ret *PlayToClientPacketScoreboardScore) Decode(r io.ReadSeeker) (err error) { err = proto_base.ToDoError return } func (ret *PlayToClientPacketScoreboardScore) Encode(w io.Writer) (err error) { err = proto_base.ToDoError 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 PlayToClientPacketServerData struct { Motd nbt.Anon IconBytes *ByteArray } func (ret *PlayToClientPacketServerData) Decode(r io.ReadSeeker) (err error) { err = ret.Motd.Decode(r) if err != nil { return } var PlayToClientPacketServerDataIconBytesPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketServerDataIconBytesPresent) if err != nil { return } if PlayToClientPacketServerDataIconBytesPresent { var PlayToClientPacketServerDataIconBytesPresentValue ByteArray err = PlayToClientPacketServerDataIconBytesPresentValue.Decode(r) if err != nil { return } ret.IconBytes = &PlayToClientPacketServerDataIconBytesPresentValue } return } func (ret *PlayToClientPacketServerData) Encode(w io.Writer) (err error) { PlayToClientPacketServerDataMotdEncTmp := ret.Motd err = PlayToClientPacketServerDataMotdEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.IconBytes != nil) if err != nil { return } if ret.IconBytes != nil { PlayToClientPacketServerDataIconBytesEncTmp := *ret.IconBytes err = PlayToClientPacketServerDataIconBytesEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketSetCooldown struct { CooldownGroup string CooldownTicks int32 } func (ret *PlayToClientPacketSetCooldown) Decode(r io.ReadSeeker) (err error) { ret.CooldownGroup, err = proto_base.DecodeString(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.EncodeString(w, ret.CooldownGroup) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.CooldownTicks) if err != nil { return } return } type PlayToClientPacketSetCursorItem struct { Contents Slot } func (ret *PlayToClientPacketSetCursorItem) Decode(r io.ReadSeeker) (err error) { err = ret.Contents.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketSetCursorItem) Encode(w io.Writer) (err error) { PlayToClientPacketSetCursorItemContentsEncTmp := ret.Contents err = PlayToClientPacketSetCursorItemContentsEncTmp.Encode(w) 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 PlayToClientPacketSetPlayerInventory struct { SlotId int32 Contents Slot } func (ret *PlayToClientPacketSetPlayerInventory) Decode(r io.ReadSeeker) (err error) { ret.SlotId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = ret.Contents.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketSetPlayerInventory) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.SlotId) if err != nil { return } PlayToClientPacketSetPlayerInventoryContentsEncTmp := ret.Contents err = PlayToClientPacketSetPlayerInventoryContentsEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketSetProjectilePower struct { Id int32 AccelerationPower float64 } func (ret *PlayToClientPacketSetProjectilePower) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.AccelerationPower) if err != nil { return } return } func (ret *PlayToClientPacketSetProjectilePower) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.AccelerationPower) if err != nil { return } return } type PlayToClientPacketSetSlot struct { WindowId ContainerID StateId int32 Slot int16 Item Slot } func (ret *PlayToClientPacketSetSlot) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) if err != nil { return } ret.StateId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Slot) if err != nil { return } err = ret.Item.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketSetSlot) Encode(w io.Writer) (err error) { PlayToClientPacketSetSlotWindowIdEncTmp := ret.WindowId err = PlayToClientPacketSetSlotWindowIdEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.StateId) 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 PlayToClientPacketSetTickingState struct { TickRate float32 IsFrozen bool } func (ret *PlayToClientPacketSetTickingState) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.TickRate) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.IsFrozen) if err != nil { return } return } func (ret *PlayToClientPacketSetTickingState) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.TickRate) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.IsFrozen) if err != nil { return } return } type PlayToClientPacketSetTitleSubtitle struct { Text nbt.Anon } func (ret *PlayToClientPacketSetTitleSubtitle) Decode(r io.ReadSeeker) (err error) { err = ret.Text.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketSetTitleSubtitle) Encode(w io.Writer) (err error) { PlayToClientPacketSetTitleSubtitleTextEncTmp := ret.Text err = PlayToClientPacketSetTitleSubtitleTextEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketSetTitleText struct { Text nbt.Anon } func (ret *PlayToClientPacketSetTitleText) Decode(r io.ReadSeeker) (err error) { err = ret.Text.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketSetTitleText) Encode(w io.Writer) (err error) { PlayToClientPacketSetTitleTextTextEncTmp := ret.Text err = PlayToClientPacketSetTitleTextTextEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketSetTitleTime struct { FadeIn int32 Stay int32 FadeOut int32 } func (ret *PlayToClientPacketSetTitleTime) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.FadeIn) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Stay) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.FadeOut) if err != nil { return } return } func (ret *PlayToClientPacketSetTitleTime) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.FadeIn) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Stay) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.FadeOut) if err != nil { return } return } type PlayToClientPacketShowDialog struct { Dialog any } func (ret *PlayToClientPacketShowDialog) Decode(r io.ReadSeeker) (err error) { var PlayToClientPacketShowDialogDialogId int32 PlayToClientPacketShowDialogDialogId, err = proto_base.DecodeVarInt(r) if err != nil { return } if PlayToClientPacketShowDialogDialogId != 0 { ret.Dialog = PlayToClientPacketShowDialogDialogId } else { var PlayToClientPacketShowDialogDialogResult nbt.Anon err = PlayToClientPacketShowDialogDialogResult.Decode(r) if err != nil { return } ret.Dialog = PlayToClientPacketShowDialogDialogResult } return } func (ret *PlayToClientPacketShowDialog) Encode(w io.Writer) (err error) { switch PlayToClientPacketShowDialogDialogKnownType := ret.Dialog.(type) { case int32: err = proto_base.EncodeVarInt(w, PlayToClientPacketShowDialogDialogKnownType) if err != nil { return } case nbt.Anon: err = proto_base.EncodeVarInt(w, 0) if err != nil { return } PlayToClientPacketShowDialogDialogOtherwiseEncTmp := PlayToClientPacketShowDialogDialogKnownType err = PlayToClientPacketShowDialogDialogOtherwiseEncTmp.Encode(w) if err != nil { return } default: err = proto_base.BadTypeError } return } type PlayToClientPacketSimulationDistance struct { Distance int32 } func (ret *PlayToClientPacketSimulationDistance) Decode(r io.ReadSeeker) (err error) { ret.Distance, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketSimulationDistance) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Distance) if err != nil { return } return } type PlayToClientPacketSoundEffect struct { Sound ItemSoundHolder SoundCategory SoundSource X int32 Y int32 Z int32 Volume float32 Pitch float32 Seed int64 } func (ret *PlayToClientPacketSoundEffect) Decode(r io.ReadSeeker) (err error) { err = ret.Sound.Decode(r) if err != nil { return } err = ret.SoundCategory.Decode(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 } err = binary.Read(r, binary.BigEndian, &ret.Seed) if err != nil { return } return } func (ret *PlayToClientPacketSoundEffect) Encode(w io.Writer) (err error) { PlayToClientPacketSoundEffectSoundEncTmp := ret.Sound err = PlayToClientPacketSoundEffectSoundEncTmp.Encode(w) if err != nil { return } PlayToClientPacketSoundEffectSoundCategoryEncTmp := ret.SoundCategory err = PlayToClientPacketSoundEffectSoundCategoryEncTmp.Encode(w) 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 } err = binary.Write(w, binary.BigEndian, ret.Seed) if err != nil { return } return } type PlayToClientPacketSpawnEntity struct { EntityId int32 ObjectUUID uuid.UUID Type int32 X float64 Y float64 Z float64 Velocity proto_base.LpVec3d Pitch int8 Yaw int8 HeadPitch int8 ObjectData int32 } 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 = ret.Velocity.Decode(r) 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.HeadPitch) if err != nil { return } ret.ObjectData, err = proto_base.DecodeVarInt(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 } PlayToClientPacketSpawnEntityVelocityEncTmp := ret.Velocity err = PlayToClientPacketSpawnEntityVelocityEncTmp.Encode(w) 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.HeadPitch) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.ObjectData) if err != nil { return } return } type PlayToClientPacketSpawnPosition struct { Val RespawnData } func (ret *PlayToClientPacketSpawnPosition) Decode(r io.ReadSeeker) (err error) { err = ret.Val.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketSpawnPosition) Encode(w io.Writer) (err error) { PlayToClientPacketSpawnPositionEncTmp := ret.Val err = PlayToClientPacketSpawnPositionEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketStartConfiguration struct { } func (ret *PlayToClientPacketStartConfiguration) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToClientPacketStartConfiguration) Encode(w io.Writer) (err error) { 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 PlayToClientPacketStepTick struct { TickSteps int32 } func (ret *PlayToClientPacketStepTick) Decode(r io.ReadSeeker) (err error) { ret.TickSteps, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketStepTick) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.TickSteps) 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 PlayToClientPacketSyncEntityPosition struct { EntityId int32 X float64 Y float64 Z float64 Dx float64 Dy float64 Dz float64 Yaw float32 Pitch float32 OnGround bool } func (ret *PlayToClientPacketSyncEntityPosition) 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.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 *PlayToClientPacketSyncEntityPosition) 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.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 PlayToClientPacketSystemChat struct { Content nbt.Anon IsActionBar bool } func (ret *PlayToClientPacketSystemChat) Decode(r io.ReadSeeker) (err error) { err = ret.Content.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.IsActionBar) if err != nil { return } return } func (ret *PlayToClientPacketSystemChat) Encode(w io.Writer) (err error) { PlayToClientPacketSystemChatContentEncTmp := ret.Content err = PlayToClientPacketSystemChatContentEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.IsActionBar) if err != nil { return } return } type PlayToClientPacketTabComplete struct { TransactionId int32 Start int32 Length int32 Matches []struct { Match string Tooltip *nbt.Anon } } 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 *nbt.Anon }{} for range lPlayToClientPacketTabCompleteMatches { var PlayToClientPacketTabCompleteMatchesElement struct { Match string Tooltip *nbt.Anon } 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 nbt.Anon err = PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue.Decode(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 { PlayToClientPacketTabCompleteMatchesInnerTooltipEncTmp := *ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip err = PlayToClientPacketTabCompleteMatchesInnerTooltipEncTmp.Encode(w) if err != nil { return } } } return } type PlayToClientPacketTags struct { Tags []struct { TagType string Tags Tags } } func (ret *PlayToClientPacketTags) Decode(r io.ReadSeeker) (err error) { var lPlayToClientPacketTagsTags int32 lPlayToClientPacketTagsTags, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Tags = []struct { TagType string Tags Tags }{} for range lPlayToClientPacketTagsTags { var PlayToClientPacketTagsTagsElement struct { TagType string Tags Tags } PlayToClientPacketTagsTagsElement.TagType, err = proto_base.DecodeString(r) if err != nil { return } err = PlayToClientPacketTagsTagsElement.Tags.Decode(r) if err != nil { return } ret.Tags = append(ret.Tags, PlayToClientPacketTagsTagsElement) } return } func (ret *PlayToClientPacketTags) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Tags))) if err != nil { return } for iPlayToClientPacketTagsTags := range len(ret.Tags) { err = proto_base.EncodeString(w, ret.Tags[iPlayToClientPacketTagsTags].TagType) if err != nil { return } PlayToClientPacketTagsTagsInnerTagsEncTmp := ret.Tags[iPlayToClientPacketTagsTags].Tags err = PlayToClientPacketTagsTagsInnerTagsEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketTeams struct { Team string Mode string Anon any Players any } var PlayToClientPacketTeamsModeMap = map[int8]string{0: "add", 1: "remove", 2: "change", 3: "join", 4: "leave"} var PlayToClientPacketTeamsAnonAddTmpNameTagVisibilityMap = map[int32]string{0: "always", 1: "never", 2: "hide_for_other_teams", 3: "hide_for_own_team"} var PlayToClientPacketTeamsAnonAddTmpCollisionRuleMap = map[int32]string{0: "always", 1: "never", 2: "push_other_teams", 3: "push_own_team"} var PlayToClientPacketTeamsAnonChangeTmpNameTagVisibilityMap = map[int32]string{0: "always", 1: "never", 2: "hide_for_other_teams", 3: "hide_for_own_team"} var PlayToClientPacketTeamsAnonChangeTmpCollisionRuleMap = map[int32]string{0: "always", 1: "never", 2: "push_other_teams", 3: "push_own_team"} func (ret *PlayToClientPacketTeams) Decode(r io.ReadSeeker) (err error) { ret.Team, err = proto_base.DecodeString(r) if err != nil { return } var PlayToClientPacketTeamsModeKey int8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsModeKey) if err != nil { return } ret.Mode, err = proto_base.ErroringIndex(PlayToClientPacketTeamsModeMap, PlayToClientPacketTeamsModeKey) if err != nil { return } switch ret.Mode { case "add": var PlayToClientPacketTeamsAnonAddTmp struct { Name nbt.Anon Flags uint8 NameTagVisibility string CollisionRule string Formatting int32 Prefix nbt.Anon Suffix nbt.Anon } err = PlayToClientPacketTeamsAnonAddTmp.Name.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsAnonAddTmp.Flags) if err != nil { return } var PlayToClientPacketTeamsAnonAddTmpNameTagVisibilityKey int32 PlayToClientPacketTeamsAnonAddTmpNameTagVisibilityKey, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTeamsAnonAddTmp.NameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonAddTmpNameTagVisibilityMap, PlayToClientPacketTeamsAnonAddTmpNameTagVisibilityKey) if err != nil { return } var PlayToClientPacketTeamsAnonAddTmpCollisionRuleKey int32 PlayToClientPacketTeamsAnonAddTmpCollisionRuleKey, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTeamsAnonAddTmp.CollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonAddTmpCollisionRuleMap, PlayToClientPacketTeamsAnonAddTmpCollisionRuleKey) if err != nil { return } PlayToClientPacketTeamsAnonAddTmp.Formatting, err = proto_base.DecodeVarInt(r) if err != nil { return } err = PlayToClientPacketTeamsAnonAddTmp.Prefix.Decode(r) if err != nil { return } err = PlayToClientPacketTeamsAnonAddTmp.Suffix.Decode(r) if err != nil { return } ret.Anon = PlayToClientPacketTeamsAnonAddTmp case "change": var PlayToClientPacketTeamsAnonChangeTmp struct { Name nbt.Anon Flags uint8 NameTagVisibility string CollisionRule string Formatting int32 Prefix nbt.Anon Suffix nbt.Anon } err = PlayToClientPacketTeamsAnonChangeTmp.Name.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsAnonChangeTmp.Flags) if err != nil { return } var PlayToClientPacketTeamsAnonChangeTmpNameTagVisibilityKey int32 PlayToClientPacketTeamsAnonChangeTmpNameTagVisibilityKey, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTeamsAnonChangeTmp.NameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonChangeTmpNameTagVisibilityMap, PlayToClientPacketTeamsAnonChangeTmpNameTagVisibilityKey) if err != nil { return } var PlayToClientPacketTeamsAnonChangeTmpCollisionRuleKey int32 PlayToClientPacketTeamsAnonChangeTmpCollisionRuleKey, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTeamsAnonChangeTmp.CollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonChangeTmpCollisionRuleMap, PlayToClientPacketTeamsAnonChangeTmpCollisionRuleKey) if err != nil { return } PlayToClientPacketTeamsAnonChangeTmp.Formatting, err = proto_base.DecodeVarInt(r) if err != nil { return } err = PlayToClientPacketTeamsAnonChangeTmp.Prefix.Decode(r) if err != nil { return } err = PlayToClientPacketTeamsAnonChangeTmp.Suffix.Decode(r) if err != nil { return } ret.Anon = PlayToClientPacketTeamsAnonChangeTmp default: var PlayToClientPacketTeamsAnonTmp struct { } ret.Anon = PlayToClientPacketTeamsAnonTmp } switch ret.Mode { case "add": var PlayToClientPacketTeamsPlayersAddTmp []string var lPlayToClientPacketTeamsPlayersAddTmp int32 lPlayToClientPacketTeamsPlayersAddTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTeamsPlayersAddTmp = []string{} for range lPlayToClientPacketTeamsPlayersAddTmp { var PlayToClientPacketTeamsPlayersAddTmpElement string PlayToClientPacketTeamsPlayersAddTmpElement, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketTeamsPlayersAddTmp = append(PlayToClientPacketTeamsPlayersAddTmp, PlayToClientPacketTeamsPlayersAddTmpElement) } ret.Players = PlayToClientPacketTeamsPlayersAddTmp case "join": var PlayToClientPacketTeamsPlayersJoinTmp []string var lPlayToClientPacketTeamsPlayersJoinTmp int32 lPlayToClientPacketTeamsPlayersJoinTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTeamsPlayersJoinTmp = []string{} for range lPlayToClientPacketTeamsPlayersJoinTmp { var PlayToClientPacketTeamsPlayersJoinTmpElement string PlayToClientPacketTeamsPlayersJoinTmpElement, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketTeamsPlayersJoinTmp = append(PlayToClientPacketTeamsPlayersJoinTmp, PlayToClientPacketTeamsPlayersJoinTmpElement) } ret.Players = PlayToClientPacketTeamsPlayersJoinTmp case "leave": var PlayToClientPacketTeamsPlayersLeaveTmp []string var lPlayToClientPacketTeamsPlayersLeaveTmp int32 lPlayToClientPacketTeamsPlayersLeaveTmp, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTeamsPlayersLeaveTmp = []string{} for range lPlayToClientPacketTeamsPlayersLeaveTmp { var PlayToClientPacketTeamsPlayersLeaveTmpElement string PlayToClientPacketTeamsPlayersLeaveTmpElement, err = proto_base.DecodeString(r) if err != nil { return } PlayToClientPacketTeamsPlayersLeaveTmp = append(PlayToClientPacketTeamsPlayersLeaveTmp, PlayToClientPacketTeamsPlayersLeaveTmpElement) } ret.Players = PlayToClientPacketTeamsPlayersLeaveTmp default: var PlayToClientPacketTeamsPlayersTmp struct { } ret.Players = PlayToClientPacketTeamsPlayersTmp } return } var PlayToClientPacketTeamsModeReverseMap = map[string]int8{"add": 0, "remove": 1, "change": 2, "join": 3, "leave": 4} var PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap = map[string]int32{"always": 0, "never": 1, "hide_for_other_teams": 2, "hide_for_own_team": 3} var PlayToClientPacketTeamsAnonCollisionRuleReverseMap = map[string]int32{"always": 0, "never": 1, "push_other_teams": 2, "push_own_team": 3} func (ret *PlayToClientPacketTeams) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Team) if err != nil { return } var vPlayToClientPacketTeamsMode int8 vPlayToClientPacketTeamsMode, err = proto_base.ErroringIndex(PlayToClientPacketTeamsModeReverseMap, ret.Mode) if err != nil { return } err = binary.Write(w, binary.BigEndian, vPlayToClientPacketTeamsMode) if err != nil { return } switch ret.Mode { case "add": PlayToClientPacketTeamsAnon, ok := ret.Anon.(struct { Name nbt.Anon Flags uint8 NameTagVisibility string CollisionRule string Formatting int32 Prefix nbt.Anon Suffix nbt.Anon }) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketTeamsAnonNameEncTmp := PlayToClientPacketTeamsAnon.Name err = PlayToClientPacketTeamsAnonNameEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsAnon.Flags) if err != nil { return } var vPlayToClientPacketTeamsAnonNameTagVisibility int32 vPlayToClientPacketTeamsAnonNameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap, PlayToClientPacketTeamsAnon.NameTagVisibility) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonNameTagVisibility) if err != nil { return } var vPlayToClientPacketTeamsAnonCollisionRule int32 vPlayToClientPacketTeamsAnonCollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleReverseMap, PlayToClientPacketTeamsAnon.CollisionRule) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonCollisionRule) if err != nil { return } err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsAnon.Formatting) if err != nil { return } PlayToClientPacketTeamsAnonPrefixEncTmp := PlayToClientPacketTeamsAnon.Prefix err = PlayToClientPacketTeamsAnonPrefixEncTmp.Encode(w) if err != nil { return } PlayToClientPacketTeamsAnonSuffixEncTmp := PlayToClientPacketTeamsAnon.Suffix err = PlayToClientPacketTeamsAnonSuffixEncTmp.Encode(w) if err != nil { return } case "change": PlayToClientPacketTeamsAnon, ok := ret.Anon.(struct { Name nbt.Anon Flags uint8 NameTagVisibility string CollisionRule string Formatting int32 Prefix nbt.Anon Suffix nbt.Anon }) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketTeamsAnonNameEncTmp := PlayToClientPacketTeamsAnon.Name err = PlayToClientPacketTeamsAnonNameEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsAnon.Flags) if err != nil { return } var vPlayToClientPacketTeamsAnonNameTagVisibility int32 vPlayToClientPacketTeamsAnonNameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap, PlayToClientPacketTeamsAnon.NameTagVisibility) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonNameTagVisibility) if err != nil { return } var vPlayToClientPacketTeamsAnonCollisionRule int32 vPlayToClientPacketTeamsAnonCollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleReverseMap, PlayToClientPacketTeamsAnon.CollisionRule) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonCollisionRule) if err != nil { return } err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsAnon.Formatting) if err != nil { return } PlayToClientPacketTeamsAnonPrefixEncTmp := PlayToClientPacketTeamsAnon.Prefix err = PlayToClientPacketTeamsAnonPrefixEncTmp.Encode(w) if err != nil { return } PlayToClientPacketTeamsAnonSuffixEncTmp := PlayToClientPacketTeamsAnon.Suffix err = PlayToClientPacketTeamsAnonSuffixEncTmp.Encode(w) if err != nil { return } default: _, ok := ret.Anon.(struct { }) if !ok { err = proto_base.BadTypeError return } } switch ret.Mode { case "add": 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 "join": 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 "leave": 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 PlayToClientPacketTestInstanceBlockStatus struct { Status nbt.Anon Size *Vec3i } func (ret *PlayToClientPacketTestInstanceBlockStatus) Decode(r io.ReadSeeker) (err error) { err = ret.Status.Decode(r) if err != nil { return } var PlayToClientPacketTestInstanceBlockStatusSizePresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTestInstanceBlockStatusSizePresent) if err != nil { return } if PlayToClientPacketTestInstanceBlockStatusSizePresent { var PlayToClientPacketTestInstanceBlockStatusSizePresentValue Vec3i err = PlayToClientPacketTestInstanceBlockStatusSizePresentValue.Decode(r) if err != nil { return } ret.Size = &PlayToClientPacketTestInstanceBlockStatusSizePresentValue } return } func (ret *PlayToClientPacketTestInstanceBlockStatus) Encode(w io.Writer) (err error) { PlayToClientPacketTestInstanceBlockStatusStatusEncTmp := ret.Status err = PlayToClientPacketTestInstanceBlockStatusStatusEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Size != nil) if err != nil { return } if ret.Size != nil { PlayToClientPacketTestInstanceBlockStatusSizeEncTmp := *ret.Size err = PlayToClientPacketTestInstanceBlockStatusSizeEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketTileEntityData struct { Location Position Action int32 NbtData nbt.Anon } func (ret *PlayToClientPacketTileEntityData) 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 } 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 = proto_base.EncodeVarInt(w, ret.Action) if err != nil { return } PlayToClientPacketTileEntityDataNbtDataEncTmp := ret.NbtData err = PlayToClientPacketTileEntityDataNbtDataEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketTrackedWaypoint struct { Operation string Waypoint struct { HasUUID bool Anon any Icon struct { Style string Color *struct { Red uint8 Green uint8 Blue uint8 } } Type string Data any } } var PlayToClientPacketTrackedWaypointOperationMap = map[int32]string{0: "track", 1: "untrack", 2: "update"} var PlayToClientPacketTrackedWaypointWaypointTypeMap = map[int32]string{0: "empty", 1: "vec3i", 2: "chunk", 3: "azimuth"} func (ret *PlayToClientPacketTrackedWaypoint) Decode(r io.ReadSeeker) (err error) { var PlayToClientPacketTrackedWaypointOperationKey int32 PlayToClientPacketTrackedWaypointOperationKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Operation, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointOperationMap, PlayToClientPacketTrackedWaypointOperationKey) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Waypoint.HasUUID) if err != nil { return } switch ret.Waypoint.HasUUID { case false: var PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp struct { Id string } PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp.Id, err = proto_base.DecodeString(r) if err != nil { return } ret.Waypoint.Anon = PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp case true: var PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp struct { Uuid uuid.UUID } _, err = io.ReadFull(r, PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp.Uuid[:]) if err != nil { return } ret.Waypoint.Anon = PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp } ret.Waypoint.Icon.Style, err = proto_base.DecodeString(r) if err != nil { return } var PlayToClientPacketTrackedWaypointWaypointIconColorPresent bool err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresent) if err != nil { return } if PlayToClientPacketTrackedWaypointWaypointIconColorPresent { var PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue struct { Red uint8 Green uint8 Blue uint8 } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue.Red) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue.Green) if err != nil { return } err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue.Blue) if err != nil { return } ret.Waypoint.Icon.Color = &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue } var PlayToClientPacketTrackedWaypointWaypointTypeKey int32 PlayToClientPacketTrackedWaypointWaypointTypeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Waypoint.Type, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointWaypointTypeMap, PlayToClientPacketTrackedWaypointWaypointTypeKey) if err != nil { return } switch ret.Waypoint.Anon { case "azimuth": var PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp float32 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp) if err != nil { return } ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp case "chunk": var PlayToClientPacketTrackedWaypointWaypointDataChunkTmp struct { ChunkX int32 ChunkZ int32 } PlayToClientPacketTrackedWaypointWaypointDataChunkTmp.ChunkX, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTrackedWaypointWaypointDataChunkTmp.ChunkZ, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataChunkTmp case "vec3i": var PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp Vec3i err = PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp.Decode(r) if err != nil { return } ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp } return } var PlayToClientPacketTrackedWaypointOperationReverseMap = map[string]int32{"track": 0, "untrack": 1, "update": 2} var PlayToClientPacketTrackedWaypointWaypointTypeReverseMap = map[string]int32{"empty": 0, "vec3i": 1, "chunk": 2, "azimuth": 3} func (ret *PlayToClientPacketTrackedWaypoint) Encode(w io.Writer) (err error) { var vPlayToClientPacketTrackedWaypointOperation int32 vPlayToClientPacketTrackedWaypointOperation, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointOperationReverseMap, ret.Operation) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketTrackedWaypointOperation) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Waypoint.HasUUID) if err != nil { return } switch ret.Waypoint.HasUUID { case false: PlayToClientPacketTrackedWaypointWaypointAnon, ok := ret.Waypoint.Anon.(struct { Id string }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeString(w, PlayToClientPacketTrackedWaypointWaypointAnon.Id) if err != nil { return } case true: PlayToClientPacketTrackedWaypointWaypointAnon, ok := ret.Waypoint.Anon.(struct { Uuid uuid.UUID }) if !ok { err = proto_base.BadTypeError return } _, err = w.Write(PlayToClientPacketTrackedWaypointWaypointAnon.Uuid[:]) if err != nil { return } } err = proto_base.EncodeString(w, ret.Waypoint.Icon.Style) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Waypoint.Icon.Color != nil) if err != nil { return } if ret.Waypoint.Icon.Color != nil { err = binary.Write(w, binary.BigEndian, (*ret.Waypoint.Icon.Color).Red) if err != nil { return } err = binary.Write(w, binary.BigEndian, (*ret.Waypoint.Icon.Color).Green) if err != nil { return } err = binary.Write(w, binary.BigEndian, (*ret.Waypoint.Icon.Color).Blue) if err != nil { return } } var vPlayToClientPacketTrackedWaypointWaypointType int32 vPlayToClientPacketTrackedWaypointWaypointType, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointWaypointTypeReverseMap, ret.Waypoint.Type) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToClientPacketTrackedWaypointWaypointType) if err != nil { return } switch ret.Waypoint.Anon { case "azimuth": PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(float32) if !ok { err = proto_base.BadTypeError return } err = binary.Write(w, binary.BigEndian, PlayToClientPacketTrackedWaypointWaypointData) if err != nil { return } case "chunk": PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(struct { ChunkX int32 ChunkZ int32 }) if !ok { err = proto_base.BadTypeError return } err = proto_base.EncodeVarInt(w, PlayToClientPacketTrackedWaypointWaypointData.ChunkX) if err != nil { return } err = proto_base.EncodeVarInt(w, PlayToClientPacketTrackedWaypointWaypointData.ChunkZ) if err != nil { return } case "vec3i": PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(Vec3i) if !ok { err = proto_base.BadTypeError return } PlayToClientPacketTrackedWaypointWaypointDataEncTmp := PlayToClientPacketTrackedWaypointWaypointData err = PlayToClientPacketTrackedWaypointWaypointDataEncTmp.Encode(w) if err != nil { return } } return } type PlayToClientPacketTradeList struct { WindowId ContainerID Trades []struct { InputItem1 struct { ItemId int32 ItemCount int32 Components ExactComponentMatcher } OutputItem Slot InputItem2 *struct { ItemId int32 ItemCount int32 Components ExactComponentMatcher } 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) { err = ret.WindowId.Decode(r) if err != nil { return } var lPlayToClientPacketTradeListTrades int32 lPlayToClientPacketTradeListTrades, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Trades = []struct { InputItem1 struct { ItemId int32 ItemCount int32 Components ExactComponentMatcher } OutputItem Slot InputItem2 *struct { ItemId int32 ItemCount int32 Components ExactComponentMatcher } TradeDisabled bool NbTradeUses int32 MaximumNbTradeUses int32 Xp int32 SpecialPrice int32 PriceMultiplier float32 Demand int32 }{} for range lPlayToClientPacketTradeListTrades { var PlayToClientPacketTradeListTradesElement struct { InputItem1 struct { ItemId int32 ItemCount int32 Components ExactComponentMatcher } OutputItem Slot InputItem2 *struct { ItemId int32 ItemCount int32 Components ExactComponentMatcher } TradeDisabled bool NbTradeUses int32 MaximumNbTradeUses int32 Xp int32 SpecialPrice int32 PriceMultiplier float32 Demand int32 } PlayToClientPacketTradeListTradesElement.InputItem1.ItemId, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTradeListTradesElement.InputItem1.ItemCount, err = proto_base.DecodeVarInt(r) if err != nil { return } err = PlayToClientPacketTradeListTradesElement.InputItem1.Components.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 struct { ItemId int32 ItemCount int32 Components ExactComponentMatcher } PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemId, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemCount, err = proto_base.DecodeVarInt(r) if err != nil { return } err = PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Components.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) { PlayToClientPacketTradeListWindowIdEncTmp := ret.WindowId err = PlayToClientPacketTradeListWindowIdEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Trades))) if err != nil { return } for iPlayToClientPacketTradeListTrades := range len(ret.Trades) { err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemCount) if err != nil { return } PlayToClientPacketTradeListTradesInnerInputItem1ComponentsEncTmp := ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.Components err = PlayToClientPacketTradeListTradesInnerInputItem1ComponentsEncTmp.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 { err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemId) if err != nil { return } err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemCount) if err != nil { return } PlayToClientPacketTradeListTradesInnerInputItem2ComponentsEncTmp := (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).Components err = PlayToClientPacketTradeListTradesInnerInputItem2ComponentsEncTmp.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 PlayToClientPacketUnloadChunk struct { ChunkZ int32 ChunkX int32 } func (ret *PlayToClientPacketUnloadChunk) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.ChunkZ) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.ChunkX) if err != nil { return } return } func (ret *PlayToClientPacketUnloadChunk) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.ChunkZ) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.ChunkX) if err != nil { return } return } type PlayToClientPacketUpdateHealth struct { Health float32 Food int32 FoodSaturation float32 } func (ret *PlayToClientPacketUpdateHealth) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Health) if err != nil { return } ret.Food, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.FoodSaturation) if err != nil { return } return } func (ret *PlayToClientPacketUpdateHealth) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Health) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Food) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.FoodSaturation) if err != nil { return } return } type PlayToClientPacketUpdateLight struct { ChunkX int32 ChunkZ int32 SkyLightMask []int64 BlockLightMask []int64 EmptySkyLightMask []int64 EmptyBlockLightMask []int64 SkyLight [][]uint8 BlockLight [][]uint8 } 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 } var lPlayToClientPacketUpdateLightSkyLightMask int32 lPlayToClientPacketUpdateLightSkyLightMask, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SkyLightMask = []int64{} for range lPlayToClientPacketUpdateLightSkyLightMask { var PlayToClientPacketUpdateLightSkyLightMaskElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightSkyLightMaskElement) if err != nil { return } ret.SkyLightMask = append(ret.SkyLightMask, PlayToClientPacketUpdateLightSkyLightMaskElement) } var lPlayToClientPacketUpdateLightBlockLightMask int32 lPlayToClientPacketUpdateLightBlockLightMask, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.BlockLightMask = []int64{} for range lPlayToClientPacketUpdateLightBlockLightMask { var PlayToClientPacketUpdateLightBlockLightMaskElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightBlockLightMaskElement) if err != nil { return } ret.BlockLightMask = append(ret.BlockLightMask, PlayToClientPacketUpdateLightBlockLightMaskElement) } var lPlayToClientPacketUpdateLightEmptySkyLightMask int32 lPlayToClientPacketUpdateLightEmptySkyLightMask, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.EmptySkyLightMask = []int64{} for range lPlayToClientPacketUpdateLightEmptySkyLightMask { var PlayToClientPacketUpdateLightEmptySkyLightMaskElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightEmptySkyLightMaskElement) if err != nil { return } ret.EmptySkyLightMask = append(ret.EmptySkyLightMask, PlayToClientPacketUpdateLightEmptySkyLightMaskElement) } var lPlayToClientPacketUpdateLightEmptyBlockLightMask int32 lPlayToClientPacketUpdateLightEmptyBlockLightMask, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.EmptyBlockLightMask = []int64{} for range lPlayToClientPacketUpdateLightEmptyBlockLightMask { var PlayToClientPacketUpdateLightEmptyBlockLightMaskElement int64 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightEmptyBlockLightMaskElement) if err != nil { return } ret.EmptyBlockLightMask = append(ret.EmptyBlockLightMask, PlayToClientPacketUpdateLightEmptyBlockLightMaskElement) } var lPlayToClientPacketUpdateLightSkyLight int32 lPlayToClientPacketUpdateLightSkyLight, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SkyLight = [][]uint8{} for range lPlayToClientPacketUpdateLightSkyLight { var PlayToClientPacketUpdateLightSkyLightElement []uint8 var lPlayToClientPacketUpdateLightSkyLightElement int32 lPlayToClientPacketUpdateLightSkyLightElement, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketUpdateLightSkyLightElement = []uint8{} for range lPlayToClientPacketUpdateLightSkyLightElement { var PlayToClientPacketUpdateLightSkyLightElementElement uint8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightSkyLightElementElement) if err != nil { return } PlayToClientPacketUpdateLightSkyLightElement = append(PlayToClientPacketUpdateLightSkyLightElement, PlayToClientPacketUpdateLightSkyLightElementElement) } ret.SkyLight = append(ret.SkyLight, PlayToClientPacketUpdateLightSkyLightElement) } var lPlayToClientPacketUpdateLightBlockLight int32 lPlayToClientPacketUpdateLightBlockLight, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.BlockLight = [][]uint8{} for range lPlayToClientPacketUpdateLightBlockLight { var PlayToClientPacketUpdateLightBlockLightElement []uint8 var lPlayToClientPacketUpdateLightBlockLightElement int32 lPlayToClientPacketUpdateLightBlockLightElement, err = proto_base.DecodeVarInt(r) if err != nil { return } PlayToClientPacketUpdateLightBlockLightElement = []uint8{} for range lPlayToClientPacketUpdateLightBlockLightElement { var PlayToClientPacketUpdateLightBlockLightElementElement uint8 err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightBlockLightElementElement) if err != nil { return } PlayToClientPacketUpdateLightBlockLightElement = append(PlayToClientPacketUpdateLightBlockLightElement, PlayToClientPacketUpdateLightBlockLightElementElement) } ret.BlockLight = append(ret.BlockLight, PlayToClientPacketUpdateLightBlockLightElement) } return } func (ret *PlayToClientPacketUpdateLight) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.ChunkX) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.ChunkZ) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLightMask))) if err != nil { return } for iPlayToClientPacketUpdateLightSkyLightMask := range len(ret.SkyLightMask) { err = binary.Write(w, binary.BigEndian, ret.SkyLightMask[iPlayToClientPacketUpdateLightSkyLightMask]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLightMask))) if err != nil { return } for iPlayToClientPacketUpdateLightBlockLightMask := range len(ret.BlockLightMask) { err = binary.Write(w, binary.BigEndian, ret.BlockLightMask[iPlayToClientPacketUpdateLightBlockLightMask]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.EmptySkyLightMask))) if err != nil { return } for iPlayToClientPacketUpdateLightEmptySkyLightMask := range len(ret.EmptySkyLightMask) { err = binary.Write(w, binary.BigEndian, ret.EmptySkyLightMask[iPlayToClientPacketUpdateLightEmptySkyLightMask]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.EmptyBlockLightMask))) if err != nil { return } for iPlayToClientPacketUpdateLightEmptyBlockLightMask := range len(ret.EmptyBlockLightMask) { err = binary.Write(w, binary.BigEndian, ret.EmptyBlockLightMask[iPlayToClientPacketUpdateLightEmptyBlockLightMask]) if err != nil { return } } err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight))) if err != nil { return } for iPlayToClientPacketUpdateLightSkyLight := range len(ret.SkyLight) { err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight]))) if err != nil { return } for iPlayToClientPacketUpdateLightSkyLightInner := range len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight]) { err = binary.Write(w, binary.BigEndian, ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight][iPlayToClientPacketUpdateLightSkyLightInner]) if err != nil { return } } } err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight))) if err != nil { return } for iPlayToClientPacketUpdateLightBlockLight := range len(ret.BlockLight) { err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight]))) if err != nil { return } for iPlayToClientPacketUpdateLightBlockLightInner := range len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight]) { err = binary.Write(w, binary.BigEndian, ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight][iPlayToClientPacketUpdateLightBlockLightInner]) if err != nil { return } } } return } type PlayToClientPacketUpdateTime struct { Age int64 Time int64 TickDayTime bool } 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 } err = binary.Read(r, binary.BigEndian, &ret.TickDayTime) 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 } err = binary.Write(w, binary.BigEndian, ret.TickDayTime) 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 ContainerID StateId int32 Items []Slot CarriedItem Slot } func (ret *PlayToClientPacketWindowItems) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) if err != nil { return } ret.StateId, err = proto_base.DecodeVarInt(r) if err != nil { return } var lPlayToClientPacketWindowItemsItems int32 lPlayToClientPacketWindowItemsItems, err = proto_base.DecodeVarInt(r) 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) } err = ret.CarriedItem.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketWindowItems) Encode(w io.Writer) (err error) { PlayToClientPacketWindowItemsWindowIdEncTmp := ret.WindowId err = PlayToClientPacketWindowItemsWindowIdEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.StateId) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(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 } } PlayToClientPacketWindowItemsCarriedItemEncTmp := ret.CarriedItem err = PlayToClientPacketWindowItemsCarriedItemEncTmp.Encode(w) if err != nil { return } return } type PlayToClientPacketWorldBorderCenter struct { X float64 Z float64 } func (ret *PlayToClientPacketWorldBorderCenter) 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 } return } func (ret *PlayToClientPacketWorldBorderCenter) 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 } return } type PlayToClientPacketWorldBorderLerpSize struct { OldDiameter float64 NewDiameter float64 Speed int32 } func (ret *PlayToClientPacketWorldBorderLerpSize) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.OldDiameter) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.NewDiameter) if err != nil { return } ret.Speed, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketWorldBorderLerpSize) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.OldDiameter) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.NewDiameter) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Speed) if err != nil { return } return } type PlayToClientPacketWorldBorderSize struct { Diameter float64 } func (ret *PlayToClientPacketWorldBorderSize) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Diameter) if err != nil { return } return } func (ret *PlayToClientPacketWorldBorderSize) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Diameter) if err != nil { return } return } type PlayToClientPacketWorldBorderWarningDelay struct { WarningTime int32 } func (ret *PlayToClientPacketWorldBorderWarningDelay) Decode(r io.ReadSeeker) (err error) { ret.WarningTime, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketWorldBorderWarningDelay) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.WarningTime) if err != nil { return } return } type PlayToClientPacketWorldBorderWarningReach struct { WarningBlocks int32 } func (ret *PlayToClientPacketWorldBorderWarningReach) Decode(r io.ReadSeeker) (err error) { ret.WarningBlocks, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToClientPacketWorldBorderWarningReach) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.WarningBlocks) if err != nil { 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 { LongDistance bool AlwaysShow bool X float64 Y float64 Z float64 OffsetX float32 OffsetY float32 OffsetZ float32 VelocityOffset float32 Amount int32 Particle Particle } func (ret *PlayToClientPacketWorldParticles) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.LongDistance) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.AlwaysShow) 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.VelocityOffset) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Amount) if err != nil { return } err = ret.Particle.Decode(r) if err != nil { return } return } func (ret *PlayToClientPacketWorldParticles) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.LongDistance) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.AlwaysShow) 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.VelocityOffset) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Amount) if err != nil { return } PlayToClientPacketWorldParticlesParticleEncTmp := ret.Particle err = PlayToClientPacketWorldParticlesParticleEncTmp.Encode(w) if err != nil { return } return } type PlayToServerMovementFlags struct { Val uint8 } func (ret *PlayToServerMovementFlags) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Val) if err != nil { return } return } func (ret *PlayToServerMovementFlags) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Val) if err != nil { return } return } type PlayToServerPacket struct { Name string Params any } var PlayToServerPacketNameMap = map[int32]string{0x00: "teleport_confirm", 0x01: "query_block_nbt", 0x02: "select_bundle_item", 0x03: "set_difficulty", 0x04: "change_gamemode", 0x05: "message_acknowledgement", 0x06: "chat_command", 0x07: "chat_command_signed", 0x08: "chat_message", 0x09: "chat_session_update", 0x0a: "chunk_batch_received", 0x0b: "client_command", 0x0c: "tick_end", 0x0d: "settings", 0x0e: "tab_complete", 0x0f: "configuration_acknowledged", 0x10: "enchant_item", 0x11: "window_click", 0x12: "close_window", 0x13: "set_slot_state", 0x14: "cookie_response", 0x15: "custom_payload", 0x16: "debug_subscription_request", 0x17: "edit_book", 0x18: "query_entity_nbt", 0x19: "use_entity", 0x1a: "generate_structure", 0x1b: "keep_alive", 0x1c: "lock_difficulty", 0x1d: "position", 0x1e: "position_look", 0x1f: "look", 0x20: "flying", 0x21: "vehicle_move", 0x22: "steer_boat", 0x23: "pick_item_from_block", 0x24: "pick_item_from_entity", 0x25: "ping_request", 0x26: "craft_recipe_request", 0x27: "abilities", 0x28: "block_dig", 0x29: "entity_action", 0x2a: "player_input", 0x2b: "player_loaded", 0x2c: "pong", 0x2d: "recipe_book", 0x2e: "displayed_recipe", 0x2f: "name_item", 0x30: "resource_pack_receive", 0x31: "advancement_tab", 0x32: "select_trade", 0x33: "set_beacon_effect", 0x34: "held_item_slot", 0x35: "update_command_block", 0x36: "update_command_block_minecart", 0x37: "set_creative_slot", 0x38: "update_jigsaw_block", 0x39: "update_structure_block", 0x3a: "set_test_block", 0x3b: "update_sign", 0x3c: "arm_animation", 0x3d: "spectate", 0x3e: "test_instance_block_action", 0x3f: "block_place", 0x40: "use_item", 0x41: "custom_click_action"} 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 "change_gamemode": var PlayToServerPacketParamsChangeGamemodeTmp PlayToServerPacketChangeGamemode err = PlayToServerPacketParamsChangeGamemodeTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsChangeGamemodeTmp case "chat_command": var PlayToServerPacketParamsChatCommandTmp PlayToServerPacketChatCommand err = PlayToServerPacketParamsChatCommandTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsChatCommandTmp case "chat_command_signed": var PlayToServerPacketParamsChatCommandSignedTmp PlayToServerPacketChatCommandSigned err = PlayToServerPacketParamsChatCommandSignedTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsChatCommandSignedTmp case "chat_message": var PlayToServerPacketParamsChatMessageTmp PlayToServerPacketChatMessage err = PlayToServerPacketParamsChatMessageTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsChatMessageTmp case "chat_session_update": var PlayToServerPacketParamsChatSessionUpdateTmp PlayToServerPacketChatSessionUpdate err = PlayToServerPacketParamsChatSessionUpdateTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsChatSessionUpdateTmp case "chunk_batch_received": var PlayToServerPacketParamsChunkBatchReceivedTmp PlayToServerPacketChunkBatchReceived err = PlayToServerPacketParamsChunkBatchReceivedTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsChunkBatchReceivedTmp 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 "configuration_acknowledged": var PlayToServerPacketParamsConfigurationAcknowledgedTmp PlayToServerPacketConfigurationAcknowledged err = PlayToServerPacketParamsConfigurationAcknowledgedTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsConfigurationAcknowledgedTmp case "cookie_response": var PlayToServerPacketParamsCookieResponseTmp PlayToServerPacketCommonCookieResponse err = PlayToServerPacketParamsCookieResponseTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsCookieResponseTmp case "craft_recipe_request": var PlayToServerPacketParamsCraftRecipeRequestTmp PlayToServerPacketCraftRecipeRequest err = PlayToServerPacketParamsCraftRecipeRequestTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsCraftRecipeRequestTmp case "custom_click_action": var PlayToServerPacketParamsCustomClickActionTmp PlayToServerPacketCommonCustomClickAction err = PlayToServerPacketParamsCustomClickActionTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsCustomClickActionTmp case "custom_payload": var PlayToServerPacketParamsCustomPayloadTmp PlayToServerPacketCustomPayload err = PlayToServerPacketParamsCustomPayloadTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsCustomPayloadTmp case "debug_subscription_request": var PlayToServerPacketParamsDebugSubscriptionRequestTmp PlayToServerPacketDebugSubscriptionRequest err = PlayToServerPacketParamsDebugSubscriptionRequestTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsDebugSubscriptionRequestTmp 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 "message_acknowledgement": var PlayToServerPacketParamsMessageAcknowledgementTmp PlayToServerPacketMessageAcknowledgement err = PlayToServerPacketParamsMessageAcknowledgementTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsMessageAcknowledgementTmp case "name_item": var PlayToServerPacketParamsNameItemTmp PlayToServerPacketNameItem err = PlayToServerPacketParamsNameItemTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsNameItemTmp case "pick_item_from_block": var PlayToServerPacketParamsPickItemFromBlockTmp PlayToServerPacketPickItemFromBlock err = PlayToServerPacketParamsPickItemFromBlockTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsPickItemFromBlockTmp case "pick_item_from_entity": var PlayToServerPacketParamsPickItemFromEntityTmp PlayToServerPacketPickItemFromEntity err = PlayToServerPacketParamsPickItemFromEntityTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsPickItemFromEntityTmp case "ping_request": var PlayToServerPacketParamsPingRequestTmp PlayToServerPacketPingRequest err = PlayToServerPacketParamsPingRequestTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsPingRequestTmp case "player_input": var PlayToServerPacketParamsPlayerInputTmp PlayToServerPacketPlayerInput err = PlayToServerPacketParamsPlayerInputTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsPlayerInputTmp case "player_loaded": var PlayToServerPacketParamsPlayerLoadedTmp PlayToServerPacketPlayerLoaded err = PlayToServerPacketParamsPlayerLoadedTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsPlayerLoadedTmp case "pong": var PlayToServerPacketParamsPongTmp PlayToServerPacketPong err = PlayToServerPacketParamsPongTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsPongTmp 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_bundle_item": var PlayToServerPacketParamsSelectBundleItemTmp PlayToServerPacketSelectBundleItem err = PlayToServerPacketParamsSelectBundleItemTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsSelectBundleItemTmp 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 "set_slot_state": var PlayToServerPacketParamsSetSlotStateTmp PlayToServerPacketSetSlotState err = PlayToServerPacketParamsSetSlotStateTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsSetSlotStateTmp case "set_test_block": var PlayToServerPacketParamsSetTestBlockTmp PlayToServerPacketSetTestBlock err = PlayToServerPacketParamsSetTestBlockTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsSetTestBlockTmp case "settings": var PlayToServerPacketParamsSettingsTmp PlayToServerPacketCommonSettings 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 "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 "test_instance_block_action": var PlayToServerPacketParamsTestInstanceBlockActionTmp PlayToServerPacketTestInstanceBlockAction err = PlayToServerPacketParamsTestInstanceBlockActionTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsTestInstanceBlockActionTmp case "tick_end": var PlayToServerPacketParamsTickEndTmp PlayToServerPacketTickEnd err = PlayToServerPacketParamsTickEndTmp.Decode(r) if err != nil { return } ret.Params = PlayToServerPacketParamsTickEndTmp 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, "select_bundle_item": 0x02, "set_difficulty": 0x03, "change_gamemode": 0x04, "message_acknowledgement": 0x05, "chat_command": 0x06, "chat_command_signed": 0x07, "chat_message": 0x08, "chat_session_update": 0x09, "chunk_batch_received": 0x0a, "client_command": 0x0b, "tick_end": 0x0c, "settings": 0x0d, "tab_complete": 0x0e, "configuration_acknowledged": 0x0f, "enchant_item": 0x10, "window_click": 0x11, "close_window": 0x12, "set_slot_state": 0x13, "cookie_response": 0x14, "custom_payload": 0x15, "debug_subscription_request": 0x16, "edit_book": 0x17, "query_entity_nbt": 0x18, "use_entity": 0x19, "generate_structure": 0x1a, "keep_alive": 0x1b, "lock_difficulty": 0x1c, "position": 0x1d, "position_look": 0x1e, "look": 0x1f, "flying": 0x20, "vehicle_move": 0x21, "steer_boat": 0x22, "pick_item_from_block": 0x23, "pick_item_from_entity": 0x24, "ping_request": 0x25, "craft_recipe_request": 0x26, "abilities": 0x27, "block_dig": 0x28, "entity_action": 0x29, "player_input": 0x2a, "player_loaded": 0x2b, "pong": 0x2c, "recipe_book": 0x2d, "displayed_recipe": 0x2e, "name_item": 0x2f, "resource_pack_receive": 0x30, "advancement_tab": 0x31, "select_trade": 0x32, "set_beacon_effect": 0x33, "held_item_slot": 0x34, "update_command_block": 0x35, "update_command_block_minecart": 0x36, "set_creative_slot": 0x37, "update_jigsaw_block": 0x38, "update_structure_block": 0x39, "set_test_block": 0x3a, "update_sign": 0x3b, "arm_animation": 0x3c, "spectate": 0x3d, "test_instance_block_action": 0x3e, "block_place": 0x3f, "use_item": 0x40, "custom_click_action": 0x41} 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 "change_gamemode": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChangeGamemode) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "chat_command": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommand) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "chat_command_signed": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommandSigned) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "chat_message": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatMessage) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "chat_session_update": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatSessionUpdate) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "chunk_batch_received": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChunkBatchReceived) 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 "configuration_acknowledged": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketConfigurationAcknowledged) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "cookie_response": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonCookieResponse) 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_click_action": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonCustomClickAction) 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 "debug_subscription_request": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDebugSubscriptionRequest) 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 "message_acknowledgement": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketMessageAcknowledgement) 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_from_block": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItemFromBlock) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "pick_item_from_entity": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItemFromEntity) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "ping_request": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPingRequest) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "player_input": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPlayerInput) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "player_loaded": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPlayerLoaded) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "pong": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPong) 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_bundle_item": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectBundleItem) 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 "set_slot_state": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetSlotState) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "set_test_block": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetTestBlock) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "settings": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonSettings) 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 "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 "test_instance_block_action": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTestInstanceBlockAction) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketParamsEncTmp := PlayToServerPacketParams err = PlayToServerPacketParamsEncTmp.Encode(w) if err != nil { return } case "tick_end": PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTickEnd) 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 Sequence int32 } 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 } ret.Sequence, err = proto_base.DecodeVarInt(r) 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 } err = proto_base.EncodeVarInt(w, ret.Sequence) if err != nil { return } return } type PlayToServerPacketBlockPlace struct { Hand int32 Location Position Direction int32 CursorX float32 CursorY float32 CursorZ float32 InsideBlock bool WorldBorderHit bool Sequence int32 } 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 } err = binary.Read(r, binary.BigEndian, &ret.WorldBorderHit) if err != nil { return } ret.Sequence, err = proto_base.DecodeVarInt(r) 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 } err = binary.Write(w, binary.BigEndian, ret.WorldBorderHit) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Sequence) if err != nil { return } return } type PlayToServerPacketChangeGamemode struct { Mode string } var PlayToServerPacketChangeGamemodeModeMap = map[int32]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"} func (ret *PlayToServerPacketChangeGamemode) Decode(r io.ReadSeeker) (err error) { var PlayToServerPacketChangeGamemodeModeKey int32 PlayToServerPacketChangeGamemodeModeKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Mode, err = proto_base.ErroringIndex(PlayToServerPacketChangeGamemodeModeMap, PlayToServerPacketChangeGamemodeModeKey) if err != nil { return } return } var PlayToServerPacketChangeGamemodeModeReverseMap = map[string]int32{"survival": 0, "creative": 1, "adventure": 2, "spectator": 3} func (ret *PlayToServerPacketChangeGamemode) Encode(w io.Writer) (err error) { var vPlayToServerPacketChangeGamemodeMode int32 vPlayToServerPacketChangeGamemodeMode, err = proto_base.ErroringIndex(PlayToServerPacketChangeGamemodeModeReverseMap, ret.Mode) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToServerPacketChangeGamemodeMode) if err != nil { return } return } type PlayToServerPacketChatCommand struct { Command string } func (ret *PlayToServerPacketChatCommand) Decode(r io.ReadSeeker) (err error) { ret.Command, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *PlayToServerPacketChatCommand) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Command) if err != nil { return } return } type PlayToServerPacketChatCommandSigned struct { Command string Timestamp int64 Salt int64 ArgumentSignatures []struct { ArgumentName string Signature [256]byte } MessageCount int32 Acknowledged [3]byte Checksum uint8 } func (ret *PlayToServerPacketChatCommandSigned) Decode(r io.ReadSeeker) (err error) { ret.Command, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Timestamp) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Salt) if err != nil { return } var lPlayToServerPacketChatCommandSignedArgumentSignatures int32 lPlayToServerPacketChatCommandSignedArgumentSignatures, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ArgumentSignatures = []struct { ArgumentName string Signature [256]byte }{} for range lPlayToServerPacketChatCommandSignedArgumentSignatures { var PlayToServerPacketChatCommandSignedArgumentSignaturesElement struct { ArgumentName string Signature [256]byte } PlayToServerPacketChatCommandSignedArgumentSignaturesElement.ArgumentName, err = proto_base.DecodeString(r) if err != nil { return } _, err = r.Read(PlayToServerPacketChatCommandSignedArgumentSignaturesElement.Signature[:]) if err != nil { return } ret.ArgumentSignatures = append(ret.ArgumentSignatures, PlayToServerPacketChatCommandSignedArgumentSignaturesElement) } ret.MessageCount, err = proto_base.DecodeVarInt(r) if err != nil { return } _, err = r.Read(ret.Acknowledged[:]) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Checksum) if err != nil { return } return } func (ret *PlayToServerPacketChatCommandSigned) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Command) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Timestamp) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Salt) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.ArgumentSignatures))) if err != nil { return } for iPlayToServerPacketChatCommandSignedArgumentSignatures := range len(ret.ArgumentSignatures) { err = proto_base.EncodeString(w, ret.ArgumentSignatures[iPlayToServerPacketChatCommandSignedArgumentSignatures].ArgumentName) if err != nil { return } arr := ret.ArgumentSignatures[iPlayToServerPacketChatCommandSignedArgumentSignatures].Signature _, err = w.Write(arr[:]) if err != nil { return } } err = proto_base.EncodeVarInt(w, ret.MessageCount) if err != nil { return } arr := ret.Acknowledged _, err = w.Write(arr[:]) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Checksum) if err != nil { return } return } type PlayToServerPacketChatMessage struct { Message string Timestamp int64 Salt int64 Signature *[256]byte Offset int32 Acknowledged [3]byte Checksum uint8 } func (ret *PlayToServerPacketChatMessage) Decode(r io.ReadSeeker) (err error) { ret.Message, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Timestamp) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Salt) if err != nil { return } var PlayToServerPacketChatMessageSignaturePresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketChatMessageSignaturePresent) if err != nil { return } if PlayToServerPacketChatMessageSignaturePresent { var PlayToServerPacketChatMessageSignaturePresentValue [256]byte _, err = r.Read(PlayToServerPacketChatMessageSignaturePresentValue[:]) if err != nil { return } ret.Signature = &PlayToServerPacketChatMessageSignaturePresentValue } ret.Offset, err = proto_base.DecodeVarInt(r) if err != nil { return } _, err = r.Read(ret.Acknowledged[:]) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Checksum) if err != nil { return } return } func (ret *PlayToServerPacketChatMessage) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Message) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Timestamp) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Salt) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Signature != nil) if err != nil { return } if ret.Signature != nil { arr := *ret.Signature _, err = w.Write(arr[:]) if err != nil { return } } err = proto_base.EncodeVarInt(w, ret.Offset) if err != nil { return } arr := ret.Acknowledged _, err = w.Write(arr[:]) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Checksum) if err != nil { return } return } type PlayToServerPacketChatSessionUpdate struct { SessionUUID uuid.UUID ExpireTime int64 PublicKey ByteArray Signature ByteArray } func (ret *PlayToServerPacketChatSessionUpdate) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.SessionUUID[:]) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.ExpireTime) if err != nil { return } err = ret.PublicKey.Decode(r) if err != nil { return } err = ret.Signature.Decode(r) if err != nil { return } return } func (ret *PlayToServerPacketChatSessionUpdate) Encode(w io.Writer) (err error) { _, err = w.Write(ret.SessionUUID[:]) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.ExpireTime) if err != nil { return } PlayToServerPacketChatSessionUpdatePublicKeyEncTmp := ret.PublicKey err = PlayToServerPacketChatSessionUpdatePublicKeyEncTmp.Encode(w) if err != nil { return } PlayToServerPacketChatSessionUpdateSignatureEncTmp := ret.Signature err = PlayToServerPacketChatSessionUpdateSignatureEncTmp.Encode(w) if err != nil { return } return } type PlayToServerPacketChunkBatchReceived struct { ChunksPerTick float32 } func (ret *PlayToServerPacketChunkBatchReceived) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.ChunksPerTick) if err != nil { return } return } func (ret *PlayToServerPacketChunkBatchReceived) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.ChunksPerTick) 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 ContainerID } func (ret *PlayToServerPacketCloseWindow) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) if err != nil { return } return } func (ret *PlayToServerPacketCloseWindow) Encode(w io.Writer) (err error) { PlayToServerPacketCloseWindowWindowIdEncTmp := ret.WindowId err = PlayToServerPacketCloseWindowWindowIdEncTmp.Encode(w) if err != nil { return } return } type PlayToServerPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *PlayToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var PlayToServerPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if PlayToServerPacketCommonAddResourcePackPromptMessagePresent { var PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *PlayToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { PlayToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = PlayToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type PlayToServerPacketCommonClearDialog struct { } func (ret *PlayToServerPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type PlayToServerPacketCommonCookieRequest struct { Cookie string } func (ret *PlayToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *PlayToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type PlayToServerPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *PlayToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var PlayToServerPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonCookieResponseValuePresent) if err != nil { return } if PlayToServerPacketCommonCookieResponseValuePresent { var PlayToServerPacketCommonCookieResponseValuePresentValue ByteArray err = PlayToServerPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &PlayToServerPacketCommonCookieResponseValuePresentValue } return } func (ret *PlayToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { PlayToServerPacketCommonCookieResponseValueEncTmp := *ret.Value err = PlayToServerPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type PlayToServerPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *PlayToServerPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var PlayToServerPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonCustomClickActionNbtPresent) if err != nil { return } if PlayToServerPacketCommonCustomClickActionNbtPresent { var PlayToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = PlayToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &PlayToServerPacketCommonCustomClickActionNbtPresentValue } return } func (ret *PlayToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { PlayToServerPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = PlayToServerPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type PlayToServerPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *PlayToServerPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lPlayToServerPacketCommonCustomReportDetailsDetails int32 lPlayToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lPlayToServerPacketCommonCustomReportDetailsDetails { var PlayToServerPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } PlayToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } PlayToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, PlayToServerPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *PlayToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iPlayToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iPlayToServerPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iPlayToServerPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type PlayToServerPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *PlayToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var PlayToServerPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if PlayToServerPacketCommonRemoveResourcePackUuidPresent { var PlayToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, PlayToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &PlayToServerPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *PlayToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type PlayToServerPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *PlayToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lPlayToServerPacketCommonSelectKnownPacksPacks int32 lPlayToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lPlayToServerPacketCommonSelectKnownPacksPacks { var PlayToServerPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } PlayToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } PlayToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } PlayToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, PlayToServerPacketCommonSelectKnownPacksPacksElement) } return } func (ret *PlayToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iPlayToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type PlayToServerPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *PlayToServerPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lPlayToServerPacketCommonServerLinksLinks int32 lPlayToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lPlayToServerPacketCommonServerLinksLinks { var PlayToServerPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch PlayToServerPacketCommonServerLinksLinksElement.HasKnownType { case true: var PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } PlayToServerPacketCommonServerLinksLinksElement.KnownType = PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch PlayToServerPacketCommonServerLinksLinksElement.HasKnownType { case false: var PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } PlayToServerPacketCommonServerLinksLinksElement.UnknownType = PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } PlayToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, PlayToServerPacketCommonServerLinksLinksElement) } return } func (ret *PlayToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iPlayToServerPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType { case true: PlayToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iPlayToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp := PlayToServerPacketCommonServerLinksLinksInnerKnownType err = PlayToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType { case false: PlayToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iPlayToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } PlayToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := PlayToServerPacketCommonServerLinksLinksInnerUnknownType err = PlayToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iPlayToServerPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type PlayToServerPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var PlayToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *PlayToServerPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var PlayToServerPacketCommonSettingsParticleStatusKey int32 PlayToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(PlayToServerPacketCommonSettingsParticleStatusMap, PlayToServerPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var PlayToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *PlayToServerPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vPlayToServerPacketCommonSettingsParticleStatus int32 vPlayToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(PlayToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToServerPacketCommonSettingsParticleStatus) if err != nil { return } return } type PlayToServerPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *PlayToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *PlayToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } PlayToServerPacketCommonStoreCookieValueEncTmp := ret.Value err = PlayToServerPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type PlayToServerPacketCommonTransfer struct { Host string Port int32 } func (ret *PlayToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) if err != nil { return } return } type PlayToServerPacketConfigurationAcknowledged struct { } func (ret *PlayToServerPacketConfigurationAcknowledged) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToServerPacketConfigurationAcknowledged) Encode(w io.Writer) (err error) { return } type PlayToServerPacketCraftRecipeRequest struct { WindowId ContainerID RecipeId int32 MakeAll bool } func (ret *PlayToServerPacketCraftRecipeRequest) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) if err != nil { return } ret.RecipeId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.MakeAll) if err != nil { return } return } func (ret *PlayToServerPacketCraftRecipeRequest) Encode(w io.Writer) (err error) { PlayToServerPacketCraftRecipeRequestWindowIdEncTmp := ret.WindowId err = PlayToServerPacketCraftRecipeRequestWindowIdEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.RecipeId) 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 PlayToServerPacketDebugSubscriptionRequest struct { Subscriptions []DebugSubscriptionDataType } func (ret *PlayToServerPacketDebugSubscriptionRequest) Decode(r io.ReadSeeker) (err error) { var lPlayToServerPacketDebugSubscriptionRequestSubscriptions int32 lPlayToServerPacketDebugSubscriptionRequestSubscriptions, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Subscriptions = []DebugSubscriptionDataType{} for range lPlayToServerPacketDebugSubscriptionRequestSubscriptions { var PlayToServerPacketDebugSubscriptionRequestSubscriptionsElement DebugSubscriptionDataType err = PlayToServerPacketDebugSubscriptionRequestSubscriptionsElement.Decode(r) if err != nil { return } ret.Subscriptions = append(ret.Subscriptions, PlayToServerPacketDebugSubscriptionRequestSubscriptionsElement) } return } func (ret *PlayToServerPacketDebugSubscriptionRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Subscriptions))) if err != nil { return } for iPlayToServerPacketDebugSubscriptionRequestSubscriptions := range len(ret.Subscriptions) { PlayToServerPacketDebugSubscriptionRequestSubscriptionsInnerEncTmp := ret.Subscriptions[iPlayToServerPacketDebugSubscriptionRequestSubscriptions] err = PlayToServerPacketDebugSubscriptionRequestSubscriptionsInnerEncTmp.Encode(w) if err != nil { return } } return } type PlayToServerPacketDisplayedRecipe struct { RecipeId int32 } func (ret *PlayToServerPacketDisplayedRecipe) Decode(r io.ReadSeeker) (err error) { ret.RecipeId, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToServerPacketDisplayedRecipe) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.RecipeId) if err != nil { return } return } type PlayToServerPacketEditBook struct { Hand int32 Pages []string Title *string } func (ret *PlayToServerPacketEditBook) Decode(r io.ReadSeeker) (err error) { ret.Hand, err = proto_base.DecodeVarInt(r) if err != nil { return } var lPlayToServerPacketEditBookPages int32 lPlayToServerPacketEditBookPages, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Pages = []string{} for range lPlayToServerPacketEditBookPages { var PlayToServerPacketEditBookPagesElement string PlayToServerPacketEditBookPagesElement, err = proto_base.DecodeString(r) if err != nil { return } ret.Pages = append(ret.Pages, PlayToServerPacketEditBookPagesElement) } var PlayToServerPacketEditBookTitlePresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketEditBookTitlePresent) if err != nil { return } if PlayToServerPacketEditBookTitlePresent { var PlayToServerPacketEditBookTitlePresentValue string PlayToServerPacketEditBookTitlePresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Title = &PlayToServerPacketEditBookTitlePresentValue } return } func (ret *PlayToServerPacketEditBook) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Hand) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.Pages))) if err != nil { return } for iPlayToServerPacketEditBookPages := range len(ret.Pages) { err = proto_base.EncodeString(w, ret.Pages[iPlayToServerPacketEditBookPages]) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.Title != nil) if err != nil { return } if ret.Title != nil { err = proto_base.EncodeString(w, *ret.Title) if err != nil { return } } return } type PlayToServerPacketEnchantItem struct { WindowId ContainerID Enchantment int32 } func (ret *PlayToServerPacketEnchantItem) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) if err != nil { return } ret.Enchantment, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToServerPacketEnchantItem) Encode(w io.Writer) (err error) { PlayToServerPacketEnchantItemWindowIdEncTmp := ret.WindowId err = PlayToServerPacketEnchantItemWindowIdEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Enchantment) if err != nil { return } return } type PlayToServerPacketEntityAction struct { EntityId int32 ActionId string JumpBoost int32 } var PlayToServerPacketEntityActionActionIdMap = map[int32]string{0: "leave_bed", 1: "start_sprinting", 2: "stop_sprinting", 3: "start_horse_jump", 4: "stop_horse_jump", 5: "open_vehicle_inventory", 6: "start_elytra_flying"} func (ret *PlayToServerPacketEntityAction) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } var PlayToServerPacketEntityActionActionIdKey int32 PlayToServerPacketEntityActionActionIdKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ActionId, err = proto_base.ErroringIndex(PlayToServerPacketEntityActionActionIdMap, PlayToServerPacketEntityActionActionIdKey) if err != nil { return } ret.JumpBoost, err = proto_base.DecodeVarInt(r) if err != nil { return } return } var PlayToServerPacketEntityActionActionIdReverseMap = map[string]int32{"leave_bed": 0, "start_sprinting": 1, "stop_sprinting": 2, "start_horse_jump": 3, "stop_horse_jump": 4, "open_vehicle_inventory": 5, "start_elytra_flying": 6} func (ret *PlayToServerPacketEntityAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.EntityId) if err != nil { return } var vPlayToServerPacketEntityActionActionId int32 vPlayToServerPacketEntityActionActionId, err = proto_base.ErroringIndex(PlayToServerPacketEntityActionActionIdReverseMap, ret.ActionId) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToServerPacketEntityActionActionId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.JumpBoost) if err != nil { return } return } type PlayToServerPacketFlying struct { Flags PlayToServerMovementFlags } func (ret *PlayToServerPacketFlying) Decode(r io.ReadSeeker) (err error) { err = ret.Flags.Decode(r) if err != nil { return } return } func (ret *PlayToServerPacketFlying) Encode(w io.Writer) (err error) { PlayToServerPacketFlyingFlagsEncTmp := ret.Flags err = PlayToServerPacketFlyingFlagsEncTmp.Encode(w) 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 Flags PlayToServerMovementFlags } 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 = ret.Flags.Decode(r) 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 } PlayToServerPacketLookFlagsEncTmp := ret.Flags err = PlayToServerPacketLookFlagsEncTmp.Encode(w) if err != nil { return } return } type PlayToServerPacketMessageAcknowledgement struct { Count int32 } func (ret *PlayToServerPacketMessageAcknowledgement) Decode(r io.ReadSeeker) (err error) { ret.Count, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToServerPacketMessageAcknowledgement) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.Count) 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 PlayToServerPacketPickItemFromBlock struct { Position Position IncludeData bool } func (ret *PlayToServerPacketPickItemFromBlock) Decode(r io.ReadSeeker) (err error) { err = ret.Position.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.IncludeData) if err != nil { return } return } func (ret *PlayToServerPacketPickItemFromBlock) Encode(w io.Writer) (err error) { PlayToServerPacketPickItemFromBlockPositionEncTmp := ret.Position err = PlayToServerPacketPickItemFromBlockPositionEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.IncludeData) if err != nil { return } return } type PlayToServerPacketPickItemFromEntity struct { EntityId int32 IncludeData bool } func (ret *PlayToServerPacketPickItemFromEntity) Decode(r io.ReadSeeker) (err error) { ret.EntityId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.IncludeData) if err != nil { return } return } func (ret *PlayToServerPacketPickItemFromEntity) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.EntityId) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.IncludeData) if err != nil { return } return } type PlayToServerPacketPingRequest struct { Id int64 } func (ret *PlayToServerPacketPingRequest) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Id) if err != nil { return } return } func (ret *PlayToServerPacketPingRequest) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Id) if err != nil { return } return } type PlayToServerPacketPlayerInput struct { Inputs uint8 } func (ret *PlayToServerPacketPlayerInput) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Inputs) if err != nil { return } return } func (ret *PlayToServerPacketPlayerInput) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Inputs) if err != nil { return } return } type PlayToServerPacketPlayerLoaded struct { } func (ret *PlayToServerPacketPlayerLoaded) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToServerPacketPlayerLoaded) Encode(w io.Writer) (err error) { return } type PlayToServerPacketPong struct { Id int32 } func (ret *PlayToServerPacketPong) Decode(r io.ReadSeeker) (err error) { err = binary.Read(r, binary.BigEndian, &ret.Id) if err != nil { return } return } func (ret *PlayToServerPacketPong) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Id) if err != nil { return } return } type PlayToServerPacketPosition struct { X float64 Y float64 Z float64 Flags PlayToServerMovementFlags } 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 = ret.Flags.Decode(r) 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 } PlayToServerPacketPositionFlagsEncTmp := ret.Flags err = PlayToServerPacketPositionFlagsEncTmp.Encode(w) if err != nil { return } return } type PlayToServerPacketPositionLook struct { X float64 Y float64 Z float64 Yaw float32 Pitch float32 Flags PlayToServerMovementFlags } 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 = ret.Flags.Decode(r) 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 } PlayToServerPacketPositionLookFlagsEncTmp := ret.Flags err = PlayToServerPacketPositionLookFlagsEncTmp.Encode(w) 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 { Uuid uuid.UUID Result int32 } func (ret *PlayToServerPacketResourcePackReceive) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Result, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Result) if err != nil { return } return } type PlayToServerPacketSelectBundleItem struct { SlotId int32 SelectedItemIndex int32 } func (ret *PlayToServerPacketSelectBundleItem) Decode(r io.ReadSeeker) (err error) { ret.SlotId, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SelectedItemIndex, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *PlayToServerPacketSelectBundleItem) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.SlotId) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.SelectedItemIndex) 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) { var PlayToServerPacketSetBeaconEffectPrimaryEffectPresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectPrimaryEffectPresent) if err != nil { return } if PlayToServerPacketSetBeaconEffectPrimaryEffectPresent { var PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue int32 PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.PrimaryEffect = &PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue } var PlayToServerPacketSetBeaconEffectSecondaryEffectPresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectSecondaryEffectPresent) if err != nil { return } if PlayToServerPacketSetBeaconEffectSecondaryEffectPresent { var PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue int32 PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.SecondaryEffect = &PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue } return } func (ret *PlayToServerPacketSetBeaconEffect) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.PrimaryEffect != nil) if err != nil { return } if ret.PrimaryEffect != nil { err = proto_base.EncodeVarInt(w, *ret.PrimaryEffect) if err != nil { return } } err = binary.Write(w, binary.BigEndian, ret.SecondaryEffect != nil) if err != nil { return } if ret.SecondaryEffect != nil { err = proto_base.EncodeVarInt(w, *ret.SecondaryEffect) if err != nil { return } } return } type PlayToServerPacketSetCreativeSlot struct { Slot int16 Item UntrustedSlot } 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 string } var PlayToServerPacketSetDifficultyNewDifficultyMap = map[int32]string{0: "peaceful", 1: "easy", 2: "normal", 3: "hard"} func (ret *PlayToServerPacketSetDifficulty) Decode(r io.ReadSeeker) (err error) { var PlayToServerPacketSetDifficultyNewDifficultyKey int32 PlayToServerPacketSetDifficultyNewDifficultyKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.NewDifficulty, err = proto_base.ErroringIndex(PlayToServerPacketSetDifficultyNewDifficultyMap, PlayToServerPacketSetDifficultyNewDifficultyKey) if err != nil { return } return } var PlayToServerPacketSetDifficultyNewDifficultyReverseMap = map[string]int32{"peaceful": 0, "easy": 1, "normal": 2, "hard": 3} func (ret *PlayToServerPacketSetDifficulty) Encode(w io.Writer) (err error) { var vPlayToServerPacketSetDifficultyNewDifficulty int32 vPlayToServerPacketSetDifficultyNewDifficulty, err = proto_base.ErroringIndex(PlayToServerPacketSetDifficultyNewDifficultyReverseMap, ret.NewDifficulty) if err != nil { return } err = proto_base.EncodeVarInt(w, vPlayToServerPacketSetDifficultyNewDifficulty) if err != nil { return } return } type PlayToServerPacketSetSlotState struct { SlotId int32 WindowId ContainerID State bool } func (ret *PlayToServerPacketSetSlotState) Decode(r io.ReadSeeker) (err error) { ret.SlotId, err = proto_base.DecodeVarInt(r) if err != nil { return } err = ret.WindowId.Decode(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.State) if err != nil { return } return } func (ret *PlayToServerPacketSetSlotState) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, ret.SlotId) if err != nil { return } PlayToServerPacketSetSlotStateWindowIdEncTmp := ret.WindowId err = PlayToServerPacketSetSlotStateWindowIdEncTmp.Encode(w) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.State) if err != nil { return } return } type PlayToServerPacketSetTestBlock struct { Position Position Mode int32 Message string } func (ret *PlayToServerPacketSetTestBlock) Decode(r io.ReadSeeker) (err error) { err = ret.Position.Decode(r) if err != nil { return } ret.Mode, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Message, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *PlayToServerPacketSetTestBlock) Encode(w io.Writer) (err error) { PlayToServerPacketSetTestBlockPositionEncTmp := ret.Position err = PlayToServerPacketSetTestBlockPositionEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Mode) if err != nil { return } err = proto_base.EncodeString(w, ret.Message) 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 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 PlayToServerPacketTestInstanceBlockAction struct { Pos Position Action int32 Data struct { Test *string Size Vec3i Rotation int32 IgnoreEntities bool Status int32 ErrorMessage *nbt.Anon } } func (ret *PlayToServerPacketTestInstanceBlockAction) Decode(r io.ReadSeeker) (err error) { err = ret.Pos.Decode(r) if err != nil { return } ret.Action, err = proto_base.DecodeVarInt(r) if err != nil { return } var PlayToServerPacketTestInstanceBlockActionDataTestPresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTestInstanceBlockActionDataTestPresent) if err != nil { return } if PlayToServerPacketTestInstanceBlockActionDataTestPresent { var PlayToServerPacketTestInstanceBlockActionDataTestPresentValue string PlayToServerPacketTestInstanceBlockActionDataTestPresentValue, err = proto_base.DecodeString(r) if err != nil { return } ret.Data.Test = &PlayToServerPacketTestInstanceBlockActionDataTestPresentValue } err = ret.Data.Size.Decode(r) if err != nil { return } ret.Data.Rotation, err = proto_base.DecodeVarInt(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Data.IgnoreEntities) if err != nil { return } ret.Data.Status, err = proto_base.DecodeVarInt(r) if err != nil { return } var PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent) if err != nil { return } if PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent { var PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue nbt.Anon err = PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue.Decode(r) if err != nil { return } ret.Data.ErrorMessage = &PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue } return } func (ret *PlayToServerPacketTestInstanceBlockAction) Encode(w io.Writer) (err error) { PlayToServerPacketTestInstanceBlockActionPosEncTmp := ret.Pos err = PlayToServerPacketTestInstanceBlockActionPosEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Action) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Data.Test != nil) if err != nil { return } if ret.Data.Test != nil { err = proto_base.EncodeString(w, *ret.Data.Test) if err != nil { return } } PlayToServerPacketTestInstanceBlockActionDataSizeEncTmp := ret.Data.Size err = PlayToServerPacketTestInstanceBlockActionDataSizeEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Data.Rotation) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Data.IgnoreEntities) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Data.Status) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Data.ErrorMessage != nil) if err != nil { return } if ret.Data.ErrorMessage != nil { PlayToServerPacketTestInstanceBlockActionDataErrorMessageEncTmp := *ret.Data.ErrorMessage err = PlayToServerPacketTestInstanceBlockActionDataErrorMessageEncTmp.Encode(w) if err != nil { return } } return } type PlayToServerPacketTickEnd struct { } func (ret *PlayToServerPacketTickEnd) Decode(r io.ReadSeeker) (err error) { return } func (ret *PlayToServerPacketTickEnd) Encode(w io.Writer) (err error) { 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 SelectionPriority int32 PlacementPriority int32 } 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 } ret.SelectionPriority, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.PlacementPriority, err = proto_base.DecodeVarInt(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 } err = proto_base.EncodeVarInt(w, ret.SelectionPriority) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.PlacementPriority) if err != nil { return } return } type PlayToServerPacketUpdateSign struct { Location Position IsFrontText bool 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 } err = binary.Read(r, binary.BigEndian, &ret.IsFrontText) 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 = binary.Write(w, binary.BigEndian, ret.IsFrontText) 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 int32 Flags string } var PlayToServerPacketUpdateStructureBlockFlagsMap = map[uint8]string{0: "ignore_entities", 1: "show_air", 2: "show_bounding_box", 3: "strict"} 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.DecodeVarInt(r) if err != nil { return } var PlayToServerPacketUpdateStructureBlockFlagsKey uint8 err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUpdateStructureBlockFlagsKey) if err != nil { return } ret.Flags, err = proto_base.ErroringIndex(PlayToServerPacketUpdateStructureBlockFlagsMap, PlayToServerPacketUpdateStructureBlockFlagsKey) if err != nil { return } return } var PlayToServerPacketUpdateStructureBlockFlagsReverseMap = map[string]uint8{"ignore_entities": 0, "show_air": 1, "show_bounding_box": 2, "strict": 3} 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.EncodeVarInt(w, ret.Seed) if err != nil { return } var vPlayToServerPacketUpdateStructureBlockFlags uint8 vPlayToServerPacketUpdateStructureBlockFlags, err = proto_base.ErroringIndex(PlayToServerPacketUpdateStructureBlockFlagsReverseMap, ret.Flags) if err != nil { return } err = binary.Write(w, binary.BigEndian, vPlayToServerPacketUpdateStructureBlockFlags) 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 Sequence int32 Rotation Vec2f } func (ret *PlayToServerPacketUseItem) Decode(r io.ReadSeeker) (err error) { ret.Hand, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Sequence, err = proto_base.DecodeVarInt(r) if err != nil { return } err = ret.Rotation.Decode(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 } err = proto_base.EncodeVarInt(w, ret.Sequence) if err != nil { return } PlayToServerPacketUseItemRotationEncTmp := ret.Rotation err = PlayToServerPacketUseItemRotationEncTmp.Encode(w) if err != nil { return } return } type PlayToServerPacketVehicleMove struct { X float64 Y float64 Z float64 Yaw float32 Pitch float32 OnGround bool } 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 } err = binary.Read(r, binary.BigEndian, &ret.OnGround) 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 } err = binary.Write(w, binary.BigEndian, ret.OnGround) if err != nil { return } return } type PlayToServerPacketWindowClick struct { WindowId ContainerID StateId int32 Slot int16 MouseButton int8 Mode int32 ChangedSlots []struct { Location int16 Item *HashedSlot } CursorItem *HashedSlot } func (ret *PlayToServerPacketWindowClick) Decode(r io.ReadSeeker) (err error) { err = ret.WindowId.Decode(r) if err != nil { return } ret.StateId, err = proto_base.DecodeVarInt(r) 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 } ret.Mode, err = proto_base.DecodeVarInt(r) if err != nil { return } var lPlayToServerPacketWindowClickChangedSlots int32 lPlayToServerPacketWindowClickChangedSlots, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ChangedSlots = []struct { Location int16 Item *HashedSlot }{} for range lPlayToServerPacketWindowClickChangedSlots { var PlayToServerPacketWindowClickChangedSlotsElement struct { Location int16 Item *HashedSlot } err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickChangedSlotsElement.Location) if err != nil { return } var PlayToServerPacketWindowClickChangedSlotsElementItemPresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickChangedSlotsElementItemPresent) if err != nil { return } if PlayToServerPacketWindowClickChangedSlotsElementItemPresent { var PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue HashedSlot err = PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue.Decode(r) if err != nil { return } PlayToServerPacketWindowClickChangedSlotsElement.Item = &PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue } ret.ChangedSlots = append(ret.ChangedSlots, PlayToServerPacketWindowClickChangedSlotsElement) } var PlayToServerPacketWindowClickCursorItemPresent bool err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickCursorItemPresent) if err != nil { return } if PlayToServerPacketWindowClickCursorItemPresent { var PlayToServerPacketWindowClickCursorItemPresentValue HashedSlot err = PlayToServerPacketWindowClickCursorItemPresentValue.Decode(r) if err != nil { return } ret.CursorItem = &PlayToServerPacketWindowClickCursorItemPresentValue } return } func (ret *PlayToServerPacketWindowClick) Encode(w io.Writer) (err error) { PlayToServerPacketWindowClickWindowIdEncTmp := ret.WindowId err = PlayToServerPacketWindowClickWindowIdEncTmp.Encode(w) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.StateId) 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 = proto_base.EncodeVarInt(w, ret.Mode) if err != nil { return } err = proto_base.EncodeVarInt(w, int32(len(ret.ChangedSlots))) if err != nil { return } for iPlayToServerPacketWindowClickChangedSlots := range len(ret.ChangedSlots) { err = binary.Write(w, binary.BigEndian, ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Location) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item != nil) if err != nil { return } if ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item != nil { PlayToServerPacketWindowClickChangedSlotsInnerItemEncTmp := *ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item err = PlayToServerPacketWindowClickChangedSlotsInnerItemEncTmp.Encode(w) if err != nil { return } } } err = binary.Write(w, binary.BigEndian, ret.CursorItem != nil) if err != nil { return } if ret.CursorItem != nil { PlayToServerPacketWindowClickCursorItemEncTmp := *ret.CursorItem err = PlayToServerPacketWindowClickCursorItemEncTmp.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 StatusToClientPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *StatusToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var StatusToClientPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if StatusToClientPacketCommonAddResourcePackPromptMessagePresent { var StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *StatusToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { StatusToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = StatusToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type StatusToClientPacketCommonClearDialog struct { } func (ret *StatusToClientPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *StatusToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type StatusToClientPacketCommonCookieRequest struct { Cookie string } func (ret *StatusToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *StatusToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type StatusToClientPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *StatusToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var StatusToClientPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonCookieResponseValuePresent) if err != nil { return } if StatusToClientPacketCommonCookieResponseValuePresent { var StatusToClientPacketCommonCookieResponseValuePresentValue ByteArray err = StatusToClientPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &StatusToClientPacketCommonCookieResponseValuePresentValue } return } func (ret *StatusToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { StatusToClientPacketCommonCookieResponseValueEncTmp := *ret.Value err = StatusToClientPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type StatusToClientPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *StatusToClientPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var StatusToClientPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonCustomClickActionNbtPresent) if err != nil { return } if StatusToClientPacketCommonCustomClickActionNbtPresent { var StatusToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = StatusToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &StatusToClientPacketCommonCustomClickActionNbtPresentValue } return } func (ret *StatusToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { StatusToClientPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = StatusToClientPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type StatusToClientPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *StatusToClientPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lStatusToClientPacketCommonCustomReportDetailsDetails int32 lStatusToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lStatusToClientPacketCommonCustomReportDetailsDetails { var StatusToClientPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } StatusToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } StatusToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, StatusToClientPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *StatusToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iStatusToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iStatusToClientPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iStatusToClientPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type StatusToClientPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *StatusToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var StatusToClientPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if StatusToClientPacketCommonRemoveResourcePackUuidPresent { var StatusToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, StatusToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &StatusToClientPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *StatusToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type StatusToClientPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *StatusToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lStatusToClientPacketCommonSelectKnownPacksPacks int32 lStatusToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lStatusToClientPacketCommonSelectKnownPacksPacks { var StatusToClientPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } StatusToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } StatusToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } StatusToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, StatusToClientPacketCommonSelectKnownPacksPacksElement) } return } func (ret *StatusToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iStatusToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type StatusToClientPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *StatusToClientPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lStatusToClientPacketCommonServerLinksLinks int32 lStatusToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lStatusToClientPacketCommonServerLinksLinks { var StatusToClientPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch StatusToClientPacketCommonServerLinksLinksElement.HasKnownType { case true: var StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } StatusToClientPacketCommonServerLinksLinksElement.KnownType = StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch StatusToClientPacketCommonServerLinksLinksElement.HasKnownType { case false: var StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } StatusToClientPacketCommonServerLinksLinksElement.UnknownType = StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } StatusToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, StatusToClientPacketCommonServerLinksLinksElement) } return } func (ret *StatusToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iStatusToClientPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType { case true: StatusToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iStatusToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } StatusToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp := StatusToClientPacketCommonServerLinksLinksInnerKnownType err = StatusToClientPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType { case false: StatusToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iStatusToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } StatusToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := StatusToClientPacketCommonServerLinksLinksInnerUnknownType err = StatusToClientPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iStatusToClientPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type StatusToClientPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var StatusToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *StatusToClientPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var StatusToClientPacketCommonSettingsParticleStatusKey int32 StatusToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(StatusToClientPacketCommonSettingsParticleStatusMap, StatusToClientPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var StatusToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *StatusToClientPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vStatusToClientPacketCommonSettingsParticleStatus int32 vStatusToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(StatusToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vStatusToClientPacketCommonSettingsParticleStatus) if err != nil { return } return } type StatusToClientPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *StatusToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *StatusToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } StatusToClientPacketCommonStoreCookieValueEncTmp := ret.Value err = StatusToClientPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type StatusToClientPacketCommonTransfer struct { Host string Port int32 } func (ret *StatusToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *StatusToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) 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 StatusToServerPacketCommonAddResourcePack struct { Uuid uuid.UUID Url string Hash string Forced bool PromptMessage *nbt.Anon } func (ret *StatusToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) { _, err = io.ReadFull(r, ret.Uuid[:]) if err != nil { return } ret.Url, err = proto_base.DecodeString(r) if err != nil { return } ret.Hash, err = proto_base.DecodeString(r) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.Forced) if err != nil { return } var StatusToServerPacketCommonAddResourcePackPromptMessagePresent bool err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonAddResourcePackPromptMessagePresent) if err != nil { return } if StatusToServerPacketCommonAddResourcePackPromptMessagePresent { var StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon err = StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) if err != nil { return } ret.PromptMessage = &StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue } return } func (ret *StatusToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { _, err = w.Write(ret.Uuid[:]) if err != nil { return } err = proto_base.EncodeString(w, ret.Url) if err != nil { return } err = proto_base.EncodeString(w, ret.Hash) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Forced) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) if err != nil { return } if ret.PromptMessage != nil { StatusToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage err = StatusToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w) if err != nil { return } } return } type StatusToServerPacketCommonClearDialog struct { } func (ret *StatusToServerPacketCommonClearDialog) Decode(r io.ReadSeeker) (err error) { return } func (ret *StatusToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { return } type StatusToServerPacketCommonCookieRequest struct { Cookie string } func (ret *StatusToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) { ret.Cookie, err = proto_base.DecodeString(r) if err != nil { return } return } func (ret *StatusToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Cookie) if err != nil { return } return } type StatusToServerPacketCommonCookieResponse struct { Key string Value *ByteArray } func (ret *StatusToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } var StatusToServerPacketCommonCookieResponseValuePresent bool err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonCookieResponseValuePresent) if err != nil { return } if StatusToServerPacketCommonCookieResponseValuePresent { var StatusToServerPacketCommonCookieResponseValuePresentValue ByteArray err = StatusToServerPacketCommonCookieResponseValuePresentValue.Decode(r) if err != nil { return } ret.Value = &StatusToServerPacketCommonCookieResponseValuePresentValue } return } func (ret *StatusToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Value != nil) if err != nil { return } if ret.Value != nil { StatusToServerPacketCommonCookieResponseValueEncTmp := *ret.Value err = StatusToServerPacketCommonCookieResponseValueEncTmp.Encode(w) if err != nil { return } } return } type StatusToServerPacketCommonCustomClickAction struct { Id string Nbt *nbt.Anon } func (ret *StatusToServerPacketCommonCustomClickAction) Decode(r io.ReadSeeker) (err error) { ret.Id, err = proto_base.DecodeString(r) if err != nil { return } var StatusToServerPacketCommonCustomClickActionNbtPresent bool err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonCustomClickActionNbtPresent) if err != nil { return } if StatusToServerPacketCommonCustomClickActionNbtPresent { var StatusToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon err = StatusToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) if err != nil { return } ret.Nbt = &StatusToServerPacketCommonCustomClickActionNbtPresentValue } return } func (ret *StatusToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Id) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) if err != nil { return } if ret.Nbt != nil { StatusToServerPacketCommonCustomClickActionNbtEncTmp := *ret.Nbt err = StatusToServerPacketCommonCustomClickActionNbtEncTmp.Encode(w) if err != nil { return } } return } type StatusToServerPacketCommonCustomReportDetails struct { Details []struct { Key string Value string } } func (ret *StatusToServerPacketCommonCustomReportDetails) Decode(r io.ReadSeeker) (err error) { var lStatusToServerPacketCommonCustomReportDetailsDetails int32 lStatusToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Details = []struct { Key string Value string }{} for range lStatusToServerPacketCommonCustomReportDetailsDetails { var StatusToServerPacketCommonCustomReportDetailsDetailsElement struct { Key string Value string } StatusToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) if err != nil { return } StatusToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) if err != nil { return } ret.Details = append(ret.Details, StatusToServerPacketCommonCustomReportDetailsDetailsElement) } return } func (ret *StatusToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) if err != nil { return } for iStatusToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { err = proto_base.EncodeString(w, ret.Details[iStatusToServerPacketCommonCustomReportDetailsDetails].Key) if err != nil { return } err = proto_base.EncodeString(w, ret.Details[iStatusToServerPacketCommonCustomReportDetailsDetails].Value) if err != nil { return } } return } type StatusToServerPacketCommonRemoveResourcePack struct { Uuid *uuid.UUID } func (ret *StatusToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) { var StatusToServerPacketCommonRemoveResourcePackUuidPresent bool err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonRemoveResourcePackUuidPresent) if err != nil { return } if StatusToServerPacketCommonRemoveResourcePackUuidPresent { var StatusToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID _, err = io.ReadFull(r, StatusToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) if err != nil { return } ret.Uuid = &StatusToServerPacketCommonRemoveResourcePackUuidPresentValue } return } func (ret *StatusToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) if err != nil { return } if ret.Uuid != nil { _, err = w.Write((*ret.Uuid)[:]) if err != nil { return } } return } type StatusToServerPacketCommonSelectKnownPacks struct { Packs []struct { Namespace string Id string Version string } } func (ret *StatusToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) { var lStatusToServerPacketCommonSelectKnownPacksPacks int32 lStatusToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Packs = []struct { Namespace string Id string Version string }{} for range lStatusToServerPacketCommonSelectKnownPacksPacks { var StatusToServerPacketCommonSelectKnownPacksPacksElement struct { Namespace string Id string Version string } StatusToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) if err != nil { return } StatusToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) if err != nil { return } StatusToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) if err != nil { return } ret.Packs = append(ret.Packs, StatusToServerPacketCommonSelectKnownPacksPacksElement) } return } func (ret *StatusToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) if err != nil { return } for iStatusToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Namespace) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Id) if err != nil { return } err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Version) if err != nil { return } } return } type StatusToServerPacketCommonServerLinks struct { Links []struct { HasKnownType bool KnownType any UnknownType any Link string } } func (ret *StatusToServerPacketCommonServerLinks) Decode(r io.ReadSeeker) (err error) { var lStatusToServerPacketCommonServerLinksLinks int32 lStatusToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.Links = []struct { HasKnownType bool KnownType any UnknownType any Link string }{} for range lStatusToServerPacketCommonServerLinksLinks { var StatusToServerPacketCommonServerLinksLinksElement struct { HasKnownType bool KnownType any UnknownType any Link string } err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonServerLinksLinksElement.HasKnownType) if err != nil { return } switch StatusToServerPacketCommonServerLinksLinksElement.HasKnownType { case true: var StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType err = StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) if err != nil { return } StatusToServerPacketCommonServerLinksLinksElement.KnownType = StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp } switch StatusToServerPacketCommonServerLinksLinksElement.HasKnownType { case false: var StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon err = StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) if err != nil { return } StatusToServerPacketCommonServerLinksLinksElement.UnknownType = StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp } StatusToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) if err != nil { return } ret.Links = append(ret.Links, StatusToServerPacketCommonServerLinksLinksElement) } return } func (ret *StatusToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) if err != nil { return } for iStatusToServerPacketCommonServerLinksLinks := range len(ret.Links) { err = binary.Write(w, binary.BigEndian, ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType) if err != nil { return } switch ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType { case true: StatusToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iStatusToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) if !ok { err = proto_base.BadTypeError return } StatusToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp := StatusToServerPacketCommonServerLinksLinksInnerKnownType err = StatusToServerPacketCommonServerLinksLinksInnerKnownTypeEncTmp.Encode(w) if err != nil { return } } switch ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType { case false: StatusToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iStatusToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) if !ok { err = proto_base.BadTypeError return } StatusToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp := StatusToServerPacketCommonServerLinksLinksInnerUnknownType err = StatusToServerPacketCommonServerLinksLinksInnerUnknownTypeEncTmp.Encode(w) if err != nil { return } } err = proto_base.EncodeString(w, ret.Links[iStatusToServerPacketCommonServerLinksLinks].Link) if err != nil { return } } return } type StatusToServerPacketCommonSettings struct { Locale string ViewDistance int8 ChatFlags int32 ChatColors bool SkinParts uint8 MainHand int32 EnableTextFiltering bool EnableServerListing bool ParticleStatus string } var StatusToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} func (ret *StatusToServerPacketCommonSettings) 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 } err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) if err != nil { return } err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) if err != nil { return } var StatusToServerPacketCommonSettingsParticleStatusKey int32 StatusToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) if err != nil { return } ret.ParticleStatus, err = proto_base.ErroringIndex(StatusToServerPacketCommonSettingsParticleStatusMap, StatusToServerPacketCommonSettingsParticleStatusKey) if err != nil { return } return } var StatusToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} func (ret *StatusToServerPacketCommonSettings) 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 } err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) if err != nil { return } err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) if err != nil { return } var vStatusToServerPacketCommonSettingsParticleStatus int32 vStatusToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(StatusToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) if err != nil { return } err = proto_base.EncodeVarInt(w, vStatusToServerPacketCommonSettingsParticleStatus) if err != nil { return } return } type StatusToServerPacketCommonStoreCookie struct { Key string Value ByteArray } func (ret *StatusToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) { ret.Key, err = proto_base.DecodeString(r) if err != nil { return } err = ret.Value.Decode(r) if err != nil { return } return } func (ret *StatusToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Key) if err != nil { return } StatusToServerPacketCommonStoreCookieValueEncTmp := ret.Value err = StatusToServerPacketCommonStoreCookieValueEncTmp.Encode(w) if err != nil { return } return } type StatusToServerPacketCommonTransfer struct { Host string Port int32 } func (ret *StatusToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) { ret.Host, err = proto_base.DecodeString(r) if err != nil { return } ret.Port, err = proto_base.DecodeVarInt(r) if err != nil { return } return } func (ret *StatusToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { err = proto_base.EncodeString(w, ret.Host) if err != nil { return } err = proto_base.EncodeVarInt(w, ret.Port) 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 }