21855 lines
598 KiB
Go
21855 lines
598 KiB
Go
package v1_21_8
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"io"
|
|
|
|
"github.com/admin-else/strom/nbt"
|
|
"github.com/admin-else/strom/proto_base"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type ArmorTrimMaterial struct {
|
|
AssetBase string
|
|
OverrideArmorAssets []struct {
|
|
Key string
|
|
Value string
|
|
}
|
|
Description nbt.Anon
|
|
}
|
|
|
|
func (_ ArmorTrimMaterial) Decode(r io.Reader) (ret ArmorTrimMaterial, err error) {
|
|
ret.AssetBase, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lArmorTrimMaterialOverrideArmorAssets proto_base.VarInt
|
|
lArmorTrimMaterialOverrideArmorAssets, err = lArmorTrimMaterialOverrideArmorAssets.Decode(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)
|
|
}
|
|
ret.Description, 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.VarInt(len(ret.OverrideArmorAssets)).Encode(w)
|
|
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
|
|
}
|
|
}
|
|
err = ret.Description.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ArmorTrimPattern struct {
|
|
AssetId string
|
|
Description nbt.Anon
|
|
Decal bool
|
|
}
|
|
|
|
func (_ ArmorTrimPattern) Decode(r io.Reader) (ret ArmorTrimPattern, err error) {
|
|
ret.AssetId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Description, 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
|
|
}
|
|
err = ret.Description.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 (_ BannerPattern) Decode(r io.Reader) (ret BannerPattern, 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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ BannerPatternLayer) Decode(r io.Reader) (ret BannerPatternLayer, err error) {
|
|
var BannerPatternLayerPatternId proto_base.VarInt
|
|
BannerPatternLayerPatternId, err = BannerPatternLayerPatternId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if BannerPatternLayerPatternId != 0 {
|
|
ret.Pattern = BannerPatternLayerPatternId
|
|
return
|
|
}
|
|
var BannerPatternLayerPatternResult BannerPattern
|
|
BannerPatternLayerPatternResult, err = BannerPatternLayerPatternResult.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Pattern = BannerPatternLayerPatternResult
|
|
ret.ColorId, err = ret.ColorId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret BannerPatternLayer) Encode(w io.Writer) (err error) {
|
|
switch BannerPatternLayerPatternKnownType := ret.Pattern.(type) {
|
|
case proto_base.VarInt:
|
|
err = BannerPatternLayerPatternKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case BannerPattern:
|
|
err = BannerPatternLayerPatternKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
err = ret.ColorId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ByteArray struct {
|
|
Val []byte
|
|
}
|
|
|
|
func (_ ByteArray) Decode(r io.Reader) (ret ByteArray, err error) {
|
|
var lByteArray proto_base.VarInt
|
|
lByteArray, err = lByteArray.Decode(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.VarInt(len(ret.Val)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ContainerID struct {
|
|
Val proto_base.VarInt
|
|
}
|
|
|
|
func (_ ContainerID) Decode(r io.Reader) (ret ContainerID, err error) {
|
|
ret.Val, err = ret.Val.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret ContainerID) Encode(w io.Writer) (err error) {
|
|
err = ret.Val.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type DataComponentMatchers struct {
|
|
ExactMatchers ExactComponentMatcher
|
|
PartialMatchers []proto_base.VarInt
|
|
}
|
|
|
|
func (_ DataComponentMatchers) Decode(r io.Reader) (ret DataComponentMatchers, err error) {
|
|
ret.ExactMatchers, err = ret.ExactMatchers.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lDataComponentMatchersPartialMatchers proto_base.VarInt
|
|
lDataComponentMatchersPartialMatchers, err = lDataComponentMatchersPartialMatchers.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PartialMatchers = []proto_base.VarInt{}
|
|
for range lDataComponentMatchersPartialMatchers {
|
|
var DataComponentMatchersPartialMatchersElement proto_base.VarInt
|
|
DataComponentMatchersPartialMatchersElement, err = DataComponentMatchersPartialMatchersElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PartialMatchers = append(ret.PartialMatchers, DataComponentMatchersPartialMatchersElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret DataComponentMatchers) Encode(w io.Writer) (err error) {
|
|
err = ret.ExactMatchers.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.PartialMatchers)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iDataComponentMatchersPartialMatchers := range len(ret.PartialMatchers) {
|
|
err = ret.PartialMatchers[iDataComponentMatchersPartialMatchers].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadataPaintingVariant struct {
|
|
Width int32
|
|
Height int32
|
|
AssetId string
|
|
Title *nbt.Anon
|
|
Author *nbt.Anon
|
|
}
|
|
|
|
func (_ EntityMetadataPaintingVariant) Decode(r io.Reader) (ret EntityMetadataPaintingVariant, 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
|
|
EntityMetadataPaintingVariantTitlePresentValue, 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
|
|
EntityMetadataPaintingVariantAuthorPresentValue, 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 {
|
|
err = (*ret.Title).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Author != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Author != nil {
|
|
err = (*ret.Author).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ExactComponentMatcher struct {
|
|
Val []SlotComponent
|
|
}
|
|
|
|
func (_ ExactComponentMatcher) Decode(r io.Reader) (ret ExactComponentMatcher, err error) {
|
|
var lExactComponentMatcher proto_base.VarInt
|
|
lExactComponentMatcher, err = lExactComponentMatcher.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []SlotComponent{}
|
|
for range lExactComponentMatcher {
|
|
var ExactComponentMatcherElement SlotComponent
|
|
ExactComponentMatcherElement, 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.VarInt(len(ret.Val)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iExactComponentMatcher := range len(ret.Val) {
|
|
err = ret.Val[iExactComponentMatcher].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HashedSlot struct {
|
|
ItemId proto_base.VarInt
|
|
ItemCount proto_base.VarInt
|
|
Components []struct {
|
|
Type SlotComponentType
|
|
Hash int32
|
|
}
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}
|
|
|
|
func (_ HashedSlot) Decode(r io.Reader) (ret HashedSlot, err error) {
|
|
ret.ItemId, err = ret.ItemId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ItemCount, err = ret.ItemCount.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lHashedSlotComponents proto_base.VarInt
|
|
lHashedSlotComponents, err = lHashedSlotComponents.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Components = []struct {
|
|
Type SlotComponentType
|
|
Hash int32
|
|
}{}
|
|
for range lHashedSlotComponents {
|
|
var HashedSlotComponentsElement struct {
|
|
Type SlotComponentType
|
|
Hash int32
|
|
}
|
|
HashedSlotComponentsElement.Type, 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 proto_base.VarInt
|
|
lHashedSlotRemoveComponents, err = lHashedSlotRemoveComponents.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RemoveComponents = []struct {
|
|
Type SlotComponentType
|
|
}{}
|
|
for range lHashedSlotRemoveComponents {
|
|
var HashedSlotRemoveComponentsElement struct {
|
|
Type SlotComponentType
|
|
}
|
|
HashedSlotRemoveComponentsElement.Type, 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 = ret.ItemId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.ItemCount.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Components)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iHashedSlotComponents := range len(ret.Components) {
|
|
err = ret.Components[iHashedSlotComponents].Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Components[iHashedSlotComponents].Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.VarInt(len(ret.RemoveComponents)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iHashedSlotRemoveComponents := range len(ret.RemoveComponents) {
|
|
err = ret.RemoveComponents[iHashedSlotRemoveComponents].Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type IDSet struct {
|
|
Val any
|
|
}
|
|
|
|
func (_ IDSet) Decode(r io.Reader) (ret IDSet, err error) {
|
|
var lIDSet proto_base.VarInt
|
|
lIDSet, err = lIDSet.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
lIDSet = lIDSet - 1
|
|
if lIDSet == -1 {
|
|
var IDSetResult string
|
|
IDSetResult, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = IDSetResult
|
|
return
|
|
}
|
|
var IDSetResult []proto_base.VarInt
|
|
for range lIDSet {
|
|
var IDSetElement proto_base.VarInt
|
|
IDSetElement, err = IDSetElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
IDSetResult = append(IDSetResult, IDSetElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret IDSet) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type InstrumentData struct {
|
|
SoundEvent ItemSoundHolder
|
|
UseDuration float32
|
|
Range float32
|
|
Description nbt.Anon
|
|
}
|
|
|
|
func (_ InstrumentData) Decode(r io.Reader) (ret InstrumentData, err error) {
|
|
ret.SoundEvent, 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
|
|
}
|
|
ret.Description, err = ret.Description.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret InstrumentData) Encode(w io.Writer) (err error) {
|
|
err = ret.SoundEvent.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
|
|
}
|
|
err = ret.Description.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemBlockPredicate struct {
|
|
BlockSet *any
|
|
Properties *[]ItemBlockProperty
|
|
Nbt nbt.Anon
|
|
Components DataComponentMatchers
|
|
}
|
|
|
|
func (_ ItemBlockPredicate) Decode(r io.Reader) (ret ItemBlockPredicate, err error) {
|
|
var ItemBlockPredicateBlockSetPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ItemBlockPredicateBlockSetPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemBlockPredicateBlockSetPresent {
|
|
var ItemBlockPredicateBlockSetPresentValue any
|
|
var lItemBlockPredicateBlockSet proto_base.VarInt
|
|
lItemBlockPredicateBlockSet, err = lItemBlockPredicateBlockSet.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
lItemBlockPredicateBlockSet = lItemBlockPredicateBlockSet - 1
|
|
if lItemBlockPredicateBlockSet == -1 {
|
|
var ItemBlockPredicateBlockSetResult string
|
|
ItemBlockPredicateBlockSetResult, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPredicateBlockSetPresentValue = ItemBlockPredicateBlockSetResult
|
|
return
|
|
}
|
|
var ItemBlockPredicateBlockSetResult []proto_base.VarInt
|
|
for range lItemBlockPredicateBlockSet {
|
|
var ItemBlockPredicateBlockSetElement proto_base.VarInt
|
|
ItemBlockPredicateBlockSetElement, err = ItemBlockPredicateBlockSetElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPredicateBlockSetResult = append(ItemBlockPredicateBlockSetResult, ItemBlockPredicateBlockSetElement)
|
|
}
|
|
ret.BlockSet = &ItemBlockPredicateBlockSetPresentValue
|
|
}
|
|
var ItemBlockPredicatePropertiesPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ItemBlockPredicatePropertiesPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemBlockPredicatePropertiesPresent {
|
|
var ItemBlockPredicatePropertiesPresentValue []ItemBlockProperty
|
|
var lItemBlockPredicateProperties proto_base.VarInt
|
|
lItemBlockPredicateProperties, err = lItemBlockPredicateProperties.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPredicatePropertiesPresentValue = []ItemBlockProperty{}
|
|
for range lItemBlockPredicateProperties {
|
|
var ItemBlockPredicatePropertiesElement ItemBlockProperty
|
|
ItemBlockPredicatePropertiesElement, err = ItemBlockPredicatePropertiesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPredicatePropertiesPresentValue = append(ItemBlockPredicatePropertiesPresentValue, ItemBlockPredicatePropertiesElement)
|
|
}
|
|
ret.Properties = &ItemBlockPredicatePropertiesPresentValue
|
|
}
|
|
ret.Nbt, err = ret.Nbt.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Components, err = ret.Components.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret ItemBlockPredicate) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type ItemBlockProperty struct {
|
|
Name string
|
|
IsExactMatch bool
|
|
Value any
|
|
}
|
|
|
|
func (_ ItemBlockProperty) Decode(r io.Reader) (ret ItemBlockProperty, 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 ItemBlockPropertyValueTmp struct {
|
|
MinValue string
|
|
MaxValue string
|
|
}
|
|
ItemBlockPropertyValueTmp.MinValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPropertyValueTmp.MaxValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = ItemBlockPropertyValueTmp
|
|
case true:
|
|
var ItemBlockPropertyValueTmp struct {
|
|
ExactValue string
|
|
}
|
|
ItemBlockPropertyValueTmp.ExactValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = ItemBlockPropertyValueTmp
|
|
}
|
|
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 (_ ItemBookPage) Decode(r io.Reader) (ret ItemBookPage, 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[proto_base.VarInt]string{0: "apply_effects", 1: "remove_effects", 2: "clear_all_effects", 3: "teleport_randomly", 4: "play_sound"}
|
|
|
|
func (_ ItemConsumeEffect) Decode(r io.Reader) (ret ItemConsumeEffect, err error) {
|
|
var ItemConsumeEffectTypeKey proto_base.VarInt
|
|
ItemConsumeEffectTypeKey, err = ItemConsumeEffectTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.ErroringIndex(ItemConsumeEffectTypeMap, ItemConsumeEffectTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "apply_effects":
|
|
var ItemConsumeEffectAnonTmp struct {
|
|
Effects []ItemPotionEffect
|
|
Probability float32
|
|
}
|
|
var lItemConsumeEffectAnonEffects proto_base.VarInt
|
|
lItemConsumeEffectAnonEffects, err = lItemConsumeEffectAnonEffects.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemConsumeEffectAnonTmp.Effects = []ItemPotionEffect{}
|
|
for range lItemConsumeEffectAnonEffects {
|
|
var ItemConsumeEffectAnonEffectsElement ItemPotionEffect
|
|
ItemConsumeEffectAnonEffectsElement, err = ItemConsumeEffectAnonEffectsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemConsumeEffectAnonTmp.Effects = append(ItemConsumeEffectAnonTmp.Effects, ItemConsumeEffectAnonEffectsElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ItemConsumeEffectAnonTmp.Probability)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = ItemConsumeEffectAnonTmp
|
|
case "clear_all_effects":
|
|
var ItemConsumeEffectAnonTmp proto_base.Void
|
|
ItemConsumeEffectAnonTmp, err = ItemConsumeEffectAnonTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = ItemConsumeEffectAnonTmp
|
|
case "play_sound":
|
|
var ItemConsumeEffectAnonTmp struct {
|
|
Sound ItemSoundHolder
|
|
}
|
|
ItemConsumeEffectAnonTmp.Sound, err = ItemConsumeEffectAnonTmp.Sound.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = ItemConsumeEffectAnonTmp
|
|
case "remove_effects":
|
|
var ItemConsumeEffectAnonTmp struct {
|
|
Effects IDSet
|
|
}
|
|
ItemConsumeEffectAnonTmp.Effects, err = ItemConsumeEffectAnonTmp.Effects.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = ItemConsumeEffectAnonTmp
|
|
case "teleport_randomly":
|
|
var ItemConsumeEffectAnonTmp struct {
|
|
Diameter float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ItemConsumeEffectAnonTmp.Diameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = ItemConsumeEffectAnonTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var ItemConsumeEffectTypeReverseMap = map[string]proto_base.VarInt{"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 proto_base.VarInt
|
|
vItemConsumeEffectType, err = proto_base.ErroringIndex(ItemConsumeEffectTypeReverseMap, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vItemConsumeEffectType.Encode(w)
|
|
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.VarInt(len(ItemConsumeEffectAnon.Effects)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iItemConsumeEffectAnonEffects := range len(ItemConsumeEffectAnon.Effects) {
|
|
err = ItemConsumeEffectAnon.Effects[iItemConsumeEffectAnonEffects].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ItemConsumeEffectAnon.Probability)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "clear_all_effects":
|
|
ItemConsumeEffectAnon, ok := ret.Anon.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ItemConsumeEffectAnon.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "play_sound":
|
|
ItemConsumeEffectAnon, ok := ret.Anon.(struct {
|
|
Sound ItemSoundHolder
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ItemConsumeEffectAnon.Sound.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_effects":
|
|
ItemConsumeEffectAnon, ok := ret.Anon.(struct {
|
|
Effects IDSet
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ItemConsumeEffectAnon.Effects.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 proto_base.VarInt
|
|
Duration proto_base.VarInt
|
|
Ambient bool
|
|
ShowParticles bool
|
|
ShowIcon bool
|
|
HiddenEffect *ItemEffectDetail
|
|
}
|
|
|
|
func (_ ItemEffectDetail) Decode(r io.Reader) (ret ItemEffectDetail, err error) {
|
|
ret.Amplifier, err = ret.Amplifier.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Duration, err = ret.Duration.Decode(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
|
|
ItemEffectDetailHiddenEffectPresentValue, err = ItemEffectDetailHiddenEffectPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.HiddenEffect = &ItemEffectDetailHiddenEffectPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret ItemEffectDetail) Encode(w io.Writer) (err error) {
|
|
err = ret.Amplifier.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Duration.Encode(w)
|
|
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 {
|
|
err = (*ret.HiddenEffect).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemFireworkExplosion struct {
|
|
Shape string
|
|
Colors []int32
|
|
FadeColors []int32
|
|
HasTrail bool
|
|
HasTwinkle bool
|
|
}
|
|
|
|
var ItemFireworkExplosionShapeMap = map[proto_base.VarInt]string{0: "small_ball", 1: "large_ball", 2: "star", 3: "creeper", 4: "burst"}
|
|
|
|
func (_ ItemFireworkExplosion) Decode(r io.Reader) (ret ItemFireworkExplosion, err error) {
|
|
var ItemFireworkExplosionShapeKey proto_base.VarInt
|
|
ItemFireworkExplosionShapeKey, err = ItemFireworkExplosionShapeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Shape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeMap, ItemFireworkExplosionShapeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lItemFireworkExplosionColors proto_base.VarInt
|
|
lItemFireworkExplosionColors, err = lItemFireworkExplosionColors.Decode(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 proto_base.VarInt
|
|
lItemFireworkExplosionFadeColors, err = lItemFireworkExplosionFadeColors.Decode(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]proto_base.VarInt{"small_ball": 0, "large_ball": 1, "star": 2, "creeper": 3, "burst": 4}
|
|
|
|
func (ret ItemFireworkExplosion) Encode(w io.Writer) (err error) {
|
|
var vItemFireworkExplosionShape proto_base.VarInt
|
|
vItemFireworkExplosionShape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeReverseMap, ret.Shape)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vItemFireworkExplosionShape.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Colors)).Encode(w)
|
|
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.VarInt(len(ret.FadeColors)).Encode(w)
|
|
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 proto_base.VarInt
|
|
Details ItemEffectDetail
|
|
}
|
|
|
|
func (_ ItemPotionEffect) Decode(r io.Reader) (ret ItemPotionEffect, err error) {
|
|
ret.Id, err = ret.Id.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Details, err = ret.Details.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret ItemPotionEffect) Encode(w io.Writer) (err error) {
|
|
err = ret.Id.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Details.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemSoundEvent struct {
|
|
SoundName string
|
|
FixedRange *float32
|
|
}
|
|
|
|
func (_ ItemSoundEvent) Decode(r io.Reader) (ret ItemSoundEvent, 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 (_ ItemSoundHolder) Decode(r io.Reader) (ret ItemSoundHolder, err error) {
|
|
var ItemSoundHolderId proto_base.VarInt
|
|
ItemSoundHolderId, err = ItemSoundHolderId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemSoundHolderId != 0 {
|
|
ret.Val = ItemSoundHolderId
|
|
return
|
|
}
|
|
var ItemSoundHolderResult ItemSoundEvent
|
|
ItemSoundHolderResult, 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 proto_base.VarInt:
|
|
err = ItemSoundHolderKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case ItemSoundEvent:
|
|
err = ItemSoundHolderKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemWrittenBookPage struct {
|
|
Content nbt.Anon
|
|
FilteredContent nbt.Anon
|
|
}
|
|
|
|
func (_ ItemWrittenBookPage) Decode(r io.Reader) (ret ItemWrittenBookPage, err error) {
|
|
ret.Content, err = ret.Content.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FilteredContent, err = ret.FilteredContent.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret ItemWrittenBookPage) Encode(w io.Writer) (err error) {
|
|
err = ret.Content.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.FilteredContent.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type JukeboxSongData struct {
|
|
SoundEvent ItemSoundHolder
|
|
Description nbt.Anon
|
|
LengthInSeconds float32
|
|
ComparatorOutput proto_base.VarInt
|
|
}
|
|
|
|
func (_ JukeboxSongData) Decode(r io.Reader) (ret JukeboxSongData, err error) {
|
|
ret.SoundEvent, err = ret.SoundEvent.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Description, err = ret.Description.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.LengthInSeconds)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ComparatorOutput, err = ret.ComparatorOutput.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret JukeboxSongData) Encode(w io.Writer) (err error) {
|
|
err = ret.SoundEvent.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Description.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.LengthInSeconds)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.ComparatorOutput.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Particle struct {
|
|
Type string
|
|
Data any
|
|
}
|
|
|
|
var ParticleTypeMap = map[proto_base.VarInt]string{0: "angry_villager", 1: "block", 10: "landing_lava", 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: "ominous_spawning", 11: "dripping_water", 110: "raid_omen", 111: "trial_omen", 112: "block_crumble", 113: "firefly", 12: "falling_water", 13: "dust", 14: "dust_color_transition", 15: "effect", 16: "elder_guardian", 17: "enchanted_hit", 18: "enchant", 19: "end_rod", 2: "block_marker", 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: "firework", 3: "bubble", 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: "soul_fire_flame", 4: "cloud", 40: "soul", 41: "flash", 42: "happy_villager", 43: "composter", 44: "heart", 45: "instant_effect", 46: "item", 47: "vibration", 48: "trail", 49: "item_slime", 5: "crit", 50: "item_cobweb", 51: "item_snowball", 52: "large_smoke", 53: "lava", 54: "mycelium", 55: "note", 56: "poof", 57: "portal", 58: "rain", 59: "smoke", 6: "damage_indicator", 60: "white_smoke", 61: "sneeze", 62: "spit", 63: "squid_ink", 64: "sweep_attack", 65: "totem_of_undying", 66: "underwater", 67: "splash", 68: "witch", 69: "bubble_pop", 7: "dragon_breath", 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: "falling_nectar", 8: "dripping_lava", 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: "white_ash", 9: "falling_lava", 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: "wax_off"}
|
|
var ParticleDataPositionTypeMap = map[proto_base.VarInt]string{0: "block", 1: "entity"}
|
|
|
|
func (_ Particle) Decode(r io.Reader) (ret Particle, err error) {
|
|
var ParticleTypeKey proto_base.VarInt
|
|
ParticleTypeKey, err = ParticleTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.ErroringIndex(ParticleTypeMap, ParticleTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "block":
|
|
var ParticleDataTmp proto_base.VarInt
|
|
ParticleDataTmp, err = ParticleDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "block_crumble":
|
|
var ParticleDataTmp proto_base.VarInt
|
|
ParticleDataTmp, err = ParticleDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "block_marker":
|
|
var ParticleDataTmp proto_base.VarInt
|
|
ParticleDataTmp, err = ParticleDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "dust":
|
|
var ParticleDataTmp struct {
|
|
Red float32
|
|
Green float32
|
|
Blue float32
|
|
Scale float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.Red)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.Green)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.Blue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "dust_color_transition":
|
|
var ParticleDataTmp struct {
|
|
FromRed float32
|
|
FromGreen float32
|
|
FromBlue float32
|
|
Scale float32
|
|
ToRed float32
|
|
ToGreen float32
|
|
ToBlue float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.FromRed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.FromGreen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.FromBlue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.ToRed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.ToGreen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.ToBlue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "dust_pillar":
|
|
var ParticleDataTmp proto_base.VarInt
|
|
ParticleDataTmp, err = ParticleDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "entity_effect":
|
|
var ParticleDataTmp int32
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "falling_dust":
|
|
var ParticleDataTmp proto_base.VarInt
|
|
ParticleDataTmp, err = ParticleDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "firefly":
|
|
var ParticleDataTmp proto_base.Void
|
|
ParticleDataTmp, err = ParticleDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "item":
|
|
var ParticleDataTmp Slot
|
|
ParticleDataTmp, err = ParticleDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "sculk_charge":
|
|
var ParticleDataTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "shriek":
|
|
var ParticleDataTmp proto_base.VarInt
|
|
ParticleDataTmp, err = ParticleDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "tinted_leaves":
|
|
var ParticleDataTmp int32
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "trail":
|
|
var ParticleDataTmp struct {
|
|
Target Vec3f64
|
|
Color uint8
|
|
}
|
|
ParticleDataTmp.Target, err = ParticleDataTmp.Target.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataTmp.Color)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
case "vibration":
|
|
var ParticleDataTmp struct {
|
|
PositionType string
|
|
Position any
|
|
Ticks proto_base.VarInt
|
|
}
|
|
var ParticleDataPositionTypeKey proto_base.VarInt
|
|
ParticleDataPositionTypeKey, err = ParticleDataPositionTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ParticleDataTmp.PositionType, err = proto_base.ErroringIndex(ParticleDataPositionTypeMap, ParticleDataPositionTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ParticleDataTmp.PositionType {
|
|
case "block":
|
|
var ParticleDataPositionTmp Position
|
|
ParticleDataPositionTmp, err = ParticleDataPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ParticleDataTmp.Position = ParticleDataPositionTmp
|
|
case "entity":
|
|
var ParticleDataPositionTmp struct {
|
|
EntityId proto_base.VarInt
|
|
EntityEyeHeight float32
|
|
}
|
|
ParticleDataPositionTmp.EntityId, err = ParticleDataPositionTmp.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataPositionTmp.EntityEyeHeight)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ParticleDataTmp.Position = ParticleDataPositionTmp
|
|
}
|
|
ParticleDataTmp.Ticks, err = ParticleDataTmp.Ticks.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var ParticleTypeReverseMap = map[string]proto_base.VarInt{"angry_villager": 0, "block": 1, "landing_lava": 10, "electric_spark": 100, "scrape": 101, "shriek": 102, "egg_crack": 103, "dust_plume": 104, "trial_spawner_detected_player": 105, "trial_spawner_detected_player_ominous": 106, "vault_connection": 107, "dust_pillar": 108, "ominous_spawning": 109, "dripping_water": 11, "raid_omen": 110, "trial_omen": 111, "block_crumble": 112, "firefly": 113, "falling_water": 12, "dust": 13, "dust_color_transition": 14, "effect": 15, "elder_guardian": 16, "enchanted_hit": 17, "enchant": 18, "end_rod": 19, "block_marker": 2, "entity_effect": 20, "explosion_emitter": 21, "explosion": 22, "gust": 23, "small_gust": 24, "gust_emitter_large": 25, "gust_emitter_small": 26, "sonic_boom": 27, "falling_dust": 28, "firework": 29, "bubble": 3, "fishing": 30, "flame": 31, "infested": 32, "cherry_leaves": 33, "pale_oak_leaves": 34, "tinted_leaves": 35, "sculk_soul": 36, "sculk_charge": 37, "sculk_charge_pop": 38, "soul_fire_flame": 39, "cloud": 4, "soul": 40, "flash": 41, "happy_villager": 42, "composter": 43, "heart": 44, "instant_effect": 45, "item": 46, "vibration": 47, "trail": 48, "item_slime": 49, "crit": 5, "item_cobweb": 50, "item_snowball": 51, "large_smoke": 52, "lava": 53, "mycelium": 54, "note": 55, "poof": 56, "portal": 57, "rain": 58, "smoke": 59, "damage_indicator": 6, "white_smoke": 60, "sneeze": 61, "spit": 62, "squid_ink": 63, "sweep_attack": 64, "totem_of_undying": 65, "underwater": 66, "splash": 67, "witch": 68, "bubble_pop": 69, "dragon_breath": 7, "current_down": 70, "bubble_column_up": 71, "nautilus": 72, "dolphin": 73, "campfire_cosy_smoke": 74, "campfire_signal_smoke": 75, "dripping_honey": 76, "falling_honey": 77, "landing_honey": 78, "falling_nectar": 79, "dripping_lava": 8, "falling_spore_blossom": 80, "ash": 81, "crimson_spore": 82, "warped_spore": 83, "spore_blossom_air": 84, "dripping_obsidian_tear": 85, "falling_obsidian_tear": 86, "landing_obsidian_tear": 87, "reverse_portal": 88, "white_ash": 89, "falling_lava": 9, "small_flame": 90, "snowflake": 91, "dripping_dripstone_lava": 92, "falling_dripstone_lava": 93, "dripping_dripstone_water": 94, "falling_dripstone_water": 95, "glow_squid_ink": 96, "glow": 97, "wax_on": 98, "wax_off": 99}
|
|
var ParticleDataPositionTypeReverseMap = map[string]proto_base.VarInt{"block": 0, "entity": 1}
|
|
|
|
func (ret Particle) Encode(w io.Writer) (err error) {
|
|
var vParticleType proto_base.VarInt
|
|
vParticleType, err = proto_base.ErroringIndex(ParticleTypeReverseMap, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vParticleType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "block":
|
|
ParticleData, ok := ret.Data.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_crumble":
|
|
ParticleData, ok := ret.Data.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_marker":
|
|
ParticleData, ok := ret.Data.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleData.Encode(w)
|
|
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.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleData.Encode(w)
|
|
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.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "firefly":
|
|
ParticleData, ok := ret.Data.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "item":
|
|
ParticleData, ok := ret.Data.(Slot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleData.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.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleData.Encode(w)
|
|
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
|
|
}
|
|
err = ParticleData.Target.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 proto_base.VarInt
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var vParticleDataPositionType proto_base.VarInt
|
|
vParticleDataPositionType, err = proto_base.ErroringIndex(ParticleDataPositionTypeReverseMap, ParticleData.PositionType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vParticleDataPositionType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ParticleData.PositionType {
|
|
case "block":
|
|
ParticleDataPosition, ok := ParticleData.Position.(Position)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleDataPosition.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity":
|
|
ParticleDataPosition, ok := ParticleData.Position.(struct {
|
|
EntityId proto_base.VarInt
|
|
EntityEyeHeight float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ParticleDataPosition.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleDataPosition.EntityEyeHeight)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ParticleData.Ticks.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ServerLinkType struct {
|
|
Val string
|
|
}
|
|
|
|
var ServerLinkTypeMap = map[proto_base.VarInt]string{0: "bug_report", 1: "community_guidelines", 2: "support", 3: "status", 4: "feedback", 5: "community", 6: "website", 7: "forums", 8: "news", 9: "announcements"}
|
|
|
|
func (_ ServerLinkType) Decode(r io.Reader) (ret ServerLinkType, err error) {
|
|
var ServerLinkTypeKey proto_base.VarInt
|
|
ServerLinkTypeKey, err = ServerLinkTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = proto_base.ErroringIndex(ServerLinkTypeMap, ServerLinkTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var ServerLinkTypeReverseMap = map[string]proto_base.VarInt{"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 proto_base.VarInt
|
|
vServerLinkType, err = proto_base.ErroringIndex(ServerLinkTypeReverseMap, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vServerLinkType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Slot struct {
|
|
ItemCount proto_base.VarInt
|
|
Anon any
|
|
}
|
|
|
|
func (_ Slot) Decode(r io.Reader) (ret Slot, err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret Slot) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type SlotComponent struct {
|
|
Type SlotComponentType
|
|
Data any
|
|
}
|
|
|
|
func (_ SlotComponent) Decode(r io.Reader) (ret SlotComponent, 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[proto_base.VarInt]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: "potion_duration_scale", 41: "charged_projectiles", 42: "bundle_contents", 43: "potion_contents", 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 (_ SlotComponentType) Decode(r io.Reader) (ret SlotComponentType, err error) {
|
|
var SlotComponentTypeKey proto_base.VarInt
|
|
SlotComponentTypeKey, err = SlotComponentTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = proto_base.ErroringIndex(SlotComponentTypeMap, SlotComponentTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var SlotComponentTypeReverseMap = map[string]proto_base.VarInt{"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, "potion_duration_scale": 40, "charged_projectiles": 41, "bundle_contents": 42, "potion_contents": 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 proto_base.VarInt
|
|
vSlotComponentType, err = proto_base.ErroringIndex(SlotComponentTypeReverseMap, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vSlotComponentType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type UntrustedSlot struct {
|
|
ItemCount proto_base.VarInt
|
|
Anon any
|
|
}
|
|
|
|
func (_ UntrustedSlot) Decode(r io.Reader) (ret UntrustedSlot, err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret UntrustedSlot) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type UntrustedSlotComponent struct {
|
|
Type SlotComponentType
|
|
Data ByteArray
|
|
}
|
|
|
|
func (_ UntrustedSlotComponent) Decode(r io.Reader) (ret UntrustedSlotComponent, err error) {
|
|
ret.Type, err = ret.Type.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data, err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret UntrustedSlotComponent) Encode(w io.Writer) (err error) {
|
|
err = ret.Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ChatSession struct {
|
|
Val *struct {
|
|
Uuid uuid.UUID
|
|
PublicKey struct {
|
|
ExpireTime int64
|
|
KeyBytes []byte
|
|
KeySignature []byte
|
|
}
|
|
}
|
|
}
|
|
|
|
func (_ ChatSession) Decode(r io.Reader) (ret ChatSession, 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 proto_base.VarInt
|
|
lChatSessionPublicKeyKeyBytes, err = lChatSessionPublicKeyKeyBytes.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ChatSessionPresentValue.PublicKey.KeyBytes, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeyBytes)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lChatSessionPublicKeyKeySignature proto_base.VarInt
|
|
lChatSessionPublicKeyKeySignature, err = lChatSessionPublicKeyKeySignature.Decode(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.VarInt(len((*ret.Val).PublicKey.KeyBytes)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write((*ret.Val).PublicKey.KeyBytes)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len((*ret.Val).PublicKey.KeySignature)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write((*ret.Val).PublicKey.KeySignature)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ChunkBlockEntity struct {
|
|
Anon uint8
|
|
Y int16
|
|
Type proto_base.VarInt
|
|
NbtData nbt.Anon
|
|
}
|
|
|
|
func (_ ChunkBlockEntity) Decode(r io.Reader) (ret ChunkBlockEntity, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Anon)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = ret.Type.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NbtData, err = ret.NbtData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret ChunkBlockEntity) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Anon)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NbtData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type CommandNode struct {
|
|
Flags uint8
|
|
Children []proto_base.VarInt
|
|
RedirectNode any
|
|
ExtraNodeData any
|
|
}
|
|
|
|
var CommandNodeExtraNodeDataParserMap = map[proto_base.VarInt]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 CommandNodeExtraNodeDataPropertiesMap = map[proto_base.VarInt]string{0: "SINGLE_WORD", 1: "QUOTABLE_PHRASE", 2: "GREEDY_PHRASE"}
|
|
|
|
func (_ CommandNode) Decode(r io.Reader) (ret CommandNode, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lCommandNodeChildren proto_base.VarInt
|
|
lCommandNodeChildren, err = lCommandNodeChildren.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Children = []proto_base.VarInt{}
|
|
for range lCommandNodeChildren {
|
|
var CommandNodeChildrenElement proto_base.VarInt
|
|
CommandNodeChildrenElement, err = CommandNodeChildrenElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Children = append(ret.Children, CommandNodeChildrenElement)
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
var CommandNodeRedirectNodeTmp proto_base.VarInt
|
|
CommandNodeRedirectNodeTmp, err = CommandNodeRedirectNodeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RedirectNode = CommandNodeRedirectNodeTmp
|
|
default:
|
|
var CommandNodeRedirectNodeTmp proto_base.Void
|
|
CommandNodeRedirectNodeTmp, err = CommandNodeRedirectNodeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RedirectNode = CommandNodeRedirectNodeTmp
|
|
}
|
|
switch ret.Flags {
|
|
case 0:
|
|
var CommandNodeExtraNodeDataTmp proto_base.Void
|
|
CommandNodeExtraNodeDataTmp, err = CommandNodeExtraNodeDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ExtraNodeData = CommandNodeExtraNodeDataTmp
|
|
case 1:
|
|
var CommandNodeExtraNodeDataTmp struct {
|
|
Name string
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ExtraNodeData = CommandNodeExtraNodeDataTmp
|
|
case 2:
|
|
var CommandNodeExtraNodeDataTmp struct {
|
|
Name string
|
|
Parser string
|
|
Properties any
|
|
SuggestionType any
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var CommandNodeExtraNodeDataParserKey proto_base.VarInt
|
|
CommandNodeExtraNodeDataParserKey, err = CommandNodeExtraNodeDataParserKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Parser, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataParserMap, CommandNodeExtraNodeDataParserKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataTmp.Parser {
|
|
case "brigadier:bool":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "brigadier:double":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Flags uint8
|
|
Min any
|
|
Max any
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesTmp.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataPropertiesTmp.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataPropertiesMinTmp float64
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMinTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataPropertiesMinTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesMinTmp, err = CommandNodeExtraNodeDataPropertiesMinTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp
|
|
}
|
|
switch CommandNodeExtraNodeDataPropertiesTmp.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataPropertiesMaxTmp float64
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMaxTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataPropertiesMaxTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesMaxTmp, err = CommandNodeExtraNodeDataPropertiesMaxTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "brigadier:float":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Flags uint8
|
|
Min any
|
|
Max any
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesTmp.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataPropertiesTmp.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataPropertiesMinTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMinTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataPropertiesMinTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesMinTmp, err = CommandNodeExtraNodeDataPropertiesMinTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp
|
|
}
|
|
switch CommandNodeExtraNodeDataPropertiesTmp.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataPropertiesMaxTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMaxTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataPropertiesMaxTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesMaxTmp, err = CommandNodeExtraNodeDataPropertiesMaxTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "brigadier:integer":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Flags uint8
|
|
Min any
|
|
Max any
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesTmp.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataPropertiesTmp.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataPropertiesMinTmp int32
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMinTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataPropertiesMinTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesMinTmp, err = CommandNodeExtraNodeDataPropertiesMinTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp
|
|
}
|
|
switch CommandNodeExtraNodeDataPropertiesTmp.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataPropertiesMaxTmp int32
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMaxTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataPropertiesMaxTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesMaxTmp, err = CommandNodeExtraNodeDataPropertiesMaxTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "brigadier:long":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Flags uint8
|
|
Min any
|
|
Max any
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesTmp.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataPropertiesTmp.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataPropertiesMinTmp int64
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMinTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataPropertiesMinTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesMinTmp, err = CommandNodeExtraNodeDataPropertiesMinTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp
|
|
}
|
|
switch CommandNodeExtraNodeDataPropertiesTmp.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataPropertiesMaxTmp int64
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMaxTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataPropertiesMaxTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesMaxTmp, err = CommandNodeExtraNodeDataPropertiesMaxTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "brigadier:string":
|
|
var CommandNodeExtraNodeDataPropertiesTmp string
|
|
var CommandNodeExtraNodeDataPropertiesKey proto_base.VarInt
|
|
CommandNodeExtraNodeDataPropertiesKey, err = CommandNodeExtraNodeDataPropertiesKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataPropertiesMap, CommandNodeExtraNodeDataPropertiesKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:angle":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:block_pos":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:block_predicate":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:block_state":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:color":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:column_pos":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:component":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:dialog":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:dimension":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:entity":
|
|
var CommandNodeExtraNodeDataPropertiesTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:entity_anchor":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:float_range":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:function":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:game_profile":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:gamemode":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:heightmap":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:hex_color":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:int_range":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:item_predicate":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:item_slot":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:item_stack":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:message":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:nbt":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:nbt_path":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:objective":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:objective_criteria":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:operation":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:particle":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:resource":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:resource_key":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:resource_location":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:resource_or_tag":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:resource_or_tag_key":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:resource_selector":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeDataPropertiesTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:rotation":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:score_holder":
|
|
var CommandNodeExtraNodeDataPropertiesTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:scoreboard_slot":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:swizzle":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:team":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:template_mirror":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:template_rotation":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:time":
|
|
var CommandNodeExtraNodeDataPropertiesTmp struct {
|
|
Min int32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesTmp.Min)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:uuid":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:vec2":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
case "minecraft:vec3":
|
|
var CommandNodeExtraNodeDataPropertiesTmp proto_base.Void
|
|
CommandNodeExtraNodeDataPropertiesTmp, err = CommandNodeExtraNodeDataPropertiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.Properties = CommandNodeExtraNodeDataPropertiesTmp
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
var CommandNodeExtraNodeDataSuggestionTypeTmp string
|
|
CommandNodeExtraNodeDataSuggestionTypeTmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.SuggestionType = CommandNodeExtraNodeDataSuggestionTypeTmp
|
|
default:
|
|
var CommandNodeExtraNodeDataSuggestionTypeTmp proto_base.Void
|
|
CommandNodeExtraNodeDataSuggestionTypeTmp, err = CommandNodeExtraNodeDataSuggestionTypeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeDataTmp.SuggestionType = CommandNodeExtraNodeDataSuggestionTypeTmp
|
|
}
|
|
ret.ExtraNodeData = CommandNodeExtraNodeDataTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var CommandNodeExtraNodeDataParserReverseMap = map[string]proto_base.VarInt{"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]proto_base.VarInt{"SINGLE_WORD": 0, "QUOTABLE_PHRASE": 1, "GREEDY_PHRASE": 2}
|
|
|
|
func (ret CommandNode) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Children)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iCommandNodeChildren := range len(ret.Children) {
|
|
err = ret.Children[iCommandNodeChildren].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
CommandNodeRedirectNode, ok := ret.RedirectNode.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeRedirectNode.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.RedirectNode.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.RedirectNode.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags {
|
|
case 0:
|
|
CommandNodeExtraNodeData, ok := ret.ExtraNodeData.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeData.Encode(w)
|
|
if err != nil {
|
|
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 proto_base.VarInt
|
|
vCommandNodeExtraNodeDataParser, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataParserReverseMap, CommandNodeExtraNodeData.Parser)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vCommandNodeExtraNodeDataParser.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeData.Parser {
|
|
case "brigadier:bool":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "brigadier:double":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Flags uint8
|
|
Min any
|
|
Max any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Min.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Max.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "brigadier:float":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Flags uint8
|
|
Min any
|
|
Max any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Min.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Max.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "brigadier:integer":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Flags uint8
|
|
Min any
|
|
Max any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Min.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Max.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "brigadier:long":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Flags uint8
|
|
Min any
|
|
Max any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Min.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Max.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "brigadier:string":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var vCommandNodeExtraNodeDataProperties proto_base.VarInt
|
|
vCommandNodeExtraNodeDataProperties, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataPropertiesReverseMap, CommandNodeExtraNodeDataProperties)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vCommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:angle":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:block_pos":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:block_predicate":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:block_state":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:color":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:column_pos":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:component":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:dialog":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:dimension":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:entity":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:entity_anchor":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:float_range":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:function":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:game_profile":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:gamemode":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:heightmap":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:hex_color":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:int_range":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:item_predicate":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:item_slot":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:item_stack":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:message":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:nbt":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:nbt_path":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:objective":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:objective_criteria":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:operation":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:particle":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:resource":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Registry string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:resource_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":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
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":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:score_holder":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:scoreboard_slot":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:swizzle":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:team":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:template_mirror":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:template_rotation":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
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":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:vec2":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:vec3":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeDataProperties.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = CommandNodeExtraNodeData.SuggestionType.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadata struct {
|
|
Val proto_base.ToDo
|
|
}
|
|
|
|
func (_ EntityMetadata) Decode(r io.Reader) (ret EntityMetadata, err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret EntityMetadata) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type EntityMetadataEntry struct {
|
|
Key uint8
|
|
Type string
|
|
Value any
|
|
}
|
|
|
|
var EntityMetadataEntryTypeMap = map[proto_base.VarInt]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: "compound_tag", 17: "particle", 18: "particles", 19: "villager_data", 2: "long", 20: "optional_unsigned_int", 21: "pose", 22: "cat_variant", 23: "cow_variant", 24: "wolf_variant", 25: "wolf_sound_variant", 26: "frog_variant", 27: "pig_variant", 28: "chicken_variant", 29: "optional_global_pos", 3: "float", 30: "painting_variant", 31: "sniffer_state", 32: "armadillo_state", 33: "vector3", 34: "quaternion", 4: "string", 5: "component", 6: "optional_component", 7: "item_stack", 8: "boolean", 9: "rotations"}
|
|
|
|
func (_ EntityMetadataEntry) Decode(r io.Reader) (ret EntityMetadataEntry, err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
var EntityMetadataEntryTypeReverseMap = map[string]proto_base.VarInt{"byte": 0, "int": 1, "block_pos": 10, "optional_block_pos": 11, "direction": 12, "optional_uuid": 13, "block_state": 14, "optional_block_state": 15, "compound_tag": 16, "particle": 17, "particles": 18, "villager_data": 19, "long": 2, "optional_unsigned_int": 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, "float": 3, "painting_variant": 30, "sniffer_state": 31, "armadillo_state": 32, "vector3": 33, "quaternion": 34, "string": 4, "component": 5, "optional_component": 6, "item_stack": 7, "boolean": 8, "rotations": 9}
|
|
|
|
func (ret EntityMetadataEntry) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type GameProfile struct {
|
|
Name string
|
|
Properties []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
}
|
|
|
|
func (_ GameProfile) Decode(r io.Reader) (ret GameProfile, err error) {
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lGameProfileProperties proto_base.VarInt
|
|
lGameProfileProperties, err = lGameProfileProperties.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Properties = []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}{}
|
|
for range lGameProfileProperties {
|
|
var GameProfilePropertiesElement struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
GameProfilePropertiesElement.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
GameProfilePropertiesElement.Value, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var GameProfilePropertiesElementSignaturePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &GameProfilePropertiesElementSignaturePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if GameProfilePropertiesElementSignaturePresent {
|
|
var GameProfilePropertiesElementSignaturePresentValue string
|
|
GameProfilePropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
GameProfilePropertiesElement.Signature = &GameProfilePropertiesElementSignaturePresentValue
|
|
}
|
|
ret.Properties = append(ret.Properties, GameProfilePropertiesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret GameProfile) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Properties)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iGameProfileProperties := range len(ret.Properties) {
|
|
err = proto_base.EncodeString(w, ret.Properties[iGameProfileProperties].Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Properties[iGameProfileProperties].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iGameProfileProperties].Signature != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Properties[iGameProfileProperties].Signature != nil {
|
|
err = proto_base.EncodeString(w, *ret.Properties[iGameProfileProperties].Signature)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type Ingredient struct {
|
|
Val []Slot
|
|
}
|
|
|
|
func (_ Ingredient) Decode(r io.Reader) (ret Ingredient, err error) {
|
|
var lIngredient proto_base.VarInt
|
|
lIngredient, err = lIngredient.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []Slot{}
|
|
for range lIngredient {
|
|
var IngredientElement Slot
|
|
IngredientElement, 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.VarInt(len(ret.Val)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iIngredient := range len(ret.Val) {
|
|
err = ret.Val[iIngredient].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type Optvarint struct {
|
|
Val proto_base.VarInt
|
|
}
|
|
|
|
func (_ Optvarint) Decode(r io.Reader) (ret Optvarint, err error) {
|
|
ret.Val, err = ret.Val.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret Optvarint) Encode(w io.Writer) (err error) {
|
|
err = ret.Val.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PackedChunkPos struct {
|
|
Z int32
|
|
X int32
|
|
}
|
|
|
|
func (_ PackedChunkPos) Decode(r io.Reader) (ret PackedChunkPos, 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 PacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (_ PacketCommonAddResourcePack) Decode(r io.Reader) (ret PacketCommonAddResourcePack, 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 PacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PacketCommonAddResourcePackPromptMessagePresent {
|
|
var PacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
PacketCommonAddResourcePackPromptMessagePresentValue, err = PacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &PacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonAddResourcePack) 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 {
|
|
err = (*ret.PromptMessage).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonClearDialog struct {
|
|
}
|
|
|
|
func (_ PacketCommonClearDialog) Decode(r io.Reader) (ret PacketCommonClearDialog, err error) {
|
|
return
|
|
}
|
|
func (ret PacketCommonClearDialog) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (_ PacketCommonCookieRequest) Decode(r io.Reader) (ret PacketCommonCookieRequest, err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (_ PacketCommonCookieResponse) Decode(r io.Reader) (ret PacketCommonCookieResponse, err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PacketCommonCookieResponseValuePresent {
|
|
var PacketCommonCookieResponseValuePresentValue ByteArray
|
|
PacketCommonCookieResponseValuePresentValue, err = PacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &PacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonCookieResponse) 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 {
|
|
err = (*ret.Value).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonCustomClickAction struct {
|
|
Id string
|
|
Nbt *nbt.Anon
|
|
}
|
|
|
|
func (_ PacketCommonCustomClickAction) Decode(r io.Reader) (ret PacketCommonCustomClickAction, err error) {
|
|
ret.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PacketCommonCustomClickActionNbtPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PacketCommonCustomClickActionNbtPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PacketCommonCustomClickActionNbtPresent {
|
|
var PacketCommonCustomClickActionNbtPresentValue nbt.Anon
|
|
PacketCommonCustomClickActionNbtPresentValue, err = PacketCommonCustomClickActionNbtPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Nbt = &PacketCommonCustomClickActionNbtPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonCustomClickAction) 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 {
|
|
err = (*ret.Nbt).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonCustomReportDetails struct {
|
|
Details []struct {
|
|
Key string
|
|
Value string
|
|
}
|
|
}
|
|
|
|
func (_ PacketCommonCustomReportDetails) Decode(r io.Reader) (ret PacketCommonCustomReportDetails, err error) {
|
|
var lPacketCommonCustomReportDetailsDetails proto_base.VarInt
|
|
lPacketCommonCustomReportDetailsDetails, err = lPacketCommonCustomReportDetailsDetails.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Details = []struct {
|
|
Key string
|
|
Value string
|
|
}{}
|
|
for range lPacketCommonCustomReportDetailsDetails {
|
|
var PacketCommonCustomReportDetailsDetailsElement struct {
|
|
Key string
|
|
Value string
|
|
}
|
|
PacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Details = append(ret.Details, PacketCommonCustomReportDetailsDetailsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.Details)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
|
|
err = proto_base.EncodeString(w, ret.Details[iPacketCommonCustomReportDetailsDetails].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Details[iPacketCommonCustomReportDetailsDetails].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (_ PacketCommonRemoveResourcePack) Decode(r io.Reader) (ret PacketCommonRemoveResourcePack, err error) {
|
|
var PacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PacketCommonRemoveResourcePackUuidPresent {
|
|
var PacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, PacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &PacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonRemoveResourcePack) 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 PacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (_ PacketCommonSelectKnownPacks) Decode(r io.Reader) (ret PacketCommonSelectKnownPacks, err error) {
|
|
var lPacketCommonSelectKnownPacksPacks proto_base.VarInt
|
|
lPacketCommonSelectKnownPacksPacks, err = lPacketCommonSelectKnownPacksPacks.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lPacketCommonSelectKnownPacksPacks {
|
|
var PacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
PacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, PacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.Packs)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonServerLinks struct {
|
|
Links []struct {
|
|
HasKnownType bool
|
|
KnownType any
|
|
UnknownType any
|
|
Link string
|
|
}
|
|
}
|
|
|
|
func (_ PacketCommonServerLinks) Decode(r io.Reader) (ret PacketCommonServerLinks, err error) {
|
|
var lPacketCommonServerLinksLinks proto_base.VarInt
|
|
lPacketCommonServerLinksLinks, err = lPacketCommonServerLinksLinks.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Links = []struct {
|
|
HasKnownType bool
|
|
KnownType any
|
|
UnknownType any
|
|
Link string
|
|
}{}
|
|
for range lPacketCommonServerLinksLinks {
|
|
var PacketCommonServerLinksLinksElement struct {
|
|
HasKnownType bool
|
|
KnownType any
|
|
UnknownType any
|
|
Link string
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PacketCommonServerLinksLinksElement.HasKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch PacketCommonServerLinksLinksElement.HasKnownType {
|
|
case true:
|
|
var PacketCommonServerLinksLinksElementKnownTypeTmp ServerLinkType
|
|
PacketCommonServerLinksLinksElementKnownTypeTmp, err = PacketCommonServerLinksLinksElementKnownTypeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PacketCommonServerLinksLinksElement.KnownType = PacketCommonServerLinksLinksElementKnownTypeTmp
|
|
}
|
|
switch PacketCommonServerLinksLinksElement.HasKnownType {
|
|
case false:
|
|
var PacketCommonServerLinksLinksElementUnknownTypeTmp nbt.Anon
|
|
PacketCommonServerLinksLinksElementUnknownTypeTmp, err = PacketCommonServerLinksLinksElementUnknownTypeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PacketCommonServerLinksLinksElement.UnknownType = PacketCommonServerLinksLinksElementUnknownTypeTmp
|
|
}
|
|
PacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Links = append(ret.Links, PacketCommonServerLinksLinksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonServerLinks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.Links)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPacketCommonServerLinksLinks := range len(ret.Links) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Links[iPacketCommonServerLinksLinks].HasKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Links[iPacketCommonServerLinksLinks].HasKnownType {
|
|
case true:
|
|
PacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PacketCommonServerLinksLinksInnerKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Links[iPacketCommonServerLinksLinks].HasKnownType {
|
|
case false:
|
|
PacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PacketCommonServerLinksLinksInnerUnknownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Links[iPacketCommonServerLinksLinks].Link)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags proto_base.VarInt
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand proto_base.VarInt
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
ParticleStatus string
|
|
}
|
|
|
|
var PacketCommonSettingsParticleStatusMap = map[proto_base.VarInt]string{0: "all", 1: "decreased", 2: "minimal"}
|
|
|
|
func (_ PacketCommonSettings) Decode(r io.Reader) (ret PacketCommonSettings, 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 = ret.ChatFlags.Decode(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 = ret.MainHand.Decode(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 PacketCommonSettingsParticleStatusKey proto_base.VarInt
|
|
PacketCommonSettingsParticleStatusKey, err = PacketCommonSettingsParticleStatusKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ParticleStatus, err = proto_base.ErroringIndex(PacketCommonSettingsParticleStatusMap, PacketCommonSettingsParticleStatusKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var PacketCommonSettingsParticleStatusReverseMap = map[string]proto_base.VarInt{"all": 0, "decreased": 1, "minimal": 2}
|
|
|
|
func (ret PacketCommonSettings) 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 = ret.ChatFlags.Encode(w)
|
|
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 = ret.MainHand.Encode(w)
|
|
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 vPacketCommonSettingsParticleStatus proto_base.VarInt
|
|
vPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(PacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPacketCommonSettingsParticleStatus.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (_ PacketCommonStoreCookie) Decode(r io.Reader) (ret PacketCommonStoreCookie, err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value, err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PacketCommonTransfer struct {
|
|
Host string
|
|
Port proto_base.VarInt
|
|
}
|
|
|
|
func (_ PacketCommonTransfer) Decode(r io.Reader) (ret PacketCommonTransfer, err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = ret.Port.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Port.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Position struct {
|
|
Val uint64
|
|
}
|
|
|
|
func (_ Position) Decode(r io.Reader) (ret Position, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret Position) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PreviousMessages struct {
|
|
Val []struct {
|
|
Id proto_base.VarInt
|
|
Signature any
|
|
}
|
|
}
|
|
|
|
func (_ PreviousMessages) Decode(r io.Reader) (ret PreviousMessages, err error) {
|
|
var lPreviousMessages proto_base.VarInt
|
|
lPreviousMessages, err = lPreviousMessages.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []struct {
|
|
Id proto_base.VarInt
|
|
Signature any
|
|
}{}
|
|
for range lPreviousMessages {
|
|
var PreviousMessagesElement struct {
|
|
Id proto_base.VarInt
|
|
Signature any
|
|
}
|
|
PreviousMessagesElement.Id, err = PreviousMessagesElement.Id.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch PreviousMessagesElement.Id {
|
|
case 0:
|
|
var PreviousMessagesElementSignatureTmp [256]byte
|
|
_, err = r.Read(PreviousMessagesElementSignatureTmp[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
PreviousMessagesElement.Signature = PreviousMessagesElementSignatureTmp
|
|
default:
|
|
var PreviousMessagesElementSignatureTmp proto_base.Void
|
|
PreviousMessagesElementSignatureTmp, err = PreviousMessagesElementSignatureTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PreviousMessagesElement.Signature = PreviousMessagesElementSignatureTmp
|
|
}
|
|
ret.Val = append(ret.Val, PreviousMessagesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PreviousMessages) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.Val)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPreviousMessages := range len(ret.Val) {
|
|
err = ret.Val[iPreviousMessages].Id.Encode(w)
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Val[iPreviousMessages].Signature.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type SoundSource struct {
|
|
Val string
|
|
}
|
|
|
|
var SoundSourceMap = map[proto_base.VarInt]string{0: "master", 1: "music", 10: "ui", 2: "record", 3: "weather", 4: "block", 5: "hostile", 6: "neutral", 7: "player", 8: "ambient", 9: "voice"}
|
|
|
|
func (_ SoundSource) Decode(r io.Reader) (ret SoundSource, err error) {
|
|
var SoundSourceKey proto_base.VarInt
|
|
SoundSourceKey, err = SoundSourceKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = proto_base.ErroringIndex(SoundSourceMap, SoundSourceKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var SoundSourceReverseMap = map[string]proto_base.VarInt{"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 proto_base.VarInt
|
|
vSoundSource, err = proto_base.ErroringIndex(SoundSourceReverseMap, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vSoundSource.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Tags struct {
|
|
Val []struct {
|
|
TagName string
|
|
Entries []proto_base.VarInt
|
|
}
|
|
}
|
|
|
|
func (_ Tags) Decode(r io.Reader) (ret Tags, err error) {
|
|
var lTags proto_base.VarInt
|
|
lTags, err = lTags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []struct {
|
|
TagName string
|
|
Entries []proto_base.VarInt
|
|
}{}
|
|
for range lTags {
|
|
var TagsElement struct {
|
|
TagName string
|
|
Entries []proto_base.VarInt
|
|
}
|
|
TagsElement.TagName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lTagsElementEntries proto_base.VarInt
|
|
lTagsElementEntries, err = lTagsElementEntries.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
TagsElement.Entries = []proto_base.VarInt{}
|
|
for range lTagsElementEntries {
|
|
var TagsElementEntriesElement proto_base.VarInt
|
|
TagsElementEntriesElement, err = TagsElementEntriesElement.Decode(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.VarInt(len(ret.Val)).Encode(w)
|
|
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.VarInt(len(ret.Val[iTags].Entries)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iTagsInnerEntries := range len(ret.Val[iTags].Entries) {
|
|
err = ret.Val[iTags].Entries[iTagsInnerEntries].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type Vec2f struct {
|
|
X float32
|
|
Y float32
|
|
}
|
|
|
|
func (_ Vec2f) Decode(r io.Reader) (ret Vec2f, 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 (_ Vec3f) Decode(r io.Reader) (ret Vec3f, 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 (_ Vec3f64) Decode(r io.Reader) (ret Vec3f64, 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 proto_base.VarInt
|
|
Y proto_base.VarInt
|
|
Z proto_base.VarInt
|
|
}
|
|
|
|
func (_ Vec3i) Decode(r io.Reader) (ret Vec3i, err error) {
|
|
ret.X, err = ret.X.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y, err = ret.Y.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z, err = ret.Z.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret Vec3i) Encode(w io.Writer) (err error) {
|
|
err = ret.X.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Y.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Z.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Vec4f struct {
|
|
X float32
|
|
Y float32
|
|
Z float32
|
|
W float32
|
|
}
|
|
|
|
func (_ Vec4f) Decode(r io.Reader) (ret Vec4f, 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 HandshakingToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var HandshakingToServerPacketNameMap = map[proto_base.VarInt]string{0x00: "set_protocol", 0xfe: "legacy_server_list_ping"}
|
|
|
|
func (_ HandshakingToServerPacket) Decode(r io.Reader) (ret HandshakingToServerPacket, err error) {
|
|
var HandshakingToServerPacketNameKey proto_base.VarInt
|
|
HandshakingToServerPacketNameKey, err = HandshakingToServerPacketNameKey.Decode(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 HandshakingToServerPacketParamsTmp HandshakingToServerPacketLegacyServerListPing
|
|
HandshakingToServerPacketParamsTmp, err = HandshakingToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = HandshakingToServerPacketParamsTmp
|
|
case "set_protocol":
|
|
var HandshakingToServerPacketParamsTmp HandshakingToServerPacketSetProtocol
|
|
HandshakingToServerPacketParamsTmp, err = HandshakingToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = HandshakingToServerPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var HandshakingToServerPacketNameReverseMap = map[string]proto_base.VarInt{"set_protocol": 0x00, "legacy_server_list_ping": 0xfe}
|
|
|
|
func (ret HandshakingToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vHandshakingToServerPacketName proto_base.VarInt
|
|
vHandshakingToServerPacketName, err = proto_base.ErroringIndex(HandshakingToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vHandshakingToServerPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "legacy_server_list_ping":
|
|
HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketLegacyServerListPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = HandshakingToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_protocol":
|
|
HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketSetProtocol)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = HandshakingToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketLegacyServerListPing struct {
|
|
Payload uint8
|
|
}
|
|
|
|
func (_ HandshakingToServerPacketLegacyServerListPing) Decode(r io.Reader) (ret HandshakingToServerPacketLegacyServerListPing, 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 proto_base.VarInt
|
|
ServerHost string
|
|
ServerPort uint16
|
|
NextState proto_base.VarInt
|
|
}
|
|
|
|
func (_ HandshakingToServerPacketSetProtocol) Decode(r io.Reader) (ret HandshakingToServerPacketSetProtocol, err error) {
|
|
ret.ProtocolVersion, err = ret.ProtocolVersion.Decode(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 = ret.NextState.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret HandshakingToServerPacketSetProtocol) Encode(w io.Writer) (err error) {
|
|
err = ret.ProtocolVersion.Encode(w)
|
|
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 = ret.NextState.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var HandshakingToClientPacketNameMap = map[proto_base.VarInt]string{}
|
|
|
|
func (_ HandshakingToClientPacket) Decode(r io.Reader) (ret HandshakingToClientPacket, err error) {
|
|
var HandshakingToClientPacketNameKey proto_base.VarInt
|
|
HandshakingToClientPacketNameKey, err = HandshakingToClientPacketNameKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(HandshakingToClientPacketNameMap, HandshakingToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var HandshakingToClientPacketNameReverseMap = map[string]proto_base.VarInt{}
|
|
|
|
func (ret HandshakingToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vHandshakingToClientPacketName proto_base.VarInt
|
|
vHandshakingToClientPacketName, err = proto_base.ErroringIndex(HandshakingToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vHandshakingToClientPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var StatusToServerPacketNameMap = map[proto_base.VarInt]string{0x00: "ping_start", 0x01: "ping"}
|
|
|
|
func (_ StatusToServerPacket) Decode(r io.Reader) (ret StatusToServerPacket, err error) {
|
|
var StatusToServerPacketNameKey proto_base.VarInt
|
|
StatusToServerPacketNameKey, err = StatusToServerPacketNameKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(StatusToServerPacketNameMap, StatusToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
var StatusToServerPacketParamsTmp StatusToServerPacketPing
|
|
StatusToServerPacketParamsTmp, err = StatusToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToServerPacketParamsTmp
|
|
case "ping_start":
|
|
var StatusToServerPacketParamsTmp StatusToServerPacketPingStart
|
|
StatusToServerPacketParamsTmp, err = StatusToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToServerPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var StatusToServerPacketNameReverseMap = map[string]proto_base.VarInt{"ping_start": 0x00, "ping": 0x01}
|
|
|
|
func (ret StatusToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vStatusToServerPacketName proto_base.VarInt
|
|
vStatusToServerPacketName, err = proto_base.ErroringIndex(StatusToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vStatusToServerPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = StatusToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping_start":
|
|
StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPingStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = StatusToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketPing struct {
|
|
Time int64
|
|
}
|
|
|
|
func (_ StatusToServerPacketPing) Decode(r io.Reader) (ret StatusToServerPacketPing, 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 (_ StatusToServerPacketPingStart) Decode(r io.Reader) (ret StatusToServerPacketPingStart, err error) {
|
|
return
|
|
}
|
|
func (ret StatusToServerPacketPingStart) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var StatusToClientPacketNameMap = map[proto_base.VarInt]string{0x00: "server_info", 0x01: "ping"}
|
|
|
|
func (_ StatusToClientPacket) Decode(r io.Reader) (ret StatusToClientPacket, err error) {
|
|
var StatusToClientPacketNameKey proto_base.VarInt
|
|
StatusToClientPacketNameKey, err = StatusToClientPacketNameKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(StatusToClientPacketNameMap, StatusToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
var StatusToClientPacketParamsTmp StatusToClientPacketPing
|
|
StatusToClientPacketParamsTmp, err = StatusToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToClientPacketParamsTmp
|
|
case "server_info":
|
|
var StatusToClientPacketParamsTmp StatusToClientPacketServerInfo
|
|
StatusToClientPacketParamsTmp, err = StatusToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToClientPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var StatusToClientPacketNameReverseMap = map[string]proto_base.VarInt{"server_info": 0x00, "ping": 0x01}
|
|
|
|
func (ret StatusToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vStatusToClientPacketName proto_base.VarInt
|
|
vStatusToClientPacketName, err = proto_base.ErroringIndex(StatusToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vStatusToClientPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = StatusToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "server_info":
|
|
StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketServerInfo)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = StatusToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketPing struct {
|
|
Time int64
|
|
}
|
|
|
|
func (_ StatusToClientPacketPing) Decode(r io.Reader) (ret StatusToClientPacketPing, 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 (_ StatusToClientPacketServerInfo) Decode(r io.Reader) (ret StatusToClientPacketServerInfo, 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 LoginToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var LoginToServerPacketNameMap = map[proto_base.VarInt]string{0x00: "login_start", 0x01: "encryption_begin", 0x02: "login_plugin_response", 0x03: "login_acknowledged", 0x04: "cookie_response"}
|
|
|
|
func (_ LoginToServerPacket) Decode(r io.Reader) (ret LoginToServerPacket, err error) {
|
|
var LoginToServerPacketNameKey proto_base.VarInt
|
|
LoginToServerPacketNameKey, err = LoginToServerPacketNameKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(LoginToServerPacketNameMap, LoginToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "cookie_response":
|
|
var LoginToServerPacketParamsTmp PacketCommonCookieResponse
|
|
LoginToServerPacketParamsTmp, err = LoginToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsTmp
|
|
case "encryption_begin":
|
|
var LoginToServerPacketParamsTmp LoginToServerPacketEncryptionBegin
|
|
LoginToServerPacketParamsTmp, err = LoginToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsTmp
|
|
case "login_acknowledged":
|
|
var LoginToServerPacketParamsTmp LoginToServerPacketLoginAcknowledged
|
|
LoginToServerPacketParamsTmp, err = LoginToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsTmp
|
|
case "login_plugin_response":
|
|
var LoginToServerPacketParamsTmp LoginToServerPacketLoginPluginResponse
|
|
LoginToServerPacketParamsTmp, err = LoginToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsTmp
|
|
case "login_start":
|
|
var LoginToServerPacketParamsTmp LoginToServerPacketLoginStart
|
|
LoginToServerPacketParamsTmp, err = LoginToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var LoginToServerPacketNameReverseMap = map[string]proto_base.VarInt{"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 proto_base.VarInt
|
|
vLoginToServerPacketName, err = proto_base.ErroringIndex(LoginToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vLoginToServerPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "cookie_response":
|
|
LoginToServerPacketParams, ok := ret.Params.(PacketCommonCookieResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "encryption_begin":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketEncryptionBegin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_acknowledged":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginAcknowledged)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_plugin_response":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginPluginResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_start":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketEncryptionBegin struct {
|
|
SharedSecret []byte
|
|
VerifyToken []byte
|
|
}
|
|
|
|
func (_ LoginToServerPacketEncryptionBegin) Decode(r io.Reader) (ret LoginToServerPacketEncryptionBegin, err error) {
|
|
var lLoginToServerPacketEncryptionBeginSharedSecret proto_base.VarInt
|
|
lLoginToServerPacketEncryptionBeginSharedSecret, err = lLoginToServerPacketEncryptionBeginSharedSecret.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SharedSecret, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginSharedSecret)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToServerPacketEncryptionBeginVerifyToken proto_base.VarInt
|
|
lLoginToServerPacketEncryptionBeginVerifyToken, err = lLoginToServerPacketEncryptionBeginVerifyToken.Decode(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.VarInt(len(ret.SharedSecret)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.SharedSecret)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.VerifyToken)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.VerifyToken)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketLoginAcknowledged struct {
|
|
}
|
|
|
|
func (_ LoginToServerPacketLoginAcknowledged) Decode(r io.Reader) (ret LoginToServerPacketLoginAcknowledged, err error) {
|
|
return
|
|
}
|
|
func (ret LoginToServerPacketLoginAcknowledged) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketLoginPluginResponse struct {
|
|
MessageId proto_base.VarInt
|
|
Data *proto_base.RestBuffer
|
|
}
|
|
|
|
func (_ LoginToServerPacketLoginPluginResponse) Decode(r io.Reader) (ret LoginToServerPacketLoginPluginResponse, err error) {
|
|
ret.MessageId, err = ret.MessageId.Decode(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
|
|
LoginToServerPacketLoginPluginResponseDataPresentValue, err = LoginToServerPacketLoginPluginResponseDataPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = &LoginToServerPacketLoginPluginResponseDataPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret LoginToServerPacketLoginPluginResponse) Encode(w io.Writer) (err error) {
|
|
err = ret.MessageId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Data != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Data != nil {
|
|
err = (*ret.Data).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketLoginStart struct {
|
|
Username string
|
|
PlayerUUID uuid.UUID
|
|
}
|
|
|
|
func (_ LoginToServerPacketLoginStart) Decode(r io.Reader) (ret LoginToServerPacketLoginStart, 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 LoginToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var LoginToClientPacketNameMap = map[proto_base.VarInt]string{0x00: "disconnect", 0x01: "encryption_begin", 0x02: "success", 0x03: "compress", 0x04: "login_plugin_request", 0x05: "cookie_request"}
|
|
|
|
func (_ LoginToClientPacket) Decode(r io.Reader) (ret LoginToClientPacket, err error) {
|
|
var LoginToClientPacketNameKey proto_base.VarInt
|
|
LoginToClientPacketNameKey, err = LoginToClientPacketNameKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(LoginToClientPacketNameMap, LoginToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "compress":
|
|
var LoginToClientPacketParamsTmp LoginToClientPacketCompress
|
|
LoginToClientPacketParamsTmp, err = LoginToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsTmp
|
|
case "cookie_request":
|
|
var LoginToClientPacketParamsTmp PacketCommonCookieRequest
|
|
LoginToClientPacketParamsTmp, err = LoginToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsTmp
|
|
case "disconnect":
|
|
var LoginToClientPacketParamsTmp LoginToClientPacketDisconnect
|
|
LoginToClientPacketParamsTmp, err = LoginToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsTmp
|
|
case "encryption_begin":
|
|
var LoginToClientPacketParamsTmp LoginToClientPacketEncryptionBegin
|
|
LoginToClientPacketParamsTmp, err = LoginToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsTmp
|
|
case "login_plugin_request":
|
|
var LoginToClientPacketParamsTmp LoginToClientPacketLoginPluginRequest
|
|
LoginToClientPacketParamsTmp, err = LoginToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsTmp
|
|
case "success":
|
|
var LoginToClientPacketParamsTmp LoginToClientPacketSuccess
|
|
LoginToClientPacketParamsTmp, err = LoginToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var LoginToClientPacketNameReverseMap = map[string]proto_base.VarInt{"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 proto_base.VarInt
|
|
vLoginToClientPacketName, err = proto_base.ErroringIndex(LoginToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vLoginToClientPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "compress":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCompress)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cookie_request":
|
|
LoginToClientPacketParams, ok := ret.Params.(PacketCommonCookieRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "disconnect":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "encryption_begin":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketEncryptionBegin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_plugin_request":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketLoginPluginRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "success":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketSuccess)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = LoginToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCompress struct {
|
|
Threshold proto_base.VarInt
|
|
}
|
|
|
|
func (_ LoginToClientPacketCompress) Decode(r io.Reader) (ret LoginToClientPacketCompress, err error) {
|
|
ret.Threshold, err = ret.Threshold.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret LoginToClientPacketCompress) Encode(w io.Writer) (err error) {
|
|
err = ret.Threshold.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketDisconnect struct {
|
|
Reason string
|
|
}
|
|
|
|
func (_ LoginToClientPacketDisconnect) Decode(r io.Reader) (ret LoginToClientPacketDisconnect, 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 (_ LoginToClientPacketEncryptionBegin) Decode(r io.Reader) (ret LoginToClientPacketEncryptionBegin, err error) {
|
|
ret.ServerId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToClientPacketEncryptionBeginPublicKey proto_base.VarInt
|
|
lLoginToClientPacketEncryptionBeginPublicKey, err = lLoginToClientPacketEncryptionBeginPublicKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PublicKey, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginPublicKey)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToClientPacketEncryptionBeginVerifyToken proto_base.VarInt
|
|
lLoginToClientPacketEncryptionBeginVerifyToken, err = lLoginToClientPacketEncryptionBeginVerifyToken.Decode(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.VarInt(len(ret.PublicKey)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.PublicKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.VerifyToken)).Encode(w)
|
|
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 proto_base.VarInt
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (_ LoginToClientPacketLoginPluginRequest) Decode(r io.Reader) (ret LoginToClientPacketLoginPluginRequest, err error) {
|
|
ret.MessageId, err = ret.MessageId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data, err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret LoginToClientPacketLoginPluginRequest) Encode(w io.Writer) (err error) {
|
|
err = ret.MessageId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketSuccess struct {
|
|
Uuid uuid.UUID
|
|
Username string
|
|
Properties []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
}
|
|
|
|
func (_ LoginToClientPacketSuccess) Decode(r io.Reader) (ret LoginToClientPacketSuccess, 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 proto_base.VarInt
|
|
lLoginToClientPacketSuccessProperties, err = lLoginToClientPacketSuccessProperties.Decode(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.VarInt(len(ret.Properties)).Encode(w)
|
|
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 ConfigurationToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var ConfigurationToServerPacketNameMap = map[proto_base.VarInt]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"}
|
|
|
|
func (_ ConfigurationToServerPacket) Decode(r io.Reader) (ret ConfigurationToServerPacket, err error) {
|
|
var ConfigurationToServerPacketNameKey proto_base.VarInt
|
|
ConfigurationToServerPacketNameKey, err = ConfigurationToServerPacketNameKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameMap, ConfigurationToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "cookie_response":
|
|
var ConfigurationToServerPacketParamsTmp PacketCommonCookieResponse
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
case "custom_click_action":
|
|
var ConfigurationToServerPacketParamsTmp PacketCommonCustomClickAction
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
case "custom_payload":
|
|
var ConfigurationToServerPacketParamsTmp ConfigurationToServerPacketCustomPayload
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
case "finish_configuration":
|
|
var ConfigurationToServerPacketParamsTmp ConfigurationToServerPacketFinishConfiguration
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
case "keep_alive":
|
|
var ConfigurationToServerPacketParamsTmp ConfigurationToServerPacketKeepAlive
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
case "pong":
|
|
var ConfigurationToServerPacketParamsTmp ConfigurationToServerPacketPong
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
case "resource_pack_receive":
|
|
var ConfigurationToServerPacketParamsTmp ConfigurationToServerPacketResourcePackReceive
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
case "select_known_packs":
|
|
var ConfigurationToServerPacketParamsTmp PacketCommonSelectKnownPacks
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
case "settings":
|
|
var ConfigurationToServerPacketParamsTmp PacketCommonSettings
|
|
ConfigurationToServerPacketParamsTmp, err = ConfigurationToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var ConfigurationToServerPacketNameReverseMap = map[string]proto_base.VarInt{"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}
|
|
|
|
func (ret ConfigurationToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vConfigurationToServerPacketName proto_base.VarInt
|
|
vConfigurationToServerPacketName, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vConfigurationToServerPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "cookie_response":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(PacketCommonCookieResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_click_action":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(PacketCommonCustomClickAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "finish_configuration":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketFinishConfiguration)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "pong":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketPong)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "resource_pack_receive":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketResourcePackReceive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_known_packs":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(PacketCommonSelectKnownPacks)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "settings":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(PacketCommonSettings)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (_ ConfigurationToServerPacketCustomPayload) Decode(r io.Reader) (ret ConfigurationToServerPacketCustomPayload, err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data, 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
|
|
}
|
|
err = ret.Data.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketFinishConfiguration struct {
|
|
}
|
|
|
|
func (_ ConfigurationToServerPacketFinishConfiguration) Decode(r io.Reader) (ret ConfigurationToServerPacketFinishConfiguration, err error) {
|
|
return
|
|
}
|
|
func (ret ConfigurationToServerPacketFinishConfiguration) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (_ ConfigurationToServerPacketKeepAlive) Decode(r io.Reader) (ret ConfigurationToServerPacketKeepAlive, 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 (_ ConfigurationToServerPacketPong) Decode(r io.Reader) (ret ConfigurationToServerPacketPong, 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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ ConfigurationToServerPacketResourcePackReceive) Decode(r io.Reader) (ret ConfigurationToServerPacketResourcePackReceive, err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Result, err = ret.Result.Decode(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 = ret.Result.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var ConfigurationToClientPacketNameMap = map[proto_base.VarInt]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"}
|
|
|
|
func (_ ConfigurationToClientPacket) Decode(r io.Reader) (ret ConfigurationToClientPacket, err error) {
|
|
var ConfigurationToClientPacketNameKey proto_base.VarInt
|
|
ConfigurationToClientPacketNameKey, err = ConfigurationToClientPacketNameKey.Decode(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 ConfigurationToClientPacketParamsTmp PacketCommonAddResourcePack
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "clear_dialog":
|
|
var ConfigurationToClientPacketParamsTmp PacketCommonClearDialog
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "cookie_request":
|
|
var ConfigurationToClientPacketParamsTmp PacketCommonCookieRequest
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "custom_payload":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketCustomPayload
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "custom_report_details":
|
|
var ConfigurationToClientPacketParamsTmp PacketCommonCustomReportDetails
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "disconnect":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketDisconnect
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "feature_flags":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketFeatureFlags
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "finish_configuration":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketFinishConfiguration
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "keep_alive":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketKeepAlive
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "ping":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketPing
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "registry_data":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketRegistryData
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "remove_resource_pack":
|
|
var ConfigurationToClientPacketParamsTmp PacketCommonRemoveResourcePack
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "reset_chat":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketResetChat
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "select_known_packs":
|
|
var ConfigurationToClientPacketParamsTmp PacketCommonSelectKnownPacks
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "server_links":
|
|
var ConfigurationToClientPacketParamsTmp PacketCommonServerLinks
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "show_dialog":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketShowDialog
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "store_cookie":
|
|
var ConfigurationToClientPacketParamsTmp PacketCommonStoreCookie
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "tags":
|
|
var ConfigurationToClientPacketParamsTmp ConfigurationToClientPacketTags
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
case "transfer":
|
|
var ConfigurationToClientPacketParamsTmp PacketCommonTransfer
|
|
ConfigurationToClientPacketParamsTmp, err = ConfigurationToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var ConfigurationToClientPacketNameReverseMap = map[string]proto_base.VarInt{"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}
|
|
|
|
func (ret ConfigurationToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vConfigurationToClientPacketName proto_base.VarInt
|
|
vConfigurationToClientPacketName, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vConfigurationToClientPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "add_resource_pack":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonAddResourcePack)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "clear_dialog":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonClearDialog)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cookie_request":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonCookieRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_report_details":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonCustomReportDetails)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "disconnect":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "feature_flags":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFeatureFlags)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "finish_configuration":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFinishConfiguration)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "registry_data":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketRegistryData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_resource_pack":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonRemoveResourcePack)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "reset_chat":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketResetChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_known_packs":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonSelectKnownPacks)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "server_links":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonServerLinks)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "show_dialog":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketShowDialog)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "store_cookie":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonStoreCookie)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tags":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketTags)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "transfer":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(PacketCommonTransfer)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (_ ConfigurationToClientPacketCustomPayload) Decode(r io.Reader) (ret ConfigurationToClientPacketCustomPayload, err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data, 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
|
|
}
|
|
err = ret.Data.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketDisconnect struct {
|
|
Reason nbt.Anon
|
|
}
|
|
|
|
func (_ ConfigurationToClientPacketDisconnect) Decode(r io.Reader) (ret ConfigurationToClientPacketDisconnect, err error) {
|
|
ret.Reason, err = ret.Reason.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret ConfigurationToClientPacketDisconnect) Encode(w io.Writer) (err error) {
|
|
err = ret.Reason.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketFeatureFlags struct {
|
|
Features []string
|
|
}
|
|
|
|
func (_ ConfigurationToClientPacketFeatureFlags) Decode(r io.Reader) (ret ConfigurationToClientPacketFeatureFlags, err error) {
|
|
var lConfigurationToClientPacketFeatureFlagsFeatures proto_base.VarInt
|
|
lConfigurationToClientPacketFeatureFlagsFeatures, err = lConfigurationToClientPacketFeatureFlagsFeatures.Decode(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.VarInt(len(ret.Features)).Encode(w)
|
|
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 (_ ConfigurationToClientPacketFinishConfiguration) Decode(r io.Reader) (ret ConfigurationToClientPacketFinishConfiguration, err error) {
|
|
return
|
|
}
|
|
func (ret ConfigurationToClientPacketFinishConfiguration) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (_ ConfigurationToClientPacketKeepAlive) Decode(r io.Reader) (ret ConfigurationToClientPacketKeepAlive, 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 (_ ConfigurationToClientPacketPing) Decode(r io.Reader) (ret ConfigurationToClientPacketPing, 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 (_ ConfigurationToClientPacketRegistryData) Decode(r io.Reader) (ret ConfigurationToClientPacketRegistryData, err error) {
|
|
ret.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lConfigurationToClientPacketRegistryDataEntries proto_base.VarInt
|
|
lConfigurationToClientPacketRegistryDataEntries, err = lConfigurationToClientPacketRegistryDataEntries.Decode(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
|
|
ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue, 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.VarInt(len(ret.Entries)).Encode(w)
|
|
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 {
|
|
err = (*ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketResetChat struct {
|
|
}
|
|
|
|
func (_ ConfigurationToClientPacketResetChat) Decode(r io.Reader) (ret ConfigurationToClientPacketResetChat, err error) {
|
|
return
|
|
}
|
|
func (ret ConfigurationToClientPacketResetChat) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketShowDialog struct {
|
|
Dialog nbt.Anon
|
|
}
|
|
|
|
func (_ ConfigurationToClientPacketShowDialog) Decode(r io.Reader) (ret ConfigurationToClientPacketShowDialog, err error) {
|
|
ret.Dialog, err = ret.Dialog.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret ConfigurationToClientPacketShowDialog) Encode(w io.Writer) (err error) {
|
|
err = ret.Dialog.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketTags struct {
|
|
Tags []struct {
|
|
TagType string
|
|
Tags Tags
|
|
}
|
|
}
|
|
|
|
func (_ ConfigurationToClientPacketTags) Decode(r io.Reader) (ret ConfigurationToClientPacketTags, err error) {
|
|
var lConfigurationToClientPacketTagsTags proto_base.VarInt
|
|
lConfigurationToClientPacketTagsTags, err = lConfigurationToClientPacketTagsTags.Decode(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
|
|
}
|
|
ConfigurationToClientPacketTagsTagsElement.Tags, 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.VarInt(len(ret.Tags)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iConfigurationToClientPacketTagsTags := range len(ret.Tags) {
|
|
err = proto_base.EncodeString(w, ret.Tags[iConfigurationToClientPacketTagsTags].TagType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Tags[iConfigurationToClientPacketTagsTags].Tags.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerMovementFlags struct {
|
|
Val uint8
|
|
}
|
|
|
|
func (_ PlayToServerMovementFlags) Decode(r io.Reader) (ret PlayToServerMovementFlags, 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[proto_base.VarInt]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_sample_subscription", 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 (_ PlayToServerPacket) Decode(r io.Reader) (ret PlayToServerPacket, err error) {
|
|
var PlayToServerPacketNameKey proto_base.VarInt
|
|
PlayToServerPacketNameKey, err = PlayToServerPacketNameKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(PlayToServerPacketNameMap, PlayToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketAbilities
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "advancement_tab":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketAdvancementTab
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "arm_animation":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketArmAnimation
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "block_dig":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketBlockDig
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "block_place":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketBlockPlace
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "change_gamemode":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketChangeGamemode
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "chat_command":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketChatCommand
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "chat_command_signed":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketChatCommandSigned
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "chat_message":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketChatMessage
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "chat_session_update":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketChatSessionUpdate
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "chunk_batch_received":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketChunkBatchReceived
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "client_command":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketClientCommand
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "close_window":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketCloseWindow
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "configuration_acknowledged":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketConfigurationAcknowledged
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "cookie_response":
|
|
var PlayToServerPacketParamsTmp PacketCommonCookieResponse
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "craft_recipe_request":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketCraftRecipeRequest
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "custom_click_action":
|
|
var PlayToServerPacketParamsTmp PacketCommonCustomClickAction
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "custom_payload":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketCustomPayload
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "debug_sample_subscription":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketDebugSampleSubscription
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "displayed_recipe":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketDisplayedRecipe
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "edit_book":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketEditBook
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "enchant_item":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketEnchantItem
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "entity_action":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketEntityAction
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "flying":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketFlying
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "generate_structure":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketGenerateStructure
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "held_item_slot":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketHeldItemSlot
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "keep_alive":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketKeepAlive
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "lock_difficulty":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketLockDifficulty
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "look":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketLook
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "message_acknowledgement":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketMessageAcknowledgement
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "name_item":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketNameItem
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "pick_item_from_block":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketPickItemFromBlock
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "pick_item_from_entity":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketPickItemFromEntity
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "ping_request":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketPingRequest
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "player_input":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketPlayerInput
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "player_loaded":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketPlayerLoaded
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "pong":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketPong
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "position":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketPosition
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "position_look":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketPositionLook
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "query_block_nbt":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketQueryBlockNbt
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "query_entity_nbt":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketQueryEntityNbt
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "recipe_book":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketRecipeBook
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "resource_pack_receive":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketResourcePackReceive
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "select_bundle_item":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSelectBundleItem
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "select_trade":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSelectTrade
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "set_beacon_effect":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSetBeaconEffect
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "set_creative_slot":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSetCreativeSlot
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "set_difficulty":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSetDifficulty
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "set_slot_state":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSetSlotState
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "set_test_block":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSetTestBlock
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "settings":
|
|
var PlayToServerPacketParamsTmp PacketCommonSettings
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "spectate":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSpectate
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "steer_boat":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketSteerBoat
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "tab_complete":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketTabComplete
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "teleport_confirm":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketTeleportConfirm
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "test_instance_block_action":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketTestInstanceBlockAction
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "tick_end":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketTickEnd
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "update_command_block":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketUpdateCommandBlock
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "update_command_block_minecart":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketUpdateCommandBlockMinecart
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "update_jigsaw_block":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketUpdateJigsawBlock
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "update_sign":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketUpdateSign
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "update_structure_block":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketUpdateStructureBlock
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "use_entity":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketUseEntity
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "use_item":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketUseItem
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "vehicle_move":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketVehicleMove
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
case "window_click":
|
|
var PlayToServerPacketParamsTmp PlayToServerPacketWindowClick
|
|
PlayToServerPacketParamsTmp, err = PlayToServerPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToServerPacketNameReverseMap = map[string]proto_base.VarInt{"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_sample_subscription": 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 proto_base.VarInt
|
|
vPlayToServerPacketName, err = proto_base.ErroringIndex(PlayToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToServerPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAbilities)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "advancement_tab":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAdvancementTab)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "arm_animation":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketArmAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_dig":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockDig)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_place":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockPlace)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "change_gamemode":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChangeGamemode)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_command":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommand)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_command_signed":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommandSigned)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_message":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatMessage)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_session_update":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatSessionUpdate)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chunk_batch_received":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChunkBatchReceived)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "client_command":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketClientCommand)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "close_window":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCloseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "configuration_acknowledged":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketConfigurationAcknowledged)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cookie_response":
|
|
PlayToServerPacketParams, ok := ret.Params.(PacketCommonCookieResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_recipe_request":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftRecipeRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_click_action":
|
|
PlayToServerPacketParams, ok := ret.Params.(PacketCommonCustomClickAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "debug_sample_subscription":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDebugSampleSubscription)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "displayed_recipe":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDisplayedRecipe)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "edit_book":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEditBook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "enchant_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEnchantItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_action":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEntityAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "flying":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketFlying)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "generate_structure":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketGenerateStructure)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "held_item_slot":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketHeldItemSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "lock_difficulty":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLockDifficulty)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "look":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "message_acknowledgement":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketMessageAcknowledgement)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "name_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketNameItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "pick_item_from_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItemFromBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "pick_item_from_entity":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItemFromEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping_request":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPingRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_input":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPlayerInput)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_loaded":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPlayerLoaded)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "pong":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPong)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position_look":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPositionLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "query_block_nbt":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryBlockNbt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "query_entity_nbt":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryEntityNbt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "recipe_book":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketRecipeBook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "resource_pack_receive":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketResourcePackReceive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_bundle_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectBundleItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_trade":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectTrade)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_beacon_effect":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetBeaconEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_creative_slot":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetCreativeSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_difficulty":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetDifficulty)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_slot_state":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetSlotState)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_test_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetTestBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "settings":
|
|
PlayToServerPacketParams, ok := ret.Params.(PacketCommonSettings)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spectate":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSpectate)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "steer_boat":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerBoat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tab_complete":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTabComplete)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "teleport_confirm":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTeleportConfirm)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "test_instance_block_action":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTestInstanceBlockAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tick_end":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTickEnd)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_command_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_command_block_minecart":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlockMinecart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_jigsaw_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateJigsawBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_sign":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateSign)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_structure_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateStructureBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "use_entity":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "use_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vehicle_move":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketVehicleMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "window_click":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketWindowClick)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketAbilities struct {
|
|
Flags int8
|
|
}
|
|
|
|
func (_ PlayToServerPacketAbilities) Decode(r io.Reader) (ret PlayToServerPacketAbilities, 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 proto_base.VarInt
|
|
TabId any
|
|
}
|
|
|
|
func (_ PlayToServerPacketAdvancementTab) Decode(r io.Reader) (ret PlayToServerPacketAdvancementTab, err error) {
|
|
ret.Action, err = ret.Action.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToServerPacketAdvancementTabTabIdTmp string
|
|
PlayToServerPacketAdvancementTabTabIdTmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TabId = PlayToServerPacketAdvancementTabTabIdTmp
|
|
case 1:
|
|
var PlayToServerPacketAdvancementTabTabIdTmp proto_base.Void
|
|
PlayToServerPacketAdvancementTabTabIdTmp, err = PlayToServerPacketAdvancementTabTabIdTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TabId = PlayToServerPacketAdvancementTabTabIdTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketAdvancementTab) Encode(w io.Writer) (err error) {
|
|
err = ret.Action.Encode(w)
|
|
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:
|
|
PlayToServerPacketAdvancementTabTabId, ok := ret.TabId.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketAdvancementTabTabId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketArmAnimation struct {
|
|
Hand proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketArmAnimation) Decode(r io.Reader) (ret PlayToServerPacketArmAnimation, err error) {
|
|
ret.Hand, err = ret.Hand.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketArmAnimation) Encode(w io.Writer) (err error) {
|
|
err = ret.Hand.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketBlockDig struct {
|
|
Status proto_base.VarInt
|
|
Location Position
|
|
Face int8
|
|
Sequence proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketBlockDig) Decode(r io.Reader) (ret PlayToServerPacketBlockDig, err error) {
|
|
ret.Status, err = ret.Status.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Face)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sequence, err = ret.Sequence.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketBlockDig) Encode(w io.Writer) (err error) {
|
|
err = ret.Status.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Face)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Sequence.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketBlockPlace struct {
|
|
Hand proto_base.VarInt
|
|
Location Position
|
|
Direction proto_base.VarInt
|
|
CursorX float32
|
|
CursorY float32
|
|
CursorZ float32
|
|
InsideBlock bool
|
|
WorldBorderHit bool
|
|
Sequence proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketBlockPlace) Decode(r io.Reader) (ret PlayToServerPacketBlockPlace, err error) {
|
|
ret.Hand, err = ret.Hand.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Direction, err = ret.Direction.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
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 = ret.Sequence.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketBlockPlace) Encode(w io.Writer) (err error) {
|
|
err = ret.Hand.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Direction.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
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 = ret.Sequence.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChangeGamemode struct {
|
|
Mode string
|
|
}
|
|
|
|
var PlayToServerPacketChangeGamemodeModeMap = map[proto_base.VarInt]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"}
|
|
|
|
func (_ PlayToServerPacketChangeGamemode) Decode(r io.Reader) (ret PlayToServerPacketChangeGamemode, err error) {
|
|
var PlayToServerPacketChangeGamemodeModeKey proto_base.VarInt
|
|
PlayToServerPacketChangeGamemodeModeKey, err = PlayToServerPacketChangeGamemodeModeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = proto_base.ErroringIndex(PlayToServerPacketChangeGamemodeModeMap, PlayToServerPacketChangeGamemodeModeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToServerPacketChangeGamemodeModeReverseMap = map[string]proto_base.VarInt{"survival": 0, "creative": 1, "adventure": 2, "spectator": 3}
|
|
|
|
func (ret PlayToServerPacketChangeGamemode) Encode(w io.Writer) (err error) {
|
|
var vPlayToServerPacketChangeGamemodeMode proto_base.VarInt
|
|
vPlayToServerPacketChangeGamemodeMode, err = proto_base.ErroringIndex(PlayToServerPacketChangeGamemodeModeReverseMap, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToServerPacketChangeGamemodeMode.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChatCommand struct {
|
|
Command string
|
|
}
|
|
|
|
func (_ PlayToServerPacketChatCommand) Decode(r io.Reader) (ret PlayToServerPacketChatCommand, 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 proto_base.VarInt
|
|
Acknowledged [3]byte
|
|
Checksum int8
|
|
}
|
|
|
|
func (_ PlayToServerPacketChatCommandSigned) Decode(r io.Reader) (ret PlayToServerPacketChatCommandSigned, 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 proto_base.VarInt
|
|
lPlayToServerPacketChatCommandSignedArgumentSignatures, err = lPlayToServerPacketChatCommandSignedArgumentSignatures.Decode(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 = ret.MessageCount.Decode(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.VarInt(len(ret.ArgumentSignatures)).Encode(w)
|
|
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 = ret.MessageCount.Encode(w)
|
|
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 proto_base.VarInt
|
|
Acknowledged [3]byte
|
|
Checksum uint8
|
|
}
|
|
|
|
func (_ PlayToServerPacketChatMessage) Decode(r io.Reader) (ret PlayToServerPacketChatMessage, 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 = ret.Offset.Decode(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 = ret.Offset.Encode(w)
|
|
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 (_ PlayToServerPacketChatSessionUpdate) Decode(r io.Reader) (ret PlayToServerPacketChatSessionUpdate, err error) {
|
|
_, err = io.ReadFull(r, ret.SessionUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ExpireTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PublicKey, err = ret.PublicKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Signature, 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
|
|
}
|
|
err = ret.PublicKey.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Signature.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChunkBatchReceived struct {
|
|
ChunksPerTick float32
|
|
}
|
|
|
|
func (_ PlayToServerPacketChunkBatchReceived) Decode(r io.Reader) (ret PlayToServerPacketChunkBatchReceived, 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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketClientCommand) Decode(r io.Reader) (ret PlayToServerPacketClientCommand, err error) {
|
|
ret.ActionId, err = ret.ActionId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketClientCommand) Encode(w io.Writer) (err error) {
|
|
err = ret.ActionId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCloseWindow struct {
|
|
WindowId ContainerID
|
|
}
|
|
|
|
func (_ PlayToServerPacketCloseWindow) Decode(r io.Reader) (ret PlayToServerPacketCloseWindow, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketCloseWindow) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketConfigurationAcknowledged struct {
|
|
}
|
|
|
|
func (_ PlayToServerPacketConfigurationAcknowledged) Decode(r io.Reader) (ret PlayToServerPacketConfigurationAcknowledged, err error) {
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketConfigurationAcknowledged) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCraftRecipeRequest struct {
|
|
WindowId ContainerID
|
|
RecipeId proto_base.VarInt
|
|
MakeAll bool
|
|
}
|
|
|
|
func (_ PlayToServerPacketCraftRecipeRequest) Decode(r io.Reader) (ret PlayToServerPacketCraftRecipeRequest, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RecipeId, err = ret.RecipeId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.MakeAll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketCraftRecipeRequest) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.RecipeId.Encode(w)
|
|
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 (_ PlayToServerPacketCustomPayload) Decode(r io.Reader) (ret PlayToServerPacketCustomPayload, err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data, 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
|
|
}
|
|
err = ret.Data.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketDebugSampleSubscription struct {
|
|
Type proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketDebugSampleSubscription) Decode(r io.Reader) (ret PlayToServerPacketDebugSampleSubscription, err error) {
|
|
ret.Type, err = ret.Type.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketDebugSampleSubscription) Encode(w io.Writer) (err error) {
|
|
err = ret.Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketDisplayedRecipe struct {
|
|
RecipeId proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketDisplayedRecipe) Decode(r io.Reader) (ret PlayToServerPacketDisplayedRecipe, err error) {
|
|
ret.RecipeId, err = ret.RecipeId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketDisplayedRecipe) Encode(w io.Writer) (err error) {
|
|
err = ret.RecipeId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEditBook struct {
|
|
Hand proto_base.VarInt
|
|
Pages []string
|
|
Title *string
|
|
}
|
|
|
|
func (_ PlayToServerPacketEditBook) Decode(r io.Reader) (ret PlayToServerPacketEditBook, err error) {
|
|
ret.Hand, err = ret.Hand.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToServerPacketEditBookPages proto_base.VarInt
|
|
lPlayToServerPacketEditBookPages, err = lPlayToServerPacketEditBookPages.Decode(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 = ret.Hand.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Pages)).Encode(w)
|
|
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 int8
|
|
}
|
|
|
|
func (_ PlayToServerPacketEnchantItem) Decode(r io.Reader) (ret PlayToServerPacketEnchantItem, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Enchantment)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketEnchantItem) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Enchantment)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEntityAction struct {
|
|
EntityId proto_base.VarInt
|
|
ActionId string
|
|
JumpBoost proto_base.VarInt
|
|
}
|
|
|
|
var PlayToServerPacketEntityActionActionIdMap = map[proto_base.VarInt]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 (_ PlayToServerPacketEntityAction) Decode(r io.Reader) (ret PlayToServerPacketEntityAction, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToServerPacketEntityActionActionIdKey proto_base.VarInt
|
|
PlayToServerPacketEntityActionActionIdKey, err = PlayToServerPacketEntityActionActionIdKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ActionId, err = proto_base.ErroringIndex(PlayToServerPacketEntityActionActionIdMap, PlayToServerPacketEntityActionActionIdKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.JumpBoost, err = ret.JumpBoost.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToServerPacketEntityActionActionIdReverseMap = map[string]proto_base.VarInt{"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 = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vPlayToServerPacketEntityActionActionId proto_base.VarInt
|
|
vPlayToServerPacketEntityActionActionId, err = proto_base.ErroringIndex(PlayToServerPacketEntityActionActionIdReverseMap, ret.ActionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToServerPacketEntityActionActionId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.JumpBoost.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketFlying struct {
|
|
Flags PlayToServerMovementFlags
|
|
}
|
|
|
|
func (_ PlayToServerPacketFlying) Decode(r io.Reader) (ret PlayToServerPacketFlying, err error) {
|
|
ret.Flags, err = ret.Flags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketFlying) Encode(w io.Writer) (err error) {
|
|
err = ret.Flags.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketGenerateStructure struct {
|
|
Location Position
|
|
Levels proto_base.VarInt
|
|
KeepJigsaws bool
|
|
}
|
|
|
|
func (_ PlayToServerPacketGenerateStructure) Decode(r io.Reader) (ret PlayToServerPacketGenerateStructure, err error) {
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Levels, err = ret.Levels.Decode(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) {
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Levels.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepJigsaws)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketHeldItemSlot struct {
|
|
SlotId int16
|
|
}
|
|
|
|
func (_ PlayToServerPacketHeldItemSlot) Decode(r io.Reader) (ret PlayToServerPacketHeldItemSlot, 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 (_ PlayToServerPacketKeepAlive) Decode(r io.Reader) (ret PlayToServerPacketKeepAlive, 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 (_ PlayToServerPacketLockDifficulty) Decode(r io.Reader) (ret PlayToServerPacketLockDifficulty, 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 (_ PlayToServerPacketLook) Decode(r io.Reader) (ret PlayToServerPacketLook, 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
|
|
}
|
|
ret.Flags, 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
|
|
}
|
|
err = ret.Flags.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketMessageAcknowledgement struct {
|
|
Count proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketMessageAcknowledgement) Decode(r io.Reader) (ret PlayToServerPacketMessageAcknowledgement, err error) {
|
|
ret.Count, err = ret.Count.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketMessageAcknowledgement) Encode(w io.Writer) (err error) {
|
|
err = ret.Count.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketNameItem struct {
|
|
Name string
|
|
}
|
|
|
|
func (_ PlayToServerPacketNameItem) Decode(r io.Reader) (ret PlayToServerPacketNameItem, 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 (_ PlayToServerPacketPickItemFromBlock) Decode(r io.Reader) (ret PlayToServerPacketPickItemFromBlock, err error) {
|
|
ret.Position, 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) {
|
|
err = ret.Position.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IncludeData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPickItemFromEntity struct {
|
|
EntityId proto_base.VarInt
|
|
IncludeData bool
|
|
}
|
|
|
|
func (_ PlayToServerPacketPickItemFromEntity) Decode(r io.Reader) (ret PlayToServerPacketPickItemFromEntity, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(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 = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IncludeData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPingRequest struct {
|
|
Id int64
|
|
}
|
|
|
|
func (_ PlayToServerPacketPingRequest) Decode(r io.Reader) (ret PlayToServerPacketPingRequest, 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 (_ PlayToServerPacketPlayerInput) Decode(r io.Reader) (ret PlayToServerPacketPlayerInput, 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 (_ PlayToServerPacketPlayerLoaded) Decode(r io.Reader) (ret PlayToServerPacketPlayerLoaded, err error) {
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketPlayerLoaded) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPong struct {
|
|
Id int32
|
|
}
|
|
|
|
func (_ PlayToServerPacketPong) Decode(r io.Reader) (ret PlayToServerPacketPong, 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 (_ PlayToServerPacketPosition) Decode(r io.Reader) (ret PlayToServerPacketPosition, 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
|
|
}
|
|
ret.Flags, 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
|
|
}
|
|
err = ret.Flags.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPositionLook struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
Flags PlayToServerMovementFlags
|
|
}
|
|
|
|
func (_ PlayToServerPacketPositionLook) Decode(r io.Reader) (ret PlayToServerPacketPositionLook, 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
|
|
}
|
|
ret.Flags, 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
|
|
}
|
|
err = ret.Flags.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketQueryBlockNbt struct {
|
|
TransactionId proto_base.VarInt
|
|
Location Position
|
|
}
|
|
|
|
func (_ PlayToServerPacketQueryBlockNbt) Decode(r io.Reader) (ret PlayToServerPacketQueryBlockNbt, err error) {
|
|
ret.TransactionId, err = ret.TransactionId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketQueryBlockNbt) Encode(w io.Writer) (err error) {
|
|
err = ret.TransactionId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketQueryEntityNbt struct {
|
|
TransactionId proto_base.VarInt
|
|
EntityId proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketQueryEntityNbt) Decode(r io.Reader) (ret PlayToServerPacketQueryEntityNbt, err error) {
|
|
ret.TransactionId, err = ret.TransactionId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketQueryEntityNbt) Encode(w io.Writer) (err error) {
|
|
err = ret.TransactionId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketRecipeBook struct {
|
|
BookId proto_base.VarInt
|
|
BookOpen bool
|
|
FilterActive bool
|
|
}
|
|
|
|
func (_ PlayToServerPacketRecipeBook) Decode(r io.Reader) (ret PlayToServerPacketRecipeBook, err error) {
|
|
ret.BookId, err = ret.BookId.Decode(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 = ret.BookId.Encode(w)
|
|
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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketResourcePackReceive) Decode(r io.Reader) (ret PlayToServerPacketResourcePackReceive, err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Result, err = ret.Result.Decode(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 = ret.Result.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSelectBundleItem struct {
|
|
SlotId proto_base.VarInt
|
|
SelectedItemIndex proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketSelectBundleItem) Decode(r io.Reader) (ret PlayToServerPacketSelectBundleItem, err error) {
|
|
ret.SlotId, err = ret.SlotId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SelectedItemIndex, err = ret.SelectedItemIndex.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketSelectBundleItem) Encode(w io.Writer) (err error) {
|
|
err = ret.SlotId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SelectedItemIndex.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSelectTrade struct {
|
|
Slot proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketSelectTrade) Decode(r io.Reader) (ret PlayToServerPacketSelectTrade, err error) {
|
|
ret.Slot, err = ret.Slot.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketSelectTrade) Encode(w io.Writer) (err error) {
|
|
err = ret.Slot.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetBeaconEffect struct {
|
|
PrimaryEffect *proto_base.VarInt
|
|
SecondaryEffect *proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketSetBeaconEffect) Decode(r io.Reader) (ret PlayToServerPacketSetBeaconEffect, err error) {
|
|
var PlayToServerPacketSetBeaconEffectPrimaryEffectPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectPrimaryEffectPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketSetBeaconEffectPrimaryEffectPresent {
|
|
var PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue proto_base.VarInt
|
|
PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue, err = PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue.Decode(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 proto_base.VarInt
|
|
PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue, err = PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue.Decode(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 = (*ret.PrimaryEffect).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SecondaryEffect != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.SecondaryEffect != nil {
|
|
err = (*ret.SecondaryEffect).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetCreativeSlot struct {
|
|
Slot int16
|
|
Item UntrustedSlot
|
|
}
|
|
|
|
func (_ PlayToServerPacketSetCreativeSlot) Decode(r io.Reader) (ret PlayToServerPacketSetCreativeSlot, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Item, 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
|
|
}
|
|
err = ret.Item.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetDifficulty struct {
|
|
NewDifficulty string
|
|
}
|
|
|
|
var PlayToServerPacketSetDifficultyNewDifficultyMap = map[proto_base.VarInt]string{0: "peaceful", 1: "easy", 2: "normal", 3: "hard"}
|
|
|
|
func (_ PlayToServerPacketSetDifficulty) Decode(r io.Reader) (ret PlayToServerPacketSetDifficulty, err error) {
|
|
var PlayToServerPacketSetDifficultyNewDifficultyKey proto_base.VarInt
|
|
PlayToServerPacketSetDifficultyNewDifficultyKey, err = PlayToServerPacketSetDifficultyNewDifficultyKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NewDifficulty, err = proto_base.ErroringIndex(PlayToServerPacketSetDifficultyNewDifficultyMap, PlayToServerPacketSetDifficultyNewDifficultyKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToServerPacketSetDifficultyNewDifficultyReverseMap = map[string]proto_base.VarInt{"peaceful": 0, "easy": 1, "normal": 2, "hard": 3}
|
|
|
|
func (ret PlayToServerPacketSetDifficulty) Encode(w io.Writer) (err error) {
|
|
var vPlayToServerPacketSetDifficultyNewDifficulty proto_base.VarInt
|
|
vPlayToServerPacketSetDifficultyNewDifficulty, err = proto_base.ErroringIndex(PlayToServerPacketSetDifficultyNewDifficultyReverseMap, ret.NewDifficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToServerPacketSetDifficultyNewDifficulty.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetSlotState struct {
|
|
SlotId proto_base.VarInt
|
|
WindowId ContainerID
|
|
State bool
|
|
}
|
|
|
|
func (_ PlayToServerPacketSetSlotState) Decode(r io.Reader) (ret PlayToServerPacketSetSlotState, err error) {
|
|
ret.SlotId, err = ret.SlotId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WindowId, 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 = ret.SlotId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.WindowId.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 proto_base.VarInt
|
|
Message string
|
|
}
|
|
|
|
func (_ PlayToServerPacketSetTestBlock) Decode(r io.Reader) (ret PlayToServerPacketSetTestBlock, err error) {
|
|
ret.Position, err = ret.Position.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = ret.Mode.Decode(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) {
|
|
err = ret.Position.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Mode.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Message)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSpectate struct {
|
|
Target uuid.UUID
|
|
}
|
|
|
|
func (_ PlayToServerPacketSpectate) Decode(r io.Reader) (ret PlayToServerPacketSpectate, 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 (_ PlayToServerPacketSteerBoat) Decode(r io.Reader) (ret PlayToServerPacketSteerBoat, 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 proto_base.VarInt
|
|
Text string
|
|
}
|
|
|
|
func (_ PlayToServerPacketTabComplete) Decode(r io.Reader) (ret PlayToServerPacketTabComplete, err error) {
|
|
ret.TransactionId, err = ret.TransactionId.Decode(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 = ret.TransactionId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTeleportConfirm struct {
|
|
TeleportId proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketTeleportConfirm) Decode(r io.Reader) (ret PlayToServerPacketTeleportConfirm, err error) {
|
|
ret.TeleportId, err = ret.TeleportId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketTeleportConfirm) Encode(w io.Writer) (err error) {
|
|
err = ret.TeleportId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTestInstanceBlockAction struct {
|
|
Pos Position
|
|
Action proto_base.VarInt
|
|
Data struct {
|
|
Test *string
|
|
Size Vec3i
|
|
Rotation proto_base.VarInt
|
|
IgnoreEntities bool
|
|
Status proto_base.VarInt
|
|
ErrorMessage *nbt.Anon
|
|
}
|
|
}
|
|
|
|
func (_ PlayToServerPacketTestInstanceBlockAction) Decode(r io.Reader) (ret PlayToServerPacketTestInstanceBlockAction, err error) {
|
|
ret.Pos, err = ret.Pos.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = ret.Action.Decode(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
|
|
}
|
|
ret.Data.Size, err = ret.Data.Size.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data.Rotation, err = ret.Data.Rotation.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Data.IgnoreEntities)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data.Status, err = ret.Data.Status.Decode(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
|
|
PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue, err = PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data.ErrorMessage = &PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketTestInstanceBlockAction) Encode(w io.Writer) (err error) {
|
|
err = ret.Pos.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Action.Encode(w)
|
|
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
|
|
}
|
|
}
|
|
err = ret.Data.Size.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Rotation.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Data.IgnoreEntities)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Status.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Data.ErrorMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Data.ErrorMessage != nil {
|
|
err = (*ret.Data.ErrorMessage).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTickEnd struct {
|
|
}
|
|
|
|
func (_ PlayToServerPacketTickEnd) Decode(r io.Reader) (ret PlayToServerPacketTickEnd, err error) {
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketTickEnd) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateCommandBlock struct {
|
|
Location Position
|
|
Command string
|
|
Mode proto_base.VarInt
|
|
Flags uint8
|
|
}
|
|
|
|
func (_ PlayToServerPacketUpdateCommandBlock) Decode(r io.Reader) (ret PlayToServerPacketUpdateCommandBlock, err error) {
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Command, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = ret.Mode.Decode(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) {
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Command)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Mode.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateCommandBlockMinecart struct {
|
|
EntityId proto_base.VarInt
|
|
Command string
|
|
TrackOutput bool
|
|
}
|
|
|
|
func (_ PlayToServerPacketUpdateCommandBlockMinecart) Decode(r io.Reader) (ret PlayToServerPacketUpdateCommandBlockMinecart, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(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 = ret.EntityId.Encode(w)
|
|
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 proto_base.VarInt
|
|
PlacementPriority proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToServerPacketUpdateJigsawBlock) Decode(r io.Reader) (ret PlayToServerPacketUpdateJigsawBlock, err error) {
|
|
ret.Location, 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 = ret.SelectionPriority.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PlacementPriority, err = ret.PlacementPriority.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketUpdateJigsawBlock) Encode(w io.Writer) (err error) {
|
|
err = ret.Location.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 = ret.SelectionPriority.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.PlacementPriority.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateSign struct {
|
|
Location Position
|
|
IsFrontText bool
|
|
Text1 string
|
|
Text2 string
|
|
Text3 string
|
|
Text4 string
|
|
}
|
|
|
|
func (_ PlayToServerPacketUpdateSign) Decode(r io.Reader) (ret PlayToServerPacketUpdateSign, err error) {
|
|
ret.Location, 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) {
|
|
err = ret.Location.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 proto_base.VarInt
|
|
Mode proto_base.VarInt
|
|
Name string
|
|
OffsetX int8
|
|
OffsetY int8
|
|
OffsetZ int8
|
|
SizeX int8
|
|
SizeY int8
|
|
SizeZ int8
|
|
Mirror proto_base.VarInt
|
|
Rotation proto_base.VarInt
|
|
Metadata string
|
|
Integrity float32
|
|
Seed proto_base.VarInt
|
|
Flags string
|
|
}
|
|
|
|
var PlayToServerPacketUpdateStructureBlockFlagsMap = map[uint8]string{0: "ignore_entities", 1: "show_air", 2: "show_bounding_box", 3: "strict"}
|
|
|
|
func (_ PlayToServerPacketUpdateStructureBlock) Decode(r io.Reader) (ret PlayToServerPacketUpdateStructureBlock, err error) {
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = ret.Action.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = ret.Mode.Decode(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 = ret.Mirror.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rotation, err = ret.Rotation.Decode(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 = ret.Seed.Decode(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) {
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Action.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Mode.Encode(w)
|
|
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 = ret.Mirror.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Rotation.Encode(w)
|
|
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 = ret.Seed.Encode(w)
|
|
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 proto_base.VarInt
|
|
Mouse proto_base.VarInt
|
|
X any
|
|
Y any
|
|
Z any
|
|
Hand any
|
|
Sneaking bool
|
|
}
|
|
|
|
func (_ PlayToServerPacketUseEntity) Decode(r io.Reader) (ret PlayToServerPacketUseEntity, err error) {
|
|
ret.Target, err = ret.Target.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mouse, err = ret.Mouse.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityXTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityXTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToServerPacketUseEntityXTmp
|
|
default:
|
|
var PlayToServerPacketUseEntityXTmp proto_base.Void
|
|
PlayToServerPacketUseEntityXTmp, err = PlayToServerPacketUseEntityXTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToServerPacketUseEntityXTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityYTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityYTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToServerPacketUseEntityYTmp
|
|
default:
|
|
var PlayToServerPacketUseEntityYTmp proto_base.Void
|
|
PlayToServerPacketUseEntityYTmp, err = PlayToServerPacketUseEntityYTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToServerPacketUseEntityYTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityZTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityZTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToServerPacketUseEntityZTmp
|
|
default:
|
|
var PlayToServerPacketUseEntityZTmp proto_base.Void
|
|
PlayToServerPacketUseEntityZTmp, err = PlayToServerPacketUseEntityZTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToServerPacketUseEntityZTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 0:
|
|
var PlayToServerPacketUseEntityHandTmp proto_base.VarInt
|
|
PlayToServerPacketUseEntityHandTmp, err = PlayToServerPacketUseEntityHandTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHandTmp
|
|
case 2:
|
|
var PlayToServerPacketUseEntityHandTmp proto_base.VarInt
|
|
PlayToServerPacketUseEntityHandTmp, err = PlayToServerPacketUseEntityHandTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHandTmp
|
|
default:
|
|
var PlayToServerPacketUseEntityHandTmp proto_base.Void
|
|
PlayToServerPacketUseEntityHandTmp, err = PlayToServerPacketUseEntityHandTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
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 = ret.Target.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Mouse.Encode(w)
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.X.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Y.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Z.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 0:
|
|
PlayToServerPacketUseEntityHand, ok := ret.Hand.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketUseEntityHand.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToServerPacketUseEntityHand, ok := ret.Hand.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToServerPacketUseEntityHand.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Hand.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Hand.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Sneaking)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUseItem struct {
|
|
Hand proto_base.VarInt
|
|
Sequence proto_base.VarInt
|
|
Rotation Vec2f
|
|
}
|
|
|
|
func (_ PlayToServerPacketUseItem) Decode(r io.Reader) (ret PlayToServerPacketUseItem, err error) {
|
|
ret.Hand, err = ret.Hand.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sequence, err = ret.Sequence.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rotation, err = ret.Rotation.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketUseItem) Encode(w io.Writer) (err error) {
|
|
err = ret.Hand.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Sequence.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Rotation.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketVehicleMove struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
OnGround bool
|
|
}
|
|
|
|
func (_ PlayToServerPacketVehicleMove) Decode(r io.Reader) (ret PlayToServerPacketVehicleMove, 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 proto_base.VarInt
|
|
Slot int16
|
|
MouseButton int8
|
|
Mode proto_base.VarInt
|
|
ChangedSlots []struct {
|
|
Location int16
|
|
Item *HashedSlot
|
|
}
|
|
CursorItem *HashedSlot
|
|
}
|
|
|
|
func (_ PlayToServerPacketWindowClick) Decode(r io.Reader) (ret PlayToServerPacketWindowClick, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.StateId, err = ret.StateId.Decode(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 = ret.Mode.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToServerPacketWindowClickChangedSlots proto_base.VarInt
|
|
lPlayToServerPacketWindowClickChangedSlots, err = lPlayToServerPacketWindowClickChangedSlots.Decode(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
|
|
PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue, 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
|
|
PlayToServerPacketWindowClickCursorItemPresentValue, err = PlayToServerPacketWindowClickCursorItemPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CursorItem = &PlayToServerPacketWindowClickCursorItemPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToServerPacketWindowClick) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.StateId.Encode(w)
|
|
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 = ret.Mode.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.ChangedSlots)).Encode(w)
|
|
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 {
|
|
err = (*ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorItem != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.CursorItem != nil {
|
|
err = (*ret.CursorItem).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientChatType struct {
|
|
TranslationKey string
|
|
Parameters []PlayToClientChatTypeParameterType
|
|
Style nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientChatType) Decode(r io.Reader) (ret PlayToClientChatType, err error) {
|
|
ret.TranslationKey, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientChatTypeParameters proto_base.VarInt
|
|
lPlayToClientChatTypeParameters, err = lPlayToClientChatTypeParameters.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Parameters = []PlayToClientChatTypeParameterType{}
|
|
for range lPlayToClientChatTypeParameters {
|
|
var PlayToClientChatTypeParametersElement PlayToClientChatTypeParameterType
|
|
PlayToClientChatTypeParametersElement, err = PlayToClientChatTypeParametersElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Parameters = append(ret.Parameters, PlayToClientChatTypeParametersElement)
|
|
}
|
|
ret.Style, 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.VarInt(len(ret.Parameters)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientChatTypeParameters := range len(ret.Parameters) {
|
|
err = ret.Parameters[iPlayToClientChatTypeParameters].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.Style.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientChatTypeParameterType struct {
|
|
Val string
|
|
}
|
|
|
|
var PlayToClientChatTypeParameterTypeMap = map[proto_base.VarInt]string{0: "content", 1: "sender", 2: "target"}
|
|
|
|
func (_ PlayToClientChatTypeParameterType) Decode(r io.Reader) (ret PlayToClientChatTypeParameterType, err error) {
|
|
var PlayToClientChatTypeParameterTypeKey proto_base.VarInt
|
|
PlayToClientChatTypeParameterTypeKey, err = PlayToClientChatTypeParameterTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeMap, PlayToClientChatTypeParameterTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientChatTypeParameterTypeReverseMap = map[string]proto_base.VarInt{"content": 0, "sender": 1, "target": 2}
|
|
|
|
func (ret PlayToClientChatTypeParameterType) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientChatTypeParameterType proto_base.VarInt
|
|
vPlayToClientChatTypeParameterType, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeReverseMap, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientChatTypeParameterType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientChatTypes struct {
|
|
Chat PlayToClientChatType
|
|
Narration PlayToClientChatType
|
|
}
|
|
|
|
func (_ PlayToClientChatTypes) Decode(r io.Reader) (ret PlayToClientChatTypes, err error) {
|
|
ret.Chat, err = ret.Chat.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Narration, err = ret.Narration.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientChatTypes) Encode(w io.Writer) (err error) {
|
|
err = ret.Chat.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Narration.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientChatTypesHolder struct {
|
|
Val any
|
|
}
|
|
|
|
func (_ PlayToClientChatTypesHolder) Decode(r io.Reader) (ret PlayToClientChatTypesHolder, err error) {
|
|
var PlayToClientChatTypesHolderId proto_base.VarInt
|
|
PlayToClientChatTypesHolderId, err = PlayToClientChatTypesHolderId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientChatTypesHolderId != 0 {
|
|
ret.Val = PlayToClientChatTypesHolderId
|
|
return
|
|
}
|
|
var PlayToClientChatTypesHolderResult PlayToClientChatTypes
|
|
PlayToClientChatTypesHolderResult, 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 proto_base.VarInt:
|
|
err = PlayToClientChatTypesHolderKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case PlayToClientChatTypes:
|
|
err = PlayToClientChatTypesHolderKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPositionUpdateRelatives struct {
|
|
Val uint32
|
|
}
|
|
|
|
func (_ PlayToClientPositionUpdateRelatives) Decode(r io.Reader) (ret PlayToClientPositionUpdateRelatives, 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 (_ PlayToClientRecipeBookSetting) Decode(r io.Reader) (ret PlayToClientRecipeBookSetting, 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[proto_base.VarInt]string{0: "crafting_shapeless", 1: "crafting_shaped", 2: "furnace", 3: "stonecutter", 4: "smithing"}
|
|
|
|
func (_ PlayToClientRecipeDisplay) Decode(r io.Reader) (ret PlayToClientRecipeDisplay, err error) {
|
|
var PlayToClientRecipeDisplayTypeKey proto_base.VarInt
|
|
PlayToClientRecipeDisplayTypeKey, err = PlayToClientRecipeDisplayTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.ErroringIndex(PlayToClientRecipeDisplayTypeMap, PlayToClientRecipeDisplayTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "crafting_shaped":
|
|
var PlayToClientRecipeDisplayDataTmp struct {
|
|
Width proto_base.VarInt
|
|
Height proto_base.VarInt
|
|
Ingredients []PlayToClientSlotDisplay
|
|
Result PlayToClientSlotDisplay
|
|
CraftingStation PlayToClientSlotDisplay
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Width, err = PlayToClientRecipeDisplayDataTmp.Width.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Height, err = PlayToClientRecipeDisplayDataTmp.Height.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientRecipeDisplayDataIngredients proto_base.VarInt
|
|
lPlayToClientRecipeDisplayDataIngredients, err = lPlayToClientRecipeDisplayDataIngredients.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Ingredients = []PlayToClientSlotDisplay{}
|
|
for range lPlayToClientRecipeDisplayDataIngredients {
|
|
var PlayToClientRecipeDisplayDataIngredientsElement PlayToClientSlotDisplay
|
|
PlayToClientRecipeDisplayDataIngredientsElement, err = PlayToClientRecipeDisplayDataIngredientsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Ingredients = append(PlayToClientRecipeDisplayDataTmp.Ingredients, PlayToClientRecipeDisplayDataIngredientsElement)
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Result, err = PlayToClientRecipeDisplayDataTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.CraftingStation, err = PlayToClientRecipeDisplayDataTmp.CraftingStation.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientRecipeDisplayDataTmp
|
|
case "crafting_shapeless":
|
|
var PlayToClientRecipeDisplayDataTmp struct {
|
|
Ingredients []PlayToClientSlotDisplay
|
|
Result PlayToClientSlotDisplay
|
|
CraftingStation PlayToClientSlotDisplay
|
|
}
|
|
var lPlayToClientRecipeDisplayDataIngredients proto_base.VarInt
|
|
lPlayToClientRecipeDisplayDataIngredients, err = lPlayToClientRecipeDisplayDataIngredients.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Ingredients = []PlayToClientSlotDisplay{}
|
|
for range lPlayToClientRecipeDisplayDataIngredients {
|
|
var PlayToClientRecipeDisplayDataIngredientsElement PlayToClientSlotDisplay
|
|
PlayToClientRecipeDisplayDataIngredientsElement, err = PlayToClientRecipeDisplayDataIngredientsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Ingredients = append(PlayToClientRecipeDisplayDataTmp.Ingredients, PlayToClientRecipeDisplayDataIngredientsElement)
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Result, err = PlayToClientRecipeDisplayDataTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.CraftingStation, err = PlayToClientRecipeDisplayDataTmp.CraftingStation.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientRecipeDisplayDataTmp
|
|
case "furnace":
|
|
var PlayToClientRecipeDisplayDataTmp struct {
|
|
Ingredient PlayToClientSlotDisplay
|
|
Fuel PlayToClientSlotDisplay
|
|
Result PlayToClientSlotDisplay
|
|
CraftingStation PlayToClientSlotDisplay
|
|
Duration proto_base.VarInt
|
|
Experience float32
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Ingredient, err = PlayToClientRecipeDisplayDataTmp.Ingredient.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Fuel, err = PlayToClientRecipeDisplayDataTmp.Fuel.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Result, err = PlayToClientRecipeDisplayDataTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.CraftingStation, err = PlayToClientRecipeDisplayDataTmp.CraftingStation.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Duration, err = PlayToClientRecipeDisplayDataTmp.Duration.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientRecipeDisplayDataTmp.Experience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientRecipeDisplayDataTmp
|
|
case "smithing":
|
|
var PlayToClientRecipeDisplayDataTmp struct {
|
|
Template PlayToClientSlotDisplay
|
|
Base PlayToClientSlotDisplay
|
|
Addition PlayToClientSlotDisplay
|
|
Result PlayToClientSlotDisplay
|
|
CraftingStation PlayToClientSlotDisplay
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Template, err = PlayToClientRecipeDisplayDataTmp.Template.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Base, err = PlayToClientRecipeDisplayDataTmp.Base.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Addition, err = PlayToClientRecipeDisplayDataTmp.Addition.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Result, err = PlayToClientRecipeDisplayDataTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.CraftingStation, err = PlayToClientRecipeDisplayDataTmp.CraftingStation.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientRecipeDisplayDataTmp
|
|
case "stonecutter":
|
|
var PlayToClientRecipeDisplayDataTmp struct {
|
|
Ingredient PlayToClientSlotDisplay
|
|
Result PlayToClientSlotDisplay
|
|
CraftingStation PlayToClientSlotDisplay
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Ingredient, err = PlayToClientRecipeDisplayDataTmp.Ingredient.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.Result, err = PlayToClientRecipeDisplayDataTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientRecipeDisplayDataTmp.CraftingStation, err = PlayToClientRecipeDisplayDataTmp.CraftingStation.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientRecipeDisplayDataTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientRecipeDisplayTypeReverseMap = map[string]proto_base.VarInt{"crafting_shapeless": 0, "crafting_shaped": 1, "furnace": 2, "stonecutter": 3, "smithing": 4}
|
|
|
|
func (ret PlayToClientRecipeDisplay) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientRecipeDisplayType proto_base.VarInt
|
|
vPlayToClientRecipeDisplayType, err = proto_base.ErroringIndex(PlayToClientRecipeDisplayTypeReverseMap, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientRecipeDisplayType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "crafting_shaped":
|
|
PlayToClientRecipeDisplayData, ok := ret.Data.(struct {
|
|
Width proto_base.VarInt
|
|
Height proto_base.VarInt
|
|
Ingredients []PlayToClientSlotDisplay
|
|
Result PlayToClientSlotDisplay
|
|
CraftingStation PlayToClientSlotDisplay
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Width.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Height.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(PlayToClientRecipeDisplayData.Ingredients)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientRecipeDisplayDataIngredients := range len(PlayToClientRecipeDisplayData.Ingredients) {
|
|
err = PlayToClientRecipeDisplayData.Ingredients[iPlayToClientRecipeDisplayDataIngredients].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Result.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.CraftingStation.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.VarInt(len(PlayToClientRecipeDisplayData.Ingredients)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientRecipeDisplayDataIngredients := range len(PlayToClientRecipeDisplayData.Ingredients) {
|
|
err = PlayToClientRecipeDisplayData.Ingredients[iPlayToClientRecipeDisplayDataIngredients].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Result.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "furnace":
|
|
PlayToClientRecipeDisplayData, ok := ret.Data.(struct {
|
|
Ingredient PlayToClientSlotDisplay
|
|
Fuel PlayToClientSlotDisplay
|
|
Result PlayToClientSlotDisplay
|
|
CraftingStation PlayToClientSlotDisplay
|
|
Duration proto_base.VarInt
|
|
Experience float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Ingredient.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Fuel.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Result.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Duration.Encode(w)
|
|
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
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Template.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Base.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Addition.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Result.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.CraftingStation.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
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Ingredient.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.Result.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientSlotDisplay struct {
|
|
Type string
|
|
Data any
|
|
}
|
|
|
|
var PlayToClientSlotDisplayTypeMap = map[proto_base.VarInt]string{0: "empty", 1: "any_fuel", 2: "item", 3: "item_stack", 4: "tag", 5: "smithing_trim", 6: "with_remainder", 7: "composite"}
|
|
|
|
func (_ PlayToClientSlotDisplay) Decode(r io.Reader) (ret PlayToClientSlotDisplay, err error) {
|
|
var PlayToClientSlotDisplayTypeKey proto_base.VarInt
|
|
PlayToClientSlotDisplayTypeKey, err = PlayToClientSlotDisplayTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.ErroringIndex(PlayToClientSlotDisplayTypeMap, PlayToClientSlotDisplayTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "any_fuel":
|
|
var PlayToClientSlotDisplayDataTmp proto_base.Void
|
|
PlayToClientSlotDisplayDataTmp, err = PlayToClientSlotDisplayDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientSlotDisplayDataTmp
|
|
case "composite":
|
|
var PlayToClientSlotDisplayDataTmp []PlayToClientSlotDisplay
|
|
var lPlayToClientSlotDisplayData proto_base.VarInt
|
|
lPlayToClientSlotDisplayData, err = lPlayToClientSlotDisplayData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientSlotDisplayDataTmp = []PlayToClientSlotDisplay{}
|
|
for range lPlayToClientSlotDisplayData {
|
|
var PlayToClientSlotDisplayDataElement PlayToClientSlotDisplay
|
|
PlayToClientSlotDisplayDataElement, err = PlayToClientSlotDisplayDataElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientSlotDisplayDataTmp = append(PlayToClientSlotDisplayDataTmp, PlayToClientSlotDisplayDataElement)
|
|
}
|
|
ret.Data = PlayToClientSlotDisplayDataTmp
|
|
case "empty":
|
|
var PlayToClientSlotDisplayDataTmp proto_base.Void
|
|
PlayToClientSlotDisplayDataTmp, err = PlayToClientSlotDisplayDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientSlotDisplayDataTmp
|
|
case "item":
|
|
var PlayToClientSlotDisplayDataTmp proto_base.VarInt
|
|
PlayToClientSlotDisplayDataTmp, err = PlayToClientSlotDisplayDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientSlotDisplayDataTmp
|
|
case "item_stack":
|
|
var PlayToClientSlotDisplayDataTmp Slot
|
|
PlayToClientSlotDisplayDataTmp, err = PlayToClientSlotDisplayDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientSlotDisplayDataTmp
|
|
case "smithing_trim":
|
|
var PlayToClientSlotDisplayDataTmp struct {
|
|
Base PlayToClientSlotDisplay
|
|
Material PlayToClientSlotDisplay
|
|
Pattern any
|
|
}
|
|
PlayToClientSlotDisplayDataTmp.Base, err = PlayToClientSlotDisplayDataTmp.Base.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientSlotDisplayDataTmp.Material, err = PlayToClientSlotDisplayDataTmp.Material.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientSlotDisplayDataPatternId proto_base.VarInt
|
|
PlayToClientSlotDisplayDataPatternId, err = PlayToClientSlotDisplayDataPatternId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientSlotDisplayDataPatternId != 0 {
|
|
PlayToClientSlotDisplayDataTmp.Pattern = PlayToClientSlotDisplayDataPatternId
|
|
return
|
|
}
|
|
var PlayToClientSlotDisplayDataPatternResult ArmorTrimPattern
|
|
PlayToClientSlotDisplayDataPatternResult, err = PlayToClientSlotDisplayDataPatternResult.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientSlotDisplayDataTmp.Pattern = PlayToClientSlotDisplayDataPatternResult
|
|
ret.Data = PlayToClientSlotDisplayDataTmp
|
|
case "tag":
|
|
var PlayToClientSlotDisplayDataTmp string
|
|
PlayToClientSlotDisplayDataTmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientSlotDisplayDataTmp
|
|
case "with_remainder":
|
|
var PlayToClientSlotDisplayDataTmp struct {
|
|
Input PlayToClientSlotDisplay
|
|
Remainder PlayToClientSlotDisplay
|
|
}
|
|
PlayToClientSlotDisplayDataTmp.Input, err = PlayToClientSlotDisplayDataTmp.Input.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientSlotDisplayDataTmp.Remainder, err = PlayToClientSlotDisplayDataTmp.Remainder.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientSlotDisplayDataTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientSlotDisplayTypeReverseMap = map[string]proto_base.VarInt{"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 proto_base.VarInt
|
|
vPlayToClientSlotDisplayType, err = proto_base.ErroringIndex(PlayToClientSlotDisplayTypeReverseMap, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientSlotDisplayType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "any_fuel":
|
|
PlayToClientSlotDisplayData, ok := ret.Data.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientSlotDisplayData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "composite":
|
|
PlayToClientSlotDisplayData, ok := ret.Data.([]PlayToClientSlotDisplay)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(PlayToClientSlotDisplayData)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientSlotDisplayData := range len(PlayToClientSlotDisplayData) {
|
|
err = PlayToClientSlotDisplayData[iPlayToClientSlotDisplayData].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "empty":
|
|
PlayToClientSlotDisplayData, ok := ret.Data.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientSlotDisplayData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "item":
|
|
PlayToClientSlotDisplayData, ok := ret.Data.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientSlotDisplayData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "item_stack":
|
|
PlayToClientSlotDisplayData, ok := ret.Data.(Slot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientSlotDisplayData.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
|
|
}
|
|
err = PlayToClientSlotDisplayData.Base.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientSlotDisplayData.Material.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch PlayToClientSlotDisplayDataPatternKnownType := PlayToClientSlotDisplayData.Pattern.(type) {
|
|
case proto_base.VarInt:
|
|
err = PlayToClientSlotDisplayDataPatternKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case ArmorTrimPattern:
|
|
err = PlayToClientSlotDisplayDataPatternKnownType.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
|
|
}
|
|
err = PlayToClientSlotDisplayData.Input.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientSlotDisplayData.Remainder.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientSpawnInfo struct {
|
|
Dimension proto_base.VarInt
|
|
Name string
|
|
HashedSeed int64
|
|
Gamemode string
|
|
PreviousGamemode uint8
|
|
IsDebug bool
|
|
IsFlat bool
|
|
Death *struct {
|
|
DimensionName string
|
|
Location Position
|
|
}
|
|
PortalCooldown proto_base.VarInt
|
|
SeaLevel proto_base.VarInt
|
|
}
|
|
|
|
var PlayToClientSpawnInfoGamemodeMap = map[int8]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"}
|
|
|
|
func (_ PlayToClientSpawnInfo) Decode(r io.Reader) (ret PlayToClientSpawnInfo, err error) {
|
|
ret.Dimension, err = ret.Dimension.Decode(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 struct {
|
|
DimensionName string
|
|
Location Position
|
|
}
|
|
PlayToClientSpawnInfoDeathPresentValue.DimensionName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientSpawnInfoDeathPresentValue.Location, err = PlayToClientSpawnInfoDeathPresentValue.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Death = &PlayToClientSpawnInfoDeathPresentValue
|
|
}
|
|
ret.PortalCooldown, err = ret.PortalCooldown.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SeaLevel, err = ret.SeaLevel.Decode(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 = ret.Dimension.Encode(w)
|
|
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 {
|
|
err = proto_base.EncodeString(w, (*ret.Death).DimensionName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = (*ret.Death).Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.PortalCooldown.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SeaLevel.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var PlayToClientPacketNameMap = map[proto_base.VarInt]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_sample", 0x1b: "hide_message", 0x1c: "kick_disconnect", 0x1d: "profileless_chat", 0x1e: "entity_status", 0x1f: "sync_entity_position", 0x20: "explosion", 0x21: "unload_chunk", 0x22: "game_state_change", 0x23: "open_horse_window", 0x24: "hurt_animation", 0x25: "initialize_world_border", 0x26: "keep_alive", 0x27: "map_chunk", 0x28: "world_event", 0x29: "world_particles", 0x2a: "update_light", 0x2b: "login", 0x2c: "map", 0x2d: "trade_list", 0x2e: "rel_entity_move", 0x2f: "entity_move_look", 0x30: "move_minecart", 0x31: "entity_look", 0x32: "vehicle_move", 0x33: "open_book", 0x34: "open_window", 0x35: "open_sign_entity", 0x36: "ping", 0x37: "ping_response", 0x38: "craft_recipe_response", 0x39: "abilities", 0x3a: "player_chat", 0x3b: "end_combat_event", 0x3c: "enter_combat_event", 0x3d: "death_combat_event", 0x3e: "player_remove", 0x3f: "player_info", 0x40: "face_player", 0x41: "position", 0x42: "player_rotation", 0x43: "recipe_book_add", 0x44: "recipe_book_remove", 0x45: "recipe_book_settings", 0x46: "entity_destroy", 0x47: "remove_entity_effect", 0x48: "reset_score", 0x49: "remove_resource_pack", 0x4a: "add_resource_pack", 0x4b: "respawn", 0x4c: "entity_head_rotation", 0x4d: "multi_block_change", 0x4e: "select_advancement_tab", 0x4f: "server_data", 0x50: "action_bar", 0x51: "world_border_center", 0x52: "world_border_lerp_size", 0x53: "world_border_size", 0x54: "world_border_warning_delay", 0x55: "world_border_warning_reach", 0x56: "camera", 0x57: "update_view_position", 0x58: "update_view_distance", 0x59: "set_cursor_item", 0x5a: "spawn_position", 0x5b: "scoreboard_display_objective", 0x5c: "entity_metadata", 0x5d: "attach_entity", 0x5e: "entity_velocity", 0x5f: "entity_equipment", 0x60: "experience", 0x61: "update_health", 0x62: "held_item_slot", 0x63: "scoreboard_objective", 0x64: "set_passengers", 0x65: "set_player_inventory", 0x66: "teams", 0x67: "scoreboard_score", 0x68: "simulation_distance", 0x69: "set_title_subtitle", 0x6a: "update_time", 0x6b: "set_title_text", 0x6c: "set_title_time", 0x6d: "entity_sound_effect", 0x6e: "sound_effect", 0x6f: "start_configuration", 0x70: "stop_sound", 0x71: "store_cookie", 0x72: "system_chat", 0x73: "playerlist_header", 0x74: "nbt_query_response", 0x75: "collect", 0x76: "entity_teleport", 0x77: "test_instance_block_status", 0x78: "set_ticking_state", 0x79: "step_tick", 0x7a: "transfer", 0x7b: "advancements", 0x7c: "entity_update_attributes", 0x7d: "entity_effect", 0x7e: "declare_recipes", 0x7f: "tags", 0x80: "set_projectile_power", 0x81: "custom_report_details", 0x82: "server_links", 0x83: "tracked_waypoint", 0x84: "clear_dialog", 0x85: "show_dialog"}
|
|
|
|
func (_ PlayToClientPacket) Decode(r io.Reader) (ret PlayToClientPacket, err error) {
|
|
var PlayToClientPacketNameKey proto_base.VarInt
|
|
PlayToClientPacketNameKey, err = PlayToClientPacketNameKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(PlayToClientPacketNameMap, PlayToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketAbilities
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "acknowledge_player_digging":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketAcknowledgePlayerDigging
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "action_bar":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketActionBar
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "add_resource_pack":
|
|
var PlayToClientPacketParamsTmp PacketCommonAddResourcePack
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "advancements":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketAdvancements
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "animation":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketAnimation
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "attach_entity":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketAttachEntity
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "block_action":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketBlockAction
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "block_break_animation":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketBlockBreakAnimation
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "block_change":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketBlockChange
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "boss_bar":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketBossBar
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "bundle_delimiter":
|
|
var PlayToClientPacketParamsTmp proto_base.Void
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "camera":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketCamera
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "chat_suggestions":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketChatSuggestions
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "chunk_batch_finished":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketChunkBatchFinished
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "chunk_batch_start":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketChunkBatchStart
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "chunk_biomes":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketChunkBiomes
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "clear_dialog":
|
|
var PlayToClientPacketParamsTmp PacketCommonClearDialog
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "clear_titles":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketClearTitles
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "close_window":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketCloseWindow
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "collect":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketCollect
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "cookie_request":
|
|
var PlayToClientPacketParamsTmp PacketCommonCookieRequest
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "craft_progress_bar":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketCraftProgressBar
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "craft_recipe_response":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketCraftRecipeResponse
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "custom_payload":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketCustomPayload
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "custom_report_details":
|
|
var PlayToClientPacketParamsTmp PacketCommonCustomReportDetails
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "damage_event":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketDamageEvent
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "death_combat_event":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketDeathCombatEvent
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "debug_sample":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketDebugSample
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "declare_commands":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketDeclareCommands
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "declare_recipes":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketDeclareRecipes
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "difficulty":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketDifficulty
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "end_combat_event":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEndCombatEvent
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "enter_combat_event":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEnterCombatEvent
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_destroy":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityDestroy
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_effect":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityEffect
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_equipment":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityEquipment
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_head_rotation":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityHeadRotation
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_look":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityLook
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_metadata":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityMetadata
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_move_look":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityMoveLook
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_sound_effect":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntitySoundEffect
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_status":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityStatus
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_teleport":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityTeleport
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_update_attributes":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityUpdateAttributes
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "entity_velocity":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketEntityVelocity
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "experience":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketExperience
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "explosion":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketExplosion
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "face_player":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketFacePlayer
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "game_state_change":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketGameStateChange
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "held_item_slot":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketHeldItemSlot
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "hide_message":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketHideMessage
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "hurt_animation":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketHurtAnimation
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "initialize_world_border":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketInitializeWorldBorder
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "keep_alive":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketKeepAlive
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "kick_disconnect":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketKickDisconnect
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "login":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketLogin
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "map":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketMap
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "map_chunk":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketMapChunk
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "move_minecart":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketMoveMinecart
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "multi_block_change":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketMultiBlockChange
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "nbt_query_response":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketNbtQueryResponse
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "open_book":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketOpenBook
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "open_horse_window":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketOpenHorseWindow
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "open_sign_entity":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketOpenSignEntity
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "open_window":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketOpenWindow
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "ping":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketPing
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "ping_response":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketPingResponse
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "player_chat":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketPlayerChat
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "player_info":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketPlayerInfo
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "player_remove":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketPlayerRemove
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "player_rotation":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketPlayerRotation
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "playerlist_header":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketPlayerlistHeader
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "position":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketPosition
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "profileless_chat":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketProfilelessChat
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "recipe_book_add":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketRecipeBookAdd
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "recipe_book_remove":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketRecipeBookRemove
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "recipe_book_settings":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketRecipeBookSettings
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "rel_entity_move":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketRelEntityMove
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "remove_entity_effect":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketRemoveEntityEffect
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "remove_resource_pack":
|
|
var PlayToClientPacketParamsTmp PacketCommonRemoveResourcePack
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "reset_score":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketResetScore
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "respawn":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketRespawn
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "scoreboard_display_objective":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketScoreboardDisplayObjective
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "scoreboard_objective":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketScoreboardObjective
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "scoreboard_score":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketScoreboardScore
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "select_advancement_tab":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSelectAdvancementTab
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "server_data":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketServerData
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "server_links":
|
|
var PlayToClientPacketParamsTmp PacketCommonServerLinks
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_cooldown":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetCooldown
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_cursor_item":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetCursorItem
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_passengers":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetPassengers
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_player_inventory":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetPlayerInventory
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_projectile_power":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetProjectilePower
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_slot":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetSlot
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_ticking_state":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetTickingState
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_title_subtitle":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetTitleSubtitle
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_title_text":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetTitleText
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "set_title_time":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSetTitleTime
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "show_dialog":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketShowDialog
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "simulation_distance":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSimulationDistance
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "sound_effect":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSoundEffect
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "spawn_entity":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSpawnEntity
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "spawn_position":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSpawnPosition
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "start_configuration":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketStartConfiguration
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "statistics":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketStatistics
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "step_tick":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketStepTick
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "stop_sound":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketStopSound
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "store_cookie":
|
|
var PlayToClientPacketParamsTmp PacketCommonStoreCookie
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "sync_entity_position":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSyncEntityPosition
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "system_chat":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketSystemChat
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "tab_complete":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketTabComplete
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "tags":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketTags
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "teams":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketTeams
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "test_instance_block_status":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketTestInstanceBlockStatus
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "tile_entity_data":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketTileEntityData
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "tracked_waypoint":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketTrackedWaypoint
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "trade_list":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketTradeList
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "transfer":
|
|
var PlayToClientPacketParamsTmp PacketCommonTransfer
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "unload_chunk":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketUnloadChunk
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "update_health":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketUpdateHealth
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "update_light":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketUpdateLight
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "update_time":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketUpdateTime
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "update_view_distance":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketUpdateViewDistance
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "update_view_position":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketUpdateViewPosition
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "vehicle_move":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketVehicleMove
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "window_items":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketWindowItems
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "world_border_center":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketWorldBorderCenter
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "world_border_lerp_size":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketWorldBorderLerpSize
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "world_border_size":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketWorldBorderSize
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "world_border_warning_delay":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketWorldBorderWarningDelay
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "world_border_warning_reach":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketWorldBorderWarningReach
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "world_event":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketWorldEvent
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
case "world_particles":
|
|
var PlayToClientPacketParamsTmp PlayToClientPacketWorldParticles
|
|
PlayToClientPacketParamsTmp, err = PlayToClientPacketParamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketNameReverseMap = map[string]proto_base.VarInt{"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_sample": 0x1a, "hide_message": 0x1b, "kick_disconnect": 0x1c, "profileless_chat": 0x1d, "entity_status": 0x1e, "sync_entity_position": 0x1f, "explosion": 0x20, "unload_chunk": 0x21, "game_state_change": 0x22, "open_horse_window": 0x23, "hurt_animation": 0x24, "initialize_world_border": 0x25, "keep_alive": 0x26, "map_chunk": 0x27, "world_event": 0x28, "world_particles": 0x29, "update_light": 0x2a, "login": 0x2b, "map": 0x2c, "trade_list": 0x2d, "rel_entity_move": 0x2e, "entity_move_look": 0x2f, "move_minecart": 0x30, "entity_look": 0x31, "vehicle_move": 0x32, "open_book": 0x33, "open_window": 0x34, "open_sign_entity": 0x35, "ping": 0x36, "ping_response": 0x37, "craft_recipe_response": 0x38, "abilities": 0x39, "player_chat": 0x3a, "end_combat_event": 0x3b, "enter_combat_event": 0x3c, "death_combat_event": 0x3d, "player_remove": 0x3e, "player_info": 0x3f, "face_player": 0x40, "position": 0x41, "player_rotation": 0x42, "recipe_book_add": 0x43, "recipe_book_remove": 0x44, "recipe_book_settings": 0x45, "entity_destroy": 0x46, "remove_entity_effect": 0x47, "reset_score": 0x48, "remove_resource_pack": 0x49, "add_resource_pack": 0x4a, "respawn": 0x4b, "entity_head_rotation": 0x4c, "multi_block_change": 0x4d, "select_advancement_tab": 0x4e, "server_data": 0x4f, "action_bar": 0x50, "world_border_center": 0x51, "world_border_lerp_size": 0x52, "world_border_size": 0x53, "world_border_warning_delay": 0x54, "world_border_warning_reach": 0x55, "camera": 0x56, "update_view_position": 0x57, "update_view_distance": 0x58, "set_cursor_item": 0x59, "spawn_position": 0x5a, "scoreboard_display_objective": 0x5b, "entity_metadata": 0x5c, "attach_entity": 0x5d, "entity_velocity": 0x5e, "entity_equipment": 0x5f, "experience": 0x60, "update_health": 0x61, "held_item_slot": 0x62, "scoreboard_objective": 0x63, "set_passengers": 0x64, "set_player_inventory": 0x65, "teams": 0x66, "scoreboard_score": 0x67, "simulation_distance": 0x68, "set_title_subtitle": 0x69, "update_time": 0x6a, "set_title_text": 0x6b, "set_title_time": 0x6c, "entity_sound_effect": 0x6d, "sound_effect": 0x6e, "start_configuration": 0x6f, "stop_sound": 0x70, "store_cookie": 0x71, "system_chat": 0x72, "playerlist_header": 0x73, "nbt_query_response": 0x74, "collect": 0x75, "entity_teleport": 0x76, "test_instance_block_status": 0x77, "set_ticking_state": 0x78, "step_tick": 0x79, "transfer": 0x7a, "advancements": 0x7b, "entity_update_attributes": 0x7c, "entity_effect": 0x7d, "declare_recipes": 0x7e, "tags": 0x7f, "set_projectile_power": 0x80, "custom_report_details": 0x81, "server_links": 0x82, "tracked_waypoint": 0x83, "clear_dialog": 0x84, "show_dialog": 0x85}
|
|
|
|
func (ret PlayToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientPacketName proto_base.VarInt
|
|
vPlayToClientPacketName, err = proto_base.ErroringIndex(PlayToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAbilities)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "acknowledge_player_digging":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAcknowledgePlayerDigging)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "action_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketActionBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "add_resource_pack":
|
|
PlayToClientPacketParams, ok := ret.Params.(PacketCommonAddResourcePack)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "advancements":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAdvancements)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "attach_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAttachEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_action":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_break_animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockBreakAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "boss_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBossBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "bundle_delimiter":
|
|
PlayToClientPacketParams, ok := ret.Params.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "camera":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCamera)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_suggestions":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChatSuggestions)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chunk_batch_finished":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchFinished)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chunk_batch_start":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chunk_biomes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBiomes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "clear_dialog":
|
|
PlayToClientPacketParams, ok := ret.Params.(PacketCommonClearDialog)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "clear_titles":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketClearTitles)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "close_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCloseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "collect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCollect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cookie_request":
|
|
PlayToClientPacketParams, ok := ret.Params.(PacketCommonCookieRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_progress_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftProgressBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_recipe_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftRecipeResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_report_details":
|
|
PlayToClientPacketParams, ok := ret.Params.(PacketCommonCustomReportDetails)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "damage_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDamageEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "death_combat_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeathCombatEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "debug_sample":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugSample)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "declare_commands":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareCommands)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "declare_recipes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareRecipes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "difficulty":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDifficulty)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "end_combat_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEndCombatEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "enter_combat_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEnterCombatEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_destroy":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityDestroy)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_equipment":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEquipment)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_head_rotation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityHeadRotation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_look":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_metadata":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMetadata)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_move_look":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMoveLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntitySoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_status":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityStatus)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_teleport":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityTeleport)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_update_attributes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityUpdateAttributes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_velocity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityVelocity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "experience":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExperience)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "explosion":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExplosion)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "face_player":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketFacePlayer)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "game_state_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameStateChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "held_item_slot":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHeldItemSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "hide_message":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHideMessage)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "hurt_animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHurtAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "initialize_world_border":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketInitializeWorldBorder)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "kick_disconnect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKickDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketLogin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "map":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMap)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "map_chunk":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunk)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "move_minecart":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMoveMinecart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "multi_block_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMultiBlockChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "nbt_query_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNbtQueryResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_book":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenBook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_horse_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenHorseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_sign_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenSignEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPingResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_chat":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_info":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerInfo)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_remove":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRemove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_rotation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRotation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "playerlist_header":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerlistHeader)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "profileless_chat":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketProfilelessChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "recipe_book_add":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookAdd)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "recipe_book_remove":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookRemove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "recipe_book_settings":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookSettings)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "rel_entity_move":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRelEntityMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_entity_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRemoveEntityEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_resource_pack":
|
|
PlayToClientPacketParams, ok := ret.Params.(PacketCommonRemoveResourcePack)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "reset_score":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResetScore)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "respawn":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRespawn)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_display_objective":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardDisplayObjective)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_objective":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardObjective)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_score":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardScore)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_advancement_tab":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSelectAdvancementTab)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "server_data":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketServerData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "server_links":
|
|
PlayToClientPacketParams, ok := ret.Params.(PacketCommonServerLinks)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_cooldown":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCooldown)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_cursor_item":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCursorItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_passengers":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPassengers)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_player_inventory":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPlayerInventory)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_projectile_power":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetProjectilePower)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_slot":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_ticking_state":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTickingState)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_title_subtitle":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleSubtitle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_title_text":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleText)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_title_time":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleTime)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "show_dialog":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketShowDialog)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "simulation_distance":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSimulationDistance)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "start_configuration":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStartConfiguration)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "statistics":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStatistics)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "step_tick":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStepTick)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "stop_sound":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStopSound)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "store_cookie":
|
|
PlayToClientPacketParams, ok := ret.Params.(PacketCommonStoreCookie)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "sync_entity_position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSyncEntityPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "system_chat":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSystemChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tab_complete":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTabComplete)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tags":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTags)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "teams":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTeams)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "test_instance_block_status":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTestInstanceBlockStatus)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tile_entity_data":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTileEntityData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tracked_waypoint":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTrackedWaypoint)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "trade_list":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTradeList)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "transfer":
|
|
PlayToClientPacketParams, ok := ret.Params.(PacketCommonTransfer)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "unload_chunk":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnloadChunk)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_health":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateHealth)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_light":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateLight)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_time":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateTime)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_view_distance":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewDistance)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_view_position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vehicle_move":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketVehicleMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "window_items":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWindowItems)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_center":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderCenter)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_lerp_size":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderLerpSize)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_size":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderSize)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_warning_delay":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningDelay)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_warning_reach":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningReach)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_particles":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldParticles)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketParams.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAbilities struct {
|
|
Flags int8
|
|
FlyingSpeed float32
|
|
WalkingSpeed float32
|
|
}
|
|
|
|
func (_ PlayToClientPacketAbilities) Decode(r io.Reader) (ret PlayToClientPacketAbilities, 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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketAcknowledgePlayerDigging) Decode(r io.Reader) (ret PlayToClientPacketAcknowledgePlayerDigging, err error) {
|
|
ret.SequenceId, err = ret.SequenceId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketAcknowledgePlayerDigging) Encode(w io.Writer) (err error) {
|
|
err = ret.SequenceId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketActionBar struct {
|
|
Text nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketActionBar) Decode(r io.Reader) (ret PlayToClientPacketActionBar, err error) {
|
|
ret.Text, err = ret.Text.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketActionBar) Encode(w io.Writer) (err error) {
|
|
err = ret.Text.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAdvancements struct {
|
|
Val proto_base.ToDo
|
|
}
|
|
|
|
func (_ PlayToClientPacketAdvancements) Decode(r io.Reader) (ret PlayToClientPacketAdvancements, err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketAdvancements) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAnimation struct {
|
|
EntityId proto_base.VarInt
|
|
Animation uint8
|
|
}
|
|
|
|
func (_ PlayToClientPacketAnimation) Decode(r io.Reader) (ret PlayToClientPacketAnimation, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(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 = ret.EntityId.Encode(w)
|
|
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 (_ PlayToClientPacketAttachEntity) Decode(r io.Reader) (ret PlayToClientPacketAttachEntity, 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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketBlockAction) Decode(r io.Reader) (ret PlayToClientPacketBlockAction, err error) {
|
|
ret.Location, 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 = ret.BlockId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketBlockAction) Encode(w io.Writer) (err error) {
|
|
err = ret.Location.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 = ret.BlockId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockBreakAnimation struct {
|
|
EntityId proto_base.VarInt
|
|
Location Position
|
|
DestroyStage int8
|
|
}
|
|
|
|
func (_ PlayToClientPacketBlockBreakAnimation) Decode(r io.Reader) (ret PlayToClientPacketBlockBreakAnimation, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Location, 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 = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketBlockChange) Decode(r io.Reader) (ret PlayToClientPacketBlockChange, err error) {
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = ret.Type.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketBlockChange) Encode(w io.Writer) (err error) {
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBossBar struct {
|
|
EntityUUID uuid.UUID
|
|
Action proto_base.VarInt
|
|
Title any
|
|
Health any
|
|
Color any
|
|
Dividers any
|
|
Flags any
|
|
}
|
|
|
|
func (_ PlayToClientPacketBossBar) Decode(r io.Reader) (ret PlayToClientPacketBossBar, err error) {
|
|
_, err = io.ReadFull(r, ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = ret.Action.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarTitleTmp nbt.Anon
|
|
PlayToClientPacketBossBarTitleTmp, err = PlayToClientPacketBossBarTitleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitleTmp
|
|
case 3:
|
|
var PlayToClientPacketBossBarTitleTmp nbt.Anon
|
|
PlayToClientPacketBossBarTitleTmp, err = PlayToClientPacketBossBarTitleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitleTmp
|
|
default:
|
|
var PlayToClientPacketBossBarTitleTmp proto_base.Void
|
|
PlayToClientPacketBossBarTitleTmp, err = PlayToClientPacketBossBarTitleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitleTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarHealthTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealthTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealthTmp
|
|
case 2:
|
|
var PlayToClientPacketBossBarHealthTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealthTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealthTmp
|
|
default:
|
|
var PlayToClientPacketBossBarHealthTmp proto_base.Void
|
|
PlayToClientPacketBossBarHealthTmp, err = PlayToClientPacketBossBarHealthTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealthTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarColorTmp proto_base.VarInt
|
|
PlayToClientPacketBossBarColorTmp, err = PlayToClientPacketBossBarColorTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColorTmp
|
|
case 4:
|
|
var PlayToClientPacketBossBarColorTmp proto_base.VarInt
|
|
PlayToClientPacketBossBarColorTmp, err = PlayToClientPacketBossBarColorTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColorTmp
|
|
default:
|
|
var PlayToClientPacketBossBarColorTmp proto_base.Void
|
|
PlayToClientPacketBossBarColorTmp, err = PlayToClientPacketBossBarColorTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColorTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarDividersTmp proto_base.VarInt
|
|
PlayToClientPacketBossBarDividersTmp, err = PlayToClientPacketBossBarDividersTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividersTmp
|
|
case 4:
|
|
var PlayToClientPacketBossBarDividersTmp proto_base.VarInt
|
|
PlayToClientPacketBossBarDividersTmp, err = PlayToClientPacketBossBarDividersTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividersTmp
|
|
default:
|
|
var PlayToClientPacketBossBarDividersTmp proto_base.Void
|
|
PlayToClientPacketBossBarDividersTmp, err = PlayToClientPacketBossBarDividersTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividersTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarFlagsTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlagsTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlagsTmp
|
|
case 5:
|
|
var PlayToClientPacketBossBarFlagsTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlagsTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlagsTmp
|
|
default:
|
|
var PlayToClientPacketBossBarFlagsTmp proto_base.Void
|
|
PlayToClientPacketBossBarFlagsTmp, err = PlayToClientPacketBossBarFlagsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlagsTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketBossBar) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Action.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketBossBarTitle.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketBossBarTitle.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Title.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Title.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Health.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarColor, ok := ret.Color.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketBossBarColor.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketBossBarColor, ok := ret.Color.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketBossBarColor.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Color.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Color.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarDividers, ok := ret.Dividers.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketBossBarDividers.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketBossBarDividers, ok := ret.Dividers.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketBossBarDividers.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Dividers.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Dividers.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Flags.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCamera struct {
|
|
CameraId proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketCamera) Decode(r io.Reader) (ret PlayToClientPacketCamera, err error) {
|
|
ret.CameraId, err = ret.CameraId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketCamera) Encode(w io.Writer) (err error) {
|
|
err = ret.CameraId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChatSuggestions struct {
|
|
Action proto_base.VarInt
|
|
Entries []string
|
|
}
|
|
|
|
func (_ PlayToClientPacketChatSuggestions) Decode(r io.Reader) (ret PlayToClientPacketChatSuggestions, err error) {
|
|
ret.Action, err = ret.Action.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketChatSuggestionsEntries proto_base.VarInt
|
|
lPlayToClientPacketChatSuggestionsEntries, err = lPlayToClientPacketChatSuggestionsEntries.Decode(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 = ret.Action.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Entries)).Encode(w)
|
|
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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketChunkBatchFinished) Decode(r io.Reader) (ret PlayToClientPacketChunkBatchFinished, err error) {
|
|
ret.BatchSize, err = ret.BatchSize.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketChunkBatchFinished) Encode(w io.Writer) (err error) {
|
|
err = ret.BatchSize.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChunkBatchStart struct {
|
|
}
|
|
|
|
func (_ PlayToClientPacketChunkBatchStart) Decode(r io.Reader) (ret PlayToClientPacketChunkBatchStart, err error) {
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketChunkBatchStart) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChunkBiomes struct {
|
|
Biomes []struct {
|
|
Position PackedChunkPos
|
|
Data ByteArray
|
|
}
|
|
}
|
|
|
|
func (_ PlayToClientPacketChunkBiomes) Decode(r io.Reader) (ret PlayToClientPacketChunkBiomes, err error) {
|
|
var lPlayToClientPacketChunkBiomesBiomes proto_base.VarInt
|
|
lPlayToClientPacketChunkBiomesBiomes, err = lPlayToClientPacketChunkBiomesBiomes.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Biomes = []struct {
|
|
Position PackedChunkPos
|
|
Data ByteArray
|
|
}{}
|
|
for range lPlayToClientPacketChunkBiomesBiomes {
|
|
var PlayToClientPacketChunkBiomesBiomesElement struct {
|
|
Position PackedChunkPos
|
|
Data ByteArray
|
|
}
|
|
PlayToClientPacketChunkBiomesBiomesElement.Position, err = PlayToClientPacketChunkBiomesBiomesElement.Position.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketChunkBiomesBiomesElement.Data, 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.VarInt(len(ret.Biomes)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketChunkBiomesBiomes := range len(ret.Biomes) {
|
|
err = ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Position.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Data.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketClearTitles struct {
|
|
Reset bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketClearTitles) Decode(r io.Reader) (ret PlayToClientPacketClearTitles, 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 (_ PlayToClientPacketCloseWindow) Decode(r io.Reader) (ret PlayToClientPacketCloseWindow, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketCloseWindow) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCollect struct {
|
|
CollectedEntityId proto_base.VarInt
|
|
CollectorEntityId proto_base.VarInt
|
|
PickupItemCount proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketCollect) Decode(r io.Reader) (ret PlayToClientPacketCollect, err error) {
|
|
ret.CollectedEntityId, err = ret.CollectedEntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollectorEntityId, err = ret.CollectorEntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PickupItemCount, err = ret.PickupItemCount.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketCollect) Encode(w io.Writer) (err error) {
|
|
err = ret.CollectedEntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.CollectorEntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.PickupItemCount.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCraftProgressBar struct {
|
|
WindowId ContainerID
|
|
Property int16
|
|
Value int16
|
|
}
|
|
|
|
func (_ PlayToClientPacketCraftProgressBar) Decode(r io.Reader) (ret PlayToClientPacketCraftProgressBar, err error) {
|
|
ret.WindowId, 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) {
|
|
err = ret.WindowId.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 (_ PlayToClientPacketCraftRecipeResponse) Decode(r io.Reader) (ret PlayToClientPacketCraftRecipeResponse, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RecipeDisplay, err = ret.RecipeDisplay.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketCraftRecipeResponse) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.RecipeDisplay.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (_ PlayToClientPacketCustomPayload) Decode(r io.Reader) (ret PlayToClientPacketCustomPayload, err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data, 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
|
|
}
|
|
err = ret.Data.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDamageEvent struct {
|
|
EntityId proto_base.VarInt
|
|
SourceTypeId proto_base.VarInt
|
|
SourceCauseId proto_base.VarInt
|
|
SourceDirectId proto_base.VarInt
|
|
SourcePosition *Vec3f64
|
|
}
|
|
|
|
func (_ PlayToClientPacketDamageEvent) Decode(r io.Reader) (ret PlayToClientPacketDamageEvent, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SourceTypeId, err = ret.SourceTypeId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SourceCauseId, err = ret.SourceCauseId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SourceDirectId, err = ret.SourceDirectId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketDamageEventSourcePositionPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDamageEventSourcePositionPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketDamageEventSourcePositionPresent {
|
|
var PlayToClientPacketDamageEventSourcePositionPresentValue Vec3f64
|
|
PlayToClientPacketDamageEventSourcePositionPresentValue, err = PlayToClientPacketDamageEventSourcePositionPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SourcePosition = &PlayToClientPacketDamageEventSourcePositionPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketDamageEvent) Encode(w io.Writer) (err error) {
|
|
err = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SourceTypeId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SourceCauseId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SourceDirectId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SourcePosition != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.SourcePosition != nil {
|
|
err = (*ret.SourcePosition).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDeathCombatEvent struct {
|
|
PlayerId proto_base.VarInt
|
|
Message nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketDeathCombatEvent) Decode(r io.Reader) (ret PlayToClientPacketDeathCombatEvent, err error) {
|
|
ret.PlayerId, err = ret.PlayerId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Message, err = ret.Message.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketDeathCombatEvent) Encode(w io.Writer) (err error) {
|
|
err = ret.PlayerId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Message.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDebugSample struct {
|
|
Sample []int64
|
|
Type proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketDebugSample) Decode(r io.Reader) (ret PlayToClientPacketDebugSample, err error) {
|
|
var lPlayToClientPacketDebugSampleSample proto_base.VarInt
|
|
lPlayToClientPacketDebugSampleSample, err = lPlayToClientPacketDebugSampleSample.Decode(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 = ret.Type.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketDebugSample) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.Sample)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDebugSampleSample := range len(ret.Sample) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Sample[iPlayToClientPacketDebugSampleSample])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDeclareCommands struct {
|
|
Nodes []CommandNode
|
|
RootIndex proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketDeclareCommands) Decode(r io.Reader) (ret PlayToClientPacketDeclareCommands, err error) {
|
|
var lPlayToClientPacketDeclareCommandsNodes proto_base.VarInt
|
|
lPlayToClientPacketDeclareCommandsNodes, err = lPlayToClientPacketDeclareCommandsNodes.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Nodes = []CommandNode{}
|
|
for range lPlayToClientPacketDeclareCommandsNodes {
|
|
var PlayToClientPacketDeclareCommandsNodesElement CommandNode
|
|
PlayToClientPacketDeclareCommandsNodesElement, err = PlayToClientPacketDeclareCommandsNodesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Nodes = append(ret.Nodes, PlayToClientPacketDeclareCommandsNodesElement)
|
|
}
|
|
ret.RootIndex, err = ret.RootIndex.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketDeclareCommands) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.Nodes)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareCommandsNodes := range len(ret.Nodes) {
|
|
err = ret.Nodes[iPlayToClientPacketDeclareCommandsNodes].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.RootIndex.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDeclareRecipes struct {
|
|
Recipes []struct {
|
|
Name string
|
|
Items []proto_base.VarInt
|
|
}
|
|
StoneCutterRecipes []struct {
|
|
Input IDSet
|
|
SlotDisplay PlayToClientSlotDisplay
|
|
}
|
|
}
|
|
|
|
func (_ PlayToClientPacketDeclareRecipes) Decode(r io.Reader) (ret PlayToClientPacketDeclareRecipes, err error) {
|
|
var lPlayToClientPacketDeclareRecipesRecipes proto_base.VarInt
|
|
lPlayToClientPacketDeclareRecipesRecipes, err = lPlayToClientPacketDeclareRecipesRecipes.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes = []struct {
|
|
Name string
|
|
Items []proto_base.VarInt
|
|
}{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipes {
|
|
var PlayToClientPacketDeclareRecipesRecipesElement struct {
|
|
Name string
|
|
Items []proto_base.VarInt
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketDeclareRecipesRecipesElementItems proto_base.VarInt
|
|
lPlayToClientPacketDeclareRecipesRecipesElementItems, err = lPlayToClientPacketDeclareRecipesRecipesElementItems.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Items = []proto_base.VarInt{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipesElementItems {
|
|
var PlayToClientPacketDeclareRecipesRecipesElementItemsElement proto_base.VarInt
|
|
PlayToClientPacketDeclareRecipesRecipesElementItemsElement, err = PlayToClientPacketDeclareRecipesRecipesElementItemsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Items = append(PlayToClientPacketDeclareRecipesRecipesElement.Items, PlayToClientPacketDeclareRecipesRecipesElementItemsElement)
|
|
}
|
|
ret.Recipes = append(ret.Recipes, PlayToClientPacketDeclareRecipesRecipesElement)
|
|
}
|
|
var lPlayToClientPacketDeclareRecipesStoneCutterRecipes proto_base.VarInt
|
|
lPlayToClientPacketDeclareRecipesStoneCutterRecipes, err = lPlayToClientPacketDeclareRecipesStoneCutterRecipes.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.StoneCutterRecipes = []struct {
|
|
Input IDSet
|
|
SlotDisplay PlayToClientSlotDisplay
|
|
}{}
|
|
for range lPlayToClientPacketDeclareRecipesStoneCutterRecipes {
|
|
var PlayToClientPacketDeclareRecipesStoneCutterRecipesElement struct {
|
|
Input IDSet
|
|
SlotDisplay PlayToClientSlotDisplay
|
|
}
|
|
PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.Input, err = PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.Input.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.SlotDisplay, 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.VarInt(len(ret.Recipes)).Encode(w)
|
|
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.VarInt(len(ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareRecipesRecipesInnerItems := range len(ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items) {
|
|
err = ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items[iPlayToClientPacketDeclareRecipesRecipesInnerItems].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = proto_base.VarInt(len(ret.StoneCutterRecipes)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareRecipesStoneCutterRecipes := range len(ret.StoneCutterRecipes) {
|
|
err = ret.StoneCutterRecipes[iPlayToClientPacketDeclareRecipesStoneCutterRecipes].Input.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.StoneCutterRecipes[iPlayToClientPacketDeclareRecipesStoneCutterRecipes].SlotDisplay.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDifficulty struct {
|
|
Difficulty string
|
|
DifficultyLocked bool
|
|
}
|
|
|
|
var PlayToClientPacketDifficultyDifficultyMap = map[proto_base.VarInt]string{0: "peaceful", 1: "easy", 2: "normal", 3: "hard"}
|
|
|
|
func (_ PlayToClientPacketDifficulty) Decode(r io.Reader) (ret PlayToClientPacketDifficulty, err error) {
|
|
var PlayToClientPacketDifficultyDifficultyKey proto_base.VarInt
|
|
PlayToClientPacketDifficultyDifficultyKey, err = PlayToClientPacketDifficultyDifficultyKey.Decode(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]proto_base.VarInt{"peaceful": 0, "easy": 1, "normal": 2, "hard": 3}
|
|
|
|
func (ret PlayToClientPacketDifficulty) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientPacketDifficultyDifficulty proto_base.VarInt
|
|
vPlayToClientPacketDifficultyDifficulty, err = proto_base.ErroringIndex(PlayToClientPacketDifficultyDifficultyReverseMap, ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketDifficultyDifficulty.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DifficultyLocked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEndCombatEvent struct {
|
|
Duration proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketEndCombatEvent) Decode(r io.Reader) (ret PlayToClientPacketEndCombatEvent, err error) {
|
|
ret.Duration, err = ret.Duration.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketEndCombatEvent) Encode(w io.Writer) (err error) {
|
|
err = ret.Duration.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEnterCombatEvent struct {
|
|
}
|
|
|
|
func (_ PlayToClientPacketEnterCombatEvent) Decode(r io.Reader) (ret PlayToClientPacketEnterCombatEvent, err error) {
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketEnterCombatEvent) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityDestroy struct {
|
|
EntityIds []proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityDestroy) Decode(r io.Reader) (ret PlayToClientPacketEntityDestroy, err error) {
|
|
var lPlayToClientPacketEntityDestroyEntityIds proto_base.VarInt
|
|
lPlayToClientPacketEntityDestroyEntityIds, err = lPlayToClientPacketEntityDestroyEntityIds.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityIds = []proto_base.VarInt{}
|
|
for range lPlayToClientPacketEntityDestroyEntityIds {
|
|
var PlayToClientPacketEntityDestroyEntityIdsElement proto_base.VarInt
|
|
PlayToClientPacketEntityDestroyEntityIdsElement, err = PlayToClientPacketEntityDestroyEntityIdsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityIds = append(ret.EntityIds, PlayToClientPacketEntityDestroyEntityIdsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketEntityDestroy) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.EntityIds)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityDestroyEntityIds := range len(ret.EntityIds) {
|
|
err = ret.EntityIds[iPlayToClientPacketEntityDestroyEntityIds].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityEffect struct {
|
|
EntityId proto_base.VarInt
|
|
EffectId proto_base.VarInt
|
|
Amplifier proto_base.VarInt
|
|
Duration proto_base.VarInt
|
|
Flags uint8
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityEffect) Decode(r io.Reader) (ret PlayToClientPacketEntityEffect, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EffectId, err = ret.EffectId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Amplifier, err = ret.Amplifier.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Duration, err = ret.Duration.Decode(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 = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.EffectId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Amplifier.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Duration.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityEquipment struct {
|
|
Val proto_base.ToDo
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityEquipment) Decode(r io.Reader) (ret PlayToClientPacketEntityEquipment, err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityHeadRotation struct {
|
|
EntityId proto_base.VarInt
|
|
HeadYaw int8
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityHeadRotation) Decode(r io.Reader) (ret PlayToClientPacketEntityHeadRotation, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(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 = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HeadYaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityLook struct {
|
|
EntityId proto_base.VarInt
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityLook) Decode(r io.Reader) (ret PlayToClientPacketEntityLook, err error) {
|
|
ret.EntityId, err = ret.EntityId.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
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketEntityLook) Encode(w io.Writer) (err error) {
|
|
err = ret.EntityId.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
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityMetadata struct {
|
|
EntityId proto_base.VarInt
|
|
Metadata EntityMetadata
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityMetadata) Decode(r io.Reader) (ret PlayToClientPacketEntityMetadata, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Metadata, err = ret.Metadata.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketEntityMetadata) Encode(w io.Writer) (err error) {
|
|
err = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Metadata.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityMoveLook struct {
|
|
EntityId proto_base.VarInt
|
|
DX int16
|
|
DY int16
|
|
DZ int16
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityMoveLook) Decode(r io.Reader) (ret PlayToClientPacketEntityMoveLook, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(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 = ret.EntityId.Encode(w)
|
|
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 proto_base.VarInt
|
|
Volume float32
|
|
Pitch float32
|
|
Seed int64
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntitySoundEffect) Decode(r io.Reader) (ret PlayToClientPacketEntitySoundEffect, err error) {
|
|
ret.Sound, err = ret.Sound.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SoundCategory, err = ret.SoundCategory.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId, err = ret.EntityId.Decode(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) {
|
|
err = ret.Sound.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SoundCategory.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.EntityId.Encode(w)
|
|
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 (_ PlayToClientPacketEntityStatus) Decode(r io.Reader) (ret PlayToClientPacketEntityStatus, 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 proto_base.VarInt
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityTeleport) Decode(r io.Reader) (ret PlayToClientPacketEntityTeleport, err error) {
|
|
ret.EntityId, err = ret.EntityId.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.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 = ret.EntityId.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.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 proto_base.VarInt
|
|
Properties []struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid string
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}
|
|
}
|
|
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap = map[proto_base.VarInt]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 (_ PlayToClientPacketEntityUpdateAttributes) Decode(r io.Reader) (ret PlayToClientPacketEntityUpdateAttributes, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketEntityUpdateAttributesProperties proto_base.VarInt
|
|
lPlayToClientPacketEntityUpdateAttributesProperties, err = lPlayToClientPacketEntityUpdateAttributesProperties.Decode(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 proto_base.VarInt
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey, err = PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers, err = lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers.Decode(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 PlayToClientPacketEntityUpdateAttributesPropertiesKeyReverseMap = map[string]proto_base.VarInt{"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}
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap = map[string]proto_base.VarInt{"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 = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Properties)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityUpdateAttributesProperties := range len(ret.Properties) {
|
|
var vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey proto_base.VarInt
|
|
vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers)).Encode(w)
|
|
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 proto_base.VarInt
|
|
VelocityX int16
|
|
VelocityY int16
|
|
VelocityZ int16
|
|
}
|
|
|
|
func (_ PlayToClientPacketEntityVelocity) Decode(r io.Reader) (ret PlayToClientPacketEntityVelocity, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VelocityX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VelocityY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VelocityZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketEntityVelocity) Encode(w io.Writer) (err error) {
|
|
err = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VelocityX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VelocityY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VelocityZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketExperience struct {
|
|
ExperienceBar float32
|
|
Level proto_base.VarInt
|
|
TotalExperience proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketExperience) Decode(r io.Reader) (ret PlayToClientPacketExperience, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ExperienceBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Level, err = ret.Level.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TotalExperience, err = ret.TotalExperience.Decode(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 = ret.Level.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.TotalExperience.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketExplosion struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
PlayerKnockback *Vec3f
|
|
ExplosionParticle Particle
|
|
Sound ItemSoundHolder
|
|
}
|
|
|
|
func (_ PlayToClientPacketExplosion) Decode(r io.Reader) (ret PlayToClientPacketExplosion, 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
|
|
}
|
|
var PlayToClientPacketExplosionPlayerKnockbackPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionPlayerKnockbackPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketExplosionPlayerKnockbackPresent {
|
|
var PlayToClientPacketExplosionPlayerKnockbackPresentValue Vec3f
|
|
PlayToClientPacketExplosionPlayerKnockbackPresentValue, err = PlayToClientPacketExplosionPlayerKnockbackPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PlayerKnockback = &PlayToClientPacketExplosionPlayerKnockbackPresentValue
|
|
}
|
|
ret.ExplosionParticle, err = ret.ExplosionParticle.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sound, err = ret.Sound.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketExplosion) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerKnockback != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PlayerKnockback != nil {
|
|
err = (*ret.PlayerKnockback).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.ExplosionParticle.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Sound.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketFacePlayer struct {
|
|
FeetEyes proto_base.VarInt
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
IsEntity bool
|
|
EntityId any
|
|
EntityFeetEyes any
|
|
}
|
|
|
|
func (_ PlayToClientPacketFacePlayer) Decode(r io.Reader) (ret PlayToClientPacketFacePlayer, err error) {
|
|
ret.FeetEyes, err = ret.FeetEyes.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.IsEntity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
var PlayToClientPacketFacePlayerEntityIdTmp proto_base.VarInt
|
|
PlayToClientPacketFacePlayerEntityIdTmp, err = PlayToClientPacketFacePlayerEntityIdTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketFacePlayerEntityIdTmp
|
|
default:
|
|
var PlayToClientPacketFacePlayerEntityIdTmp proto_base.Void
|
|
PlayToClientPacketFacePlayerEntityIdTmp, err = PlayToClientPacketFacePlayerEntityIdTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketFacePlayerEntityIdTmp
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
var PlayToClientPacketFacePlayerEntityFeetEyesTmp proto_base.VarInt
|
|
PlayToClientPacketFacePlayerEntityFeetEyesTmp, err = PlayToClientPacketFacePlayerEntityFeetEyesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTmp
|
|
default:
|
|
var PlayToClientPacketFacePlayerEntityFeetEyesTmp proto_base.Void
|
|
PlayToClientPacketFacePlayerEntityFeetEyesTmp, err = PlayToClientPacketFacePlayerEntityFeetEyesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketFacePlayer) Encode(w io.Writer) (err error) {
|
|
err = ret.FeetEyes.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.IsEntity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
PlayToClientPacketFacePlayerEntityId, ok := ret.EntityId.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketFacePlayerEntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityId.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.EntityId.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
PlayToClientPacketFacePlayerEntityFeetEyes, ok := ret.EntityFeetEyes.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketFacePlayerEntityFeetEyes.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityFeetEyes.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.EntityFeetEyes.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
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 (_ PlayToClientPacketGameStateChange) Decode(r io.Reader) (ret PlayToClientPacketGameStateChange, 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 PlayToClientPacketHeldItemSlot struct {
|
|
Slot proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketHeldItemSlot) Decode(r io.Reader) (ret PlayToClientPacketHeldItemSlot, err error) {
|
|
ret.Slot, err = ret.Slot.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketHeldItemSlot) Encode(w io.Writer) (err error) {
|
|
err = ret.Slot.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketHideMessage struct {
|
|
Id proto_base.VarInt
|
|
Signature any
|
|
}
|
|
|
|
func (_ PlayToClientPacketHideMessage) Decode(r io.Reader) (ret PlayToClientPacketHideMessage, err error) {
|
|
ret.Id, err = ret.Id.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Id {
|
|
case 0:
|
|
var PlayToClientPacketHideMessageSignatureTmp [256]byte
|
|
_, err = r.Read(PlayToClientPacketHideMessageSignatureTmp[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Signature = PlayToClientPacketHideMessageSignatureTmp
|
|
default:
|
|
var PlayToClientPacketHideMessageSignatureTmp proto_base.Void
|
|
PlayToClientPacketHideMessageSignatureTmp, err = PlayToClientPacketHideMessageSignatureTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Signature = PlayToClientPacketHideMessageSignatureTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketHideMessage) Encode(w io.Writer) (err error) {
|
|
err = ret.Id.Encode(w)
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Signature.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketHurtAnimation struct {
|
|
EntityId proto_base.VarInt
|
|
Yaw float32
|
|
}
|
|
|
|
func (_ PlayToClientPacketHurtAnimation) Decode(r io.Reader) (ret PlayToClientPacketHurtAnimation, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(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 = ret.EntityId.Encode(w)
|
|
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 proto_base.VarInt
|
|
PortalTeleportBoundary proto_base.VarInt
|
|
WarningBlocks proto_base.VarInt
|
|
WarningTime proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketInitializeWorldBorder) Decode(r io.Reader) (ret PlayToClientPacketInitializeWorldBorder, 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 = ret.Speed.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PortalTeleportBoundary, err = ret.PortalTeleportBoundary.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningBlocks, err = ret.WarningBlocks.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningTime, err = ret.WarningTime.Decode(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 = ret.Speed.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.PortalTeleportBoundary.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.WarningBlocks.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.WarningTime.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (_ PlayToClientPacketKeepAlive) Decode(r io.Reader) (ret PlayToClientPacketKeepAlive, 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 (_ PlayToClientPacketKickDisconnect) Decode(r io.Reader) (ret PlayToClientPacketKickDisconnect, err error) {
|
|
ret.Reason, err = ret.Reason.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketKickDisconnect) Encode(w io.Writer) (err error) {
|
|
err = ret.Reason.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketLogin struct {
|
|
EntityId int32
|
|
IsHardcore bool
|
|
WorldNames []string
|
|
MaxPlayers proto_base.VarInt
|
|
ViewDistance proto_base.VarInt
|
|
SimulationDistance proto_base.VarInt
|
|
ReducedDebugInfo bool
|
|
EnableRespawnScreen bool
|
|
DoLimitedCrafting bool
|
|
WorldState PlayToClientSpawnInfo
|
|
EnforcesSecureChat bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketLogin) Decode(r io.Reader) (ret PlayToClientPacketLogin, 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 proto_base.VarInt
|
|
lPlayToClientPacketLoginWorldNames, err = lPlayToClientPacketLoginWorldNames.Decode(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 = ret.MaxPlayers.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ViewDistance, err = ret.ViewDistance.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SimulationDistance, err = ret.SimulationDistance.Decode(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
|
|
}
|
|
ret.WorldState, 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.VarInt(len(ret.WorldNames)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketLoginWorldNames := range len(ret.WorldNames) {
|
|
err = proto_base.EncodeString(w, ret.WorldNames[iPlayToClientPacketLoginWorldNames])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.MaxPlayers.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.ViewDistance.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SimulationDistance.Encode(w)
|
|
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
|
|
}
|
|
err = ret.WorldState.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnforcesSecureChat)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMap struct {
|
|
ItemDamage proto_base.VarInt
|
|
Scale int8
|
|
Locked bool
|
|
Icons *[]struct {
|
|
Type proto_base.VarInt
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *nbt.Anon
|
|
}
|
|
Columns uint8
|
|
Rows any
|
|
X any
|
|
Y any
|
|
Data any
|
|
}
|
|
|
|
func (_ PlayToClientPacketMap) Decode(r io.Reader) (ret PlayToClientPacketMap, err error) {
|
|
ret.ItemDamage, err = ret.ItemDamage.Decode(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 proto_base.VarInt
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *nbt.Anon
|
|
}
|
|
var lPlayToClientPacketMapIcons proto_base.VarInt
|
|
lPlayToClientPacketMapIcons, err = lPlayToClientPacketMapIcons.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapIconsPresentValue = []struct {
|
|
Type proto_base.VarInt
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *nbt.Anon
|
|
}{}
|
|
for range lPlayToClientPacketMapIcons {
|
|
var PlayToClientPacketMapIconsElement struct {
|
|
Type proto_base.VarInt
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *nbt.Anon
|
|
}
|
|
PlayToClientPacketMapIconsElement.Type, err = PlayToClientPacketMapIconsElement.Type.Decode(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
|
|
PlayToClientPacketMapIconsElementDisplayNamePresentValue, 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 PlayToClientPacketMapRowsTmp proto_base.Void
|
|
PlayToClientPacketMapRowsTmp, err = PlayToClientPacketMapRowsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rows = PlayToClientPacketMapRowsTmp
|
|
default:
|
|
var PlayToClientPacketMapRowsTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapRowsTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rows = PlayToClientPacketMapRowsTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapXTmp proto_base.Void
|
|
PlayToClientPacketMapXTmp, err = PlayToClientPacketMapXTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketMapXTmp
|
|
default:
|
|
var PlayToClientPacketMapXTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapXTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketMapXTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapYTmp proto_base.Void
|
|
PlayToClientPacketMapYTmp, err = PlayToClientPacketMapYTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToClientPacketMapYTmp
|
|
default:
|
|
var PlayToClientPacketMapYTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapYTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToClientPacketMapYTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapDataTmp proto_base.Void
|
|
PlayToClientPacketMapDataTmp, err = PlayToClientPacketMapDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientPacketMapDataTmp
|
|
default:
|
|
var PlayToClientPacketMapDataTmp []byte
|
|
var lPlayToClientPacketMapData proto_base.VarInt
|
|
lPlayToClientPacketMapData, err = lPlayToClientPacketMapData.Decode(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 = ret.ItemDamage.Encode(w)
|
|
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.VarInt(len(*ret.Icons)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapIcons := range len(*ret.Icons) {
|
|
err = (*ret.Icons)[iPlayToClientPacketMapIcons].Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if (*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName != nil {
|
|
err = (*(*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Columns)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
PlayToClientPacketMapRows, ok := ret.Rows.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketMapRows.Encode(w)
|
|
if err != nil {
|
|
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:
|
|
PlayToClientPacketMapX, ok := ret.X.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketMapX.Encode(w)
|
|
if err != nil {
|
|
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:
|
|
PlayToClientPacketMapY, ok := ret.Y.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketMapY.Encode(w)
|
|
if err != nil {
|
|
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:
|
|
PlayToClientPacketMapData, ok := ret.Data.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketMapData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data.([]byte)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Data.([]byte))).Encode(w)
|
|
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[proto_base.VarInt]string{0: "world_surface_wg", 1: "world_surface", 2: "ocean_floor_wg", 3: "ocean_floor", 4: "motion_blocking", 5: "motion_blocking_no_leaves"}
|
|
|
|
func (_ PlayToClientPacketMapChunk) Decode(r io.Reader) (ret PlayToClientPacketMapChunk, 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 proto_base.VarInt
|
|
lPlayToClientPacketMapChunkHeightmaps, err = lPlayToClientPacketMapChunkHeightmaps.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Heightmaps = []struct {
|
|
Type string
|
|
Data []int64
|
|
}{}
|
|
for range lPlayToClientPacketMapChunkHeightmaps {
|
|
var PlayToClientPacketMapChunkHeightmapsElement struct {
|
|
Type string
|
|
Data []int64
|
|
}
|
|
var PlayToClientPacketMapChunkHeightmapsElementTypeKey proto_base.VarInt
|
|
PlayToClientPacketMapChunkHeightmapsElementTypeKey, err = PlayToClientPacketMapChunkHeightmapsElementTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapChunkHeightmapsElement.Type, err = proto_base.ErroringIndex(PlayToClientPacketMapChunkHeightmapsElementTypeMap, PlayToClientPacketMapChunkHeightmapsElementTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapChunkHeightmapsElementData proto_base.VarInt
|
|
lPlayToClientPacketMapChunkHeightmapsElementData, err = lPlayToClientPacketMapChunkHeightmapsElementData.Decode(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)
|
|
}
|
|
ret.ChunkData, err = ret.ChunkData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapChunkBlockEntities proto_base.VarInt
|
|
lPlayToClientPacketMapChunkBlockEntities, err = lPlayToClientPacketMapChunkBlockEntities.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockEntities = []ChunkBlockEntity{}
|
|
for range lPlayToClientPacketMapChunkBlockEntities {
|
|
var PlayToClientPacketMapChunkBlockEntitiesElement ChunkBlockEntity
|
|
PlayToClientPacketMapChunkBlockEntitiesElement, err = PlayToClientPacketMapChunkBlockEntitiesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockEntities = append(ret.BlockEntities, PlayToClientPacketMapChunkBlockEntitiesElement)
|
|
}
|
|
var lPlayToClientPacketMapChunkSkyLightMask proto_base.VarInt
|
|
lPlayToClientPacketMapChunkSkyLightMask, err = lPlayToClientPacketMapChunkSkyLightMask.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketMapChunkBlockLightMask, err = lPlayToClientPacketMapChunkBlockLightMask.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketMapChunkEmptySkyLightMask, err = lPlayToClientPacketMapChunkEmptySkyLightMask.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketMapChunkEmptyBlockLightMask, err = lPlayToClientPacketMapChunkEmptyBlockLightMask.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketMapChunkSkyLight, err = lPlayToClientPacketMapChunkSkyLight.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLight = [][]uint8{}
|
|
for range lPlayToClientPacketMapChunkSkyLight {
|
|
var PlayToClientPacketMapChunkSkyLightElement []uint8
|
|
var lPlayToClientPacketMapChunkSkyLightElement proto_base.VarInt
|
|
lPlayToClientPacketMapChunkSkyLightElement, err = lPlayToClientPacketMapChunkSkyLightElement.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketMapChunkBlockLight, err = lPlayToClientPacketMapChunkBlockLight.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLight = [][]uint8{}
|
|
for range lPlayToClientPacketMapChunkBlockLight {
|
|
var PlayToClientPacketMapChunkBlockLightElement []uint8
|
|
var lPlayToClientPacketMapChunkBlockLightElement proto_base.VarInt
|
|
lPlayToClientPacketMapChunkBlockLightElement, err = lPlayToClientPacketMapChunkBlockLightElement.Decode(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 PlayToClientPacketMapChunkHeightmapsTypeReverseMap = map[string]proto_base.VarInt{"world_surface_wg": 0, "world_surface": 1, "ocean_floor_wg": 2, "ocean_floor": 3, "motion_blocking": 4, "motion_blocking_no_leaves": 5}
|
|
var PlayToClientPacketMapChunkHeightmapsInnerTypeReverseMap = map[string]proto_base.VarInt{"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.VarInt(len(ret.Heightmaps)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkHeightmaps := range len(ret.Heightmaps) {
|
|
var vPlayToClientPacketMapChunkHeightmapsInnerType proto_base.VarInt
|
|
vPlayToClientPacketMapChunkHeightmapsInnerType, err = proto_base.ErroringIndex(PlayToClientPacketMapChunkHeightmapsInnerTypeReverseMap, ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketMapChunkHeightmapsInnerType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data)).Encode(w)
|
|
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
|
|
}
|
|
}
|
|
}
|
|
err = ret.ChunkData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.BlockEntities)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkBlockEntities := range len(ret.BlockEntities) {
|
|
err = ret.BlockEntities[iPlayToClientPacketMapChunkBlockEntities].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.VarInt(len(ret.SkyLightMask)).Encode(w)
|
|
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.VarInt(len(ret.BlockLightMask)).Encode(w)
|
|
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.VarInt(len(ret.EmptySkyLightMask)).Encode(w)
|
|
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.VarInt(len(ret.EmptyBlockLightMask)).Encode(w)
|
|
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.VarInt(len(ret.SkyLight)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkSkyLight := range len(ret.SkyLight) {
|
|
err = proto_base.VarInt(len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight])).Encode(w)
|
|
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.VarInt(len(ret.BlockLight)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkBlockLight := range len(ret.BlockLight) {
|
|
err = proto_base.VarInt(len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight])).Encode(w)
|
|
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 proto_base.VarInt
|
|
Steps []struct {
|
|
Position Vec3f
|
|
Movement Vec3f
|
|
Yaw float32
|
|
Pitch float32
|
|
Weight float32
|
|
}
|
|
}
|
|
|
|
func (_ PlayToClientPacketMoveMinecart) Decode(r io.Reader) (ret PlayToClientPacketMoveMinecart, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMoveMinecartSteps proto_base.VarInt
|
|
lPlayToClientPacketMoveMinecartSteps, err = lPlayToClientPacketMoveMinecartSteps.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Steps = []struct {
|
|
Position Vec3f
|
|
Movement Vec3f
|
|
Yaw float32
|
|
Pitch float32
|
|
Weight float32
|
|
}{}
|
|
for range lPlayToClientPacketMoveMinecartSteps {
|
|
var PlayToClientPacketMoveMinecartStepsElement struct {
|
|
Position Vec3f
|
|
Movement Vec3f
|
|
Yaw float32
|
|
Pitch float32
|
|
Weight float32
|
|
}
|
|
PlayToClientPacketMoveMinecartStepsElement.Position, err = PlayToClientPacketMoveMinecartStepsElement.Position.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMoveMinecartStepsElement.Movement, err = PlayToClientPacketMoveMinecartStepsElement.Movement.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 = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Steps)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMoveMinecartSteps := range len(ret.Steps) {
|
|
err = ret.Steps[iPlayToClientPacketMoveMinecartSteps].Position.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Steps[iPlayToClientPacketMoveMinecartSteps].Movement.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 uint64
|
|
Records []proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketMultiBlockChange) Decode(r io.Reader) (ret PlayToClientPacketMultiBlockChange, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkCoordinates)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMultiBlockChangeRecords proto_base.VarInt
|
|
lPlayToClientPacketMultiBlockChangeRecords, err = lPlayToClientPacketMultiBlockChangeRecords.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Records = []proto_base.VarInt{}
|
|
for range lPlayToClientPacketMultiBlockChangeRecords {
|
|
var PlayToClientPacketMultiBlockChangeRecordsElement proto_base.VarInt
|
|
PlayToClientPacketMultiBlockChangeRecordsElement, err = PlayToClientPacketMultiBlockChangeRecordsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkCoordinates)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Records)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) {
|
|
err = ret.Records[iPlayToClientPacketMultiBlockChangeRecords].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketNbtQueryResponse struct {
|
|
TransactionId proto_base.VarInt
|
|
Nbt nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketNbtQueryResponse) Decode(r io.Reader) (ret PlayToClientPacketNbtQueryResponse, err error) {
|
|
ret.TransactionId, err = ret.TransactionId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Nbt, err = ret.Nbt.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketNbtQueryResponse) Encode(w io.Writer) (err error) {
|
|
err = ret.TransactionId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Nbt.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenBook struct {
|
|
Hand proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketOpenBook) Decode(r io.Reader) (ret PlayToClientPacketOpenBook, err error) {
|
|
ret.Hand, err = ret.Hand.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketOpenBook) Encode(w io.Writer) (err error) {
|
|
err = ret.Hand.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenHorseWindow struct {
|
|
WindowId ContainerID
|
|
NbSlots proto_base.VarInt
|
|
EntityId int32
|
|
}
|
|
|
|
func (_ PlayToClientPacketOpenHorseWindow) Decode(r io.Reader) (ret PlayToClientPacketOpenHorseWindow, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NbSlots, err = ret.NbSlots.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketOpenHorseWindow) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NbSlots.Encode(w)
|
|
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 (_ PlayToClientPacketOpenSignEntity) Decode(r io.Reader) (ret PlayToClientPacketOpenSignEntity, err error) {
|
|
ret.Location, 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) {
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsFrontText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenWindow struct {
|
|
WindowId proto_base.VarInt
|
|
InventoryType proto_base.VarInt
|
|
WindowTitle nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketOpenWindow) Decode(r io.Reader) (ret PlayToClientPacketOpenWindow, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.InventoryType, err = ret.InventoryType.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WindowTitle, err = ret.WindowTitle.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketOpenWindow) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.InventoryType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.WindowTitle.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPing struct {
|
|
Id int32
|
|
}
|
|
|
|
func (_ PlayToClientPacketPing) Decode(r io.Reader) (ret PlayToClientPacketPing, 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 (_ PlayToClientPacketPingResponse) Decode(r io.Reader) (ret PlayToClientPacketPingResponse, 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 proto_base.VarInt
|
|
SenderUuid uuid.UUID
|
|
Index proto_base.VarInt
|
|
Signature *[256]byte
|
|
PlainMessage string
|
|
Timestamp int64
|
|
Salt int64
|
|
PreviousMessages PreviousMessages
|
|
UnsignedChatContent *nbt.Anon
|
|
FilterType proto_base.VarInt
|
|
FilterTypeMask any
|
|
Type PlayToClientChatTypesHolder
|
|
NetworkName nbt.Anon
|
|
NetworkTargetName *nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketPlayerChat) Decode(r io.Reader) (ret PlayToClientPacketPlayerChat, err error) {
|
|
ret.GlobalIndex, err = ret.GlobalIndex.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.SenderUuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Index, err = ret.Index.Decode(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
|
|
}
|
|
ret.PreviousMessages, 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
|
|
PlayToClientPacketPlayerChatUnsignedChatContentPresentValue, err = PlayToClientPacketPlayerChatUnsignedChatContentPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.UnsignedChatContent = &PlayToClientPacketPlayerChatUnsignedChatContentPresentValue
|
|
}
|
|
ret.FilterType, err = ret.FilterType.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.FilterType {
|
|
case 2:
|
|
var PlayToClientPacketPlayerChatFilterTypeMaskTmp []int64
|
|
var lPlayToClientPacketPlayerChatFilterTypeMask proto_base.VarInt
|
|
lPlayToClientPacketPlayerChatFilterTypeMask, err = lPlayToClientPacketPlayerChatFilterTypeMask.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerChatFilterTypeMaskTmp = []int64{}
|
|
for range lPlayToClientPacketPlayerChatFilterTypeMask {
|
|
var PlayToClientPacketPlayerChatFilterTypeMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatFilterTypeMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerChatFilterTypeMaskTmp = append(PlayToClientPacketPlayerChatFilterTypeMaskTmp, PlayToClientPacketPlayerChatFilterTypeMaskElement)
|
|
}
|
|
ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMaskTmp
|
|
default:
|
|
var PlayToClientPacketPlayerChatFilterTypeMaskTmp proto_base.Void
|
|
PlayToClientPacketPlayerChatFilterTypeMaskTmp, err = PlayToClientPacketPlayerChatFilterTypeMaskTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMaskTmp
|
|
}
|
|
ret.Type, err = ret.Type.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NetworkName, 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
|
|
PlayToClientPacketPlayerChatNetworkTargetNamePresentValue, err = PlayToClientPacketPlayerChatNetworkTargetNamePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NetworkTargetName = &PlayToClientPacketPlayerChatNetworkTargetNamePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketPlayerChat) Encode(w io.Writer) (err error) {
|
|
err = ret.GlobalIndex.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.SenderUuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Index.Encode(w)
|
|
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
|
|
}
|
|
err = ret.PreviousMessages.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.UnsignedChatContent != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.UnsignedChatContent != nil {
|
|
err = (*ret.UnsignedChatContent).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.FilterType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.FilterType {
|
|
case 2:
|
|
PlayToClientPacketPlayerChatFilterTypeMask, ok := ret.FilterTypeMask.([]int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(PlayToClientPacketPlayerChatFilterTypeMask)).Encode(w)
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.FilterTypeMask.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NetworkName.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.NetworkTargetName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.NetworkTargetName != nil {
|
|
err = (*ret.NetworkTargetName).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 (_ PlayToClientPacketPlayerInfo) Decode(r io.Reader) (ret PlayToClientPacketPlayerInfo, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketPlayerInfoData proto_base.VarInt
|
|
lPlayToClientPacketPlayerInfoData, err = lPlayToClientPacketPlayerInfoData.Decode(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&1 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementPlayerTmp GameProfile
|
|
PlayToClientPacketPlayerInfoDataElementPlayerTmp, err = PlayToClientPacketPlayerInfoDataElementPlayerTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementPlayerTmp proto_base.Void
|
|
PlayToClientPacketPlayerInfoDataElementPlayerTmp, err = PlayToClientPacketPlayerInfoDataElementPlayerTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTmp
|
|
}
|
|
switch ret.Action&2 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementChatSessionTmp ChatSession
|
|
PlayToClientPacketPlayerInfoDataElementChatSessionTmp, err = PlayToClientPacketPlayerInfoDataElementChatSessionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementChatSessionTmp proto_base.Void
|
|
PlayToClientPacketPlayerInfoDataElementChatSessionTmp, err = PlayToClientPacketPlayerInfoDataElementChatSessionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTmp
|
|
}
|
|
switch ret.Action&4 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementGamemodeTmp proto_base.VarInt
|
|
PlayToClientPacketPlayerInfoDataElementGamemodeTmp, err = PlayToClientPacketPlayerInfoDataElementGamemodeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementGamemodeTmp proto_base.Void
|
|
PlayToClientPacketPlayerInfoDataElementGamemodeTmp, err = PlayToClientPacketPlayerInfoDataElementGamemodeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTmp
|
|
}
|
|
switch ret.Action&8 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementListedTmp proto_base.VarInt
|
|
PlayToClientPacketPlayerInfoDataElementListedTmp, err = PlayToClientPacketPlayerInfoDataElementListedTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementListedTmp proto_base.Void
|
|
PlayToClientPacketPlayerInfoDataElementListedTmp, err = PlayToClientPacketPlayerInfoDataElementListedTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTmp
|
|
}
|
|
switch ret.Action&10 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementLatencyTmp proto_base.VarInt
|
|
PlayToClientPacketPlayerInfoDataElementLatencyTmp, err = PlayToClientPacketPlayerInfoDataElementLatencyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementLatencyTmp proto_base.Void
|
|
PlayToClientPacketPlayerInfoDataElementLatencyTmp, err = PlayToClientPacketPlayerInfoDataElementLatencyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTmp
|
|
}
|
|
switch ret.Action&20 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementDisplayNameTmp *nbt.Anon
|
|
var PlayToClientPacketPlayerInfoDataElementDisplayNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementDisplayNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataElementDisplayNamePresent {
|
|
var PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue nbt.Anon
|
|
PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue, err = PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementDisplayNameTmp = &PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementDisplayNameTmp proto_base.Void
|
|
PlayToClientPacketPlayerInfoDataElementDisplayNameTmp, err = PlayToClientPacketPlayerInfoDataElementDisplayNameTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTmp
|
|
}
|
|
switch ret.Action&80 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementListPriorityTmp proto_base.VarInt
|
|
PlayToClientPacketPlayerInfoDataElementListPriorityTmp, err = PlayToClientPacketPlayerInfoDataElementListPriorityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.ListPriority = PlayToClientPacketPlayerInfoDataElementListPriorityTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementListPriorityTmp proto_base.Void
|
|
PlayToClientPacketPlayerInfoDataElementListPriorityTmp, err = PlayToClientPacketPlayerInfoDataElementListPriorityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.ListPriority = PlayToClientPacketPlayerInfoDataElementListPriorityTmp
|
|
}
|
|
switch ret.Action&40 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementShowHatTmp bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementShowHatTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.ShowHat = PlayToClientPacketPlayerInfoDataElementShowHatTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementShowHatTmp proto_base.Void
|
|
PlayToClientPacketPlayerInfoDataElementShowHatTmp, err = PlayToClientPacketPlayerInfoDataElementShowHatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
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.VarInt(len(ret.Data)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketPlayerInfoData := range len(ret.Data) {
|
|
_, err = w.Write(ret.Data[iPlayToClientPacketPlayerInfoData].Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action&1 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerPlayer, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(GameProfile)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketPlayerInfoDataInnerPlayer.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Data[iPlayToClientPacketPlayerInfoData].Player.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&2 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerChatSession, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(ChatSession)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketPlayerInfoDataInnerChatSession.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&4 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerGamemode, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketPlayerInfoDataInnerGamemode.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&8 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerListed, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketPlayerInfoDataInnerListed.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&10 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerLatency, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketPlayerInfoDataInnerLatency.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&20 != 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 {
|
|
err = (*PlayToClientPacketPlayerInfoDataInnerDisplayName).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&80 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerListPriority, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketPlayerInfoDataInnerListPriority.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&40 != 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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Data[iPlayToClientPacketPlayerInfoData].ShowHat.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerRemove struct {
|
|
Players []uuid.UUID
|
|
}
|
|
|
|
func (_ PlayToClientPacketPlayerRemove) Decode(r io.Reader) (ret PlayToClientPacketPlayerRemove, err error) {
|
|
var lPlayToClientPacketPlayerRemovePlayers proto_base.VarInt
|
|
lPlayToClientPacketPlayerRemovePlayers, err = lPlayToClientPacketPlayerRemovePlayers.Decode(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.VarInt(len(ret.Players)).Encode(w)
|
|
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
|
|
Pitch float32
|
|
}
|
|
|
|
func (_ PlayToClientPacketPlayerRotation) Decode(r io.Reader) (ret PlayToClientPacketPlayerRotation, 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
|
|
}
|
|
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.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerlistHeader struct {
|
|
Header nbt.Anon
|
|
Footer nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketPlayerlistHeader) Decode(r io.Reader) (ret PlayToClientPacketPlayerlistHeader, err error) {
|
|
ret.Header, err = ret.Header.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Footer, err = ret.Footer.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketPlayerlistHeader) Encode(w io.Writer) (err error) {
|
|
err = ret.Header.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Footer.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPosition struct {
|
|
TeleportId proto_base.VarInt
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Dx float64
|
|
Dy float64
|
|
Dz float64
|
|
Yaw float32
|
|
Pitch float32
|
|
Flags PlayToClientPositionUpdateRelatives
|
|
}
|
|
|
|
func (_ PlayToClientPacketPosition) Decode(r io.Reader) (ret PlayToClientPacketPosition, err error) {
|
|
ret.TeleportId, err = ret.TeleportId.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.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
|
|
}
|
|
ret.Flags, err = ret.Flags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketPosition) Encode(w io.Writer) (err error) {
|
|
err = ret.TeleportId.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.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 = ret.Flags.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketProfilelessChat struct {
|
|
Message nbt.Anon
|
|
Type PlayToClientChatTypesHolder
|
|
Name nbt.Anon
|
|
Target *nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketProfilelessChat) Decode(r io.Reader) (ret PlayToClientPacketProfilelessChat, err error) {
|
|
ret.Message, err = ret.Message.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = ret.Type.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, 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
|
|
PlayToClientPacketProfilelessChatTargetPresentValue, err = PlayToClientPacketProfilelessChatTargetPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Target = &PlayToClientPacketProfilelessChatTargetPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketProfilelessChat) Encode(w io.Writer) (err error) {
|
|
err = ret.Message.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Type.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Name.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Target != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Target != nil {
|
|
err = (*ret.Target).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRecipeBookAdd struct {
|
|
Entries []struct {
|
|
Recipe struct {
|
|
DisplayId proto_base.VarInt
|
|
Display PlayToClientRecipeDisplay
|
|
Group Optvarint
|
|
Category string
|
|
CraftingRequirements *[]IDSet
|
|
}
|
|
Flags uint8
|
|
}
|
|
Replace bool
|
|
}
|
|
|
|
var PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryMap = map[proto_base.VarInt]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 (_ PlayToClientPacketRecipeBookAdd) Decode(r io.Reader) (ret PlayToClientPacketRecipeBookAdd, err error) {
|
|
var lPlayToClientPacketRecipeBookAddEntries proto_base.VarInt
|
|
lPlayToClientPacketRecipeBookAddEntries, err = lPlayToClientPacketRecipeBookAddEntries.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = []struct {
|
|
Recipe struct {
|
|
DisplayId proto_base.VarInt
|
|
Display PlayToClientRecipeDisplay
|
|
Group Optvarint
|
|
Category string
|
|
CraftingRequirements *[]IDSet
|
|
}
|
|
Flags uint8
|
|
}{}
|
|
for range lPlayToClientPacketRecipeBookAddEntries {
|
|
var PlayToClientPacketRecipeBookAddEntriesElement struct {
|
|
Recipe struct {
|
|
DisplayId proto_base.VarInt
|
|
Display PlayToClientRecipeDisplay
|
|
Group Optvarint
|
|
Category string
|
|
CraftingRequirements *[]IDSet
|
|
}
|
|
Flags uint8
|
|
}
|
|
PlayToClientPacketRecipeBookAddEntriesElement.Recipe.DisplayId, err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.DisplayId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Display, err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Display.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Group, err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Group.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey proto_base.VarInt
|
|
PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey, err = PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements, err = lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue = []IDSet{}
|
|
for range lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements {
|
|
var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement IDSet
|
|
PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement, 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 PlayToClientPacketRecipeBookAddEntriesRecipeCategoryReverseMap = map[string]proto_base.VarInt{"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}
|
|
var PlayToClientPacketRecipeBookAddEntriesInnerRecipeCategoryReverseMap = map[string]proto_base.VarInt{"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.VarInt(len(ret.Entries)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketRecipeBookAddEntries := range len(ret.Entries) {
|
|
err = ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.DisplayId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Display.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Group.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory proto_base.VarInt
|
|
vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory, err = proto_base.ErroringIndex(PlayToClientPacketRecipeBookAddEntriesInnerRecipeCategoryReverseMap, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Category)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory.Encode(w)
|
|
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.VarInt(len(*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirements := range len(*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements) {
|
|
err = (*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements)[iPlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirements].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 []proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketRecipeBookRemove) Decode(r io.Reader) (ret PlayToClientPacketRecipeBookRemove, err error) {
|
|
var lPlayToClientPacketRecipeBookRemoveRecipeIds proto_base.VarInt
|
|
lPlayToClientPacketRecipeBookRemoveRecipeIds, err = lPlayToClientPacketRecipeBookRemoveRecipeIds.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RecipeIds = []proto_base.VarInt{}
|
|
for range lPlayToClientPacketRecipeBookRemoveRecipeIds {
|
|
var PlayToClientPacketRecipeBookRemoveRecipeIdsElement proto_base.VarInt
|
|
PlayToClientPacketRecipeBookRemoveRecipeIdsElement, err = PlayToClientPacketRecipeBookRemoveRecipeIdsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RecipeIds = append(ret.RecipeIds, PlayToClientPacketRecipeBookRemoveRecipeIdsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketRecipeBookRemove) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.RecipeIds)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketRecipeBookRemoveRecipeIds := range len(ret.RecipeIds) {
|
|
err = ret.RecipeIds[iPlayToClientPacketRecipeBookRemoveRecipeIds].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRecipeBookSettings struct {
|
|
Crafting PlayToClientRecipeBookSetting
|
|
Furnace PlayToClientRecipeBookSetting
|
|
Blast PlayToClientRecipeBookSetting
|
|
Smoker PlayToClientRecipeBookSetting
|
|
}
|
|
|
|
func (_ PlayToClientPacketRecipeBookSettings) Decode(r io.Reader) (ret PlayToClientPacketRecipeBookSettings, err error) {
|
|
ret.Crafting, err = ret.Crafting.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Furnace, err = ret.Furnace.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Blast, err = ret.Blast.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Smoker, err = ret.Smoker.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketRecipeBookSettings) Encode(w io.Writer) (err error) {
|
|
err = ret.Crafting.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Furnace.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Blast.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Smoker.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRelEntityMove struct {
|
|
EntityId proto_base.VarInt
|
|
DX int16
|
|
DY int16
|
|
DZ int16
|
|
OnGround bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketRelEntityMove) Decode(r io.Reader) (ret PlayToClientPacketRelEntityMove, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(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 = ret.EntityId.Encode(w)
|
|
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 proto_base.VarInt
|
|
EffectId proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketRemoveEntityEffect) Decode(r io.Reader) (ret PlayToClientPacketRemoveEntityEffect, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EffectId, err = ret.EffectId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketRemoveEntityEffect) Encode(w io.Writer) (err error) {
|
|
err = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.EffectId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketResetScore struct {
|
|
EntityName string
|
|
ObjectiveName *string
|
|
}
|
|
|
|
func (_ PlayToClientPacketResetScore) Decode(r io.Reader) (ret PlayToClientPacketResetScore, 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 (_ PlayToClientPacketRespawn) Decode(r io.Reader) (ret PlayToClientPacketRespawn, err error) {
|
|
ret.WorldState, 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) {
|
|
err = ret.WorldState.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CopyMetadata)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardDisplayObjective struct {
|
|
Position proto_base.VarInt
|
|
Name string
|
|
}
|
|
|
|
func (_ PlayToClientPacketScoreboardDisplayObjective) Decode(r io.Reader) (ret PlayToClientPacketScoreboardDisplayObjective, err error) {
|
|
ret.Position, err = ret.Position.Decode(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 = ret.Position.Encode(w)
|
|
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 (_ PlayToClientPacketScoreboardObjective) Decode(r io.Reader) (ret PlayToClientPacketScoreboardObjective, 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 PlayToClientPacketScoreboardObjectiveDisplayTextTmp nbt.Anon
|
|
PlayToClientPacketScoreboardObjectiveDisplayTextTmp, err = PlayToClientPacketScoreboardObjectiveDisplayTextTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayTextTmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveDisplayTextTmp nbt.Anon
|
|
PlayToClientPacketScoreboardObjectiveDisplayTextTmp, err = PlayToClientPacketScoreboardObjectiveDisplayTextTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayTextTmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveDisplayTextTmp proto_base.Void
|
|
PlayToClientPacketScoreboardObjectiveDisplayTextTmp, err = PlayToClientPacketScoreboardObjectiveDisplayTextTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayTextTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveTypeTmp proto_base.VarInt
|
|
PlayToClientPacketScoreboardObjectiveTypeTmp, err = PlayToClientPacketScoreboardObjectiveTypeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveTypeTmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveTypeTmp proto_base.VarInt
|
|
PlayToClientPacketScoreboardObjectiveTypeTmp, err = PlayToClientPacketScoreboardObjectiveTypeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveTypeTmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveTypeTmp proto_base.Void
|
|
PlayToClientPacketScoreboardObjectiveTypeTmp, err = PlayToClientPacketScoreboardObjectiveTypeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveTypeTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormatTmp *proto_base.VarInt
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormatPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormatPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketScoreboardObjectiveNumberFormatPresent {
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue proto_base.VarInt
|
|
PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue, err = PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveNumberFormatTmp = &PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue
|
|
}
|
|
ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormatTmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormatTmp *proto_base.VarInt
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormatPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormatPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketScoreboardObjectiveNumberFormatPresent {
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue proto_base.VarInt
|
|
PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue, err = PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveNumberFormatTmp = &PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue
|
|
}
|
|
ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormatTmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormatTmp proto_base.Void
|
|
PlayToClientPacketScoreboardObjectiveNumberFormatTmp, err = PlayToClientPacketScoreboardObjectiveNumberFormatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormatTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp any
|
|
switch ret.NumberFormat {
|
|
case 1:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp nbt.Anon
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp, err = PlayToClientPacketScoreboardObjectiveStylingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp nbt.Anon
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp, err = PlayToClientPacketScoreboardObjectiveStylingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp proto_base.Void
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp, err = PlayToClientPacketScoreboardObjectiveStylingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
}
|
|
ret.Styling = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp any
|
|
switch ret.NumberFormat {
|
|
case 1:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp nbt.Anon
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp, err = PlayToClientPacketScoreboardObjectiveStylingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp nbt.Anon
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp, err = PlayToClientPacketScoreboardObjectiveStylingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp proto_base.Void
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp, err = PlayToClientPacketScoreboardObjectiveStylingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
}
|
|
ret.Styling = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp proto_base.Void
|
|
PlayToClientPacketScoreboardObjectiveStylingTmp, err = PlayToClientPacketScoreboardObjectiveStylingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
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
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveDisplayText.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveDisplayText.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.DisplayText.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.DisplayText.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Type.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Type.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketScoreboardObjectiveNumberFormat != nil {
|
|
err = (*PlayToClientPacketScoreboardObjectiveNumberFormat).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketScoreboardObjectiveNumberFormat != nil {
|
|
err = (*PlayToClientPacketScoreboardObjectiveNumberFormat).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.NumberFormat.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.NumberFormat.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
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
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := PlayToClientPacketScoreboardObjectiveStyling.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveStyling.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
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
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := PlayToClientPacketScoreboardObjectiveStyling.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketScoreboardObjectiveStyling.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Styling.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Styling.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardScore struct {
|
|
Val proto_base.ToDo
|
|
}
|
|
|
|
func (_ PlayToClientPacketScoreboardScore) Decode(r io.Reader) (ret PlayToClientPacketScoreboardScore, 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 (_ PlayToClientPacketSelectAdvancementTab) Decode(r io.Reader) (ret PlayToClientPacketSelectAdvancementTab, 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 (_ PlayToClientPacketServerData) Decode(r io.Reader) (ret PlayToClientPacketServerData, err error) {
|
|
ret.Motd, 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
|
|
PlayToClientPacketServerDataIconBytesPresentValue, err = PlayToClientPacketServerDataIconBytesPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.IconBytes = &PlayToClientPacketServerDataIconBytesPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketServerData) Encode(w io.Writer) (err error) {
|
|
err = ret.Motd.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IconBytes != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.IconBytes != nil {
|
|
err = (*ret.IconBytes).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetCooldown struct {
|
|
CooldownGroup string
|
|
CooldownTicks proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetCooldown) Decode(r io.Reader) (ret PlayToClientPacketSetCooldown, err error) {
|
|
ret.CooldownGroup, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CooldownTicks, err = ret.CooldownTicks.Decode(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 = ret.CooldownTicks.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetCursorItem struct {
|
|
Contents Slot
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetCursorItem) Decode(r io.Reader) (ret PlayToClientPacketSetCursorItem, err error) {
|
|
ret.Contents, err = ret.Contents.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSetCursorItem) Encode(w io.Writer) (err error) {
|
|
err = ret.Contents.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetPassengers struct {
|
|
EntityId proto_base.VarInt
|
|
Passengers []proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetPassengers) Decode(r io.Reader) (ret PlayToClientPacketSetPassengers, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketSetPassengersPassengers proto_base.VarInt
|
|
lPlayToClientPacketSetPassengersPassengers, err = lPlayToClientPacketSetPassengersPassengers.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Passengers = []proto_base.VarInt{}
|
|
for range lPlayToClientPacketSetPassengersPassengers {
|
|
var PlayToClientPacketSetPassengersPassengersElement proto_base.VarInt
|
|
PlayToClientPacketSetPassengersPassengersElement, err = PlayToClientPacketSetPassengersPassengersElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Passengers = append(ret.Passengers, PlayToClientPacketSetPassengersPassengersElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSetPassengers) Encode(w io.Writer) (err error) {
|
|
err = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Passengers)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketSetPassengersPassengers := range len(ret.Passengers) {
|
|
err = ret.Passengers[iPlayToClientPacketSetPassengersPassengers].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetPlayerInventory struct {
|
|
SlotId proto_base.VarInt
|
|
Contents Slot
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetPlayerInventory) Decode(r io.Reader) (ret PlayToClientPacketSetPlayerInventory, err error) {
|
|
ret.SlotId, err = ret.SlotId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Contents, err = ret.Contents.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSetPlayerInventory) Encode(w io.Writer) (err error) {
|
|
err = ret.SlotId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Contents.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetProjectilePower struct {
|
|
Id proto_base.VarInt
|
|
AccelerationPower float64
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetProjectilePower) Decode(r io.Reader) (ret PlayToClientPacketSetProjectilePower, err error) {
|
|
ret.Id, err = ret.Id.Decode(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 = ret.Id.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AccelerationPower)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetSlot struct {
|
|
WindowId ContainerID
|
|
StateId proto_base.VarInt
|
|
Slot int16
|
|
Item Slot
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetSlot) Decode(r io.Reader) (ret PlayToClientPacketSetSlot, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.StateId, err = ret.StateId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Item, err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSetSlot) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.StateId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetTickingState struct {
|
|
TickRate float32
|
|
IsFrozen bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetTickingState) Decode(r io.Reader) (ret PlayToClientPacketSetTickingState, 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 (_ PlayToClientPacketSetTitleSubtitle) Decode(r io.Reader) (ret PlayToClientPacketSetTitleSubtitle, err error) {
|
|
ret.Text, err = ret.Text.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSetTitleSubtitle) Encode(w io.Writer) (err error) {
|
|
err = ret.Text.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetTitleText struct {
|
|
Text nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetTitleText) Decode(r io.Reader) (ret PlayToClientPacketSetTitleText, err error) {
|
|
ret.Text, err = ret.Text.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSetTitleText) Encode(w io.Writer) (err error) {
|
|
err = ret.Text.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetTitleTime struct {
|
|
FadeIn int32
|
|
Stay int32
|
|
FadeOut int32
|
|
}
|
|
|
|
func (_ PlayToClientPacketSetTitleTime) Decode(r io.Reader) (ret PlayToClientPacketSetTitleTime, 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 (_ PlayToClientPacketShowDialog) Decode(r io.Reader) (ret PlayToClientPacketShowDialog, err error) {
|
|
var PlayToClientPacketShowDialogDialogId proto_base.VarInt
|
|
PlayToClientPacketShowDialogDialogId, err = PlayToClientPacketShowDialogDialogId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketShowDialogDialogId != 0 {
|
|
ret.Dialog = PlayToClientPacketShowDialogDialogId
|
|
return
|
|
}
|
|
var PlayToClientPacketShowDialogDialogResult nbt.Anon
|
|
PlayToClientPacketShowDialogDialogResult, 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 proto_base.VarInt:
|
|
err = PlayToClientPacketShowDialogDialogKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case nbt.Anon:
|
|
err = PlayToClientPacketShowDialogDialogKnownType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSimulationDistance struct {
|
|
Distance proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketSimulationDistance) Decode(r io.Reader) (ret PlayToClientPacketSimulationDistance, err error) {
|
|
ret.Distance, err = ret.Distance.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSimulationDistance) Encode(w io.Writer) (err error) {
|
|
err = ret.Distance.Encode(w)
|
|
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 (_ PlayToClientPacketSoundEffect) Decode(r io.Reader) (ret PlayToClientPacketSoundEffect, err error) {
|
|
ret.Sound, err = ret.Sound.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SoundCategory, 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) {
|
|
err = ret.Sound.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SoundCategory.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 proto_base.VarInt
|
|
ObjectUUID uuid.UUID
|
|
Type proto_base.VarInt
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Pitch int8
|
|
Yaw int8
|
|
HeadPitch int8
|
|
ObjectData proto_base.VarInt
|
|
VelocityX int16
|
|
VelocityY int16
|
|
VelocityZ int16
|
|
}
|
|
|
|
func (_ PlayToClientPacketSpawnEntity) Decode(r io.Reader) (ret PlayToClientPacketSpawnEntity, err error) {
|
|
ret.EntityId, err = ret.EntityId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.ObjectUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = ret.Type.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.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 = ret.ObjectData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VelocityX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VelocityY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VelocityZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSpawnEntity) Encode(w io.Writer) (err error) {
|
|
err = ret.EntityId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.ObjectUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Type.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.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 = ret.ObjectData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VelocityX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VelocityY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VelocityZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnPosition struct {
|
|
Location Position
|
|
Angle float32
|
|
}
|
|
|
|
func (_ PlayToClientPacketSpawnPosition) Decode(r io.Reader) (ret PlayToClientPacketSpawnPosition, err error) {
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Angle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketSpawnPosition) Encode(w io.Writer) (err error) {
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Angle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStartConfiguration struct {
|
|
}
|
|
|
|
func (_ PlayToClientPacketStartConfiguration) Decode(r io.Reader) (ret PlayToClientPacketStartConfiguration, err error) {
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketStartConfiguration) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStatistics struct {
|
|
Entries []struct {
|
|
CategoryId proto_base.VarInt
|
|
StatisticId proto_base.VarInt
|
|
Value proto_base.VarInt
|
|
}
|
|
}
|
|
|
|
func (_ PlayToClientPacketStatistics) Decode(r io.Reader) (ret PlayToClientPacketStatistics, err error) {
|
|
var lPlayToClientPacketStatisticsEntries proto_base.VarInt
|
|
lPlayToClientPacketStatisticsEntries, err = lPlayToClientPacketStatisticsEntries.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = []struct {
|
|
CategoryId proto_base.VarInt
|
|
StatisticId proto_base.VarInt
|
|
Value proto_base.VarInt
|
|
}{}
|
|
for range lPlayToClientPacketStatisticsEntries {
|
|
var PlayToClientPacketStatisticsEntriesElement struct {
|
|
CategoryId proto_base.VarInt
|
|
StatisticId proto_base.VarInt
|
|
Value proto_base.VarInt
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.CategoryId, err = PlayToClientPacketStatisticsEntriesElement.CategoryId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.StatisticId, err = PlayToClientPacketStatisticsEntriesElement.StatisticId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.Value, err = PlayToClientPacketStatisticsEntriesElement.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = append(ret.Entries, PlayToClientPacketStatisticsEntriesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketStatistics) Encode(w io.Writer) (err error) {
|
|
err = proto_base.VarInt(len(ret.Entries)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketStatisticsEntries := range len(ret.Entries) {
|
|
err = ret.Entries[iPlayToClientPacketStatisticsEntries].CategoryId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Entries[iPlayToClientPacketStatisticsEntries].StatisticId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Entries[iPlayToClientPacketStatisticsEntries].Value.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStepTick struct {
|
|
TickSteps proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketStepTick) Decode(r io.Reader) (ret PlayToClientPacketStepTick, err error) {
|
|
ret.TickSteps, err = ret.TickSteps.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketStepTick) Encode(w io.Writer) (err error) {
|
|
err = ret.TickSteps.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStopSound struct {
|
|
Flags int8
|
|
Source any
|
|
Sound any
|
|
}
|
|
|
|
func (_ PlayToClientPacketStopSound) Decode(r io.Reader) (ret PlayToClientPacketStopSound, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
var PlayToClientPacketStopSoundSourceTmp proto_base.VarInt
|
|
PlayToClientPacketStopSoundSourceTmp, err = PlayToClientPacketStopSoundSourceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSourceTmp
|
|
case 3:
|
|
var PlayToClientPacketStopSoundSourceTmp proto_base.VarInt
|
|
PlayToClientPacketStopSoundSourceTmp, err = PlayToClientPacketStopSoundSourceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSourceTmp
|
|
default:
|
|
var PlayToClientPacketStopSoundSourceTmp proto_base.Void
|
|
PlayToClientPacketStopSoundSourceTmp, err = PlayToClientPacketStopSoundSourceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSourceTmp
|
|
}
|
|
switch ret.Flags {
|
|
case 2:
|
|
var PlayToClientPacketStopSoundSoundTmp string
|
|
PlayToClientPacketStopSoundSoundTmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sound = PlayToClientPacketStopSoundSoundTmp
|
|
case 3:
|
|
var PlayToClientPacketStopSoundSoundTmp string
|
|
PlayToClientPacketStopSoundSoundTmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sound = PlayToClientPacketStopSoundSoundTmp
|
|
default:
|
|
var PlayToClientPacketStopSoundSoundTmp proto_base.Void
|
|
PlayToClientPacketStopSoundSoundTmp, err = PlayToClientPacketStopSoundSoundTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
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.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketStopSoundSource.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketStopSoundSource, ok := ret.Source.(proto_base.VarInt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketStopSoundSource.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Source.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Source.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
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.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Sound.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSyncEntityPosition struct {
|
|
EntityId proto_base.VarInt
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Dx float64
|
|
Dy float64
|
|
Dz float64
|
|
Yaw float32
|
|
Pitch float32
|
|
OnGround bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketSyncEntityPosition) Decode(r io.Reader) (ret PlayToClientPacketSyncEntityPosition, err error) {
|
|
ret.EntityId, err = ret.EntityId.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.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 = ret.EntityId.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.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 (_ PlayToClientPacketSystemChat) Decode(r io.Reader) (ret PlayToClientPacketSystemChat, err error) {
|
|
ret.Content, 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) {
|
|
err = ret.Content.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsActionBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTabComplete struct {
|
|
TransactionId proto_base.VarInt
|
|
Start proto_base.VarInt
|
|
Length proto_base.VarInt
|
|
Matches []struct {
|
|
Match string
|
|
Tooltip *nbt.Anon
|
|
}
|
|
}
|
|
|
|
func (_ PlayToClientPacketTabComplete) Decode(r io.Reader) (ret PlayToClientPacketTabComplete, err error) {
|
|
ret.TransactionId, err = ret.TransactionId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Start, err = ret.Start.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Length, err = ret.Length.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketTabCompleteMatches proto_base.VarInt
|
|
lPlayToClientPacketTabCompleteMatches, err = lPlayToClientPacketTabCompleteMatches.Decode(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
|
|
PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue, 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 = ret.TransactionId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Start.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Length.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Matches)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTabCompleteMatches := range len(ret.Matches) {
|
|
err = proto_base.EncodeString(w, ret.Matches[iPlayToClientPacketTabCompleteMatches].Match)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil {
|
|
err = (*ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTags struct {
|
|
Tags []struct {
|
|
TagType string
|
|
Tags Tags
|
|
}
|
|
}
|
|
|
|
func (_ PlayToClientPacketTags) Decode(r io.Reader) (ret PlayToClientPacketTags, err error) {
|
|
var lPlayToClientPacketTagsTags proto_base.VarInt
|
|
lPlayToClientPacketTagsTags, err = lPlayToClientPacketTagsTags.Decode(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
|
|
}
|
|
PlayToClientPacketTagsTagsElement.Tags, 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.VarInt(len(ret.Tags)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTagsTags := range len(ret.Tags) {
|
|
err = proto_base.EncodeString(w, ret.Tags[iPlayToClientPacketTagsTags].TagType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Tags[iPlayToClientPacketTagsTags].Tags.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 PlayToClientPacketTeamsAnonNameTagVisibilityMap = map[proto_base.VarInt]string{0: "always", 1: "never", 2: "hide_for_other_teams", 3: "hide_for_own_team"}
|
|
var PlayToClientPacketTeamsAnonCollisionRuleMap = map[proto_base.VarInt]string{0: "always", 1: "never", 2: "push_other_teams", 3: "push_own_team"}
|
|
|
|
func (_ PlayToClientPacketTeams) Decode(r io.Reader) (ret PlayToClientPacketTeams, 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 PlayToClientPacketTeamsAnonTmp struct {
|
|
Name nbt.Anon
|
|
Flags uint8
|
|
NameTagVisibility string
|
|
CollisionRule string
|
|
Formatting proto_base.VarInt
|
|
Prefix nbt.Anon
|
|
Suffix nbt.Anon
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.Name, err = PlayToClientPacketTeamsAnonTmp.Name.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsAnonTmp.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketTeamsAnonNameTagVisibilityKey proto_base.VarInt
|
|
PlayToClientPacketTeamsAnonNameTagVisibilityKey, err = PlayToClientPacketTeamsAnonNameTagVisibilityKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.NameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityMap, PlayToClientPacketTeamsAnonNameTagVisibilityKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketTeamsAnonCollisionRuleKey proto_base.VarInt
|
|
PlayToClientPacketTeamsAnonCollisionRuleKey, err = PlayToClientPacketTeamsAnonCollisionRuleKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.CollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleMap, PlayToClientPacketTeamsAnonCollisionRuleKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.Formatting, err = PlayToClientPacketTeamsAnonTmp.Formatting.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.Prefix, err = PlayToClientPacketTeamsAnonTmp.Prefix.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.Suffix, err = PlayToClientPacketTeamsAnonTmp.Suffix.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = PlayToClientPacketTeamsAnonTmp
|
|
case "change":
|
|
var PlayToClientPacketTeamsAnonTmp struct {
|
|
Name nbt.Anon
|
|
Flags uint8
|
|
NameTagVisibility string
|
|
CollisionRule string
|
|
Formatting proto_base.VarInt
|
|
Prefix nbt.Anon
|
|
Suffix nbt.Anon
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.Name, err = PlayToClientPacketTeamsAnonTmp.Name.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsAnonTmp.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketTeamsAnonNameTagVisibilityKey proto_base.VarInt
|
|
PlayToClientPacketTeamsAnonNameTagVisibilityKey, err = PlayToClientPacketTeamsAnonNameTagVisibilityKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.NameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityMap, PlayToClientPacketTeamsAnonNameTagVisibilityKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketTeamsAnonCollisionRuleKey proto_base.VarInt
|
|
PlayToClientPacketTeamsAnonCollisionRuleKey, err = PlayToClientPacketTeamsAnonCollisionRuleKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.CollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleMap, PlayToClientPacketTeamsAnonCollisionRuleKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.Formatting, err = PlayToClientPacketTeamsAnonTmp.Formatting.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.Prefix, err = PlayToClientPacketTeamsAnonTmp.Prefix.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsAnonTmp.Suffix, err = PlayToClientPacketTeamsAnonTmp.Suffix.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = PlayToClientPacketTeamsAnonTmp
|
|
default:
|
|
var PlayToClientPacketTeamsAnonTmp proto_base.Void
|
|
PlayToClientPacketTeamsAnonTmp, err = PlayToClientPacketTeamsAnonTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon = PlayToClientPacketTeamsAnonTmp
|
|
}
|
|
switch ret.Mode {
|
|
case "add":
|
|
var PlayToClientPacketTeamsPlayersTmp []string
|
|
var lPlayToClientPacketTeamsPlayers proto_base.VarInt
|
|
lPlayToClientPacketTeamsPlayers, err = lPlayToClientPacketTeamsPlayers.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayersTmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers {
|
|
var PlayToClientPacketTeamsPlayersElement string
|
|
PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayersTmp = append(PlayToClientPacketTeamsPlayersTmp, PlayToClientPacketTeamsPlayersElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayersTmp
|
|
case "join":
|
|
var PlayToClientPacketTeamsPlayersTmp []string
|
|
var lPlayToClientPacketTeamsPlayers proto_base.VarInt
|
|
lPlayToClientPacketTeamsPlayers, err = lPlayToClientPacketTeamsPlayers.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayersTmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers {
|
|
var PlayToClientPacketTeamsPlayersElement string
|
|
PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayersTmp = append(PlayToClientPacketTeamsPlayersTmp, PlayToClientPacketTeamsPlayersElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayersTmp
|
|
case "leave":
|
|
var PlayToClientPacketTeamsPlayersTmp []string
|
|
var lPlayToClientPacketTeamsPlayers proto_base.VarInt
|
|
lPlayToClientPacketTeamsPlayers, err = lPlayToClientPacketTeamsPlayers.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayersTmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers {
|
|
var PlayToClientPacketTeamsPlayersElement string
|
|
PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayersTmp = append(PlayToClientPacketTeamsPlayersTmp, PlayToClientPacketTeamsPlayersElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayersTmp
|
|
default:
|
|
var PlayToClientPacketTeamsPlayersTmp proto_base.Void
|
|
PlayToClientPacketTeamsPlayersTmp, err = PlayToClientPacketTeamsPlayersTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayersTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketTeamsModeReverseMap = map[string]int8{"add": 0, "remove": 1, "change": 2, "join": 3, "leave": 4}
|
|
var PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap = map[string]proto_base.VarInt{"always": 0, "never": 1, "hide_for_other_teams": 2, "hide_for_own_team": 3}
|
|
var PlayToClientPacketTeamsAnonCollisionRuleReverseMap = map[string]proto_base.VarInt{"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 proto_base.VarInt
|
|
Prefix nbt.Anon
|
|
Suffix nbt.Anon
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketTeamsAnon.Name.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsAnon.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vPlayToClientPacketTeamsAnonNameTagVisibility proto_base.VarInt
|
|
vPlayToClientPacketTeamsAnonNameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap, PlayToClientPacketTeamsAnon.NameTagVisibility)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketTeamsAnonNameTagVisibility.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vPlayToClientPacketTeamsAnonCollisionRule proto_base.VarInt
|
|
vPlayToClientPacketTeamsAnonCollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleReverseMap, PlayToClientPacketTeamsAnon.CollisionRule)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketTeamsAnonCollisionRule.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTeamsAnon.Formatting.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTeamsAnon.Prefix.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTeamsAnon.Suffix.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "change":
|
|
PlayToClientPacketTeamsAnon, ok := ret.Anon.(struct {
|
|
Name nbt.Anon
|
|
Flags uint8
|
|
NameTagVisibility string
|
|
CollisionRule string
|
|
Formatting proto_base.VarInt
|
|
Prefix nbt.Anon
|
|
Suffix nbt.Anon
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketTeamsAnon.Name.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsAnon.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vPlayToClientPacketTeamsAnonNameTagVisibility proto_base.VarInt
|
|
vPlayToClientPacketTeamsAnonNameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap, PlayToClientPacketTeamsAnon.NameTagVisibility)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketTeamsAnonNameTagVisibility.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vPlayToClientPacketTeamsAnonCollisionRule proto_base.VarInt
|
|
vPlayToClientPacketTeamsAnonCollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleReverseMap, PlayToClientPacketTeamsAnon.CollisionRule)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketTeamsAnonCollisionRule.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTeamsAnon.Formatting.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTeamsAnon.Prefix.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTeamsAnon.Suffix.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Anon.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Anon.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case "add":
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(PlayToClientPacketTeamsPlayers)).Encode(w)
|
|
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.VarInt(len(PlayToClientPacketTeamsPlayers)).Encode(w)
|
|
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.VarInt(len(PlayToClientPacketTeamsPlayers)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Players.(proto_base.Void)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = ret.Players.(proto_base.Void).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTestInstanceBlockStatus struct {
|
|
Status nbt.Anon
|
|
Size *Vec3i
|
|
}
|
|
|
|
func (_ PlayToClientPacketTestInstanceBlockStatus) Decode(r io.Reader) (ret PlayToClientPacketTestInstanceBlockStatus, err error) {
|
|
ret.Status, 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
|
|
PlayToClientPacketTestInstanceBlockStatusSizePresentValue, err = PlayToClientPacketTestInstanceBlockStatusSizePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Size = &PlayToClientPacketTestInstanceBlockStatusSizePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketTestInstanceBlockStatus) Encode(w io.Writer) (err error) {
|
|
err = ret.Status.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Size != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Size != nil {
|
|
err = (*ret.Size).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTileEntityData struct {
|
|
Location Position
|
|
Action proto_base.VarInt
|
|
NbtData nbt.Anon
|
|
}
|
|
|
|
func (_ PlayToClientPacketTileEntityData) Decode(r io.Reader) (ret PlayToClientPacketTileEntityData, err error) {
|
|
ret.Location, err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = ret.Action.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NbtData, err = ret.NbtData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketTileEntityData) Encode(w io.Writer) (err error) {
|
|
err = ret.Location.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Action.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NbtData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTrackedWaypoint struct {
|
|
Operation string
|
|
Waypoint struct {
|
|
HasUUID bool
|
|
Anon any
|
|
Icon struct {
|
|
Style string
|
|
Color *int32
|
|
}
|
|
Type string
|
|
Data any
|
|
}
|
|
}
|
|
|
|
var PlayToClientPacketTrackedWaypointOperationMap = map[proto_base.VarInt]string{0: "track", 1: "untrack", 2: "update"}
|
|
var PlayToClientPacketTrackedWaypointWaypointTypeMap = map[proto_base.VarInt]string{0: "empty", 1: "vec3i", 2: "chunk", 3: "azimuth"}
|
|
|
|
func (_ PlayToClientPacketTrackedWaypoint) Decode(r io.Reader) (ret PlayToClientPacketTrackedWaypoint, err error) {
|
|
var PlayToClientPacketTrackedWaypointOperationKey proto_base.VarInt
|
|
PlayToClientPacketTrackedWaypointOperationKey, err = PlayToClientPacketTrackedWaypointOperationKey.Decode(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 PlayToClientPacketTrackedWaypointWaypointAnonTmp struct {
|
|
Id string
|
|
}
|
|
PlayToClientPacketTrackedWaypointWaypointAnonTmp.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Waypoint.Anon = PlayToClientPacketTrackedWaypointWaypointAnonTmp
|
|
case true:
|
|
var PlayToClientPacketTrackedWaypointWaypointAnonTmp struct {
|
|
Uuid uuid.UUID
|
|
}
|
|
_, err = io.ReadFull(r, PlayToClientPacketTrackedWaypointWaypointAnonTmp.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Waypoint.Anon = PlayToClientPacketTrackedWaypointWaypointAnonTmp
|
|
}
|
|
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 int32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Waypoint.Icon.Color = &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue
|
|
}
|
|
var PlayToClientPacketTrackedWaypointWaypointTypeKey proto_base.VarInt
|
|
PlayToClientPacketTrackedWaypointWaypointTypeKey, err = PlayToClientPacketTrackedWaypointWaypointTypeKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Waypoint.Type, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointWaypointTypeMap, PlayToClientPacketTrackedWaypointWaypointTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Waypoint.Type {
|
|
case "azimuth":
|
|
var PlayToClientPacketTrackedWaypointWaypointDataTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointDataTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataTmp
|
|
case "chunk":
|
|
var PlayToClientPacketTrackedWaypointWaypointDataTmp struct {
|
|
ChunkX proto_base.VarInt
|
|
ChunkZ proto_base.VarInt
|
|
}
|
|
PlayToClientPacketTrackedWaypointWaypointDataTmp.ChunkX, err = PlayToClientPacketTrackedWaypointWaypointDataTmp.ChunkX.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTrackedWaypointWaypointDataTmp.ChunkZ, err = PlayToClientPacketTrackedWaypointWaypointDataTmp.ChunkZ.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataTmp
|
|
case "vec3i":
|
|
var PlayToClientPacketTrackedWaypointWaypointDataTmp Vec3i
|
|
PlayToClientPacketTrackedWaypointWaypointDataTmp, err = PlayToClientPacketTrackedWaypointWaypointDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketTrackedWaypointOperationReverseMap = map[string]proto_base.VarInt{"track": 0, "untrack": 1, "update": 2}
|
|
var PlayToClientPacketTrackedWaypointWaypointTypeReverseMap = map[string]proto_base.VarInt{"empty": 0, "vec3i": 1, "chunk": 2, "azimuth": 3}
|
|
|
|
func (ret PlayToClientPacketTrackedWaypoint) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientPacketTrackedWaypointOperation proto_base.VarInt
|
|
vPlayToClientPacketTrackedWaypointOperation, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointOperationReverseMap, ret.Operation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketTrackedWaypointOperation.Encode(w)
|
|
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)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
var vPlayToClientPacketTrackedWaypointWaypointType proto_base.VarInt
|
|
vPlayToClientPacketTrackedWaypointWaypointType, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointWaypointTypeReverseMap, ret.Waypoint.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = vPlayToClientPacketTrackedWaypointWaypointType.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Waypoint.Type {
|
|
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 proto_base.VarInt
|
|
ChunkZ proto_base.VarInt
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketTrackedWaypointWaypointData.ChunkX.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTrackedWaypointWaypointData.ChunkZ.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vec3i":
|
|
PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(Vec3i)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = PlayToClientPacketTrackedWaypointWaypointData.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTradeList struct {
|
|
WindowId ContainerID
|
|
Trades []struct {
|
|
InputItem1 struct {
|
|
ItemId proto_base.VarInt
|
|
ItemCount proto_base.VarInt
|
|
Components ExactComponentMatcher
|
|
}
|
|
OutputItem Slot
|
|
InputItem2 *struct {
|
|
ItemId proto_base.VarInt
|
|
ItemCount proto_base.VarInt
|
|
Components ExactComponentMatcher
|
|
}
|
|
TradeDisabled bool
|
|
NbTradeUses int32
|
|
MaximumNbTradeUses int32
|
|
Xp int32
|
|
SpecialPrice int32
|
|
PriceMultiplier float32
|
|
Demand int32
|
|
}
|
|
VillagerLevel proto_base.VarInt
|
|
Experience proto_base.VarInt
|
|
IsRegularVillager bool
|
|
CanRestock bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketTradeList) Decode(r io.Reader) (ret PlayToClientPacketTradeList, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketTradeListTrades proto_base.VarInt
|
|
lPlayToClientPacketTradeListTrades, err = lPlayToClientPacketTradeListTrades.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Trades = []struct {
|
|
InputItem1 struct {
|
|
ItemId proto_base.VarInt
|
|
ItemCount proto_base.VarInt
|
|
Components ExactComponentMatcher
|
|
}
|
|
OutputItem Slot
|
|
InputItem2 *struct {
|
|
ItemId proto_base.VarInt
|
|
ItemCount proto_base.VarInt
|
|
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 proto_base.VarInt
|
|
ItemCount proto_base.VarInt
|
|
Components ExactComponentMatcher
|
|
}
|
|
OutputItem Slot
|
|
InputItem2 *struct {
|
|
ItemId proto_base.VarInt
|
|
ItemCount proto_base.VarInt
|
|
Components ExactComponentMatcher
|
|
}
|
|
TradeDisabled bool
|
|
NbTradeUses int32
|
|
MaximumNbTradeUses int32
|
|
Xp int32
|
|
SpecialPrice int32
|
|
PriceMultiplier float32
|
|
Demand int32
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem1.ItemId, err = PlayToClientPacketTradeListTradesElement.InputItem1.ItemId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem1.ItemCount, err = PlayToClientPacketTradeListTradesElement.InputItem1.ItemCount.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem1.Components, err = PlayToClientPacketTradeListTradesElement.InputItem1.Components.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.OutputItem, 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 proto_base.VarInt
|
|
ItemCount proto_base.VarInt
|
|
Components ExactComponentMatcher
|
|
}
|
|
PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemId, err = PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemCount, err = PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemCount.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Components, 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 = ret.VillagerLevel.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Experience, err = ret.Experience.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsRegularVillager)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CanRestock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketTradeList) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Trades)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTradeListTrades := range len(ret.Trades) {
|
|
err = ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemCount.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.Components.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Trades[iPlayToClientPacketTradeListTrades].OutputItem.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 = (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemCount.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).Components.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 = ret.VillagerLevel.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Experience.Encode(w)
|
|
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 (_ PlayToClientPacketUnloadChunk) Decode(r io.Reader) (ret PlayToClientPacketUnloadChunk, 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 proto_base.VarInt
|
|
FoodSaturation float32
|
|
}
|
|
|
|
func (_ PlayToClientPacketUpdateHealth) Decode(r io.Reader) (ret PlayToClientPacketUpdateHealth, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Health)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Food, err = ret.Food.Decode(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 = ret.Food.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FoodSaturation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateLight struct {
|
|
ChunkX proto_base.VarInt
|
|
ChunkZ proto_base.VarInt
|
|
SkyLightMask []int64
|
|
BlockLightMask []int64
|
|
EmptySkyLightMask []int64
|
|
EmptyBlockLightMask []int64
|
|
SkyLight [][]uint8
|
|
BlockLight [][]uint8
|
|
}
|
|
|
|
func (_ PlayToClientPacketUpdateLight) Decode(r io.Reader) (ret PlayToClientPacketUpdateLight, err error) {
|
|
ret.ChunkX, err = ret.ChunkX.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkZ, err = ret.ChunkZ.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketUpdateLightSkyLightMask proto_base.VarInt
|
|
lPlayToClientPacketUpdateLightSkyLightMask, err = lPlayToClientPacketUpdateLightSkyLightMask.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketUpdateLightBlockLightMask, err = lPlayToClientPacketUpdateLightBlockLightMask.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketUpdateLightEmptySkyLightMask, err = lPlayToClientPacketUpdateLightEmptySkyLightMask.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketUpdateLightEmptyBlockLightMask, err = lPlayToClientPacketUpdateLightEmptyBlockLightMask.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketUpdateLightSkyLight, err = lPlayToClientPacketUpdateLightSkyLight.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLight = [][]uint8{}
|
|
for range lPlayToClientPacketUpdateLightSkyLight {
|
|
var PlayToClientPacketUpdateLightSkyLightElement []uint8
|
|
var lPlayToClientPacketUpdateLightSkyLightElement proto_base.VarInt
|
|
lPlayToClientPacketUpdateLightSkyLightElement, err = lPlayToClientPacketUpdateLightSkyLightElement.Decode(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 proto_base.VarInt
|
|
lPlayToClientPacketUpdateLightBlockLight, err = lPlayToClientPacketUpdateLightBlockLight.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLight = [][]uint8{}
|
|
for range lPlayToClientPacketUpdateLightBlockLight {
|
|
var PlayToClientPacketUpdateLightBlockLightElement []uint8
|
|
var lPlayToClientPacketUpdateLightBlockLightElement proto_base.VarInt
|
|
lPlayToClientPacketUpdateLightBlockLightElement, err = lPlayToClientPacketUpdateLightBlockLightElement.Decode(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 = ret.ChunkX.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.ChunkZ.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.SkyLightMask)).Encode(w)
|
|
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.VarInt(len(ret.BlockLightMask)).Encode(w)
|
|
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.VarInt(len(ret.EmptySkyLightMask)).Encode(w)
|
|
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.VarInt(len(ret.EmptyBlockLightMask)).Encode(w)
|
|
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.VarInt(len(ret.SkyLight)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightSkyLight := range len(ret.SkyLight) {
|
|
err = proto_base.VarInt(len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight])).Encode(w)
|
|
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.VarInt(len(ret.BlockLight)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightBlockLight := range len(ret.BlockLight) {
|
|
err = proto_base.VarInt(len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight])).Encode(w)
|
|
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 (_ PlayToClientPacketUpdateTime) Decode(r io.Reader) (ret PlayToClientPacketUpdateTime, 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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketUpdateViewDistance) Decode(r io.Reader) (ret PlayToClientPacketUpdateViewDistance, err error) {
|
|
ret.ViewDistance, err = ret.ViewDistance.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketUpdateViewDistance) Encode(w io.Writer) (err error) {
|
|
err = ret.ViewDistance.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateViewPosition struct {
|
|
ChunkX proto_base.VarInt
|
|
ChunkZ proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketUpdateViewPosition) Decode(r io.Reader) (ret PlayToClientPacketUpdateViewPosition, err error) {
|
|
ret.ChunkX, err = ret.ChunkX.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkZ, err = ret.ChunkZ.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketUpdateViewPosition) Encode(w io.Writer) (err error) {
|
|
err = ret.ChunkX.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.ChunkZ.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketVehicleMove struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (_ PlayToClientPacketVehicleMove) Decode(r io.Reader) (ret PlayToClientPacketVehicleMove, 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 proto_base.VarInt
|
|
Items []Slot
|
|
CarriedItem Slot
|
|
}
|
|
|
|
func (_ PlayToClientPacketWindowItems) Decode(r io.Reader) (ret PlayToClientPacketWindowItems, err error) {
|
|
ret.WindowId, err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.StateId, err = ret.StateId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketWindowItemsItems proto_base.VarInt
|
|
lPlayToClientPacketWindowItemsItems, err = lPlayToClientPacketWindowItemsItems.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Items = []Slot{}
|
|
for range lPlayToClientPacketWindowItemsItems {
|
|
var PlayToClientPacketWindowItemsItemsElement Slot
|
|
PlayToClientPacketWindowItemsItemsElement, err = PlayToClientPacketWindowItemsItemsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Items = append(ret.Items, PlayToClientPacketWindowItemsItemsElement)
|
|
}
|
|
ret.CarriedItem, err = ret.CarriedItem.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketWindowItems) Encode(w io.Writer) (err error) {
|
|
err = ret.WindowId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.StateId.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.VarInt(len(ret.Items)).Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketWindowItemsItems := range len(ret.Items) {
|
|
err = ret.Items[iPlayToClientPacketWindowItemsItems].Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = ret.CarriedItem.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorderCenter struct {
|
|
X float64
|
|
Z float64
|
|
}
|
|
|
|
func (_ PlayToClientPacketWorldBorderCenter) Decode(r io.Reader) (ret PlayToClientPacketWorldBorderCenter, 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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketWorldBorderLerpSize) Decode(r io.Reader) (ret PlayToClientPacketWorldBorderLerpSize, 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 = ret.Speed.Decode(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 = ret.Speed.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorderSize struct {
|
|
Diameter float64
|
|
}
|
|
|
|
func (_ PlayToClientPacketWorldBorderSize) Decode(r io.Reader) (ret PlayToClientPacketWorldBorderSize, 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 proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketWorldBorderWarningDelay) Decode(r io.Reader) (ret PlayToClientPacketWorldBorderWarningDelay, err error) {
|
|
ret.WarningTime, err = ret.WarningTime.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketWorldBorderWarningDelay) Encode(w io.Writer) (err error) {
|
|
err = ret.WarningTime.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorderWarningReach struct {
|
|
WarningBlocks proto_base.VarInt
|
|
}
|
|
|
|
func (_ PlayToClientPacketWorldBorderWarningReach) Decode(r io.Reader) (ret PlayToClientPacketWorldBorderWarningReach, err error) {
|
|
ret.WarningBlocks, err = ret.WarningBlocks.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret PlayToClientPacketWorldBorderWarningReach) Encode(w io.Writer) (err error) {
|
|
err = ret.WarningBlocks.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldEvent struct {
|
|
EffectId int32
|
|
Location Position
|
|
Data int32
|
|
Global bool
|
|
}
|
|
|
|
func (_ PlayToClientPacketWorldEvent) Decode(r io.Reader) (ret PlayToClientPacketWorldEvent, err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Location, 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
|
|
}
|
|
err = ret.Location.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 (_ PlayToClientPacketWorldParticles) Decode(r io.Reader) (ret PlayToClientPacketWorldParticles, 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
|
|
}
|
|
ret.Particle, 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
|
|
}
|
|
err = ret.Particle.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|