- Added 45 new version directories with protocol data - Regenerated proto_generated packages for all 54 versions - Fixed void-type packets (bundle_delimiter) in 14 protocol.json files - Copied protocol data for missing minor versions from nearest release - Updated generator to include all versions in ViaVaiVersions
24483 lines
683 KiB
Go
24483 lines
683 KiB
Go
// Code generated by strom. DO NOT EDIT.
|
|
// source: minecraft-data/pc/1.20.5/protocol.json (sha256:4afdd021d644fd56106b640ca292a17c352e341d8966c869a59922bd4208ae7f)
|
|
// version: (devel) (go1.23.4)
|
|
package v1_20_6
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"io"
|
|
"git.anygate.cloud/anygatecloud/strom/mc/proto_base"
|
|
"git.anygate.cloud/anygatecloud/strom/mc/nbt"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type ArmorTrimMaterial struct {
|
|
AssetName string
|
|
IngredientId int32
|
|
OverrideArmorAssets []struct {
|
|
Key string
|
|
Value string
|
|
}
|
|
Description nbt.Anon
|
|
}
|
|
|
|
func (ret *ArmorTrimMaterial) Decode(r io.ReadSeeker) (err error) {
|
|
ret.AssetName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.IngredientId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lArmorTrimMaterialOverrideArmorAssets int32
|
|
lArmorTrimMaterialOverrideArmorAssets, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.OverrideArmorAssets = []struct {
|
|
Key string
|
|
Value string
|
|
}{}
|
|
for range lArmorTrimMaterialOverrideArmorAssets {
|
|
var ArmorTrimMaterialOverrideArmorAssetsElement struct {
|
|
Key string
|
|
Value string
|
|
}
|
|
ArmorTrimMaterialOverrideArmorAssetsElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ArmorTrimMaterialOverrideArmorAssetsElement.Value, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.OverrideArmorAssets = append(ret.OverrideArmorAssets, ArmorTrimMaterialOverrideArmorAssetsElement)
|
|
}
|
|
err = ret.Description.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ArmorTrimMaterial) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.AssetName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.IngredientId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.OverrideArmorAssets)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iArmorTrimMaterialOverrideArmorAssets := range len(ret.OverrideArmorAssets) {
|
|
err = proto_base.EncodeString(w, ret.OverrideArmorAssets[iArmorTrimMaterialOverrideArmorAssets].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.OverrideArmorAssets[iArmorTrimMaterialOverrideArmorAssets].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
ArmorTrimMaterialDescriptionEncTmp := ret.Description
|
|
err = ArmorTrimMaterialDescriptionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ArmorTrimPattern struct {
|
|
AssetId string
|
|
TemplateItemId int32
|
|
Description nbt.Anon
|
|
Decal bool
|
|
}
|
|
|
|
func (ret *ArmorTrimPattern) Decode(r io.ReadSeeker) (err error) {
|
|
ret.AssetId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TemplateItemId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Description.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Decal)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ArmorTrimPattern) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.AssetId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.TemplateItemId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ArmorTrimPatternDescriptionEncTmp := ret.Description
|
|
err = ArmorTrimPatternDescriptionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Decal)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type BannerPattern struct {
|
|
AssetId string
|
|
TranslationKey string
|
|
}
|
|
|
|
func (ret *BannerPattern) Decode(r io.ReadSeeker) (err error) {
|
|
ret.AssetId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TranslationKey, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *BannerPattern) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.AssetId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.TranslationKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type BannerPatternLayer struct {
|
|
Pattern any
|
|
ColorId int32
|
|
}
|
|
|
|
func (ret *BannerPatternLayer) Decode(r io.ReadSeeker) (err error) {
|
|
var BannerPatternLayerPatternId int32
|
|
BannerPatternLayerPatternId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if BannerPatternLayerPatternId != 0 {
|
|
ret.Pattern = BannerPatternLayerPatternId
|
|
} else {
|
|
var BannerPatternLayerPatternResult BannerPattern
|
|
err = BannerPatternLayerPatternResult.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Pattern = BannerPatternLayerPatternResult
|
|
}
|
|
ret.ColorId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *BannerPatternLayer) Encode(w io.Writer) (err error) {
|
|
switch BannerPatternLayerPatternKnownType := ret.Pattern.(type) {
|
|
case int32:
|
|
err = proto_base.EncodeVarInt(w, BannerPatternLayerPatternKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case BannerPattern:
|
|
err = proto_base.EncodeVarInt(w, 0)
|
|
if err != nil {
|
|
return
|
|
}
|
|
BannerPatternLayerPatternOtherwiseEncTmp := BannerPatternLayerPatternKnownType
|
|
err = BannerPatternLayerPatternOtherwiseEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ColorId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ByteArray struct {
|
|
Val []byte
|
|
}
|
|
|
|
func (ret *ByteArray) Decode(r io.ReadSeeker) (err error) {
|
|
var lByteArray int32
|
|
lByteArray, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = io.ReadAll(io.LimitReader(r, int64(lByteArray)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ByteArray) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ContainerID struct {
|
|
Val uint8
|
|
}
|
|
|
|
func (ret *ContainerID) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ContainerID) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadataPaintingVariant struct {
|
|
Width int32
|
|
Height int32
|
|
AssetId string
|
|
Title *nbt.Anon
|
|
Author *nbt.Anon
|
|
}
|
|
|
|
func (ret *EntityMetadataPaintingVariant) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Width)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Height)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AssetId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var EntityMetadataPaintingVariantTitlePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataPaintingVariantTitlePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataPaintingVariantTitlePresent {
|
|
var EntityMetadataPaintingVariantTitlePresentValue nbt.Anon
|
|
err = EntityMetadataPaintingVariantTitlePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = &EntityMetadataPaintingVariantTitlePresentValue
|
|
}
|
|
var EntityMetadataPaintingVariantAuthorPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataPaintingVariantAuthorPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataPaintingVariantAuthorPresent {
|
|
var EntityMetadataPaintingVariantAuthorPresentValue nbt.Anon
|
|
err = EntityMetadataPaintingVariantAuthorPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Author = &EntityMetadataPaintingVariantAuthorPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *EntityMetadataPaintingVariant) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Width)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Height)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.AssetId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Title != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Title != nil {
|
|
EntityMetadataPaintingVariantTitleEncTmp := *ret.Title
|
|
err = EntityMetadataPaintingVariantTitleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Author != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Author != nil {
|
|
EntityMetadataPaintingVariantAuthorEncTmp := *ret.Author
|
|
err = EntityMetadataPaintingVariantAuthorEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadataWolfVariant struct {
|
|
WildTexture string
|
|
TameTexture string
|
|
AngryTexture string
|
|
Biome IDSet
|
|
}
|
|
|
|
func (ret *EntityMetadataWolfVariant) Decode(r io.ReadSeeker) (err error) {
|
|
ret.WildTexture, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TameTexture, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AngryTexture, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Biome.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *EntityMetadataWolfVariant) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.WildTexture)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.TameTexture)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.AngryTexture)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataWolfVariantBiomeEncTmp := ret.Biome
|
|
err = EntityMetadataWolfVariantBiomeEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type IDSet struct {
|
|
Val any
|
|
}
|
|
|
|
func (ret *IDSet) Decode(r io.ReadSeeker) (err error) {
|
|
var IDSetId int32
|
|
IDSetId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if IDSetId != 0 {
|
|
ret.Val = IDSetId
|
|
} else {
|
|
var IDSetResult string
|
|
IDSetResult, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = IDSetResult
|
|
}
|
|
return
|
|
}
|
|
func (ret *IDSet) Encode(w io.Writer) (err error) {
|
|
switch IDSetKnownType := ret.Val.(type) {
|
|
case string:
|
|
err = proto_base.EncodeVarInt(w, 0)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, IDSetKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case int32:
|
|
err = proto_base.EncodeVarInt(w, IDSetKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
return
|
|
}
|
|
|
|
type InstrumentData struct {
|
|
SoundEvent ItemSoundHolder
|
|
UseDuration float32
|
|
Range float32
|
|
Description nbt.Anon
|
|
}
|
|
|
|
func (ret *InstrumentData) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.SoundEvent.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.UseDuration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Range)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Description.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *InstrumentData) Encode(w io.Writer) (err error) {
|
|
InstrumentDataSoundEventEncTmp := ret.SoundEvent
|
|
err = InstrumentDataSoundEventEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.UseDuration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Range)
|
|
if err != nil {
|
|
return
|
|
}
|
|
InstrumentDataDescriptionEncTmp := ret.Description
|
|
err = InstrumentDataDescriptionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemBlockPredicate struct {
|
|
BlockSet *any
|
|
Properties *[]ItemBlockProperty
|
|
Nbt nbt.Anon
|
|
}
|
|
|
|
func (ret *ItemBlockPredicate) Decode(r io.ReadSeeker) (err error) {
|
|
var ItemBlockPredicateBlockSetPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ItemBlockPredicateBlockSetPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemBlockPredicateBlockSetPresent {
|
|
var ItemBlockPredicateBlockSetPresentValue any
|
|
var ItemBlockPredicateBlockSetId int32
|
|
ItemBlockPredicateBlockSetId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemBlockPredicateBlockSetId != 0 {
|
|
ItemBlockPredicateBlockSetPresentValue = ItemBlockPredicateBlockSetId
|
|
} else {
|
|
var ItemBlockPredicateBlockSetResult string
|
|
ItemBlockPredicateBlockSetResult, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPredicateBlockSetPresentValue = ItemBlockPredicateBlockSetResult
|
|
}
|
|
ret.BlockSet = &ItemBlockPredicateBlockSetPresentValue
|
|
}
|
|
var ItemBlockPredicatePropertiesPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ItemBlockPredicatePropertiesPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemBlockPredicatePropertiesPresent {
|
|
var ItemBlockPredicatePropertiesPresentValue []ItemBlockProperty
|
|
var lItemBlockPredicateProperties int32
|
|
lItemBlockPredicateProperties, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPredicatePropertiesPresentValue = []ItemBlockProperty{}
|
|
for range lItemBlockPredicateProperties {
|
|
var ItemBlockPredicatePropertiesElement ItemBlockProperty
|
|
err = ItemBlockPredicatePropertiesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPredicatePropertiesPresentValue = append(ItemBlockPredicatePropertiesPresentValue, ItemBlockPredicatePropertiesElement)
|
|
}
|
|
ret.Properties = &ItemBlockPredicatePropertiesPresentValue
|
|
}
|
|
err = ret.Nbt.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ItemBlockPredicate) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.BlockSet != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.BlockSet != nil {
|
|
switch ItemBlockPredicateBlockSetKnownType := (*ret.BlockSet).(type) {
|
|
case string:
|
|
err = proto_base.EncodeVarInt(w, 0)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ItemBlockPredicateBlockSetKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case int32:
|
|
err = proto_base.EncodeVarInt(w, ItemBlockPredicateBlockSetKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Properties != nil {
|
|
err = proto_base.EncodeVarInt(w, int32(len(*ret.Properties)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iItemBlockPredicateProperties := range len(*ret.Properties) {
|
|
ItemBlockPredicatePropertiesInnerEncTmp := (*ret.Properties)[iItemBlockPredicateProperties]
|
|
err = ItemBlockPredicatePropertiesInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
ItemBlockPredicateNbtEncTmp := ret.Nbt
|
|
err = ItemBlockPredicateNbtEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemBlockProperty struct {
|
|
Name string
|
|
IsExactMatch bool
|
|
Value any
|
|
}
|
|
|
|
func (ret *ItemBlockProperty) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsExactMatch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.IsExactMatch {
|
|
case false:
|
|
var ItemBlockPropertyValueFalseTmp struct {
|
|
MinValue string
|
|
MaxValue string
|
|
}
|
|
ItemBlockPropertyValueFalseTmp.MinValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemBlockPropertyValueFalseTmp.MaxValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = ItemBlockPropertyValueFalseTmp
|
|
case true:
|
|
var ItemBlockPropertyValueTrueTmp struct {
|
|
ExactValue string
|
|
}
|
|
ItemBlockPropertyValueTrueTmp.ExactValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = ItemBlockPropertyValueTrueTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *ItemBlockProperty) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsExactMatch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.IsExactMatch {
|
|
case false:
|
|
ItemBlockPropertyValue, ok := ret.Value.(struct {
|
|
MinValue string
|
|
MaxValue string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ItemBlockPropertyValue.MinValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ItemBlockPropertyValue.MaxValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case true:
|
|
ItemBlockPropertyValue, ok := ret.Value.(struct {
|
|
ExactValue string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ItemBlockPropertyValue.ExactValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemBookPage struct {
|
|
Content string
|
|
FilteredContent *string
|
|
}
|
|
|
|
func (ret *ItemBookPage) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Content, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var ItemBookPageFilteredContentPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ItemBookPageFilteredContentPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemBookPageFilteredContentPresent {
|
|
var ItemBookPageFilteredContentPresentValue string
|
|
ItemBookPageFilteredContentPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FilteredContent = &ItemBookPageFilteredContentPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ItemBookPage) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Content)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilteredContent != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.FilteredContent != nil {
|
|
err = proto_base.EncodeString(w, *ret.FilteredContent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemEffectDetail struct {
|
|
Amplifier int32
|
|
Duration int32
|
|
Ambient bool
|
|
ShowParticles bool
|
|
ShowIcon bool
|
|
HiddenEffect *ItemEffectDetail
|
|
}
|
|
|
|
func (ret *ItemEffectDetail) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Amplifier, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Duration, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Ambient)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ShowParticles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ShowIcon)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var ItemEffectDetailHiddenEffectPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ItemEffectDetailHiddenEffectPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemEffectDetailHiddenEffectPresent {
|
|
var ItemEffectDetailHiddenEffectPresentValue ItemEffectDetail
|
|
err = ItemEffectDetailHiddenEffectPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.HiddenEffect = &ItemEffectDetailHiddenEffectPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ItemEffectDetail) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Amplifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Duration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Ambient)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ShowParticles)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ShowIcon)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HiddenEffect != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.HiddenEffect != nil {
|
|
ItemEffectDetailHiddenEffectEncTmp := *ret.HiddenEffect
|
|
err = ItemEffectDetailHiddenEffectEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemFireworkExplosion struct {
|
|
Shape string
|
|
Colors []int32
|
|
FadeColors []int32
|
|
HasTrail bool
|
|
HasTwinkle bool
|
|
}
|
|
|
|
var ItemFireworkExplosionShapeMap = map[int32]string{0: "small_ball", 1: "large_ball", 2: "star", 3: "creeper", 4: "burst"}
|
|
|
|
func (ret *ItemFireworkExplosion) Decode(r io.ReadSeeker) (err error) {
|
|
var ItemFireworkExplosionShapeKey int32
|
|
ItemFireworkExplosionShapeKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Shape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeMap, ItemFireworkExplosionShapeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lItemFireworkExplosionColors int32
|
|
lItemFireworkExplosionColors, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Colors = []int32{}
|
|
for range lItemFireworkExplosionColors {
|
|
var ItemFireworkExplosionColorsElement int32
|
|
err = binary.Read(r, binary.BigEndian, &ItemFireworkExplosionColorsElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Colors = append(ret.Colors, ItemFireworkExplosionColorsElement)
|
|
}
|
|
var lItemFireworkExplosionFadeColors int32
|
|
lItemFireworkExplosionFadeColors, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FadeColors = []int32{}
|
|
for range lItemFireworkExplosionFadeColors {
|
|
var ItemFireworkExplosionFadeColorsElement int32
|
|
err = binary.Read(r, binary.BigEndian, &ItemFireworkExplosionFadeColorsElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FadeColors = append(ret.FadeColors, ItemFireworkExplosionFadeColorsElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HasTrail)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HasTwinkle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var ItemFireworkExplosionShapeReverseMap = map[string]int32{"small_ball": 0, "large_ball": 1, "star": 2, "creeper": 3, "burst": 4}
|
|
|
|
func (ret *ItemFireworkExplosion) Encode(w io.Writer) (err error) {
|
|
var vItemFireworkExplosionShape int32
|
|
vItemFireworkExplosionShape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeReverseMap, ret.Shape)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vItemFireworkExplosionShape)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Colors)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iItemFireworkExplosionColors := range len(ret.Colors) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Colors[iItemFireworkExplosionColors])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.FadeColors)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iItemFireworkExplosionFadeColors := range len(ret.FadeColors) {
|
|
err = binary.Write(w, binary.BigEndian, ret.FadeColors[iItemFireworkExplosionFadeColors])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HasTrail)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HasTwinkle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemPotionEffect struct {
|
|
Id int32
|
|
Details ItemEffectDetail
|
|
}
|
|
|
|
func (ret *ItemPotionEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Id, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Details.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ItemPotionEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemPotionEffectDetailsEncTmp := ret.Details
|
|
err = ItemPotionEffectDetailsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemSoundEvent struct {
|
|
SoundName string
|
|
FixedRange *float32
|
|
}
|
|
|
|
func (ret *ItemSoundEvent) Decode(r io.ReadSeeker) (err error) {
|
|
ret.SoundName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var ItemSoundEventFixedRangePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ItemSoundEventFixedRangePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemSoundEventFixedRangePresent {
|
|
var ItemSoundEventFixedRangePresentValue float32
|
|
err = binary.Read(r, binary.BigEndian, &ItemSoundEventFixedRangePresentValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FixedRange = &ItemSoundEventFixedRangePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ItemSoundEvent) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.SoundName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FixedRange != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.FixedRange != nil {
|
|
err = binary.Write(w, binary.BigEndian, *ret.FixedRange)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemSoundHolder struct {
|
|
Val any
|
|
}
|
|
|
|
func (ret *ItemSoundHolder) Decode(r io.ReadSeeker) (err error) {
|
|
var ItemSoundHolderId int32
|
|
ItemSoundHolderId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ItemSoundHolderId != 0 {
|
|
ret.Val = ItemSoundHolderId
|
|
} else {
|
|
var ItemSoundHolderResult ItemSoundEvent
|
|
err = ItemSoundHolderResult.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = ItemSoundHolderResult
|
|
}
|
|
return
|
|
}
|
|
func (ret *ItemSoundHolder) Encode(w io.Writer) (err error) {
|
|
switch ItemSoundHolderKnownType := ret.Val.(type) {
|
|
case int32:
|
|
err = proto_base.EncodeVarInt(w, ItemSoundHolderKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case ItemSoundEvent:
|
|
err = proto_base.EncodeVarInt(w, 0)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemSoundHolderOtherwiseEncTmp := ItemSoundHolderKnownType
|
|
err = ItemSoundHolderOtherwiseEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
return
|
|
}
|
|
|
|
type ItemWrittenBookPage struct {
|
|
Content nbt.Anon
|
|
FilteredContent nbt.Anon
|
|
}
|
|
|
|
func (ret *ItemWrittenBookPage) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Content.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.FilteredContent.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ItemWrittenBookPage) Encode(w io.Writer) (err error) {
|
|
ItemWrittenBookPageContentEncTmp := ret.Content
|
|
err = ItemWrittenBookPageContentEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ItemWrittenBookPageFilteredContentEncTmp := ret.FilteredContent
|
|
err = ItemWrittenBookPageFilteredContentEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Particle struct {
|
|
Type string
|
|
Data any
|
|
}
|
|
|
|
var ParticleTypeMap = map[int32]string{0: "angry_villager", 1: "block", 10: "landing_lava", 100: "egg_crack", 101: "dust_plume", 102: "trial_spawner_detected_player", 103: "trial_spawner_detected_player_ominous", 104: "vault_connection", 105: "dust_pillar", 106: "ominous_spawning", 107: "raid_omen", 108: "trial_omen", 11: "dripping_water", 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: "sculk_soul", 35: "sculk_charge", 36: "sculk_charge_pop", 37: "soul_fire_flame", 38: "soul", 39: "flash", 4: "cloud", 40: "happy_villager", 41: "composter", 42: "heart", 43: "instant_effect", 44: "item", 45: "vibration", 46: "item_slime", 47: "item_cobweb", 48: "item_snowball", 49: "large_smoke", 5: "crit", 50: "lava", 51: "mycelium", 52: "note", 53: "poof", 54: "portal", 55: "rain", 56: "smoke", 57: "white_smoke", 58: "sneeze", 59: "spit", 6: "damage_indicator", 60: "squid_ink", 61: "sweep_attack", 62: "totem_of_undying", 63: "underwater", 64: "splash", 65: "witch", 66: "bubble_pop", 67: "current_down", 68: "bubble_column_up", 69: "nautilus", 7: "dragon_breath", 70: "dolphin", 71: "campfire_cosy_smoke", 72: "campfire_signal_smoke", 73: "dripping_honey", 74: "falling_honey", 75: "landing_honey", 76: "falling_nectar", 77: "falling_spore_blossom", 78: "ash", 79: "crimson_spore", 8: "dripping_lava", 80: "warped_spore", 81: "spore_blossom_air", 82: "dripping_obsidian_tear", 83: "falling_obsidian_tear", 84: "landing_obsidian_tear", 85: "reverse_portal", 86: "white_ash", 87: "small_flame", 88: "snowflake", 89: "dripping_dripstone_lava", 9: "falling_lava", 90: "falling_dripstone_lava", 91: "dripping_dripstone_water", 92: "falling_dripstone_water", 93: "glow_squid_ink", 94: "glow", 95: "wax_on", 96: "wax_off", 97: "electric_spark", 98: "scrape", 99: "shriek"}
|
|
var ParticleDataVibrationTmpPositionTypeMap = map[int32]string{0: "block", 1: "entity"}
|
|
|
|
func (ret *Particle) Decode(r io.ReadSeeker) (err error) {
|
|
var ParticleTypeKey int32
|
|
ParticleTypeKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.ErroringIndex(ParticleTypeMap, ParticleTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "block":
|
|
var ParticleDataBlockTmp int32
|
|
ParticleDataBlockTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataBlockTmp
|
|
case "block_marker":
|
|
var ParticleDataBlockMarkerTmp int32
|
|
ParticleDataBlockMarkerTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataBlockMarkerTmp
|
|
case "dust":
|
|
var ParticleDataDustTmp struct {
|
|
Red float32
|
|
Green float32
|
|
Blue float32
|
|
Scale float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Red)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Green)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Blue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataDustTmp
|
|
case "dust_color_transition":
|
|
var ParticleDataDustColorTransitionTmp struct {
|
|
FromRed float32
|
|
FromGreen float32
|
|
FromBlue float32
|
|
Scale float32
|
|
ToRed float32
|
|
ToGreen float32
|
|
ToBlue float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromRed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromGreen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromBlue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToRed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToGreen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToBlue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataDustColorTransitionTmp
|
|
case "dust_pillar":
|
|
var ParticleDataDustPillarTmp int32
|
|
ParticleDataDustPillarTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataDustPillarTmp
|
|
case "entity_effect":
|
|
var ParticleDataEntityEffectTmp int32
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataEntityEffectTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataEntityEffectTmp
|
|
case "falling_dust":
|
|
var ParticleDataFallingDustTmp int32
|
|
ParticleDataFallingDustTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataFallingDustTmp
|
|
case "item":
|
|
var ParticleDataItemTmp Slot
|
|
err = ParticleDataItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataItemTmp
|
|
case "sculk_charge":
|
|
var ParticleDataSculkChargeTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataSculkChargeTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataSculkChargeTmp
|
|
case "shriek":
|
|
var ParticleDataShriekTmp int32
|
|
ParticleDataShriekTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataShriekTmp
|
|
case "vibration":
|
|
var ParticleDataVibrationTmp struct {
|
|
PositionType string
|
|
Position any
|
|
Ticks int32
|
|
}
|
|
var ParticleDataVibrationTmpPositionTypeKey int32
|
|
ParticleDataVibrationTmpPositionTypeKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ParticleDataVibrationTmp.PositionType, err = proto_base.ErroringIndex(ParticleDataVibrationTmpPositionTypeMap, ParticleDataVibrationTmpPositionTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ParticleDataVibrationTmp.PositionType {
|
|
case "block":
|
|
var ParticleDataVibrationTmpPositionBlockTmp Position
|
|
err = ParticleDataVibrationTmpPositionBlockTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ParticleDataVibrationTmp.Position = ParticleDataVibrationTmpPositionBlockTmp
|
|
case "entity":
|
|
var ParticleDataVibrationTmpPositionEntityTmp struct {
|
|
EntityId int32
|
|
EntityEyeHeight float32
|
|
}
|
|
ParticleDataVibrationTmpPositionEntityTmp.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ParticleDataVibrationTmpPositionEntityTmp.EntityEyeHeight)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ParticleDataVibrationTmp.Position = ParticleDataVibrationTmpPositionEntityTmp
|
|
}
|
|
ParticleDataVibrationTmp.Ticks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = ParticleDataVibrationTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var ParticleTypeReverseMap = map[string]int32{"angry_villager": 0, "block": 1, "landing_lava": 10, "egg_crack": 100, "dust_plume": 101, "trial_spawner_detected_player": 102, "trial_spawner_detected_player_ominous": 103, "vault_connection": 104, "dust_pillar": 105, "ominous_spawning": 106, "raid_omen": 107, "trial_omen": 108, "dripping_water": 11, "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, "sculk_soul": 34, "sculk_charge": 35, "sculk_charge_pop": 36, "soul_fire_flame": 37, "soul": 38, "flash": 39, "cloud": 4, "happy_villager": 40, "composter": 41, "heart": 42, "instant_effect": 43, "item": 44, "vibration": 45, "item_slime": 46, "item_cobweb": 47, "item_snowball": 48, "large_smoke": 49, "crit": 5, "lava": 50, "mycelium": 51, "note": 52, "poof": 53, "portal": 54, "rain": 55, "smoke": 56, "white_smoke": 57, "sneeze": 58, "spit": 59, "damage_indicator": 6, "squid_ink": 60, "sweep_attack": 61, "totem_of_undying": 62, "underwater": 63, "splash": 64, "witch": 65, "bubble_pop": 66, "current_down": 67, "bubble_column_up": 68, "nautilus": 69, "dragon_breath": 7, "dolphin": 70, "campfire_cosy_smoke": 71, "campfire_signal_smoke": 72, "dripping_honey": 73, "falling_honey": 74, "landing_honey": 75, "falling_nectar": 76, "falling_spore_blossom": 77, "ash": 78, "crimson_spore": 79, "dripping_lava": 8, "warped_spore": 80, "spore_blossom_air": 81, "dripping_obsidian_tear": 82, "falling_obsidian_tear": 83, "landing_obsidian_tear": 84, "reverse_portal": 85, "white_ash": 86, "small_flame": 87, "snowflake": 88, "dripping_dripstone_lava": 89, "falling_lava": 9, "falling_dripstone_lava": 90, "dripping_dripstone_water": 91, "falling_dripstone_water": 92, "glow_squid_ink": 93, "glow": 94, "wax_on": 95, "wax_off": 96, "electric_spark": 97, "scrape": 98, "shriek": 99}
|
|
var ParticleDataPositionTypeReverseMap = map[string]int32{"block": 0, "entity": 1}
|
|
|
|
func (ret *Particle) Encode(w io.Writer) (err error) {
|
|
var vParticleType int32
|
|
vParticleType, err = proto_base.ErroringIndex(ParticleTypeReverseMap, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vParticleType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "block":
|
|
ParticleData, ok := ret.Data.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_marker":
|
|
ParticleData, ok := ret.Data.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "dust":
|
|
ParticleData, ok := ret.Data.(struct {
|
|
Red float32
|
|
Green float32
|
|
Blue float32
|
|
Scale float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Red)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Green)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Blue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "dust_color_transition":
|
|
ParticleData, ok := ret.Data.(struct {
|
|
FromRed float32
|
|
FromGreen float32
|
|
FromBlue float32
|
|
Scale float32
|
|
ToRed float32
|
|
ToGreen float32
|
|
ToBlue float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.FromRed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.FromGreen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.FromBlue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.ToRed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.ToGreen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData.ToBlue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "dust_pillar":
|
|
ParticleData, ok := ret.Data.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_effect":
|
|
ParticleData, ok := ret.Data.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "falling_dust":
|
|
ParticleData, ok := ret.Data.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "item":
|
|
ParticleData, ok := ret.Data.(Slot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ParticleDataEncTmp := ParticleData
|
|
err = ParticleDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "sculk_charge":
|
|
ParticleData, ok := ret.Data.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "shriek":
|
|
ParticleData, ok := ret.Data.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vibration":
|
|
ParticleData, ok := ret.Data.(struct {
|
|
PositionType string
|
|
Position any
|
|
Ticks int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var vParticleDataPositionType int32
|
|
vParticleDataPositionType, err = proto_base.ErroringIndex(ParticleDataPositionTypeReverseMap, ParticleData.PositionType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vParticleDataPositionType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ParticleData.PositionType {
|
|
case "block":
|
|
ParticleDataPosition, ok := ParticleData.Position.(Position)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ParticleDataPositionEncTmp := ParticleDataPosition
|
|
err = ParticleDataPositionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity":
|
|
ParticleDataPosition, ok := ParticleData.Position.(struct {
|
|
EntityId int32
|
|
EntityEyeHeight float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleDataPosition.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ParticleDataPosition.EntityEyeHeight)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ParticleData.Ticks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type Slot struct {
|
|
ItemCount int8
|
|
Anon any
|
|
}
|
|
|
|
func (ret *Slot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.ItemCount {
|
|
case 0:
|
|
var SlotAnon0Tmp struct {
|
|
}
|
|
ret.Anon = SlotAnon0Tmp
|
|
default:
|
|
var SlotAnonTmp struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}
|
|
SlotAnonTmp.ItemId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
SlotAnonTmp.AddedComponentCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
SlotAnonTmp.RemovedComponentCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lSlotAnonComponents int32
|
|
lSlotAnonComponents = SlotAnonTmp.AddedComponentCount
|
|
SlotAnonTmp.Components = []SlotComponent{}
|
|
for range lSlotAnonComponents {
|
|
var SlotAnonComponentsElement SlotComponent
|
|
err = SlotAnonComponentsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
SlotAnonTmp.Components = append(SlotAnonTmp.Components, SlotAnonComponentsElement)
|
|
}
|
|
var lSlotAnonRemoveComponents int32
|
|
lSlotAnonRemoveComponents = SlotAnonTmp.RemovedComponentCount
|
|
SlotAnonTmp.RemoveComponents = []struct {
|
|
Type SlotComponentType
|
|
}{}
|
|
for range lSlotAnonRemoveComponents {
|
|
var SlotAnonRemoveComponentsElement struct {
|
|
Type SlotComponentType
|
|
}
|
|
err = SlotAnonRemoveComponentsElement.Type.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
SlotAnonTmp.RemoveComponents = append(SlotAnonTmp.RemoveComponents, SlotAnonRemoveComponentsElement)
|
|
}
|
|
ret.Anon = SlotAnonTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *Slot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.ItemCount {
|
|
case 0:
|
|
_, ok := ret.Anon.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Anon.(struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}).ItemId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}).AddedComponentCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}).RemovedComponentCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iSlotAnonComponents := range len(ret.Anon.(struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}).Components) {
|
|
SlotAnonComponentsInnerEncTmp := ret.Anon.(struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}).Components[iSlotAnonComponents]
|
|
err = SlotAnonComponentsInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
for iSlotAnonRemoveComponents := range len(ret.Anon.(struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}).RemoveComponents) {
|
|
SlotAnonRemoveComponentsInnerTypeEncTmp := ret.Anon.(struct {
|
|
ItemId int32
|
|
AddedComponentCount int32
|
|
RemovedComponentCount int32
|
|
Components []SlotComponent
|
|
RemoveComponents []struct {
|
|
Type SlotComponentType
|
|
}
|
|
}).RemoveComponents[iSlotAnonRemoveComponents].Type
|
|
err = SlotAnonRemoveComponentsInnerTypeEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type SlotComponent struct {
|
|
Type SlotComponentType
|
|
Data any
|
|
}
|
|
|
|
func (ret *SlotComponent) Decode(r io.ReadSeeker) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret *SlotComponent) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type SlotComponentType struct {
|
|
Val string
|
|
}
|
|
|
|
var SlotComponentTypeMap = map[int32]string{0: "custom_data", 1: "max_stack_size", 10: "can_place_on", 11: "can_break", 12: "attribute_modifiers", 13: "custom_model_data", 14: "hide_additional_tooltip", 15: "hide_tooltip", 16: "repair_cost", 17: "creative_slot_lock", 18: "enchantment_glint_override", 19: "intangible_projectile", 2: "max_damage", 20: "food", 21: "fire_resistant", 22: "tool", 23: "stored_enchantments", 24: "dyed_color", 25: "map_color", 26: "map_id", 27: "map_decorations", 28: "map_post_processing", 29: "charged_projectiles", 3: "damage", 30: "bundle_contents", 31: "potion_contents", 32: "suspicious_stew_effects", 33: "writable_book_content", 34: "written_book_content", 35: "trim", 36: "debug_stick_state", 37: "entity_data", 38: "bucket_entity_data", 39: "block_entity_data", 4: "unbreakable", 40: "instrument", 41: "ominous_bottle_amplifier", 42: "recipes", 43: "lodestone_tracker", 44: "firework_explosion", 45: "fireworks", 46: "profile", 47: "note_block_sound", 48: "banner_patterns", 49: "base_color", 5: "custom_name", 50: "pot_decorations", 51: "container", 52: "block_state", 53: "bees", 54: "lock", 55: "container_loot", 6: "item_name", 7: "lore", 8: "rarity", 9: "enchantments"}
|
|
|
|
func (ret *SlotComponentType) Decode(r io.ReadSeeker) (err error) {
|
|
var SlotComponentTypeKey int32
|
|
SlotComponentTypeKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = proto_base.ErroringIndex(SlotComponentTypeMap, SlotComponentTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var SlotComponentTypeReverseMap = map[string]int32{"custom_data": 0, "max_stack_size": 1, "can_place_on": 10, "can_break": 11, "attribute_modifiers": 12, "custom_model_data": 13, "hide_additional_tooltip": 14, "hide_tooltip": 15, "repair_cost": 16, "creative_slot_lock": 17, "enchantment_glint_override": 18, "intangible_projectile": 19, "max_damage": 2, "food": 20, "fire_resistant": 21, "tool": 22, "stored_enchantments": 23, "dyed_color": 24, "map_color": 25, "map_id": 26, "map_decorations": 27, "map_post_processing": 28, "charged_projectiles": 29, "damage": 3, "bundle_contents": 30, "potion_contents": 31, "suspicious_stew_effects": 32, "writable_book_content": 33, "written_book_content": 34, "trim": 35, "debug_stick_state": 36, "entity_data": 37, "bucket_entity_data": 38, "block_entity_data": 39, "unbreakable": 4, "instrument": 40, "ominous_bottle_amplifier": 41, "recipes": 42, "lodestone_tracker": 43, "firework_explosion": 44, "fireworks": 45, "profile": 46, "note_block_sound": 47, "banner_patterns": 48, "base_color": 49, "custom_name": 5, "pot_decorations": 50, "container": 51, "block_state": 52, "bees": 53, "lock": 54, "container_loot": 55, "item_name": 6, "lore": 7, "rarity": 8, "enchantments": 9}
|
|
|
|
func (ret *SlotComponentType) Encode(w io.Writer) (err error) {
|
|
var vSlotComponentType int32
|
|
vSlotComponentType, err = proto_base.ErroringIndex(SlotComponentTypeReverseMap, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vSlotComponentType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ChatSession struct {
|
|
Val *struct {
|
|
Uuid uuid.UUID
|
|
PublicKey struct {
|
|
ExpireTime int64
|
|
KeyBytes []byte
|
|
KeySignature []byte
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ret *ChatSession) Decode(r io.ReadSeeker) (err error) {
|
|
var ChatSessionPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ChatSessionPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ChatSessionPresent {
|
|
var ChatSessionPresentValue struct {
|
|
Uuid uuid.UUID
|
|
PublicKey struct {
|
|
ExpireTime int64
|
|
KeyBytes []byte
|
|
KeySignature []byte
|
|
}
|
|
}
|
|
_, err = io.ReadFull(r, ChatSessionPresentValue.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ChatSessionPresentValue.PublicKey.ExpireTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lChatSessionPublicKeyKeyBytes int32
|
|
lChatSessionPublicKeyKeyBytes, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ChatSessionPresentValue.PublicKey.KeyBytes, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeyBytes)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lChatSessionPublicKeyKeySignature int32
|
|
lChatSessionPublicKeyKeySignature, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ChatSessionPresentValue.PublicKey.KeySignature, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeySignature)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = &ChatSessionPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ChatSession) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Val != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Val != nil {
|
|
_, err = w.Write((*ret.Val).Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Val).PublicKey.ExpireTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len((*ret.Val).PublicKey.KeyBytes)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write((*ret.Val).PublicKey.KeyBytes)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len((*ret.Val).PublicKey.KeySignature)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write((*ret.Val).PublicKey.KeySignature)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ChunkBlockEntity struct {
|
|
Anon struct {
|
|
X uint8
|
|
Z uint8
|
|
}
|
|
Y int16
|
|
Type int32
|
|
NbtData nbt.Anon
|
|
}
|
|
|
|
func (ret *ChunkBlockEntity) Decode(r io.ReadSeeker) (err error) {
|
|
var ChunkBlockEntityAnonPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &ChunkBlockEntityAnonPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Anon.Z = ChunkBlockEntityAnonPacked >> 0 & 15
|
|
ret.Anon.X = ChunkBlockEntityAnonPacked >> 4 & 15
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NbtData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ChunkBlockEntity) Encode(w io.Writer) (err error) {
|
|
var ChunkBlockEntityAnonPacked uint8
|
|
ChunkBlockEntityAnonPacked |= (uint8(ret.Anon.Z) & 0xF) << 0x0
|
|
ChunkBlockEntityAnonPacked |= (uint8(ret.Anon.X) & 0xF) << 0x4
|
|
err = binary.Write(w, binary.BigEndian, ChunkBlockEntityAnonPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ChunkBlockEntityNbtDataEncTmp := ret.NbtData
|
|
err = ChunkBlockEntityNbtDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type CommandNode struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
HasCustomSuggestions bool
|
|
HasRedirectNode bool
|
|
HasCommand bool
|
|
CommandNodeType uint8
|
|
}
|
|
Children []int32
|
|
RedirectNode any
|
|
ExtraNodeData any
|
|
}
|
|
|
|
var CommandNodeExtraNodeData2TmpParserMap = map[int32]string{0: "brigadier:bool", 1: "brigadier:float", 10: "minecraft:vec3", 11: "minecraft:vec2", 12: "minecraft:block_state", 13: "minecraft:block_predicate", 14: "minecraft:item_stack", 15: "minecraft:item_predicate", 16: "minecraft:color", 17: "minecraft:component", 18: "minecraft:style", 19: "minecraft:message", 2: "brigadier:double", 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: "minecraft:scoreboard_slot", 3: "brigadier:integer", 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: "minecraft:float_range", 4: "brigadier:long", 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:template_mirror", 48: "minecraft:template_rotation", 49: "minecraft:heightmap", 5: "brigadier:string", 50: "minecraft:loot_table", 51: "minecraft:loot_predicate", 52: "minecraft:loot_modifier", 53: "minecraft:uuid", 6: "minecraft:entity", 7: "minecraft:game_profile", 8: "minecraft:block_pos", 9: "minecraft:column_pos"}
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpMap = map[int32]string{0: "SINGLE_WORD", 1: "QUOTABLE_PHRASE", 2: "GREEDY_PHRASE"}
|
|
|
|
func (ret *CommandNode) Decode(r io.ReadSeeker) (err error) {
|
|
var CommandNodeFlagsPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags.CommandNodeType = CommandNodeFlagsPacked >> 0 & 3
|
|
ret.Flags.HasCommand = CommandNodeFlagsPacked>>2&1 == 1
|
|
ret.Flags.HasRedirectNode = CommandNodeFlagsPacked>>3&1 == 1
|
|
ret.Flags.HasCustomSuggestions = CommandNodeFlagsPacked>>4&1 == 1
|
|
ret.Flags.Unused = CommandNodeFlagsPacked >> 5 & 7
|
|
var lCommandNodeChildren int32
|
|
lCommandNodeChildren, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Children = []int32{}
|
|
for range lCommandNodeChildren {
|
|
var CommandNodeChildrenElement int32
|
|
CommandNodeChildrenElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Children = append(ret.Children, CommandNodeChildrenElement)
|
|
}
|
|
switch ret.Flags.HasRedirectNode {
|
|
case true:
|
|
var CommandNodeRedirectNode1Tmp int32
|
|
CommandNodeRedirectNode1Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.RedirectNode = CommandNodeRedirectNode1Tmp
|
|
default:
|
|
var CommandNodeRedirectNodeTmp struct {
|
|
}
|
|
ret.RedirectNode = CommandNodeRedirectNodeTmp
|
|
}
|
|
switch ret.Flags.CommandNodeType {
|
|
case 0:
|
|
var CommandNodeExtraNodeData0Tmp struct {
|
|
}
|
|
ret.ExtraNodeData = CommandNodeExtraNodeData0Tmp
|
|
case 1:
|
|
var CommandNodeExtraNodeData1Tmp struct {
|
|
Name string
|
|
}
|
|
CommandNodeExtraNodeData1Tmp.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ExtraNodeData = CommandNodeExtraNodeData1Tmp
|
|
case 2:
|
|
var CommandNodeExtraNodeData2Tmp struct {
|
|
Name string
|
|
Parser string
|
|
Properties any
|
|
SuggestionType any
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var CommandNodeExtraNodeData2TmpParserKey int32
|
|
CommandNodeExtraNodeData2TmpParserKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Parser, err = proto_base.ErroringIndex(CommandNodeExtraNodeData2TmpParserMap, CommandNodeExtraNodeData2TmpParserKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeData2Tmp.Parser {
|
|
case "brigadier:bool":
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierBoolTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierBoolTmp
|
|
case "brigadier:double":
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
MaxPresent bool
|
|
MinPresent bool
|
|
}
|
|
Min any
|
|
Max any
|
|
}
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.MinPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked>>0&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.MaxPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked>>1&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.Unused = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpFlagsPacked >> 2 & 63
|
|
switch CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.MinPresent {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMin1Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMin1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMin1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMinTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMinTmp
|
|
}
|
|
switch CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Flags.MaxPresent {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMax1Tmp float64
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMax1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMax1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMaxTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmpMaxTmp
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierDoubleTmp
|
|
case "brigadier:float":
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
MaxPresent bool
|
|
MinPresent bool
|
|
}
|
|
Min any
|
|
Max any
|
|
}
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.MinPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked>>0&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.MaxPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked>>1&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.Unused = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpFlagsPacked >> 2 & 63
|
|
switch CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.MinPresent {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMin1Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMin1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMin1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMinTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMinTmp
|
|
}
|
|
switch CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Flags.MaxPresent {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMax1Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMax1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMax1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMaxTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmpMaxTmp
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierFloatTmp
|
|
case "brigadier:integer":
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
MaxPresent bool
|
|
MinPresent bool
|
|
}
|
|
Min any
|
|
Max any
|
|
}
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.MinPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked>>0&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.MaxPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked>>1&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.Unused = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpFlagsPacked >> 2 & 63
|
|
switch CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.MinPresent {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMin1Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMin1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMin1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMinTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMinTmp
|
|
}
|
|
switch CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Flags.MaxPresent {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMax1Tmp int32
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMax1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMax1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMaxTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmpMaxTmp
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierIntegerTmp
|
|
case "brigadier:long":
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
MaxPresent bool
|
|
MinPresent bool
|
|
}
|
|
Min any
|
|
Max any
|
|
}
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.MinPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked>>0&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.MaxPresent = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked>>1&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.Unused = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpFlagsPacked >> 2 & 63
|
|
switch CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.MinPresent {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMin1Tmp int64
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMin1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMin1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMinTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Min = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMinTmp
|
|
}
|
|
switch CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Flags.MaxPresent {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMax1Tmp int64
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMax1Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMax1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMaxTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp.Max = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmpMaxTmp
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierLongTmp
|
|
case "brigadier:string":
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmp string
|
|
var CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpKey int32
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmp, err = proto_base.ErroringIndex(CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpMap, CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmpKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesBrigadierStringTmp
|
|
case "minecraft:angle":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftAngleTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftAngleTmp
|
|
case "minecraft:block_pos":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockPosTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockPosTmp
|
|
case "minecraft:block_predicate":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockPredicateTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockPredicateTmp
|
|
case "minecraft:block_state":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockStateTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftBlockStateTmp
|
|
case "minecraft:color":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftColorTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftColorTmp
|
|
case "minecraft:column_pos":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftColumnPosTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftColumnPosTmp
|
|
case "minecraft:component":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftComponentTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftComponentTmp
|
|
case "minecraft:dimension":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftDimensionTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftDimensionTmp
|
|
case "minecraft:entity":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp struct {
|
|
Unused uint8
|
|
OnlyAllowPlayers bool
|
|
OnlyAllowEntities bool
|
|
}
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp.OnlyAllowEntities = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked>>0&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp.OnlyAllowPlayers = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked>>1&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp.Unused = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmpPacked >> 2 & 63
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityTmp
|
|
case "minecraft:entity_anchor":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityAnchorTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftEntityAnchorTmp
|
|
case "minecraft:float_range":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftFloatRangeTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftFloatRangeTmp
|
|
case "minecraft:function":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftFunctionTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftFunctionTmp
|
|
case "minecraft:game_profile":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftGameProfileTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftGameProfileTmp
|
|
case "minecraft:gamemode":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftGamemodeTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftGamemodeTmp
|
|
case "minecraft:heightmap":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftHeightmapTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftHeightmapTmp
|
|
case "minecraft:int_range":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftIntRangeTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftIntRangeTmp
|
|
case "minecraft:item_predicate":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftItemPredicateTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftItemPredicateTmp
|
|
case "minecraft:item_slot":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftItemSlotTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftItemSlotTmp
|
|
case "minecraft:item_stack":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftItemStackTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftItemStackTmp
|
|
case "minecraft:message":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftMessageTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftMessageTmp
|
|
case "minecraft:nbt":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtTmp
|
|
case "minecraft:nbt_path":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtPathTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftNbtPathTmp
|
|
case "minecraft:objective":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftObjectiveTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftObjectiveTmp
|
|
case "minecraft:objective_criteria":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftObjectiveCriteriaTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftObjectiveCriteriaTmp
|
|
case "minecraft:operation":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftOperationTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftOperationTmp
|
|
case "minecraft:particle":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftParticleTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftParticleTmp
|
|
case "minecraft:resource":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceTmp
|
|
case "minecraft:resource_key":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceKeyTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceKeyTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceKeyTmp
|
|
case "minecraft:resource_location":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceLocationTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceLocationTmp
|
|
case "minecraft:resource_or_tag":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagTmp
|
|
case "minecraft:resource_or_tag_key":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagKeyTmp struct {
|
|
Registry string
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagKeyTmp.Registry, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftResourceOrTagKeyTmp
|
|
case "minecraft:rotation":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftRotationTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftRotationTmp
|
|
case "minecraft:score_holder":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmp struct {
|
|
Unused uint8
|
|
AllowMultiple bool
|
|
}
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmpPacked uint8
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmpPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmp.AllowMultiple = CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmpPacked>>0&1 == 1
|
|
CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmp.Unused = CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmpPacked >> 1 & 127
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreHolderTmp
|
|
case "minecraft:scoreboard_slot":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreboardSlotTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftScoreboardSlotTmp
|
|
case "minecraft:swizzle":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftSwizzleTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftSwizzleTmp
|
|
case "minecraft:team":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftTeamTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftTeamTmp
|
|
case "minecraft:template_mirror":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftTemplateMirrorTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftTemplateMirrorTmp
|
|
case "minecraft:template_rotation":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftTemplateRotationTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftTemplateRotationTmp
|
|
case "minecraft:time":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftTimeTmp struct {
|
|
Min int32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeData2TmpPropertiesMinecraftTimeTmp.Min)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftTimeTmp
|
|
case "minecraft:uuid":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftUuidTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftUuidTmp
|
|
case "minecraft:vec2":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftVec2Tmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftVec2Tmp
|
|
case "minecraft:vec3":
|
|
var CommandNodeExtraNodeData2TmpPropertiesMinecraftVec3Tmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeData2TmpPropertiesMinecraftVec3Tmp
|
|
}
|
|
switch ret.Flags.HasCustomSuggestions {
|
|
case true:
|
|
var CommandNodeExtraNodeData2TmpSuggestionType1Tmp string
|
|
CommandNodeExtraNodeData2TmpSuggestionType1Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.SuggestionType = CommandNodeExtraNodeData2TmpSuggestionType1Tmp
|
|
default:
|
|
var CommandNodeExtraNodeData2TmpSuggestionTypeTmp struct {
|
|
}
|
|
CommandNodeExtraNodeData2Tmp.SuggestionType = CommandNodeExtraNodeData2TmpSuggestionTypeTmp
|
|
}
|
|
ret.ExtraNodeData = CommandNodeExtraNodeData2Tmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var CommandNodeExtraNodeDataParserReverseMap = map[string]int32{"brigadier:bool": 0, "brigadier:float": 1, "minecraft:vec3": 10, "minecraft:vec2": 11, "minecraft:block_state": 12, "minecraft:block_predicate": 13, "minecraft:item_stack": 14, "minecraft:item_predicate": 15, "minecraft:color": 16, "minecraft:component": 17, "minecraft:style": 18, "minecraft:message": 19, "brigadier:double": 2, "minecraft:nbt": 20, "minecraft:nbt_tag": 21, "minecraft:nbt_path": 22, "minecraft:objective": 23, "minecraft:objective_criteria": 24, "minecraft:operation": 25, "minecraft:particle": 26, "minecraft:angle": 27, "minecraft:rotation": 28, "minecraft:scoreboard_slot": 29, "brigadier:integer": 3, "minecraft:score_holder": 30, "minecraft:swizzle": 31, "minecraft:team": 32, "minecraft:item_slot": 33, "minecraft:item_slots": 34, "minecraft:resource_location": 35, "minecraft:function": 36, "minecraft:entity_anchor": 37, "minecraft:int_range": 38, "minecraft:float_range": 39, "brigadier:long": 4, "minecraft:dimension": 40, "minecraft:gamemode": 41, "minecraft:time": 42, "minecraft:resource_or_tag": 43, "minecraft:resource_or_tag_key": 44, "minecraft:resource": 45, "minecraft:resource_key": 46, "minecraft:template_mirror": 47, "minecraft:template_rotation": 48, "minecraft:heightmap": 49, "brigadier:string": 5, "minecraft:loot_table": 50, "minecraft:loot_predicate": 51, "minecraft:loot_modifier": 52, "minecraft:uuid": 53, "minecraft:entity": 6, "minecraft:game_profile": 7, "minecraft:block_pos": 8, "minecraft:column_pos": 9}
|
|
var CommandNodeExtraNodeDataPropertiesReverseMap = map[string]int32{"SINGLE_WORD": 0, "QUOTABLE_PHRASE": 1, "GREEDY_PHRASE": 2}
|
|
|
|
func (ret *CommandNode) Encode(w io.Writer) (err error) {
|
|
var CommandNodeFlagsPacked uint8
|
|
CommandNodeFlagsPacked |= (uint8(ret.Flags.CommandNodeType) & 0x3) << 0x0
|
|
CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasCommand) & 0x1) << 0x2
|
|
CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasRedirectNode) & 0x1) << 0x3
|
|
CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasCustomSuggestions) & 0x1) << 0x4
|
|
CommandNodeFlagsPacked |= (uint8(ret.Flags.Unused) & 0x7) << 0x5
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Children)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iCommandNodeChildren := range len(ret.Children) {
|
|
err = proto_base.EncodeVarInt(w, ret.Children[iCommandNodeChildren])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags.HasRedirectNode {
|
|
case true:
|
|
CommandNodeRedirectNode, ok := ret.RedirectNode.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, CommandNodeRedirectNode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.RedirectNode.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags.CommandNodeType {
|
|
case 0:
|
|
_, ok := ret.ExtraNodeData.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case 1:
|
|
CommandNodeExtraNodeData, ok := ret.ExtraNodeData.(struct {
|
|
Name string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, CommandNodeExtraNodeData.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
CommandNodeExtraNodeData, ok := ret.ExtraNodeData.(struct {
|
|
Name string
|
|
Parser string
|
|
Properties any
|
|
SuggestionType any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, CommandNodeExtraNodeData.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vCommandNodeExtraNodeDataParser int32
|
|
vCommandNodeExtraNodeDataParser, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataParserReverseMap, CommandNodeExtraNodeData.Parser)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vCommandNodeExtraNodeDataParser)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeData.Parser {
|
|
case "brigadier:bool":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "brigadier:double":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
MaxPresent bool
|
|
MinPresent bool
|
|
}
|
|
Min any
|
|
Max any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var CommandNodeExtraNodeDataPropertiesFlagsPacked uint8
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MinPresent) & 0x1) << 0x0
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MaxPresent) & 0x1) << 0x1
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (uint8(CommandNodeExtraNodeDataProperties.Flags.Unused) & 0x3F) << 0x2
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags.MinPresent {
|
|
case true:
|
|
CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeDataProperties.Min.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags.MaxPresent {
|
|
case true:
|
|
CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(float64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeDataProperties.Max.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
case "brigadier:float":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
MaxPresent bool
|
|
MinPresent bool
|
|
}
|
|
Min any
|
|
Max any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var CommandNodeExtraNodeDataPropertiesFlagsPacked uint8
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MinPresent) & 0x1) << 0x0
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MaxPresent) & 0x1) << 0x1
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (uint8(CommandNodeExtraNodeDataProperties.Flags.Unused) & 0x3F) << 0x2
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags.MinPresent {
|
|
case true:
|
|
CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeDataProperties.Min.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags.MaxPresent {
|
|
case true:
|
|
CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeDataProperties.Max.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
case "brigadier:integer":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
MaxPresent bool
|
|
MinPresent bool
|
|
}
|
|
Min any
|
|
Max any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var CommandNodeExtraNodeDataPropertiesFlagsPacked uint8
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MinPresent) & 0x1) << 0x0
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MaxPresent) & 0x1) << 0x1
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (uint8(CommandNodeExtraNodeDataProperties.Flags.Unused) & 0x3F) << 0x2
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags.MinPresent {
|
|
case true:
|
|
CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeDataProperties.Min.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags.MaxPresent {
|
|
case true:
|
|
CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeDataProperties.Max.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
case "brigadier:long":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Flags struct {
|
|
Unused uint8
|
|
MaxPresent bool
|
|
MinPresent bool
|
|
}
|
|
Min any
|
|
Max any
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var CommandNodeExtraNodeDataPropertiesFlagsPacked uint8
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MinPresent) & 0x1) << 0x0
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.Flags.MaxPresent) & 0x1) << 0x1
|
|
CommandNodeExtraNodeDataPropertiesFlagsPacked |= (uint8(CommandNodeExtraNodeDataProperties.Flags.Unused) & 0x3F) << 0x2
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags.MinPresent {
|
|
case true:
|
|
CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeDataProperties.Min.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch CommandNodeExtraNodeDataProperties.Flags.MaxPresent {
|
|
case true:
|
|
CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeDataProperties.Max.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
case "brigadier:string":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var vCommandNodeExtraNodeDataProperties int32
|
|
vCommandNodeExtraNodeDataProperties, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataPropertiesReverseMap, CommandNodeExtraNodeDataProperties)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vCommandNodeExtraNodeDataProperties)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:angle":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:block_pos":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:block_predicate":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:block_state":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:color":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:column_pos":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:component":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:dimension":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:entity":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Unused uint8
|
|
OnlyAllowPlayers bool
|
|
OnlyAllowEntities bool
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var CommandNodeExtraNodeDataPropertiesPacked uint8
|
|
CommandNodeExtraNodeDataPropertiesPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.OnlyAllowEntities) & 0x1) << 0x0
|
|
CommandNodeExtraNodeDataPropertiesPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.OnlyAllowPlayers) & 0x1) << 0x1
|
|
CommandNodeExtraNodeDataPropertiesPacked |= (uint8(CommandNodeExtraNodeDataProperties.Unused) & 0x3F) << 0x2
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:entity_anchor":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:float_range":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:function":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:game_profile":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:gamemode":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:heightmap":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:int_range":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:item_predicate":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:item_slot":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:item_stack":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:message":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:nbt":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:nbt_path":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:objective":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:objective_criteria":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:operation":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:particle":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:resource":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Registry string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:resource_key":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Registry string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:resource_location":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:resource_or_tag":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Registry string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:resource_or_tag_key":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Registry string
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:rotation":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:score_holder":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Unused uint8
|
|
AllowMultiple bool
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
var CommandNodeExtraNodeDataPropertiesPacked uint8
|
|
CommandNodeExtraNodeDataPropertiesPacked |= (proto_base.Bool2uint8(CommandNodeExtraNodeDataProperties.AllowMultiple) & 0x1) << 0x0
|
|
CommandNodeExtraNodeDataPropertiesPacked |= (uint8(CommandNodeExtraNodeDataProperties.Unused) & 0x7F) << 0x1
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:scoreboard_slot":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:swizzle":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:team":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:template_mirror":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:template_rotation":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:time":
|
|
CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
Min int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Min)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:uuid":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:vec2":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
case "minecraft:vec3":
|
|
_, ok := CommandNodeExtraNodeData.Properties.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags.HasCustomSuggestions {
|
|
case true:
|
|
CommandNodeExtraNodeDataSuggestionType, ok := CommandNodeExtraNodeData.SuggestionType.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, CommandNodeExtraNodeDataSuggestionType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := CommandNodeExtraNodeData.SuggestionType.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadata struct {
|
|
Val map[byte]EntityMetadataEntry
|
|
}
|
|
|
|
func (ret *EntityMetadata) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Val = make(map[uint8]EntityMetadataEntry)
|
|
var id uint8
|
|
for {
|
|
err = binary.Read(r, binary.BigEndian, &id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if id == 255 {
|
|
break
|
|
}
|
|
_, err = r.Seek(-1, io.SeekCurrent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var entry EntityMetadataEntry
|
|
err = entry.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val[id] = entry
|
|
}
|
|
return
|
|
}
|
|
func (ret *EntityMetadata) Encode(w io.Writer) (err error) {
|
|
for _, v := range ret.Val {
|
|
EntityMetadataEncTmp := v
|
|
err = EntityMetadataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, uint8(255))
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type EntityMetadataEntry struct {
|
|
Key uint8
|
|
Type string
|
|
Value any
|
|
}
|
|
|
|
var EntityMetadataEntryTypeMap = map[int32]string{0: "byte", 1: "int", 10: "block_pos", 11: "optional_block_pos", 12: "direction", 13: "optional_uuid", 14: "block_state", 15: "optional_block_state", 16: "compound_tag", 17: "particle", 18: "particles", 19: "villager_data", 2: "long", 20: "optional_unsigned_int", 21: "pose", 22: "cat_variant", 23: "wolf_variant", 24: "frog_variant", 25: "optional_global_pos", 26: "painting_variant", 27: "sniffer_state", 28: "armadillo_state", 29: "vector3", 3: "float", 30: "quaternion", 4: "string", 5: "component", 6: "optional_component", 7: "item_stack", 8: "boolean", 9: "rotations"}
|
|
|
|
func (ret *EntityMetadataEntry) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var EntityMetadataEntryTypeKey int32
|
|
EntityMetadataEntryTypeKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.ErroringIndex(EntityMetadataEntryTypeMap, EntityMetadataEntryTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "armadillo_state":
|
|
var EntityMetadataEntryValueArmadilloStateTmp int32
|
|
EntityMetadataEntryValueArmadilloStateTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueArmadilloStateTmp
|
|
case "block_pos":
|
|
var EntityMetadataEntryValueBlockPosTmp Position
|
|
err = EntityMetadataEntryValueBlockPosTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueBlockPosTmp
|
|
case "block_state":
|
|
var EntityMetadataEntryValueBlockStateTmp int32
|
|
EntityMetadataEntryValueBlockStateTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueBlockStateTmp
|
|
case "boolean":
|
|
var EntityMetadataEntryValueBooleanTmp bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueBooleanTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueBooleanTmp
|
|
case "byte":
|
|
var EntityMetadataEntryValueByteTmp int8
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueByteTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueByteTmp
|
|
case "cat_variant":
|
|
var EntityMetadataEntryValueCatVariantTmp int32
|
|
EntityMetadataEntryValueCatVariantTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueCatVariantTmp
|
|
case "component":
|
|
var EntityMetadataEntryValueComponentTmp nbt.Anon
|
|
err = EntityMetadataEntryValueComponentTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueComponentTmp
|
|
case "compound_tag":
|
|
var EntityMetadataEntryValueCompoundTagTmp nbt.Anon
|
|
err = EntityMetadataEntryValueCompoundTagTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueCompoundTagTmp
|
|
case "direction":
|
|
var EntityMetadataEntryValueDirectionTmp int32
|
|
EntityMetadataEntryValueDirectionTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueDirectionTmp
|
|
case "float":
|
|
var EntityMetadataEntryValueFloatTmp float32
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueFloatTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueFloatTmp
|
|
case "frog_variant":
|
|
var EntityMetadataEntryValueFrogVariantTmp int32
|
|
EntityMetadataEntryValueFrogVariantTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueFrogVariantTmp
|
|
case "int":
|
|
var EntityMetadataEntryValueIntTmp int32
|
|
EntityMetadataEntryValueIntTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueIntTmp
|
|
case "item_stack":
|
|
var EntityMetadataEntryValueItemStackTmp Slot
|
|
err = EntityMetadataEntryValueItemStackTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueItemStackTmp
|
|
case "long":
|
|
var EntityMetadataEntryValueLongTmp int64
|
|
EntityMetadataEntryValueLongTmp, err = proto_base.DecodeVarLong(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueLongTmp
|
|
case "optional_block_pos":
|
|
var EntityMetadataEntryValueOptionalBlockPosTmp *Position
|
|
var EntityMetadataEntryValueOptionalBlockPosTmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueOptionalBlockPosTmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValueOptionalBlockPosTmpPresent {
|
|
var EntityMetadataEntryValueOptionalBlockPosTmpPresentValue Position
|
|
err = EntityMetadataEntryValueOptionalBlockPosTmpPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueOptionalBlockPosTmp = &EntityMetadataEntryValueOptionalBlockPosTmpPresentValue
|
|
}
|
|
ret.Value = EntityMetadataEntryValueOptionalBlockPosTmp
|
|
case "optional_block_state":
|
|
var EntityMetadataEntryValueOptionalBlockStateTmp Optvarint
|
|
err = EntityMetadataEntryValueOptionalBlockStateTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueOptionalBlockStateTmp
|
|
case "optional_component":
|
|
var EntityMetadataEntryValueOptionalComponentTmp *nbt.Anon
|
|
var EntityMetadataEntryValueOptionalComponentTmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueOptionalComponentTmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValueOptionalComponentTmpPresent {
|
|
var EntityMetadataEntryValueOptionalComponentTmpPresentValue nbt.Anon
|
|
err = EntityMetadataEntryValueOptionalComponentTmpPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueOptionalComponentTmp = &EntityMetadataEntryValueOptionalComponentTmpPresentValue
|
|
}
|
|
ret.Value = EntityMetadataEntryValueOptionalComponentTmp
|
|
case "optional_global_pos":
|
|
var EntityMetadataEntryValueOptionalGlobalPosTmp *string
|
|
var EntityMetadataEntryValueOptionalGlobalPosTmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueOptionalGlobalPosTmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValueOptionalGlobalPosTmpPresent {
|
|
var EntityMetadataEntryValueOptionalGlobalPosTmpPresentValue string
|
|
EntityMetadataEntryValueOptionalGlobalPosTmpPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueOptionalGlobalPosTmp = &EntityMetadataEntryValueOptionalGlobalPosTmpPresentValue
|
|
}
|
|
ret.Value = EntityMetadataEntryValueOptionalGlobalPosTmp
|
|
case "optional_unsigned_int":
|
|
var EntityMetadataEntryValueOptionalUnsignedIntTmp Optvarint
|
|
err = EntityMetadataEntryValueOptionalUnsignedIntTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueOptionalUnsignedIntTmp
|
|
case "optional_uuid":
|
|
var EntityMetadataEntryValueOptionalUuidTmp *uuid.UUID
|
|
var EntityMetadataEntryValueOptionalUuidTmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueOptionalUuidTmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValueOptionalUuidTmpPresent {
|
|
var EntityMetadataEntryValueOptionalUuidTmpPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, EntityMetadataEntryValueOptionalUuidTmpPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueOptionalUuidTmp = &EntityMetadataEntryValueOptionalUuidTmpPresentValue
|
|
}
|
|
ret.Value = EntityMetadataEntryValueOptionalUuidTmp
|
|
case "painting_variant":
|
|
var EntityMetadataEntryValuePaintingVariantTmp any
|
|
var EntityMetadataEntryValuePaintingVariantTmpId int32
|
|
EntityMetadataEntryValuePaintingVariantTmpId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValuePaintingVariantTmpId != 0 {
|
|
EntityMetadataEntryValuePaintingVariantTmp = EntityMetadataEntryValuePaintingVariantTmpId
|
|
} else {
|
|
var EntityMetadataEntryValuePaintingVariantTmpResult EntityMetadataPaintingVariant
|
|
err = EntityMetadataEntryValuePaintingVariantTmpResult.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValuePaintingVariantTmp = EntityMetadataEntryValuePaintingVariantTmpResult
|
|
}
|
|
ret.Value = EntityMetadataEntryValuePaintingVariantTmp
|
|
case "particle":
|
|
var EntityMetadataEntryValueParticleTmp Particle
|
|
err = EntityMetadataEntryValueParticleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueParticleTmp
|
|
case "particles":
|
|
var EntityMetadataEntryValueParticlesTmp []Particle
|
|
var lEntityMetadataEntryValueParticlesTmp int32
|
|
lEntityMetadataEntryValueParticlesTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueParticlesTmp = []Particle{}
|
|
for range lEntityMetadataEntryValueParticlesTmp {
|
|
var EntityMetadataEntryValueParticlesTmpElement Particle
|
|
err = EntityMetadataEntryValueParticlesTmpElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueParticlesTmp = append(EntityMetadataEntryValueParticlesTmp, EntityMetadataEntryValueParticlesTmpElement)
|
|
}
|
|
ret.Value = EntityMetadataEntryValueParticlesTmp
|
|
case "pose":
|
|
var EntityMetadataEntryValuePoseTmp int32
|
|
EntityMetadataEntryValuePoseTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValuePoseTmp
|
|
case "quaternion":
|
|
var EntityMetadataEntryValueQuaternionTmp Vec4f
|
|
err = EntityMetadataEntryValueQuaternionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueQuaternionTmp
|
|
case "rotations":
|
|
var EntityMetadataEntryValueRotationsTmp struct {
|
|
Pitch float32
|
|
Yaw float32
|
|
Roll float32
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Roll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueRotationsTmp
|
|
case "sniffer_state":
|
|
var EntityMetadataEntryValueSnifferStateTmp int32
|
|
EntityMetadataEntryValueSnifferStateTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueSnifferStateTmp
|
|
case "string":
|
|
var EntityMetadataEntryValueStringTmp string
|
|
EntityMetadataEntryValueStringTmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueStringTmp
|
|
case "vector3":
|
|
var EntityMetadataEntryValueVector3Tmp Vec3f
|
|
err = EntityMetadataEntryValueVector3Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueVector3Tmp
|
|
case "villager_data":
|
|
var EntityMetadataEntryValueVillagerDataTmp struct {
|
|
VillagerType int32
|
|
VillagerProfession int32
|
|
Level int32
|
|
}
|
|
EntityMetadataEntryValueVillagerDataTmp.VillagerType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueVillagerDataTmp.VillagerProfession, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueVillagerDataTmp.Level, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = EntityMetadataEntryValueVillagerDataTmp
|
|
case "wolf_variant":
|
|
var EntityMetadataEntryValueWolfVariantTmp any
|
|
var EntityMetadataEntryValueWolfVariantTmpId int32
|
|
EntityMetadataEntryValueWolfVariantTmpId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValueWolfVariantTmpId != 0 {
|
|
EntityMetadataEntryValueWolfVariantTmp = EntityMetadataEntryValueWolfVariantTmpId
|
|
} else {
|
|
var EntityMetadataEntryValueWolfVariantTmpResult EntityMetadataWolfVariant
|
|
err = EntityMetadataEntryValueWolfVariantTmpResult.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueWolfVariantTmp = EntityMetadataEntryValueWolfVariantTmpResult
|
|
}
|
|
ret.Value = EntityMetadataEntryValueWolfVariantTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var EntityMetadataEntryTypeReverseMap = map[string]int32{"byte": 0, "int": 1, "block_pos": 10, "optional_block_pos": 11, "direction": 12, "optional_uuid": 13, "block_state": 14, "optional_block_state": 15, "compound_tag": 16, "particle": 17, "particles": 18, "villager_data": 19, "long": 2, "optional_unsigned_int": 20, "pose": 21, "cat_variant": 22, "wolf_variant": 23, "frog_variant": 24, "optional_global_pos": 25, "painting_variant": 26, "sniffer_state": 27, "armadillo_state": 28, "vector3": 29, "float": 3, "quaternion": 30, "string": 4, "component": 5, "optional_component": 6, "item_stack": 7, "boolean": 8, "rotations": 9}
|
|
|
|
func (ret *EntityMetadataEntry) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vEntityMetadataEntryType int32
|
|
vEntityMetadataEntryType, err = proto_base.ErroringIndex(EntityMetadataEntryTypeReverseMap, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vEntityMetadataEntryType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Type {
|
|
case "armadillo_state":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_pos":
|
|
EntityMetadataEntryValue, ok := ret.Value.(Position)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_state":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "boolean":
|
|
EntityMetadataEntryValue, ok := ret.Value.(bool)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "byte":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cat_variant":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "component":
|
|
EntityMetadataEntryValue, ok := ret.Value.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "compound_tag":
|
|
EntityMetadataEntryValue, ok := ret.Value.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "direction":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "float":
|
|
EntityMetadataEntryValue, ok := ret.Value.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "frog_variant":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "int":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "item_stack":
|
|
EntityMetadataEntryValue, ok := ret.Value.(Slot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "long":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarLong(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "optional_block_pos":
|
|
EntityMetadataEntryValue, ok := ret.Value.(*Position)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValue != nil {
|
|
EntityMetadataEntryValueEncTmp := *EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "optional_block_state":
|
|
EntityMetadataEntryValue, ok := ret.Value.(Optvarint)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "optional_component":
|
|
EntityMetadataEntryValue, ok := ret.Value.(*nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValue != nil {
|
|
EntityMetadataEntryValueEncTmp := *EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "optional_global_pos":
|
|
EntityMetadataEntryValue, ok := ret.Value.(*string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValue != nil {
|
|
err = proto_base.EncodeString(w, *EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "optional_unsigned_int":
|
|
EntityMetadataEntryValue, ok := ret.Value.(Optvarint)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "optional_uuid":
|
|
EntityMetadataEntryValue, ok := ret.Value.(*uuid.UUID)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if EntityMetadataEntryValue != nil {
|
|
_, err = w.Write((*EntityMetadataEntryValue)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "painting_variant":
|
|
EntityMetadataEntryValue, ok := ret.Value.(any)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
switch EntityMetadataEntryValueKnownType := EntityMetadataEntryValue.(type) {
|
|
case int32:
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValueKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case EntityMetadataPaintingVariant:
|
|
err = proto_base.EncodeVarInt(w, 0)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueOtherwiseEncTmp := EntityMetadataEntryValueKnownType
|
|
err = EntityMetadataEntryValueOtherwiseEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
case "particle":
|
|
EntityMetadataEntryValue, ok := ret.Value.(Particle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "particles":
|
|
EntityMetadataEntryValue, ok := ret.Value.([]Particle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(EntityMetadataEntryValue)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iEntityMetadataEntryValue := range len(EntityMetadataEntryValue) {
|
|
EntityMetadataEntryValueInnerEncTmp := EntityMetadataEntryValue[iEntityMetadataEntryValue]
|
|
err = EntityMetadataEntryValueInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "pose":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "quaternion":
|
|
EntityMetadataEntryValue, ok := ret.Value.(Vec4f)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "rotations":
|
|
EntityMetadataEntryValue, ok := ret.Value.(struct {
|
|
Pitch float32
|
|
Yaw float32
|
|
Roll float32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Roll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "sniffer_state":
|
|
EntityMetadataEntryValue, ok := ret.Value.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "string":
|
|
EntityMetadataEntryValue, ok := ret.Value.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, EntityMetadataEntryValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vector3":
|
|
EntityMetadataEntryValue, ok := ret.Value.(Vec3f)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
EntityMetadataEntryValueEncTmp := EntityMetadataEntryValue
|
|
err = EntityMetadataEntryValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "villager_data":
|
|
EntityMetadataEntryValue, ok := ret.Value.(struct {
|
|
VillagerType int32
|
|
VillagerProfession int32
|
|
Level int32
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.VillagerType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.VillagerProfession)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.Level)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "wolf_variant":
|
|
EntityMetadataEntryValue, ok := ret.Value.(any)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
switch EntityMetadataEntryValueKnownType := EntityMetadataEntryValue.(type) {
|
|
case int32:
|
|
err = proto_base.EncodeVarInt(w, EntityMetadataEntryValueKnownType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case EntityMetadataWolfVariant:
|
|
err = proto_base.EncodeVarInt(w, 0)
|
|
if err != nil {
|
|
return
|
|
}
|
|
EntityMetadataEntryValueOtherwiseEncTmp := EntityMetadataEntryValueKnownType
|
|
err = EntityMetadataEntryValueOtherwiseEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = proto_base.BadTypeError
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type GameProfile struct {
|
|
Name string
|
|
Properties []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
}
|
|
|
|
func (ret *GameProfile) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lGameProfileProperties int32
|
|
lGameProfileProperties, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Properties = []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.EncodeVarInt(w, int32(len(ret.Properties)))
|
|
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 (ret *Ingredient) Decode(r io.ReadSeeker) (err error) {
|
|
var lIngredient int32
|
|
lIngredient, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []Slot{}
|
|
for range lIngredient {
|
|
var IngredientElement Slot
|
|
err = IngredientElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = append(ret.Val, IngredientElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *Ingredient) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iIngredient := range len(ret.Val) {
|
|
IngredientInnerEncTmp := ret.Val[iIngredient]
|
|
err = IngredientInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type MinecraftSimpleRecipeFormat struct {
|
|
Category int32
|
|
}
|
|
|
|
func (ret *MinecraftSimpleRecipeFormat) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Category, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *MinecraftSimpleRecipeFormat) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Category)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type MinecraftSmeltingFormat struct {
|
|
Group string
|
|
Category int32
|
|
Ingredient Ingredient
|
|
Result Slot
|
|
Experience float32
|
|
CookTime int32
|
|
}
|
|
|
|
func (ret *MinecraftSmeltingFormat) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Group, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Category, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Ingredient.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Experience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CookTime, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *MinecraftSmeltingFormat) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Group)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Category)
|
|
if err != nil {
|
|
return
|
|
}
|
|
MinecraftSmeltingFormatIngredientEncTmp := ret.Ingredient
|
|
err = MinecraftSmeltingFormatIngredientEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
MinecraftSmeltingFormatResultEncTmp := ret.Result
|
|
err = MinecraftSmeltingFormatResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Experience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.CookTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Optvarint struct {
|
|
Val int32
|
|
}
|
|
|
|
func (ret *Optvarint) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Val, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *Optvarint) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PackedChunkPos struct {
|
|
Z int32
|
|
X int32
|
|
}
|
|
|
|
func (ret *PackedChunkPos) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PackedChunkPos) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Position struct {
|
|
X int32
|
|
Z int32
|
|
Y int16
|
|
}
|
|
|
|
func (ret *Position) Decode(r io.ReadSeeker) (err error) {
|
|
var PositionPacked uint64
|
|
err = binary.Read(r, binary.BigEndian, &PositionPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = int16(PositionPacked >> 0 & 4095)
|
|
if ret.Y >= 1<<11 {
|
|
ret.Y -= 1 << 12
|
|
}
|
|
ret.Z = int32(PositionPacked >> 12 & 67108863)
|
|
if ret.Z >= 1<<25 {
|
|
ret.Z -= 1 << 26
|
|
}
|
|
ret.X = int32(PositionPacked >> 38 & 67108863)
|
|
if ret.X >= 1<<25 {
|
|
ret.X -= 1 << 26
|
|
}
|
|
return
|
|
}
|
|
func (ret *Position) Encode(w io.Writer) (err error) {
|
|
var PositionPacked uint64
|
|
PositionPacked |= (uint64(ret.Y) & 0xFFF) << 0x0
|
|
PositionPacked |= (uint64(ret.Z) & 0x3FFFFFF) << 0xC
|
|
PositionPacked |= (uint64(ret.X) & 0x3FFFFFF) << 0x26
|
|
err = binary.Write(w, binary.BigEndian, PositionPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PreviousMessages struct {
|
|
Val []struct {
|
|
Id int32
|
|
Signature any
|
|
}
|
|
}
|
|
|
|
func (ret *PreviousMessages) Decode(r io.ReadSeeker) (err error) {
|
|
var lPreviousMessages int32
|
|
lPreviousMessages, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []struct {
|
|
Id int32
|
|
Signature any
|
|
}{}
|
|
for range lPreviousMessages {
|
|
var PreviousMessagesElement struct {
|
|
Id int32
|
|
Signature any
|
|
}
|
|
PreviousMessagesElement.Id, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch PreviousMessagesElement.Id {
|
|
case 0:
|
|
var PreviousMessagesElementSignature0Tmp [256]byte
|
|
_, err = r.Read(PreviousMessagesElementSignature0Tmp[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
PreviousMessagesElement.Signature = PreviousMessagesElementSignature0Tmp
|
|
default:
|
|
var PreviousMessagesElementSignatureTmp struct {
|
|
}
|
|
PreviousMessagesElement.Signature = PreviousMessagesElementSignatureTmp
|
|
}
|
|
ret.Val = append(ret.Val, PreviousMessagesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PreviousMessages) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPreviousMessages := range len(ret.Val) {
|
|
err = proto_base.EncodeVarInt(w, ret.Val[iPreviousMessages].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Val[iPreviousMessages].Id {
|
|
case 0:
|
|
PreviousMessagesInnerSignature, ok := ret.Val[iPreviousMessages].Signature.([256]byte)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
arr := PreviousMessagesInnerSignature
|
|
_, err = w.Write(arr[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Val[iPreviousMessages].Signature.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type SoundSource struct {
|
|
Val string
|
|
}
|
|
|
|
var SoundSourceMap = map[int32]string{0: "master", 1: "music", 2: "record", 3: "weather", 4: "block", 5: "hostile", 6: "neutral", 7: "player", 8: "ambient", 9: "voice"}
|
|
|
|
func (ret *SoundSource) Decode(r io.ReadSeeker) (err error) {
|
|
var SoundSourceKey int32
|
|
SoundSourceKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = proto_base.ErroringIndex(SoundSourceMap, SoundSourceKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var SoundSourceReverseMap = map[string]int32{"master": 0, "music": 1, "record": 2, "weather": 3, "block": 4, "hostile": 5, "neutral": 6, "player": 7, "ambient": 8, "voice": 9}
|
|
|
|
func (ret *SoundSource) Encode(w io.Writer) (err error) {
|
|
var vSoundSource int32
|
|
vSoundSource, err = proto_base.ErroringIndex(SoundSourceReverseMap, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vSoundSource)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Tags struct {
|
|
Val []struct {
|
|
TagName string
|
|
Entries []int32
|
|
}
|
|
}
|
|
|
|
func (ret *Tags) Decode(r io.ReadSeeker) (err error) {
|
|
var lTags int32
|
|
lTags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val = []struct {
|
|
TagName string
|
|
Entries []int32
|
|
}{}
|
|
for range lTags {
|
|
var TagsElement struct {
|
|
TagName string
|
|
Entries []int32
|
|
}
|
|
TagsElement.TagName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lTagsElementEntries int32
|
|
lTagsElementEntries, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
TagsElement.Entries = []int32{}
|
|
for range lTagsElementEntries {
|
|
var TagsElementEntriesElement int32
|
|
TagsElementEntriesElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
TagsElement.Entries = append(TagsElement.Entries, TagsElementEntriesElement)
|
|
}
|
|
ret.Val = append(ret.Val, TagsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *Tags) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iTags := range len(ret.Val) {
|
|
err = proto_base.EncodeString(w, ret.Val[iTags].TagName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Val[iTags].Entries)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iTagsInnerEntries := range len(ret.Val[iTags].Entries) {
|
|
err = proto_base.EncodeVarInt(w, ret.Val[iTags].Entries[iTagsInnerEntries])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type Vec3f struct {
|
|
X float32
|
|
Y float32
|
|
Z float32
|
|
}
|
|
|
|
func (ret *Vec3f) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *Vec3f) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Vec3f64 struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
}
|
|
|
|
func (ret *Vec3f64) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *Vec3f64) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Vec3i16 struct {
|
|
X int16
|
|
Y int16
|
|
Z int16
|
|
}
|
|
|
|
func (ret *Vec3i16) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *Vec3i16) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type Vec4f struct {
|
|
X float32
|
|
Y float32
|
|
Z float32
|
|
W float32
|
|
}
|
|
|
|
func (ret *Vec4f) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.W)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *Vec4f) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.W)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var ConfigurationToClientPacketNameMap = map[int32]string{0x00: "cookie_request", 0x01: "custom_payload", 0x02: "disconnect", 0x03: "finish_configuration", 0x04: "keep_alive", 0x05: "ping", 0x06: "reset_chat", 0x07: "registry_data", 0x08: "remove_resource_pack", 0x09: "add_resource_pack", 0x0a: "store_cookie", 0x0b: "transfer", 0x0c: "feature_flags", 0x0d: "tags", 0x0e: "select_known_packs"}
|
|
|
|
func (ret *ConfigurationToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var ConfigurationToClientPacketNameKey int32
|
|
ConfigurationToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameMap, ConfigurationToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "add_resource_pack":
|
|
var ConfigurationToClientPacketParamsAddResourcePackTmp ConfigurationToClientPacketCommonAddResourcePack
|
|
err = ConfigurationToClientPacketParamsAddResourcePackTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsAddResourcePackTmp
|
|
case "cookie_request":
|
|
var ConfigurationToClientPacketParamsCookieRequestTmp ConfigurationToClientPacketCommonCookieRequest
|
|
err = ConfigurationToClientPacketParamsCookieRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsCookieRequestTmp
|
|
case "custom_payload":
|
|
var ConfigurationToClientPacketParamsCustomPayloadTmp ConfigurationToClientPacketCustomPayload
|
|
err = ConfigurationToClientPacketParamsCustomPayloadTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsCustomPayloadTmp
|
|
case "disconnect":
|
|
var ConfigurationToClientPacketParamsDisconnectTmp ConfigurationToClientPacketDisconnect
|
|
err = ConfigurationToClientPacketParamsDisconnectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsDisconnectTmp
|
|
case "feature_flags":
|
|
var ConfigurationToClientPacketParamsFeatureFlagsTmp ConfigurationToClientPacketFeatureFlags
|
|
err = ConfigurationToClientPacketParamsFeatureFlagsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsFeatureFlagsTmp
|
|
case "finish_configuration":
|
|
var ConfigurationToClientPacketParamsFinishConfigurationTmp ConfigurationToClientPacketFinishConfiguration
|
|
err = ConfigurationToClientPacketParamsFinishConfigurationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsFinishConfigurationTmp
|
|
case "keep_alive":
|
|
var ConfigurationToClientPacketParamsKeepAliveTmp ConfigurationToClientPacketKeepAlive
|
|
err = ConfigurationToClientPacketParamsKeepAliveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsKeepAliveTmp
|
|
case "ping":
|
|
var ConfigurationToClientPacketParamsPingTmp ConfigurationToClientPacketPing
|
|
err = ConfigurationToClientPacketParamsPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsPingTmp
|
|
case "registry_data":
|
|
var ConfigurationToClientPacketParamsRegistryDataTmp ConfigurationToClientPacketRegistryData
|
|
err = ConfigurationToClientPacketParamsRegistryDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsRegistryDataTmp
|
|
case "remove_resource_pack":
|
|
var ConfigurationToClientPacketParamsRemoveResourcePackTmp ConfigurationToClientPacketCommonRemoveResourcePack
|
|
err = ConfigurationToClientPacketParamsRemoveResourcePackTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsRemoveResourcePackTmp
|
|
case "reset_chat":
|
|
var ConfigurationToClientPacketParamsResetChatTmp ConfigurationToClientPacketResetChat
|
|
err = ConfigurationToClientPacketParamsResetChatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsResetChatTmp
|
|
case "select_known_packs":
|
|
var ConfigurationToClientPacketParamsSelectKnownPacksTmp ConfigurationToClientPacketCommonSelectKnownPacks
|
|
err = ConfigurationToClientPacketParamsSelectKnownPacksTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsSelectKnownPacksTmp
|
|
case "store_cookie":
|
|
var ConfigurationToClientPacketParamsStoreCookieTmp ConfigurationToClientPacketCommonStoreCookie
|
|
err = ConfigurationToClientPacketParamsStoreCookieTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsStoreCookieTmp
|
|
case "tags":
|
|
var ConfigurationToClientPacketParamsTagsTmp ConfigurationToClientPacketTags
|
|
err = ConfigurationToClientPacketParamsTagsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTagsTmp
|
|
case "transfer":
|
|
var ConfigurationToClientPacketParamsTransferTmp ConfigurationToClientPacketCommonTransfer
|
|
err = ConfigurationToClientPacketParamsTransferTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToClientPacketParamsTransferTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var ConfigurationToClientPacketNameReverseMap = map[string]int32{"cookie_request": 0x00, "custom_payload": 0x01, "disconnect": 0x02, "finish_configuration": 0x03, "keep_alive": 0x04, "ping": 0x05, "reset_chat": 0x06, "registry_data": 0x07, "remove_resource_pack": 0x08, "add_resource_pack": 0x09, "store_cookie": 0x0a, "transfer": 0x0b, "feature_flags": 0x0c, "tags": 0x0d, "select_known_packs": 0x0e}
|
|
|
|
func (ret *ConfigurationToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vConfigurationToClientPacketName int32
|
|
vConfigurationToClientPacketName, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vConfigurationToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "add_resource_pack":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonAddResourcePack)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cookie_request":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonCookieRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "disconnect":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "feature_flags":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFeatureFlags)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "finish_configuration":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFinishConfiguration)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "registry_data":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketRegistryData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_resource_pack":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonRemoveResourcePack)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "reset_chat":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketResetChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_known_packs":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonSelectKnownPacks)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "store_cookie":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonStoreCookie)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tags":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketTags)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "transfer":
|
|
ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonTransfer)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToClientPacketParamsEncTmp := ConfigurationToClientPacketParams
|
|
err = ConfigurationToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent {
|
|
var ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
ConfigurationToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = ConfigurationToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var ConfigurationToClientPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ConfigurationToClientPacketCommonCookieResponseValuePresent {
|
|
var ConfigurationToClientPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = ConfigurationToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &ConfigurationToClientPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
ConfigurationToClientPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = ConfigurationToClientPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent {
|
|
var ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lConfigurationToClientPacketCommonSelectKnownPacksPacks int32
|
|
lConfigurationToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lConfigurationToClientPacketCommonSelectKnownPacksPacks {
|
|
var ConfigurationToClientPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, ConfigurationToClientPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iConfigurationToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToClientPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = ConfigurationToClientPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketCustomPayload) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToClientPacketCustomPayloadDataEncTmp := ret.Data
|
|
err = ConfigurationToClientPacketCustomPayloadDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketDisconnect struct {
|
|
Reason nbt.Anon
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketDisconnect) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Reason.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketDisconnect) Encode(w io.Writer) (err error) {
|
|
ConfigurationToClientPacketDisconnectReasonEncTmp := ret.Reason
|
|
err = ConfigurationToClientPacketDisconnectReasonEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketFeatureFlags struct {
|
|
Features []string
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketFeatureFlags) Decode(r io.ReadSeeker) (err error) {
|
|
var lConfigurationToClientPacketFeatureFlagsFeatures int32
|
|
lConfigurationToClientPacketFeatureFlagsFeatures, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Features = []string{}
|
|
for range lConfigurationToClientPacketFeatureFlagsFeatures {
|
|
var ConfigurationToClientPacketFeatureFlagsFeaturesElement string
|
|
ConfigurationToClientPacketFeatureFlagsFeaturesElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Features = append(ret.Features, ConfigurationToClientPacketFeatureFlagsFeaturesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketFeatureFlags) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Features)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iConfigurationToClientPacketFeatureFlagsFeatures := range len(ret.Features) {
|
|
err = proto_base.EncodeString(w, ret.Features[iConfigurationToClientPacketFeatureFlagsFeatures])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketFinishConfiguration struct {
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketFinishConfiguration) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketFinishConfiguration) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketKeepAlive) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketPing struct {
|
|
Id int32
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketRegistryData struct {
|
|
Id string
|
|
Entries []struct {
|
|
Key string
|
|
Value *nbt.Anon
|
|
}
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketRegistryData) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lConfigurationToClientPacketRegistryDataEntries int32
|
|
lConfigurationToClientPacketRegistryDataEntries, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = []struct {
|
|
Key string
|
|
Value *nbt.Anon
|
|
}{}
|
|
for range lConfigurationToClientPacketRegistryDataEntries {
|
|
var ConfigurationToClientPacketRegistryDataEntriesElement struct {
|
|
Key string
|
|
Value *nbt.Anon
|
|
}
|
|
ConfigurationToClientPacketRegistryDataEntriesElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var ConfigurationToClientPacketRegistryDataEntriesElementValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketRegistryDataEntriesElementValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ConfigurationToClientPacketRegistryDataEntriesElementValuePresent {
|
|
var ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue nbt.Anon
|
|
err = ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToClientPacketRegistryDataEntriesElement.Value = &ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue
|
|
}
|
|
ret.Entries = append(ret.Entries, ConfigurationToClientPacketRegistryDataEntriesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketRegistryData) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iConfigurationToClientPacketRegistryDataEntries := range len(ret.Entries) {
|
|
err = proto_base.EncodeString(w, ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value != nil {
|
|
ConfigurationToClientPacketRegistryDataEntriesInnerValueEncTmp := *ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value
|
|
err = ConfigurationToClientPacketRegistryDataEntriesInnerValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketResetChat struct {
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketResetChat) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketResetChat) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type ConfigurationToClientPacketTags struct {
|
|
Tags []struct {
|
|
TagType string
|
|
Tags Tags
|
|
}
|
|
}
|
|
|
|
func (ret *ConfigurationToClientPacketTags) Decode(r io.ReadSeeker) (err error) {
|
|
var lConfigurationToClientPacketTagsTags int32
|
|
lConfigurationToClientPacketTagsTags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Tags = []struct {
|
|
TagType string
|
|
Tags Tags
|
|
}{}
|
|
for range lConfigurationToClientPacketTagsTags {
|
|
var ConfigurationToClientPacketTagsTagsElement struct {
|
|
TagType string
|
|
Tags Tags
|
|
}
|
|
ConfigurationToClientPacketTagsTagsElement.TagType, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ConfigurationToClientPacketTagsTagsElement.Tags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Tags = append(ret.Tags, ConfigurationToClientPacketTagsTagsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToClientPacketTags) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Tags)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iConfigurationToClientPacketTagsTags := range len(ret.Tags) {
|
|
err = proto_base.EncodeString(w, ret.Tags[iConfigurationToClientPacketTagsTags].TagType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToClientPacketTagsTagsInnerTagsEncTmp := ret.Tags[iConfigurationToClientPacketTagsTags].Tags
|
|
err = ConfigurationToClientPacketTagsTagsInnerTagsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var ConfigurationToServerPacketNameMap = map[int32]string{0x00: "settings", 0x01: "cookie_response", 0x02: "custom_payload", 0x03: "finish_configuration", 0x04: "keep_alive", 0x05: "pong", 0x06: "resource_pack_receive", 0x07: "select_known_packs"}
|
|
|
|
func (ret *ConfigurationToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var ConfigurationToServerPacketNameKey int32
|
|
ConfigurationToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameMap, ConfigurationToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "cookie_response":
|
|
var ConfigurationToServerPacketParamsCookieResponseTmp ConfigurationToServerPacketCommonCookieResponse
|
|
err = ConfigurationToServerPacketParamsCookieResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsCookieResponseTmp
|
|
case "custom_payload":
|
|
var ConfigurationToServerPacketParamsCustomPayloadTmp ConfigurationToServerPacketCustomPayload
|
|
err = ConfigurationToServerPacketParamsCustomPayloadTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsCustomPayloadTmp
|
|
case "finish_configuration":
|
|
var ConfigurationToServerPacketParamsFinishConfigurationTmp ConfigurationToServerPacketFinishConfiguration
|
|
err = ConfigurationToServerPacketParamsFinishConfigurationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsFinishConfigurationTmp
|
|
case "keep_alive":
|
|
var ConfigurationToServerPacketParamsKeepAliveTmp ConfigurationToServerPacketKeepAlive
|
|
err = ConfigurationToServerPacketParamsKeepAliveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsKeepAliveTmp
|
|
case "pong":
|
|
var ConfigurationToServerPacketParamsPongTmp ConfigurationToServerPacketPong
|
|
err = ConfigurationToServerPacketParamsPongTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsPongTmp
|
|
case "resource_pack_receive":
|
|
var ConfigurationToServerPacketParamsResourcePackReceiveTmp ConfigurationToServerPacketResourcePackReceive
|
|
err = ConfigurationToServerPacketParamsResourcePackReceiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsResourcePackReceiveTmp
|
|
case "select_known_packs":
|
|
var ConfigurationToServerPacketParamsSelectKnownPacksTmp ConfigurationToServerPacketCommonSelectKnownPacks
|
|
err = ConfigurationToServerPacketParamsSelectKnownPacksTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsSelectKnownPacksTmp
|
|
case "settings":
|
|
var ConfigurationToServerPacketParamsSettingsTmp ConfigurationToServerPacketCommonSettings
|
|
err = ConfigurationToServerPacketParamsSettingsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = ConfigurationToServerPacketParamsSettingsTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var ConfigurationToServerPacketNameReverseMap = map[string]int32{"settings": 0x00, "cookie_response": 0x01, "custom_payload": 0x02, "finish_configuration": 0x03, "keep_alive": 0x04, "pong": 0x05, "resource_pack_receive": 0x06, "select_known_packs": 0x07}
|
|
|
|
func (ret *ConfigurationToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vConfigurationToServerPacketName int32
|
|
vConfigurationToServerPacketName, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vConfigurationToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "cookie_response":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonCookieResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams
|
|
err = ConfigurationToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams
|
|
err = ConfigurationToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "finish_configuration":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketFinishConfiguration)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams
|
|
err = ConfigurationToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams
|
|
err = ConfigurationToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "pong":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketPong)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams
|
|
err = ConfigurationToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "resource_pack_receive":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketResourcePackReceive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams
|
|
err = ConfigurationToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_known_packs":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonSelectKnownPacks)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams
|
|
err = ConfigurationToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "settings":
|
|
ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonSettings)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
ConfigurationToServerPacketParamsEncTmp := ConfigurationToServerPacketParams
|
|
err = ConfigurationToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent {
|
|
var ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
ConfigurationToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = ConfigurationToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var ConfigurationToServerPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ConfigurationToServerPacketCommonCookieResponseValuePresent {
|
|
var ConfigurationToServerPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = ConfigurationToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &ConfigurationToServerPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
ConfigurationToServerPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = ConfigurationToServerPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent {
|
|
var ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lConfigurationToServerPacketCommonSelectKnownPacksPacks int32
|
|
lConfigurationToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lConfigurationToServerPacketCommonSelectKnownPacksPacks {
|
|
var ConfigurationToServerPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, ConfigurationToServerPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iConfigurationToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToServerPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = ConfigurationToServerPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketCustomPayload) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ConfigurationToServerPacketCustomPayloadDataEncTmp := ret.Data
|
|
err = ConfigurationToServerPacketCustomPayloadDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketFinishConfiguration struct {
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketFinishConfiguration) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketFinishConfiguration) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketKeepAlive) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketPong struct {
|
|
Id int32
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketPong) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketPong) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type ConfigurationToServerPacketResourcePackReceive struct {
|
|
Uuid uuid.UUID
|
|
Result int32
|
|
}
|
|
|
|
func (ret *ConfigurationToServerPacketResourcePackReceive) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Result, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *ConfigurationToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Result)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var HandshakingToClientPacketNameMap = map[int32]string{}
|
|
|
|
func (ret *HandshakingToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var HandshakingToClientPacketNameKey int32
|
|
HandshakingToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(HandshakingToClientPacketNameMap, HandshakingToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var HandshakingToClientPacketNameReverseMap = map[string]int32{}
|
|
|
|
func (ret *HandshakingToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vHandshakingToClientPacketName int32
|
|
vHandshakingToClientPacketName, err = proto_base.ErroringIndex(HandshakingToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vHandshakingToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *HandshakingToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent {
|
|
var HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
HandshakingToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = HandshakingToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *HandshakingToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *HandshakingToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var HandshakingToClientPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if HandshakingToClientPacketCommonCookieResponseValuePresent {
|
|
var HandshakingToClientPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = HandshakingToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &HandshakingToClientPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
HandshakingToClientPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = HandshakingToClientPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *HandshakingToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var HandshakingToClientPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if HandshakingToClientPacketCommonRemoveResourcePackUuidPresent {
|
|
var HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *HandshakingToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lHandshakingToClientPacketCommonSelectKnownPacksPacks int32
|
|
lHandshakingToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lHandshakingToClientPacketCommonSelectKnownPacksPacks {
|
|
var HandshakingToClientPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, HandshakingToClientPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iHandshakingToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *HandshakingToClientPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *HandshakingToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
HandshakingToClientPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = HandshakingToClientPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToClientPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *HandshakingToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var HandshakingToServerPacketNameMap = map[int32]string{0x00: "set_protocol", 0xfe: "legacy_server_list_ping"}
|
|
|
|
func (ret *HandshakingToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var HandshakingToServerPacketNameKey int32
|
|
HandshakingToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(HandshakingToServerPacketNameMap, HandshakingToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "legacy_server_list_ping":
|
|
var HandshakingToServerPacketParamsLegacyServerListPingTmp HandshakingToServerPacketLegacyServerListPing
|
|
err = HandshakingToServerPacketParamsLegacyServerListPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = HandshakingToServerPacketParamsLegacyServerListPingTmp
|
|
case "set_protocol":
|
|
var HandshakingToServerPacketParamsSetProtocolTmp HandshakingToServerPacketSetProtocol
|
|
err = HandshakingToServerPacketParamsSetProtocolTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = HandshakingToServerPacketParamsSetProtocolTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var HandshakingToServerPacketNameReverseMap = map[string]int32{"set_protocol": 0x00, "legacy_server_list_ping": 0xfe}
|
|
|
|
func (ret *HandshakingToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vHandshakingToServerPacketName int32
|
|
vHandshakingToServerPacketName, err = proto_base.ErroringIndex(HandshakingToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vHandshakingToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "legacy_server_list_ping":
|
|
HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketLegacyServerListPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
HandshakingToServerPacketParamsEncTmp := HandshakingToServerPacketParams
|
|
err = HandshakingToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_protocol":
|
|
HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketSetProtocol)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
HandshakingToServerPacketParamsEncTmp := HandshakingToServerPacketParams
|
|
err = HandshakingToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent {
|
|
var HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
HandshakingToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = HandshakingToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var HandshakingToServerPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if HandshakingToServerPacketCommonCookieResponseValuePresent {
|
|
var HandshakingToServerPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = HandshakingToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &HandshakingToServerPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
HandshakingToServerPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = HandshakingToServerPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var HandshakingToServerPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if HandshakingToServerPacketCommonRemoveResourcePackUuidPresent {
|
|
var HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lHandshakingToServerPacketCommonSelectKnownPacksPacks int32
|
|
lHandshakingToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lHandshakingToServerPacketCommonSelectKnownPacksPacks {
|
|
var HandshakingToServerPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, HandshakingToServerPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iHandshakingToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
HandshakingToServerPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = HandshakingToServerPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketLegacyServerListPing struct {
|
|
Payload uint8
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketLegacyServerListPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Payload)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketLegacyServerListPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Payload)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type HandshakingToServerPacketSetProtocol struct {
|
|
ProtocolVersion int32
|
|
ServerHost string
|
|
ServerPort uint16
|
|
NextState int32
|
|
}
|
|
|
|
func (ret *HandshakingToServerPacketSetProtocol) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ProtocolVersion, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ServerHost, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ServerPort)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NextState, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *HandshakingToServerPacketSetProtocol) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ProtocolVersion)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.ServerHost)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ServerPort)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.NextState)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var LoginToClientPacketNameMap = map[int32]string{0x00: "disconnect", 0x01: "encryption_begin", 0x02: "success", 0x03: "compress", 0x04: "login_plugin_request", 0x05: "cookie_request"}
|
|
|
|
func (ret *LoginToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var LoginToClientPacketNameKey int32
|
|
LoginToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(LoginToClientPacketNameMap, LoginToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "compress":
|
|
var LoginToClientPacketParamsCompressTmp LoginToClientPacketCompress
|
|
err = LoginToClientPacketParamsCompressTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsCompressTmp
|
|
case "cookie_request":
|
|
var LoginToClientPacketParamsCookieRequestTmp LoginToClientPacketCommonCookieRequest
|
|
err = LoginToClientPacketParamsCookieRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsCookieRequestTmp
|
|
case "disconnect":
|
|
var LoginToClientPacketParamsDisconnectTmp LoginToClientPacketDisconnect
|
|
err = LoginToClientPacketParamsDisconnectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsDisconnectTmp
|
|
case "encryption_begin":
|
|
var LoginToClientPacketParamsEncryptionBeginTmp LoginToClientPacketEncryptionBegin
|
|
err = LoginToClientPacketParamsEncryptionBeginTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsEncryptionBeginTmp
|
|
case "login_plugin_request":
|
|
var LoginToClientPacketParamsLoginPluginRequestTmp LoginToClientPacketLoginPluginRequest
|
|
err = LoginToClientPacketParamsLoginPluginRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsLoginPluginRequestTmp
|
|
case "success":
|
|
var LoginToClientPacketParamsSuccessTmp LoginToClientPacketSuccess
|
|
err = LoginToClientPacketParamsSuccessTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToClientPacketParamsSuccessTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var LoginToClientPacketNameReverseMap = map[string]int32{"disconnect": 0x00, "encryption_begin": 0x01, "success": 0x02, "compress": 0x03, "login_plugin_request": 0x04, "cookie_request": 0x05}
|
|
|
|
func (ret *LoginToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vLoginToClientPacketName int32
|
|
vLoginToClientPacketName, err = proto_base.ErroringIndex(LoginToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vLoginToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "compress":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCompress)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cookie_request":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCommonCookieRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "disconnect":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "encryption_begin":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketEncryptionBegin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_plugin_request":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketLoginPluginRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "success":
|
|
LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketSuccess)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToClientPacketParamsEncTmp := LoginToClientPacketParams
|
|
err = LoginToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var LoginToClientPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToClientPacketCommonAddResourcePackPromptMessagePresent {
|
|
var LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
LoginToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = LoginToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var LoginToClientPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToClientPacketCommonCookieResponseValuePresent {
|
|
var LoginToClientPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = LoginToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &LoginToClientPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
LoginToClientPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = LoginToClientPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var LoginToClientPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToClientPacketCommonRemoveResourcePackUuidPresent {
|
|
var LoginToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, LoginToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &LoginToClientPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lLoginToClientPacketCommonSelectKnownPacksPacks int32
|
|
lLoginToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lLoginToClientPacketCommonSelectKnownPacksPacks {
|
|
var LoginToClientPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
LoginToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, LoginToClientPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iLoginToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToClientPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = LoginToClientPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketCompress struct {
|
|
Threshold int32
|
|
}
|
|
|
|
func (ret *LoginToClientPacketCompress) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Threshold, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketCompress) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Threshold)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketDisconnect struct {
|
|
Reason string
|
|
}
|
|
|
|
func (ret *LoginToClientPacketDisconnect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Reason, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketDisconnect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketEncryptionBegin struct {
|
|
ServerId string
|
|
PublicKey []byte
|
|
VerifyToken []byte
|
|
ShouldAuthenticate bool
|
|
}
|
|
|
|
func (ret *LoginToClientPacketEncryptionBegin) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ServerId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToClientPacketEncryptionBeginPublicKey int32
|
|
lLoginToClientPacketEncryptionBeginPublicKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PublicKey, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginPublicKey)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToClientPacketEncryptionBeginVerifyToken int32
|
|
lLoginToClientPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginVerifyToken)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ShouldAuthenticate)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketEncryptionBegin) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.ServerId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.PublicKey)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.PublicKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.VerifyToken)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ShouldAuthenticate)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketLoginPluginRequest struct {
|
|
MessageId int32
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *LoginToClientPacketLoginPluginRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.MessageId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketLoginPluginRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.MessageId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToClientPacketLoginPluginRequestDataEncTmp := ret.Data
|
|
err = LoginToClientPacketLoginPluginRequestDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToClientPacketSuccess struct {
|
|
Uuid uuid.UUID
|
|
Username string
|
|
Properties []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
StrictErrorHandling bool
|
|
}
|
|
|
|
func (ret *LoginToClientPacketSuccess) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Username, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToClientPacketSuccessProperties int32
|
|
lLoginToClientPacketSuccessProperties, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Properties = []struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}{}
|
|
for range lLoginToClientPacketSuccessProperties {
|
|
var LoginToClientPacketSuccessPropertiesElement struct {
|
|
Name string
|
|
Value string
|
|
Signature *string
|
|
}
|
|
LoginToClientPacketSuccessPropertiesElement.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToClientPacketSuccessPropertiesElement.Value, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var LoginToClientPacketSuccessPropertiesElementSignaturePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToClientPacketSuccessPropertiesElementSignaturePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToClientPacketSuccessPropertiesElementSignaturePresent {
|
|
var LoginToClientPacketSuccessPropertiesElementSignaturePresentValue string
|
|
LoginToClientPacketSuccessPropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToClientPacketSuccessPropertiesElement.Signature = &LoginToClientPacketSuccessPropertiesElementSignaturePresentValue
|
|
}
|
|
ret.Properties = append(ret.Properties, LoginToClientPacketSuccessPropertiesElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.StrictErrorHandling)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToClientPacketSuccess) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Username)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Properties)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iLoginToClientPacketSuccessProperties := range len(ret.Properties) {
|
|
err = proto_base.EncodeString(w, ret.Properties[iLoginToClientPacketSuccessProperties].Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Properties[iLoginToClientPacketSuccessProperties].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iLoginToClientPacketSuccessProperties].Signature != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Properties[iLoginToClientPacketSuccessProperties].Signature != nil {
|
|
err = proto_base.EncodeString(w, *ret.Properties[iLoginToClientPacketSuccessProperties].Signature)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.StrictErrorHandling)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var LoginToServerPacketNameMap = map[int32]string{0x00: "login_start", 0x01: "encryption_begin", 0x02: "login_plugin_response", 0x03: "login_acknowledged", 0x04: "cookie_response"}
|
|
|
|
func (ret *LoginToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var LoginToServerPacketNameKey int32
|
|
LoginToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(LoginToServerPacketNameMap, LoginToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "cookie_response":
|
|
var LoginToServerPacketParamsCookieResponseTmp LoginToServerPacketCommonCookieResponse
|
|
err = LoginToServerPacketParamsCookieResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsCookieResponseTmp
|
|
case "encryption_begin":
|
|
var LoginToServerPacketParamsEncryptionBeginTmp LoginToServerPacketEncryptionBegin
|
|
err = LoginToServerPacketParamsEncryptionBeginTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsEncryptionBeginTmp
|
|
case "login_acknowledged":
|
|
var LoginToServerPacketParamsLoginAcknowledgedTmp LoginToServerPacketLoginAcknowledged
|
|
err = LoginToServerPacketParamsLoginAcknowledgedTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsLoginAcknowledgedTmp
|
|
case "login_plugin_response":
|
|
var LoginToServerPacketParamsLoginPluginResponseTmp LoginToServerPacketLoginPluginResponse
|
|
err = LoginToServerPacketParamsLoginPluginResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsLoginPluginResponseTmp
|
|
case "login_start":
|
|
var LoginToServerPacketParamsLoginStartTmp LoginToServerPacketLoginStart
|
|
err = LoginToServerPacketParamsLoginStartTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = LoginToServerPacketParamsLoginStartTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var LoginToServerPacketNameReverseMap = map[string]int32{"login_start": 0x00, "encryption_begin": 0x01, "login_plugin_response": 0x02, "login_acknowledged": 0x03, "cookie_response": 0x04}
|
|
|
|
func (ret *LoginToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vLoginToServerPacketName int32
|
|
vLoginToServerPacketName, err = proto_base.ErroringIndex(LoginToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vLoginToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "cookie_response":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketCommonCookieResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
|
|
err = LoginToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "encryption_begin":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketEncryptionBegin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
|
|
err = LoginToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_acknowledged":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginAcknowledged)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
|
|
err = LoginToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_plugin_response":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginPluginResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
|
|
err = LoginToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login_start":
|
|
LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
LoginToServerPacketParamsEncTmp := LoginToServerPacketParams
|
|
err = LoginToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *LoginToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var LoginToServerPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToServerPacketCommonAddResourcePackPromptMessagePresent {
|
|
var LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
LoginToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = LoginToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *LoginToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *LoginToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var LoginToServerPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToServerPacketCommonCookieResponseValuePresent {
|
|
var LoginToServerPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = LoginToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &LoginToServerPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
LoginToServerPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = LoginToServerPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *LoginToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var LoginToServerPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToServerPacketCommonRemoveResourcePackUuidPresent {
|
|
var LoginToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, LoginToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &LoginToServerPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *LoginToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lLoginToServerPacketCommonSelectKnownPacksPacks int32
|
|
lLoginToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lLoginToServerPacketCommonSelectKnownPacksPacks {
|
|
var LoginToServerPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
LoginToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, LoginToServerPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iLoginToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *LoginToServerPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *LoginToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
LoginToServerPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = LoginToServerPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *LoginToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketEncryptionBegin struct {
|
|
SharedSecret []byte
|
|
VerifyToken []byte
|
|
}
|
|
|
|
func (ret *LoginToServerPacketEncryptionBegin) Decode(r io.ReadSeeker) (err error) {
|
|
var lLoginToServerPacketEncryptionBeginSharedSecret int32
|
|
lLoginToServerPacketEncryptionBeginSharedSecret, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SharedSecret, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginSharedSecret)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lLoginToServerPacketEncryptionBeginVerifyToken int32
|
|
lLoginToServerPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginVerifyToken)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketEncryptionBegin) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.SharedSecret)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.SharedSecret)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.VerifyToken)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketLoginAcknowledged struct {
|
|
}
|
|
|
|
func (ret *LoginToServerPacketLoginAcknowledged) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketLoginAcknowledged) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketLoginPluginResponse struct {
|
|
MessageId int32
|
|
Data *proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *LoginToServerPacketLoginPluginResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.MessageId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var LoginToServerPacketLoginPluginResponseDataPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &LoginToServerPacketLoginPluginResponseDataPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if LoginToServerPacketLoginPluginResponseDataPresent {
|
|
var LoginToServerPacketLoginPluginResponseDataPresentValue proto_base.RestBuffer
|
|
err = LoginToServerPacketLoginPluginResponseDataPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = &LoginToServerPacketLoginPluginResponseDataPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketLoginPluginResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.MessageId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Data != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Data != nil {
|
|
LoginToServerPacketLoginPluginResponseDataEncTmp := *ret.Data
|
|
err = LoginToServerPacketLoginPluginResponseDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type LoginToServerPacketLoginStart struct {
|
|
Username string
|
|
PlayerUUID uuid.UUID
|
|
}
|
|
|
|
func (ret *LoginToServerPacketLoginStart) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Username, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.PlayerUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *LoginToServerPacketLoginStart) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Username)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.PlayerUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientChatType struct {
|
|
TranslationKey string
|
|
Parameters []PlayToClientChatTypeParameterType
|
|
Style nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientChatType) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TranslationKey, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientChatTypeParameters int32
|
|
lPlayToClientChatTypeParameters, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Parameters = []PlayToClientChatTypeParameterType{}
|
|
for range lPlayToClientChatTypeParameters {
|
|
var PlayToClientChatTypeParametersElement PlayToClientChatTypeParameterType
|
|
err = PlayToClientChatTypeParametersElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Parameters = append(ret.Parameters, PlayToClientChatTypeParametersElement)
|
|
}
|
|
err = ret.Style.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientChatType) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.TranslationKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Parameters)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientChatTypeParameters := range len(ret.Parameters) {
|
|
PlayToClientChatTypeParametersInnerEncTmp := ret.Parameters[iPlayToClientChatTypeParameters]
|
|
err = PlayToClientChatTypeParametersInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
PlayToClientChatTypeStyleEncTmp := ret.Style
|
|
err = PlayToClientChatTypeStyleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientChatTypeParameterType struct {
|
|
Val string
|
|
}
|
|
|
|
var PlayToClientChatTypeParameterTypeMap = map[int32]string{0: "content", 1: "sender", 2: "target"}
|
|
|
|
func (ret *PlayToClientChatTypeParameterType) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientChatTypeParameterTypeKey int32
|
|
PlayToClientChatTypeParameterTypeKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Val, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeMap, PlayToClientChatTypeParameterTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientChatTypeParameterTypeReverseMap = map[string]int32{"content": 0, "sender": 1, "target": 2}
|
|
|
|
func (ret *PlayToClientChatTypeParameterType) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientChatTypeParameterType int32
|
|
vPlayToClientChatTypeParameterType, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeReverseMap, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToClientChatTypeParameterType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientChatTypes struct {
|
|
Chat PlayToClientChatType
|
|
Narration PlayToClientChatType
|
|
}
|
|
|
|
func (ret *PlayToClientChatTypes) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Chat.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Narration.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientChatTypes) Encode(w io.Writer) (err error) {
|
|
PlayToClientChatTypesChatEncTmp := ret.Chat
|
|
err = PlayToClientChatTypesChatEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientChatTypesNarrationEncTmp := ret.Narration
|
|
err = PlayToClientChatTypesNarrationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPositionUpdateRelatives struct {
|
|
Val uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPositionUpdateRelatives) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPositionUpdateRelatives) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Val)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientSpawnInfo struct {
|
|
Dimension int32
|
|
Name string
|
|
HashedSeed int64
|
|
Gamemode string
|
|
PreviousGamemode uint8
|
|
IsDebug bool
|
|
IsFlat bool
|
|
Death *struct {
|
|
DimensionName string
|
|
Location Position
|
|
}
|
|
PortalCooldown int32
|
|
}
|
|
|
|
var PlayToClientSpawnInfoGamemodeMap = map[int8]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"}
|
|
|
|
func (ret *PlayToClientSpawnInfo) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Dimension, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HashedSeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientSpawnInfoGamemodeKey int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientSpawnInfoGamemodeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Gamemode, err = proto_base.ErroringIndex(PlayToClientSpawnInfoGamemodeMap, PlayToClientSpawnInfoGamemodeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PreviousGamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsDebug)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsFlat)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientSpawnInfoDeathPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientSpawnInfoDeathPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientSpawnInfoDeathPresent {
|
|
var PlayToClientSpawnInfoDeathPresentValue struct {
|
|
DimensionName string
|
|
Location Position
|
|
}
|
|
PlayToClientSpawnInfoDeathPresentValue.DimensionName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientSpawnInfoDeathPresentValue.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Death = &PlayToClientSpawnInfoDeathPresentValue
|
|
}
|
|
ret.PortalCooldown, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientSpawnInfoGamemodeReverseMap = map[string]int8{"survival": 0, "creative": 1, "adventure": 2, "spectator": 3}
|
|
|
|
func (ret *PlayToClientSpawnInfo) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Dimension)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HashedSeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vPlayToClientSpawnInfoGamemode int8
|
|
vPlayToClientSpawnInfoGamemode, err = proto_base.ErroringIndex(PlayToClientSpawnInfoGamemodeReverseMap, ret.Gamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, vPlayToClientSpawnInfoGamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PreviousGamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsDebug)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsFlat)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Death != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Death != nil {
|
|
err = proto_base.EncodeString(w, (*ret.Death).DimensionName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientSpawnInfoDeathLocationEncTmp := (*ret.Death).Location
|
|
err = PlayToClientSpawnInfoDeathLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.PortalCooldown)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var PlayToClientPacketNameMap = map[int32]string{0x00: "bundle_delimiter", 0x01: "spawn_entity", 0x02: "spawn_entity_experience_orb", 0x03: "animation", 0x04: "statistics", 0x05: "acknowledge_player_digging", 0x06: "block_break_animation", 0x07: "tile_entity_data", 0x08: "block_action", 0x09: "block_change", 0x0a: "boss_bar", 0x0b: "difficulty", 0x0c: "chunk_batch_finished", 0x0d: "chunk_batch_start", 0x0e: "chunk_biomes", 0x0f: "clear_titles", 0x10: "tab_complete", 0x11: "declare_commands", 0x12: "close_window", 0x13: "window_items", 0x14: "craft_progress_bar", 0x15: "set_slot", 0x16: "cookie_request", 0x17: "set_cooldown", 0x18: "chat_suggestions", 0x19: "custom_payload", 0x1a: "damage_event", 0x1b: "debug_sample", 0x1c: "hide_message", 0x1d: "kick_disconnect", 0x1e: "profileless_chat", 0x1f: "entity_status", 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: "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: "unlock_recipes", 0x42: "entity_destroy", 0x43: "remove_entity_effect", 0x44: "reset_score", 0x45: "remove_resource_pack", 0x46: "add_resource_pack", 0x47: "respawn", 0x48: "entity_head_rotation", 0x49: "multi_block_change", 0x4a: "select_advancement_tab", 0x4b: "server_data", 0x4c: "action_bar", 0x4d: "world_border_center", 0x4e: "world_border_lerp_size", 0x4f: "world_border_size", 0x50: "world_border_warning_delay", 0x51: "world_border_warning_reach", 0x52: "camera", 0x53: "held_item_slot", 0x54: "update_view_position", 0x55: "update_view_distance", 0x56: "spawn_position", 0x57: "scoreboard_display_objective", 0x58: "entity_metadata", 0x59: "attach_entity", 0x5a: "entity_velocity", 0x5b: "entity_equipment", 0x5c: "experience", 0x5d: "update_health", 0x5e: "scoreboard_objective", 0x5f: "set_passengers", 0x60: "teams", 0x61: "scoreboard_score", 0x62: "simulation_distance", 0x63: "set_title_subtitle", 0x64: "update_time", 0x65: "set_title_text", 0x66: "set_title_time", 0x67: "entity_sound_effect", 0x68: "sound_effect", 0x69: "start_configuration", 0x6a: "stop_sound", 0x6b: "store_cookie", 0x6c: "system_chat", 0x6d: "playerlist_header", 0x6e: "nbt_query_response", 0x6f: "collect", 0x70: "entity_teleport", 0x71: "set_ticking_state", 0x72: "step_tick", 0x73: "transfer", 0x74: "advancements", 0x75: "entity_update_attributes", 0x76: "entity_effect", 0x77: "declare_recipes", 0x78: "tags", 0x79: "set_projectile_power"}
|
|
|
|
func (ret *PlayToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketNameKey int32
|
|
PlayToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(PlayToClientPacketNameMap, PlayToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
var PlayToClientPacketParamsAbilitiesTmp PlayToClientPacketAbilities
|
|
err = PlayToClientPacketParamsAbilitiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAbilitiesTmp
|
|
case "acknowledge_player_digging":
|
|
var PlayToClientPacketParamsAcknowledgePlayerDiggingTmp PlayToClientPacketAcknowledgePlayerDigging
|
|
err = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp
|
|
case "action_bar":
|
|
var PlayToClientPacketParamsActionBarTmp PlayToClientPacketActionBar
|
|
err = PlayToClientPacketParamsActionBarTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsActionBarTmp
|
|
case "add_resource_pack":
|
|
var PlayToClientPacketParamsAddResourcePackTmp PlayToClientPacketCommonAddResourcePack
|
|
err = PlayToClientPacketParamsAddResourcePackTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAddResourcePackTmp
|
|
case "advancements":
|
|
var PlayToClientPacketParamsAdvancementsTmp PlayToClientPacketAdvancements
|
|
err = PlayToClientPacketParamsAdvancementsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAdvancementsTmp
|
|
case "animation":
|
|
var PlayToClientPacketParamsAnimationTmp PlayToClientPacketAnimation
|
|
err = PlayToClientPacketParamsAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAnimationTmp
|
|
case "attach_entity":
|
|
var PlayToClientPacketParamsAttachEntityTmp PlayToClientPacketAttachEntity
|
|
err = PlayToClientPacketParamsAttachEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsAttachEntityTmp
|
|
case "block_action":
|
|
var PlayToClientPacketParamsBlockActionTmp PlayToClientPacketBlockAction
|
|
err = PlayToClientPacketParamsBlockActionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockActionTmp
|
|
case "block_break_animation":
|
|
var PlayToClientPacketParamsBlockBreakAnimationTmp PlayToClientPacketBlockBreakAnimation
|
|
err = PlayToClientPacketParamsBlockBreakAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockBreakAnimationTmp
|
|
case "block_change":
|
|
var PlayToClientPacketParamsBlockChangeTmp PlayToClientPacketBlockChange
|
|
err = PlayToClientPacketParamsBlockChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBlockChangeTmp
|
|
case "boss_bar":
|
|
var PlayToClientPacketParamsBossBarTmp PlayToClientPacketBossBar
|
|
err = PlayToClientPacketParamsBossBarTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBossBarTmp
|
|
case "bundle_delimiter":
|
|
var PlayToClientPacketParamsBundleDelimiterTmp PlayToClientPacketBundleDelimiter
|
|
err = PlayToClientPacketParamsBundleDelimiterTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsBundleDelimiterTmp
|
|
case "camera":
|
|
var PlayToClientPacketParamsCameraTmp PlayToClientPacketCamera
|
|
err = PlayToClientPacketParamsCameraTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCameraTmp
|
|
case "chat_suggestions":
|
|
var PlayToClientPacketParamsChatSuggestionsTmp PlayToClientPacketChatSuggestions
|
|
err = PlayToClientPacketParamsChatSuggestionsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsChatSuggestionsTmp
|
|
case "chunk_batch_finished":
|
|
var PlayToClientPacketParamsChunkBatchFinishedTmp PlayToClientPacketChunkBatchFinished
|
|
err = PlayToClientPacketParamsChunkBatchFinishedTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsChunkBatchFinishedTmp
|
|
case "chunk_batch_start":
|
|
var PlayToClientPacketParamsChunkBatchStartTmp PlayToClientPacketChunkBatchStart
|
|
err = PlayToClientPacketParamsChunkBatchStartTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsChunkBatchStartTmp
|
|
case "chunk_biomes":
|
|
var PlayToClientPacketParamsChunkBiomesTmp PlayToClientPacketChunkBiomes
|
|
err = PlayToClientPacketParamsChunkBiomesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsChunkBiomesTmp
|
|
case "clear_titles":
|
|
var PlayToClientPacketParamsClearTitlesTmp PlayToClientPacketClearTitles
|
|
err = PlayToClientPacketParamsClearTitlesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsClearTitlesTmp
|
|
case "close_window":
|
|
var PlayToClientPacketParamsCloseWindowTmp PlayToClientPacketCloseWindow
|
|
err = PlayToClientPacketParamsCloseWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCloseWindowTmp
|
|
case "collect":
|
|
var PlayToClientPacketParamsCollectTmp PlayToClientPacketCollect
|
|
err = PlayToClientPacketParamsCollectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCollectTmp
|
|
case "cookie_request":
|
|
var PlayToClientPacketParamsCookieRequestTmp PlayToClientPacketCommonCookieRequest
|
|
err = PlayToClientPacketParamsCookieRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCookieRequestTmp
|
|
case "craft_progress_bar":
|
|
var PlayToClientPacketParamsCraftProgressBarTmp PlayToClientPacketCraftProgressBar
|
|
err = PlayToClientPacketParamsCraftProgressBarTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCraftProgressBarTmp
|
|
case "craft_recipe_response":
|
|
var PlayToClientPacketParamsCraftRecipeResponseTmp PlayToClientPacketCraftRecipeResponse
|
|
err = PlayToClientPacketParamsCraftRecipeResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCraftRecipeResponseTmp
|
|
case "custom_payload":
|
|
var PlayToClientPacketParamsCustomPayloadTmp PlayToClientPacketCustomPayload
|
|
err = PlayToClientPacketParamsCustomPayloadTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsCustomPayloadTmp
|
|
case "damage_event":
|
|
var PlayToClientPacketParamsDamageEventTmp PlayToClientPacketDamageEvent
|
|
err = PlayToClientPacketParamsDamageEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDamageEventTmp
|
|
case "death_combat_event":
|
|
var PlayToClientPacketParamsDeathCombatEventTmp PlayToClientPacketDeathCombatEvent
|
|
err = PlayToClientPacketParamsDeathCombatEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDeathCombatEventTmp
|
|
case "debug_sample":
|
|
var PlayToClientPacketParamsDebugSampleTmp PlayToClientPacketDebugSample
|
|
err = PlayToClientPacketParamsDebugSampleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDebugSampleTmp
|
|
case "declare_commands":
|
|
var PlayToClientPacketParamsDeclareCommandsTmp PlayToClientPacketDeclareCommands
|
|
err = PlayToClientPacketParamsDeclareCommandsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDeclareCommandsTmp
|
|
case "declare_recipes":
|
|
var PlayToClientPacketParamsDeclareRecipesTmp PlayToClientPacketDeclareRecipes
|
|
err = PlayToClientPacketParamsDeclareRecipesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDeclareRecipesTmp
|
|
case "difficulty":
|
|
var PlayToClientPacketParamsDifficultyTmp PlayToClientPacketDifficulty
|
|
err = PlayToClientPacketParamsDifficultyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsDifficultyTmp
|
|
case "end_combat_event":
|
|
var PlayToClientPacketParamsEndCombatEventTmp PlayToClientPacketEndCombatEvent
|
|
err = PlayToClientPacketParamsEndCombatEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEndCombatEventTmp
|
|
case "enter_combat_event":
|
|
var PlayToClientPacketParamsEnterCombatEventTmp PlayToClientPacketEnterCombatEvent
|
|
err = PlayToClientPacketParamsEnterCombatEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEnterCombatEventTmp
|
|
case "entity_destroy":
|
|
var PlayToClientPacketParamsEntityDestroyTmp PlayToClientPacketEntityDestroy
|
|
err = PlayToClientPacketParamsEntityDestroyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityDestroyTmp
|
|
case "entity_effect":
|
|
var PlayToClientPacketParamsEntityEffectTmp PlayToClientPacketEntityEffect
|
|
err = PlayToClientPacketParamsEntityEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityEffectTmp
|
|
case "entity_equipment":
|
|
var PlayToClientPacketParamsEntityEquipmentTmp PlayToClientPacketEntityEquipment
|
|
err = PlayToClientPacketParamsEntityEquipmentTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityEquipmentTmp
|
|
case "entity_head_rotation":
|
|
var PlayToClientPacketParamsEntityHeadRotationTmp PlayToClientPacketEntityHeadRotation
|
|
err = PlayToClientPacketParamsEntityHeadRotationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityHeadRotationTmp
|
|
case "entity_look":
|
|
var PlayToClientPacketParamsEntityLookTmp PlayToClientPacketEntityLook
|
|
err = PlayToClientPacketParamsEntityLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityLookTmp
|
|
case "entity_metadata":
|
|
var PlayToClientPacketParamsEntityMetadataTmp PlayToClientPacketEntityMetadata
|
|
err = PlayToClientPacketParamsEntityMetadataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityMetadataTmp
|
|
case "entity_move_look":
|
|
var PlayToClientPacketParamsEntityMoveLookTmp PlayToClientPacketEntityMoveLook
|
|
err = PlayToClientPacketParamsEntityMoveLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityMoveLookTmp
|
|
case "entity_sound_effect":
|
|
var PlayToClientPacketParamsEntitySoundEffectTmp PlayToClientPacketEntitySoundEffect
|
|
err = PlayToClientPacketParamsEntitySoundEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntitySoundEffectTmp
|
|
case "entity_status":
|
|
var PlayToClientPacketParamsEntityStatusTmp PlayToClientPacketEntityStatus
|
|
err = PlayToClientPacketParamsEntityStatusTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityStatusTmp
|
|
case "entity_teleport":
|
|
var PlayToClientPacketParamsEntityTeleportTmp PlayToClientPacketEntityTeleport
|
|
err = PlayToClientPacketParamsEntityTeleportTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityTeleportTmp
|
|
case "entity_update_attributes":
|
|
var PlayToClientPacketParamsEntityUpdateAttributesTmp PlayToClientPacketEntityUpdateAttributes
|
|
err = PlayToClientPacketParamsEntityUpdateAttributesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityUpdateAttributesTmp
|
|
case "entity_velocity":
|
|
var PlayToClientPacketParamsEntityVelocityTmp PlayToClientPacketEntityVelocity
|
|
err = PlayToClientPacketParamsEntityVelocityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsEntityVelocityTmp
|
|
case "experience":
|
|
var PlayToClientPacketParamsExperienceTmp PlayToClientPacketExperience
|
|
err = PlayToClientPacketParamsExperienceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsExperienceTmp
|
|
case "explosion":
|
|
var PlayToClientPacketParamsExplosionTmp PlayToClientPacketExplosion
|
|
err = PlayToClientPacketParamsExplosionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsExplosionTmp
|
|
case "face_player":
|
|
var PlayToClientPacketParamsFacePlayerTmp PlayToClientPacketFacePlayer
|
|
err = PlayToClientPacketParamsFacePlayerTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsFacePlayerTmp
|
|
case "game_state_change":
|
|
var PlayToClientPacketParamsGameStateChangeTmp PlayToClientPacketGameStateChange
|
|
err = PlayToClientPacketParamsGameStateChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsGameStateChangeTmp
|
|
case "held_item_slot":
|
|
var PlayToClientPacketParamsHeldItemSlotTmp PlayToClientPacketHeldItemSlot
|
|
err = PlayToClientPacketParamsHeldItemSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsHeldItemSlotTmp
|
|
case "hide_message":
|
|
var PlayToClientPacketParamsHideMessageTmp PlayToClientPacketHideMessage
|
|
err = PlayToClientPacketParamsHideMessageTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsHideMessageTmp
|
|
case "hurt_animation":
|
|
var PlayToClientPacketParamsHurtAnimationTmp PlayToClientPacketHurtAnimation
|
|
err = PlayToClientPacketParamsHurtAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsHurtAnimationTmp
|
|
case "initialize_world_border":
|
|
var PlayToClientPacketParamsInitializeWorldBorderTmp PlayToClientPacketInitializeWorldBorder
|
|
err = PlayToClientPacketParamsInitializeWorldBorderTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsInitializeWorldBorderTmp
|
|
case "keep_alive":
|
|
var PlayToClientPacketParamsKeepAliveTmp PlayToClientPacketKeepAlive
|
|
err = PlayToClientPacketParamsKeepAliveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsKeepAliveTmp
|
|
case "kick_disconnect":
|
|
var PlayToClientPacketParamsKickDisconnectTmp PlayToClientPacketKickDisconnect
|
|
err = PlayToClientPacketParamsKickDisconnectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsKickDisconnectTmp
|
|
case "login":
|
|
var PlayToClientPacketParamsLoginTmp PlayToClientPacketLogin
|
|
err = PlayToClientPacketParamsLoginTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsLoginTmp
|
|
case "map":
|
|
var PlayToClientPacketParamsMapTmp PlayToClientPacketMap
|
|
err = PlayToClientPacketParamsMapTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMapTmp
|
|
case "map_chunk":
|
|
var PlayToClientPacketParamsMapChunkTmp PlayToClientPacketMapChunk
|
|
err = PlayToClientPacketParamsMapChunkTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMapChunkTmp
|
|
case "multi_block_change":
|
|
var PlayToClientPacketParamsMultiBlockChangeTmp PlayToClientPacketMultiBlockChange
|
|
err = PlayToClientPacketParamsMultiBlockChangeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsMultiBlockChangeTmp
|
|
case "nbt_query_response":
|
|
var PlayToClientPacketParamsNbtQueryResponseTmp PlayToClientPacketNbtQueryResponse
|
|
err = PlayToClientPacketParamsNbtQueryResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsNbtQueryResponseTmp
|
|
case "open_book":
|
|
var PlayToClientPacketParamsOpenBookTmp PlayToClientPacketOpenBook
|
|
err = PlayToClientPacketParamsOpenBookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenBookTmp
|
|
case "open_horse_window":
|
|
var PlayToClientPacketParamsOpenHorseWindowTmp PlayToClientPacketOpenHorseWindow
|
|
err = PlayToClientPacketParamsOpenHorseWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenHorseWindowTmp
|
|
case "open_sign_entity":
|
|
var PlayToClientPacketParamsOpenSignEntityTmp PlayToClientPacketOpenSignEntity
|
|
err = PlayToClientPacketParamsOpenSignEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenSignEntityTmp
|
|
case "open_window":
|
|
var PlayToClientPacketParamsOpenWindowTmp PlayToClientPacketOpenWindow
|
|
err = PlayToClientPacketParamsOpenWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsOpenWindowTmp
|
|
case "ping":
|
|
var PlayToClientPacketParamsPingTmp PlayToClientPacketPing
|
|
err = PlayToClientPacketParamsPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPingTmp
|
|
case "ping_response":
|
|
var PlayToClientPacketParamsPingResponseTmp PlayToClientPacketPingResponse
|
|
err = PlayToClientPacketParamsPingResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPingResponseTmp
|
|
case "player_chat":
|
|
var PlayToClientPacketParamsPlayerChatTmp PlayToClientPacketPlayerChat
|
|
err = PlayToClientPacketParamsPlayerChatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPlayerChatTmp
|
|
case "player_info":
|
|
var PlayToClientPacketParamsPlayerInfoTmp PlayToClientPacketPlayerInfo
|
|
err = PlayToClientPacketParamsPlayerInfoTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPlayerInfoTmp
|
|
case "player_remove":
|
|
var PlayToClientPacketParamsPlayerRemoveTmp PlayToClientPacketPlayerRemove
|
|
err = PlayToClientPacketParamsPlayerRemoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPlayerRemoveTmp
|
|
case "playerlist_header":
|
|
var PlayToClientPacketParamsPlayerlistHeaderTmp PlayToClientPacketPlayerlistHeader
|
|
err = PlayToClientPacketParamsPlayerlistHeaderTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPlayerlistHeaderTmp
|
|
case "position":
|
|
var PlayToClientPacketParamsPositionTmp PlayToClientPacketPosition
|
|
err = PlayToClientPacketParamsPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsPositionTmp
|
|
case "profileless_chat":
|
|
var PlayToClientPacketParamsProfilelessChatTmp PlayToClientPacketProfilelessChat
|
|
err = PlayToClientPacketParamsProfilelessChatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsProfilelessChatTmp
|
|
case "rel_entity_move":
|
|
var PlayToClientPacketParamsRelEntityMoveTmp PlayToClientPacketRelEntityMove
|
|
err = PlayToClientPacketParamsRelEntityMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRelEntityMoveTmp
|
|
case "remove_entity_effect":
|
|
var PlayToClientPacketParamsRemoveEntityEffectTmp PlayToClientPacketRemoveEntityEffect
|
|
err = PlayToClientPacketParamsRemoveEntityEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRemoveEntityEffectTmp
|
|
case "remove_resource_pack":
|
|
var PlayToClientPacketParamsRemoveResourcePackTmp PlayToClientPacketCommonRemoveResourcePack
|
|
err = PlayToClientPacketParamsRemoveResourcePackTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRemoveResourcePackTmp
|
|
case "reset_score":
|
|
var PlayToClientPacketParamsResetScoreTmp PlayToClientPacketResetScore
|
|
err = PlayToClientPacketParamsResetScoreTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsResetScoreTmp
|
|
case "respawn":
|
|
var PlayToClientPacketParamsRespawnTmp PlayToClientPacketRespawn
|
|
err = PlayToClientPacketParamsRespawnTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsRespawnTmp
|
|
case "scoreboard_display_objective":
|
|
var PlayToClientPacketParamsScoreboardDisplayObjectiveTmp PlayToClientPacketScoreboardDisplayObjective
|
|
err = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp
|
|
case "scoreboard_objective":
|
|
var PlayToClientPacketParamsScoreboardObjectiveTmp PlayToClientPacketScoreboardObjective
|
|
err = PlayToClientPacketParamsScoreboardObjectiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardObjectiveTmp
|
|
case "scoreboard_score":
|
|
var PlayToClientPacketParamsScoreboardScoreTmp PlayToClientPacketScoreboardScore
|
|
err = PlayToClientPacketParamsScoreboardScoreTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsScoreboardScoreTmp
|
|
case "select_advancement_tab":
|
|
var PlayToClientPacketParamsSelectAdvancementTabTmp PlayToClientPacketSelectAdvancementTab
|
|
err = PlayToClientPacketParamsSelectAdvancementTabTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSelectAdvancementTabTmp
|
|
case "server_data":
|
|
var PlayToClientPacketParamsServerDataTmp PlayToClientPacketServerData
|
|
err = PlayToClientPacketParamsServerDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsServerDataTmp
|
|
case "set_cooldown":
|
|
var PlayToClientPacketParamsSetCooldownTmp PlayToClientPacketSetCooldown
|
|
err = PlayToClientPacketParamsSetCooldownTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetCooldownTmp
|
|
case "set_passengers":
|
|
var PlayToClientPacketParamsSetPassengersTmp PlayToClientPacketSetPassengers
|
|
err = PlayToClientPacketParamsSetPassengersTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetPassengersTmp
|
|
case "set_projectile_power":
|
|
var PlayToClientPacketParamsSetProjectilePowerTmp PlayToClientPacketSetProjectilePower
|
|
err = PlayToClientPacketParamsSetProjectilePowerTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetProjectilePowerTmp
|
|
case "set_slot":
|
|
var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot
|
|
err = PlayToClientPacketParamsSetSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetSlotTmp
|
|
case "set_ticking_state":
|
|
var PlayToClientPacketParamsSetTickingStateTmp PlayToClientPacketSetTickingState
|
|
err = PlayToClientPacketParamsSetTickingStateTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetTickingStateTmp
|
|
case "set_title_subtitle":
|
|
var PlayToClientPacketParamsSetTitleSubtitleTmp PlayToClientPacketSetTitleSubtitle
|
|
err = PlayToClientPacketParamsSetTitleSubtitleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetTitleSubtitleTmp
|
|
case "set_title_text":
|
|
var PlayToClientPacketParamsSetTitleTextTmp PlayToClientPacketSetTitleText
|
|
err = PlayToClientPacketParamsSetTitleTextTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetTitleTextTmp
|
|
case "set_title_time":
|
|
var PlayToClientPacketParamsSetTitleTimeTmp PlayToClientPacketSetTitleTime
|
|
err = PlayToClientPacketParamsSetTitleTimeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSetTitleTimeTmp
|
|
case "simulation_distance":
|
|
var PlayToClientPacketParamsSimulationDistanceTmp PlayToClientPacketSimulationDistance
|
|
err = PlayToClientPacketParamsSimulationDistanceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSimulationDistanceTmp
|
|
case "sound_effect":
|
|
var PlayToClientPacketParamsSoundEffectTmp PlayToClientPacketSoundEffect
|
|
err = PlayToClientPacketParamsSoundEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSoundEffectTmp
|
|
case "spawn_entity":
|
|
var PlayToClientPacketParamsSpawnEntityTmp PlayToClientPacketSpawnEntity
|
|
err = PlayToClientPacketParamsSpawnEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityTmp
|
|
case "spawn_entity_experience_orb":
|
|
var PlayToClientPacketParamsSpawnEntityExperienceOrbTmp PlayToClientPacketSpawnEntityExperienceOrb
|
|
err = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnEntityExperienceOrbTmp
|
|
case "spawn_position":
|
|
var PlayToClientPacketParamsSpawnPositionTmp PlayToClientPacketSpawnPosition
|
|
err = PlayToClientPacketParamsSpawnPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSpawnPositionTmp
|
|
case "start_configuration":
|
|
var PlayToClientPacketParamsStartConfigurationTmp PlayToClientPacketStartConfiguration
|
|
err = PlayToClientPacketParamsStartConfigurationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsStartConfigurationTmp
|
|
case "statistics":
|
|
var PlayToClientPacketParamsStatisticsTmp PlayToClientPacketStatistics
|
|
err = PlayToClientPacketParamsStatisticsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsStatisticsTmp
|
|
case "step_tick":
|
|
var PlayToClientPacketParamsStepTickTmp PlayToClientPacketStepTick
|
|
err = PlayToClientPacketParamsStepTickTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsStepTickTmp
|
|
case "stop_sound":
|
|
var PlayToClientPacketParamsStopSoundTmp PlayToClientPacketStopSound
|
|
err = PlayToClientPacketParamsStopSoundTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsStopSoundTmp
|
|
case "store_cookie":
|
|
var PlayToClientPacketParamsStoreCookieTmp PlayToClientPacketCommonStoreCookie
|
|
err = PlayToClientPacketParamsStoreCookieTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsStoreCookieTmp
|
|
case "system_chat":
|
|
var PlayToClientPacketParamsSystemChatTmp PlayToClientPacketSystemChat
|
|
err = PlayToClientPacketParamsSystemChatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsSystemChatTmp
|
|
case "tab_complete":
|
|
var PlayToClientPacketParamsTabCompleteTmp PlayToClientPacketTabComplete
|
|
err = PlayToClientPacketParamsTabCompleteTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTabCompleteTmp
|
|
case "tags":
|
|
var PlayToClientPacketParamsTagsTmp PlayToClientPacketTags
|
|
err = PlayToClientPacketParamsTagsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTagsTmp
|
|
case "teams":
|
|
var PlayToClientPacketParamsTeamsTmp PlayToClientPacketTeams
|
|
err = PlayToClientPacketParamsTeamsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTeamsTmp
|
|
case "tile_entity_data":
|
|
var PlayToClientPacketParamsTileEntityDataTmp PlayToClientPacketTileEntityData
|
|
err = PlayToClientPacketParamsTileEntityDataTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTileEntityDataTmp
|
|
case "trade_list":
|
|
var PlayToClientPacketParamsTradeListTmp PlayToClientPacketTradeList
|
|
err = PlayToClientPacketParamsTradeListTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTradeListTmp
|
|
case "transfer":
|
|
var PlayToClientPacketParamsTransferTmp PlayToClientPacketCommonTransfer
|
|
err = PlayToClientPacketParamsTransferTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsTransferTmp
|
|
case "unload_chunk":
|
|
var PlayToClientPacketParamsUnloadChunkTmp PlayToClientPacketUnloadChunk
|
|
err = PlayToClientPacketParamsUnloadChunkTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUnloadChunkTmp
|
|
case "unlock_recipes":
|
|
var PlayToClientPacketParamsUnlockRecipesTmp PlayToClientPacketUnlockRecipes
|
|
err = PlayToClientPacketParamsUnlockRecipesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUnlockRecipesTmp
|
|
case "update_health":
|
|
var PlayToClientPacketParamsUpdateHealthTmp PlayToClientPacketUpdateHealth
|
|
err = PlayToClientPacketParamsUpdateHealthTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateHealthTmp
|
|
case "update_light":
|
|
var PlayToClientPacketParamsUpdateLightTmp PlayToClientPacketUpdateLight
|
|
err = PlayToClientPacketParamsUpdateLightTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateLightTmp
|
|
case "update_time":
|
|
var PlayToClientPacketParamsUpdateTimeTmp PlayToClientPacketUpdateTime
|
|
err = PlayToClientPacketParamsUpdateTimeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateTimeTmp
|
|
case "update_view_distance":
|
|
var PlayToClientPacketParamsUpdateViewDistanceTmp PlayToClientPacketUpdateViewDistance
|
|
err = PlayToClientPacketParamsUpdateViewDistanceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateViewDistanceTmp
|
|
case "update_view_position":
|
|
var PlayToClientPacketParamsUpdateViewPositionTmp PlayToClientPacketUpdateViewPosition
|
|
err = PlayToClientPacketParamsUpdateViewPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsUpdateViewPositionTmp
|
|
case "vehicle_move":
|
|
var PlayToClientPacketParamsVehicleMoveTmp PlayToClientPacketVehicleMove
|
|
err = PlayToClientPacketParamsVehicleMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsVehicleMoveTmp
|
|
case "window_items":
|
|
var PlayToClientPacketParamsWindowItemsTmp PlayToClientPacketWindowItems
|
|
err = PlayToClientPacketParamsWindowItemsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWindowItemsTmp
|
|
case "world_border_center":
|
|
var PlayToClientPacketParamsWorldBorderCenterTmp PlayToClientPacketWorldBorderCenter
|
|
err = PlayToClientPacketParamsWorldBorderCenterTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldBorderCenterTmp
|
|
case "world_border_lerp_size":
|
|
var PlayToClientPacketParamsWorldBorderLerpSizeTmp PlayToClientPacketWorldBorderLerpSize
|
|
err = PlayToClientPacketParamsWorldBorderLerpSizeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldBorderLerpSizeTmp
|
|
case "world_border_size":
|
|
var PlayToClientPacketParamsWorldBorderSizeTmp PlayToClientPacketWorldBorderSize
|
|
err = PlayToClientPacketParamsWorldBorderSizeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldBorderSizeTmp
|
|
case "world_border_warning_delay":
|
|
var PlayToClientPacketParamsWorldBorderWarningDelayTmp PlayToClientPacketWorldBorderWarningDelay
|
|
err = PlayToClientPacketParamsWorldBorderWarningDelayTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldBorderWarningDelayTmp
|
|
case "world_border_warning_reach":
|
|
var PlayToClientPacketParamsWorldBorderWarningReachTmp PlayToClientPacketWorldBorderWarningReach
|
|
err = PlayToClientPacketParamsWorldBorderWarningReachTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldBorderWarningReachTmp
|
|
case "world_event":
|
|
var PlayToClientPacketParamsWorldEventTmp PlayToClientPacketWorldEvent
|
|
err = PlayToClientPacketParamsWorldEventTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldEventTmp
|
|
case "world_particles":
|
|
var PlayToClientPacketParamsWorldParticlesTmp PlayToClientPacketWorldParticles
|
|
err = PlayToClientPacketParamsWorldParticlesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToClientPacketParamsWorldParticlesTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketNameReverseMap = map[string]int32{"bundle_delimiter": 0x00, "spawn_entity": 0x01, "spawn_entity_experience_orb": 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, "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, "entity_look": 0x30, "vehicle_move": 0x31, "open_book": 0x32, "open_window": 0x33, "open_sign_entity": 0x34, "ping": 0x35, "ping_response": 0x36, "craft_recipe_response": 0x37, "abilities": 0x38, "player_chat": 0x39, "end_combat_event": 0x3a, "enter_combat_event": 0x3b, "death_combat_event": 0x3c, "player_remove": 0x3d, "player_info": 0x3e, "face_player": 0x3f, "position": 0x40, "unlock_recipes": 0x41, "entity_destroy": 0x42, "remove_entity_effect": 0x43, "reset_score": 0x44, "remove_resource_pack": 0x45, "add_resource_pack": 0x46, "respawn": 0x47, "entity_head_rotation": 0x48, "multi_block_change": 0x49, "select_advancement_tab": 0x4a, "server_data": 0x4b, "action_bar": 0x4c, "world_border_center": 0x4d, "world_border_lerp_size": 0x4e, "world_border_size": 0x4f, "world_border_warning_delay": 0x50, "world_border_warning_reach": 0x51, "camera": 0x52, "held_item_slot": 0x53, "update_view_position": 0x54, "update_view_distance": 0x55, "spawn_position": 0x56, "scoreboard_display_objective": 0x57, "entity_metadata": 0x58, "attach_entity": 0x59, "entity_velocity": 0x5a, "entity_equipment": 0x5b, "experience": 0x5c, "update_health": 0x5d, "scoreboard_objective": 0x5e, "set_passengers": 0x5f, "teams": 0x60, "scoreboard_score": 0x61, "simulation_distance": 0x62, "set_title_subtitle": 0x63, "update_time": 0x64, "set_title_text": 0x65, "set_title_time": 0x66, "entity_sound_effect": 0x67, "sound_effect": 0x68, "start_configuration": 0x69, "stop_sound": 0x6a, "store_cookie": 0x6b, "system_chat": 0x6c, "playerlist_header": 0x6d, "nbt_query_response": 0x6e, "collect": 0x6f, "entity_teleport": 0x70, "set_ticking_state": 0x71, "step_tick": 0x72, "transfer": 0x73, "advancements": 0x74, "entity_update_attributes": 0x75, "entity_effect": 0x76, "declare_recipes": 0x77, "tags": 0x78, "set_projectile_power": 0x79}
|
|
|
|
func (ret *PlayToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vPlayToClientPacketName int32
|
|
vPlayToClientPacketName, err = proto_base.ErroringIndex(PlayToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAbilities)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "acknowledge_player_digging":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAcknowledgePlayerDigging)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "action_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketActionBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "add_resource_pack":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonAddResourcePack)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "advancements":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAdvancements)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "attach_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAttachEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_action":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_break_animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockBreakAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "boss_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBossBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "bundle_delimiter":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBundleDelimiter)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "camera":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCamera)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_suggestions":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChatSuggestions)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chunk_batch_finished":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchFinished)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chunk_batch_start":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chunk_biomes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBiomes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "clear_titles":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketClearTitles)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "close_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCloseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "collect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCollect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cookie_request":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonCookieRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_progress_bar":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftProgressBar)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_recipe_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftRecipeResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "damage_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDamageEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "death_combat_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeathCombatEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "debug_sample":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugSample)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "declare_commands":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareCommands)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "declare_recipes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareRecipes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "difficulty":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDifficulty)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "end_combat_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEndCombatEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "enter_combat_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEnterCombatEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_destroy":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityDestroy)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_equipment":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEquipment)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_head_rotation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityHeadRotation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_look":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_metadata":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMetadata)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_move_look":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMoveLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntitySoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_status":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityStatus)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_teleport":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityTeleport)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_update_attributes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityUpdateAttributes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_velocity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityVelocity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "experience":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExperience)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "explosion":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExplosion)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "face_player":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketFacePlayer)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "game_state_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameStateChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "held_item_slot":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHeldItemSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "hide_message":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHideMessage)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "hurt_animation":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHurtAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "initialize_world_border":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketInitializeWorldBorder)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "kick_disconnect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKickDisconnect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "login":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketLogin)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "map":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMap)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "map_chunk":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunk)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "multi_block_change":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMultiBlockChange)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "nbt_query_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNbtQueryResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_book":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenBook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_horse_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenHorseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_sign_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenSignEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "open_window":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping_response":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPingResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_chat":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_info":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerInfo)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "player_remove":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRemove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "playerlist_header":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerlistHeader)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "profileless_chat":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketProfilelessChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "rel_entity_move":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRelEntityMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_entity_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRemoveEntityEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "remove_resource_pack":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonRemoveResourcePack)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "reset_score":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResetScore)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "respawn":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRespawn)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_display_objective":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardDisplayObjective)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_objective":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardObjective)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "scoreboard_score":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardScore)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_advancement_tab":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSelectAdvancementTab)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "server_data":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketServerData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_cooldown":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCooldown)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_passengers":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPassengers)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_projectile_power":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetProjectilePower)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_slot":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_ticking_state":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTickingState)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_title_subtitle":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleSubtitle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_title_text":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleText)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_title_time":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleTime)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "simulation_distance":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSimulationDistance)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "sound_effect":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSoundEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_entity_experience_orb":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntityExperienceOrb)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spawn_position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "start_configuration":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStartConfiguration)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "statistics":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStatistics)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "step_tick":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStepTick)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "stop_sound":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStopSound)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "store_cookie":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonStoreCookie)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "system_chat":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSystemChat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tab_complete":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTabComplete)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tags":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTags)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "teams":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTeams)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tile_entity_data":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTileEntityData)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "trade_list":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTradeList)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "transfer":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonTransfer)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "unload_chunk":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnloadChunk)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "unlock_recipes":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnlockRecipes)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_health":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateHealth)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_light":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateLight)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_time":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateTime)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_view_distance":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewDistance)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_view_position":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vehicle_move":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketVehicleMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "window_items":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWindowItems)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_center":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderCenter)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_lerp_size":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderLerpSize)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_size":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderSize)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_warning_delay":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningDelay)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_border_warning_reach":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningReach)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_event":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldEvent)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "world_particles":
|
|
PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldParticles)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketParamsEncTmp := PlayToClientPacketParams
|
|
err = PlayToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAbilities struct {
|
|
Flags int8
|
|
FlyingSpeed float32
|
|
WalkingSpeed float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAbilities) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAbilities) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAcknowledgePlayerDigging struct {
|
|
SequenceId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAcknowledgePlayerDigging) Decode(r io.ReadSeeker) (err error) {
|
|
ret.SequenceId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAcknowledgePlayerDigging) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.SequenceId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketActionBar struct {
|
|
Text nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketActionBar) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Text.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketActionBar) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketActionBarTextEncTmp := ret.Text
|
|
err = PlayToClientPacketActionBarTextEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAdvancements struct {
|
|
Reset bool
|
|
AdvancementMapping []struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title nbt.Anon
|
|
Description nbt.Anon
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Requirements [][]string
|
|
SendsTelemtryData bool
|
|
}
|
|
}
|
|
Identifiers []string
|
|
ProgressMapping []struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAdvancements) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Reset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketAdvancementsAdvancementMapping int32
|
|
lPlayToClientPacketAdvancementsAdvancementMapping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AdvancementMapping = []struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title nbt.Anon
|
|
Description nbt.Anon
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Requirements [][]string
|
|
SendsTelemtryData bool
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMapping {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElement struct {
|
|
Key string
|
|
Value struct {
|
|
ParentId *string
|
|
DisplayData *struct {
|
|
Title nbt.Anon
|
|
Description nbt.Anon
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
Requirements [][]string
|
|
SendsTelemtryData bool
|
|
}
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.ParentId = &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue struct {
|
|
Title nbt.Anon
|
|
Description nbt.Anon
|
|
Icon Slot
|
|
FrameType int32
|
|
Flags struct {
|
|
Unused uint32
|
|
Hidden bool
|
|
ShowToast bool
|
|
HasBackgroundTexture bool
|
|
}
|
|
BackgroundTexture any
|
|
XCord float32
|
|
YCord float32
|
|
}
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Title.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Description.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Icon.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.FrameType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked uint32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked>>0&1 == 1
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.ShowToast = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked>>1&1 == 1
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Hidden = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked>>2&1 == 1
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Unused = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked >> 3 & 536870911
|
|
switch PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture {
|
|
case true:
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp
|
|
default:
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp struct {
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.XCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.YCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.DisplayData = &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue
|
|
}
|
|
var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements int32
|
|
lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = [][]string{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement []string
|
|
var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement int32
|
|
lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = []string{}
|
|
for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement {
|
|
var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement string
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = append(PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement)
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElement.Value.SendsTelemtryData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AdvancementMapping = append(ret.AdvancementMapping, PlayToClientPacketAdvancementsAdvancementMappingElement)
|
|
}
|
|
var lPlayToClientPacketAdvancementsIdentifiers int32
|
|
lPlayToClientPacketAdvancementsIdentifiers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Identifiers = []string{}
|
|
for range lPlayToClientPacketAdvancementsIdentifiers {
|
|
var PlayToClientPacketAdvancementsIdentifiersElement string
|
|
PlayToClientPacketAdvancementsIdentifiersElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Identifiers = append(ret.Identifiers, PlayToClientPacketAdvancementsIdentifiersElement)
|
|
}
|
|
var lPlayToClientPacketAdvancementsProgressMapping int32
|
|
lPlayToClientPacketAdvancementsProgressMapping, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ProgressMapping = []struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsProgressMapping {
|
|
var PlayToClientPacketAdvancementsProgressMappingElement struct {
|
|
Key string
|
|
Value []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketAdvancementsProgressMappingElementValue int32
|
|
lPlayToClientPacketAdvancementsProgressMappingElementValue, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Value = []struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}{}
|
|
for range lPlayToClientPacketAdvancementsProgressMappingElementValue {
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElement struct {
|
|
CriterionIdentifier string
|
|
CriterionProgress *int64
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionIdentifier, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent {
|
|
var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionProgress = &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue
|
|
}
|
|
PlayToClientPacketAdvancementsProgressMappingElement.Value = append(PlayToClientPacketAdvancementsProgressMappingElement.Value, PlayToClientPacketAdvancementsProgressMappingElementValueElement)
|
|
}
|
|
ret.ProgressMapping = append(ret.ProgressMapping, PlayToClientPacketAdvancementsProgressMappingElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAdvancements) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Reset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMapping := range len(ret.AdvancementMapping) {
|
|
err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil {
|
|
err = proto_base.EncodeString(w, *ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil {
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataTitleEncTmp := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Title
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataTitleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataDescriptionEncTmp := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Description
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataDescriptionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataIconEncTmp := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Icon
|
|
err = PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataIconEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).FrameType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked uint32
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture) & 0x1) << 0x0
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.ShowToast) & 0x1) << 0x1
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Hidden) & 0x1) << 0x2
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Unused) & 0x1FFFFFFF) << 0x3
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture {
|
|
case true:
|
|
PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).XCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).YCord)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements])))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements]) {
|
|
err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements][iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.SendsTelemtryData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Identifiers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsIdentifiers := range len(ret.Identifiers) {
|
|
err = proto_base.EncodeString(w, ret.Identifiers[iPlayToClientPacketAdvancementsIdentifiers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsProgressMapping := range len(ret.ProgressMapping) {
|
|
err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketAdvancementsProgressMappingInnerValue := range len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value) {
|
|
err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionIdentifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil {
|
|
err = binary.Write(w, binary.BigEndian, *ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAnimation struct {
|
|
EntityId int32
|
|
Animation uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Animation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Animation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketAttachEntity struct {
|
|
EntityId int32
|
|
VehicleId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketAttachEntity) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VehicleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketAttachEntity) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VehicleId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockAction struct {
|
|
Location Position
|
|
Byte1 uint8
|
|
Byte2 uint8
|
|
BlockId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockAction) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Byte1)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Byte2)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockAction) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketBlockActionLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockActionLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Byte1)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Byte2)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.BlockId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockBreakAnimation struct {
|
|
EntityId int32
|
|
Location Position
|
|
DestroyStage int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockBreakAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DestroyStage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockBreakAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketBlockBreakAnimationLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockBreakAnimationLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DestroyStage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBlockChange struct {
|
|
Location Position
|
|
Type int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBlockChange) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBlockChange) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketBlockChangeLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketBlockChangeLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBossBar struct {
|
|
EntityUUID uuid.UUID
|
|
Action int32
|
|
Title any
|
|
Health any
|
|
Color any
|
|
Dividers any
|
|
Flags any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBossBar) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarTitle0Tmp nbt.Anon
|
|
err = PlayToClientPacketBossBarTitle0Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitle0Tmp
|
|
case 3:
|
|
var PlayToClientPacketBossBarTitle3Tmp nbt.Anon
|
|
err = PlayToClientPacketBossBarTitle3Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitle3Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarTitleTmp struct {
|
|
}
|
|
ret.Title = PlayToClientPacketBossBarTitleTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarHealth0Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealth0Tmp
|
|
case 2:
|
|
var PlayToClientPacketBossBarHealth2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealth2Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarHealthTmp struct {
|
|
}
|
|
ret.Health = PlayToClientPacketBossBarHealthTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarColor0Tmp int32
|
|
PlayToClientPacketBossBarColor0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColor0Tmp
|
|
case 4:
|
|
var PlayToClientPacketBossBarColor4Tmp int32
|
|
PlayToClientPacketBossBarColor4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColor4Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarColorTmp struct {
|
|
}
|
|
ret.Color = PlayToClientPacketBossBarColorTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarDividers0Tmp int32
|
|
PlayToClientPacketBossBarDividers0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividers0Tmp
|
|
case 4:
|
|
var PlayToClientPacketBossBarDividers4Tmp int32
|
|
PlayToClientPacketBossBarDividers4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividers4Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarDividersTmp struct {
|
|
}
|
|
ret.Dividers = PlayToClientPacketBossBarDividersTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketBossBarFlags0Tmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlags0Tmp
|
|
case 5:
|
|
var PlayToClientPacketBossBarFlags5Tmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags5Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlags5Tmp
|
|
default:
|
|
var PlayToClientPacketBossBarFlagsTmp struct {
|
|
}
|
|
ret.Flags = PlayToClientPacketBossBarFlagsTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBossBar) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.EntityUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketBossBarTitleEncTmp := PlayToClientPacketBossBarTitle
|
|
err = PlayToClientPacketBossBarTitleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketBossBarTitleEncTmp := PlayToClientPacketBossBarTitle
|
|
err = PlayToClientPacketBossBarTitleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Title.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Health.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Color.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 4:
|
|
PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Dividers.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 5:
|
|
PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Flags.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketBundleDelimiter struct {
|
|
}
|
|
|
|
func (ret *PlayToClientPacketBundleDelimiter) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketBundleDelimiter) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCamera struct {
|
|
CameraId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCamera) Decode(r io.ReadSeeker) (err error) {
|
|
ret.CameraId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCamera) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.CameraId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChatSuggestions struct {
|
|
Action int32
|
|
Entries []string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketChatSuggestions) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketChatSuggestionsEntries int32
|
|
lPlayToClientPacketChatSuggestionsEntries, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = []string{}
|
|
for range lPlayToClientPacketChatSuggestionsEntries {
|
|
var PlayToClientPacketChatSuggestionsEntriesElement string
|
|
PlayToClientPacketChatSuggestionsEntriesElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = append(ret.Entries, PlayToClientPacketChatSuggestionsEntriesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketChatSuggestions) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketChatSuggestionsEntries := range len(ret.Entries) {
|
|
err = proto_base.EncodeString(w, ret.Entries[iPlayToClientPacketChatSuggestionsEntries])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChunkBatchFinished struct {
|
|
BatchSize int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketChunkBatchFinished) Decode(r io.ReadSeeker) (err error) {
|
|
ret.BatchSize, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketChunkBatchFinished) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.BatchSize)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChunkBatchStart struct {
|
|
}
|
|
|
|
func (ret *PlayToClientPacketChunkBatchStart) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketChunkBatchStart) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketChunkBiomes struct {
|
|
Biomes []struct {
|
|
Position PackedChunkPos
|
|
Data ByteArray
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketChunkBiomes) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketChunkBiomesBiomes int32
|
|
lPlayToClientPacketChunkBiomesBiomes, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Biomes = []struct {
|
|
Position PackedChunkPos
|
|
Data ByteArray
|
|
}{}
|
|
for range lPlayToClientPacketChunkBiomesBiomes {
|
|
var PlayToClientPacketChunkBiomesBiomesElement struct {
|
|
Position PackedChunkPos
|
|
Data ByteArray
|
|
}
|
|
err = PlayToClientPacketChunkBiomesBiomesElement.Position.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketChunkBiomesBiomesElement.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Biomes = append(ret.Biomes, PlayToClientPacketChunkBiomesBiomesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketChunkBiomes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Biomes)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketChunkBiomesBiomes := range len(ret.Biomes) {
|
|
PlayToClientPacketChunkBiomesBiomesInnerPositionEncTmp := ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Position
|
|
err = PlayToClientPacketChunkBiomesBiomesInnerPositionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketChunkBiomesBiomesInnerDataEncTmp := ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Data
|
|
err = PlayToClientPacketChunkBiomesBiomesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketClearTitles struct {
|
|
Reset bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketClearTitles) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Reset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketClearTitles) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Reset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCloseWindow struct {
|
|
WindowId ContainerID
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCloseWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCloseWindow) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketCloseWindowWindowIdEncTmp := ret.WindowId
|
|
err = PlayToClientPacketCloseWindowWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCollect struct {
|
|
CollectedEntityId int32
|
|
CollectorEntityId int32
|
|
PickupItemCount int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCollect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.CollectedEntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollectorEntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PickupItemCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCollect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.CollectedEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.CollectorEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.PickupItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketCommonAddResourcePackPromptMessagePresent {
|
|
var PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
PlayToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = PlayToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketCommonCookieResponseValuePresent {
|
|
var PlayToClientPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = PlayToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &PlayToClientPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
PlayToClientPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = PlayToClientPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketCommonRemoveResourcePackUuidPresent {
|
|
var PlayToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, PlayToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &PlayToClientPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketCommonSelectKnownPacksPacks int32
|
|
lPlayToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lPlayToClientPacketCommonSelectKnownPacksPacks {
|
|
var PlayToClientPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
PlayToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, PlayToClientPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = PlayToClientPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCraftProgressBar struct {
|
|
WindowId ContainerID
|
|
Property int16
|
|
Value int16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCraftProgressBar) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Property)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCraftProgressBar) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketCraftProgressBarWindowIdEncTmp := ret.WindowId
|
|
err = PlayToClientPacketCraftProgressBarWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Property)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCraftRecipeResponse struct {
|
|
WindowId ContainerID
|
|
Recipe string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCraftRecipeResponse) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipe, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCraftRecipeResponse) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketCraftRecipeResponseWindowIdEncTmp := ret.WindowId
|
|
err = PlayToClientPacketCraftRecipeResponseWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Recipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *PlayToClientPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketCustomPayload) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketCustomPayloadDataEncTmp := ret.Data
|
|
err = PlayToClientPacketCustomPayloadDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDamageEvent struct {
|
|
EntityId int32
|
|
SourceTypeId int32
|
|
SourceCauseId int32
|
|
SourceDirectId int32
|
|
SourcePosition *Vec3f64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDamageEvent) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SourceTypeId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SourceCauseId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SourceDirectId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketDamageEventSourcePositionPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDamageEventSourcePositionPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketDamageEventSourcePositionPresent {
|
|
var PlayToClientPacketDamageEventSourcePositionPresentValue Vec3f64
|
|
err = PlayToClientPacketDamageEventSourcePositionPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SourcePosition = &PlayToClientPacketDamageEventSourcePositionPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketDamageEvent) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SourceTypeId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SourceCauseId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SourceDirectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SourcePosition != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.SourcePosition != nil {
|
|
PlayToClientPacketDamageEventSourcePositionEncTmp := *ret.SourcePosition
|
|
err = PlayToClientPacketDamageEventSourcePositionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDeathCombatEvent struct {
|
|
PlayerId int32
|
|
Message nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDeathCombatEvent) Decode(r io.ReadSeeker) (err error) {
|
|
ret.PlayerId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Message.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketDeathCombatEvent) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.PlayerId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeathCombatEventMessageEncTmp := ret.Message
|
|
err = PlayToClientPacketDeathCombatEventMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDebugSample struct {
|
|
Sample []int64
|
|
Type int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDebugSample) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketDebugSampleSample int32
|
|
lPlayToClientPacketDebugSampleSample, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sample = []int64{}
|
|
for range lPlayToClientPacketDebugSampleSample {
|
|
var PlayToClientPacketDebugSampleSampleElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDebugSampleSampleElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sample = append(ret.Sample, PlayToClientPacketDebugSampleSampleElement)
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketDebugSample) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Sample)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDebugSampleSample := range len(ret.Sample) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Sample[iPlayToClientPacketDebugSampleSample])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDeclareCommands struct {
|
|
Nodes []CommandNode
|
|
RootIndex int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDeclareCommands) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketDeclareCommandsNodes int32
|
|
lPlayToClientPacketDeclareCommandsNodes, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Nodes = []CommandNode{}
|
|
for range lPlayToClientPacketDeclareCommandsNodes {
|
|
var PlayToClientPacketDeclareCommandsNodesElement CommandNode
|
|
err = PlayToClientPacketDeclareCommandsNodesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Nodes = append(ret.Nodes, PlayToClientPacketDeclareCommandsNodesElement)
|
|
}
|
|
ret.RootIndex, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketDeclareCommands) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Nodes)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareCommandsNodes := range len(ret.Nodes) {
|
|
PlayToClientPacketDeclareCommandsNodesInnerEncTmp := ret.Nodes[iPlayToClientPacketDeclareCommandsNodes]
|
|
err = PlayToClientPacketDeclareCommandsNodesInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.RootIndex)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDeclareRecipes struct {
|
|
Recipes []struct {
|
|
Name string
|
|
Type string
|
|
Data any
|
|
}
|
|
}
|
|
|
|
var PlayToClientPacketDeclareRecipesRecipesElementTypeMap = map[int32]string{0: "minecraft:crafting_shaped", 1: "minecraft:crafting_shapeless", 10: "minecraft:crafting_special_bannerduplicate", 11: "minecraft:crafting_special_shielddecoration", 12: "minecraft:crafting_special_shulkerboxcoloring", 13: "minecraft:crafting_special_suspiciousstew", 14: "minecraft:crafting_special_repairitem", 15: "minecraft:smelting", 16: "minecraft:blasting", 17: "minecraft:smoking", 18: "minecraft:campfire_cooking", 19: "minecraft:stonecutting", 2: "minecraft:crafting_special_armordye", 20: "minecraft:smithing_transform", 21: "minecraft:smithing_trim", 22: "minecraft:crafting_decorated_pot", 3: "minecraft:crafting_special_bookcloning", 4: "minecraft:crafting_special_mapcloning", 5: "minecraft:crafting_special_mapextending", 6: "minecraft:crafting_special_firework_rocket", 7: "minecraft:crafting_special_firework_star", 8: "minecraft:crafting_special_firework_star_fade", 9: "minecraft:crafting_special_tippedarrow"}
|
|
|
|
func (ret *PlayToClientPacketDeclareRecipes) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketDeclareRecipesRecipes int32
|
|
lPlayToClientPacketDeclareRecipesRecipes, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes = []struct {
|
|
Name string
|
|
Type string
|
|
Data any
|
|
}{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipes {
|
|
var PlayToClientPacketDeclareRecipesRecipesElement struct {
|
|
Name string
|
|
Type string
|
|
Data any
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketDeclareRecipesRecipesElementTypeKey int32
|
|
PlayToClientPacketDeclareRecipesRecipesElementTypeKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Type, err = proto_base.ErroringIndex(PlayToClientPacketDeclareRecipesRecipesElementTypeMap, PlayToClientPacketDeclareRecipesRecipesElementTypeKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch PlayToClientPacketDeclareRecipesRecipesElement.Type {
|
|
case "minecraft:blasting":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp MinecraftSmeltingFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftBlastingTmp
|
|
case "minecraft:campfire_cooking":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp MinecraftSmeltingFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCampfireCookingTmp
|
|
case "minecraft:crafting_decorated_pot":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingDecoratedPotTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingDecoratedPotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingDecoratedPotTmp
|
|
case "minecraft:crafting_shaped":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp struct {
|
|
Group string
|
|
Category int32
|
|
GridWidth int32
|
|
GridHeight int32
|
|
Ingredients [][]Ingredient
|
|
Result Slot
|
|
ShowNotification bool
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Group, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Category, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.GridWidth, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.GridHeight, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients int32
|
|
lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.GridWidth
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients = [][]Ingredient{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredients {
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement []Ingredient
|
|
var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement int32
|
|
lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.GridHeight
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = []Ingredient{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement {
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement Ingredient
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElementElement)
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Ingredients, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmpIngredientsElement)
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp.ShowNotification)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapedTmp
|
|
case "minecraft:crafting_shapeless":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp struct {
|
|
Group string
|
|
Category int32
|
|
Ingredients []Ingredient
|
|
Result Slot
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Group, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Category, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients int32
|
|
lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients = []Ingredient{}
|
|
for range lPlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredients {
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement Ingredient
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients = append(PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Ingredients, PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmpIngredientsElement)
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingShapelessTmp
|
|
case "minecraft:crafting_special_armordye":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialArmordyeTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialArmordyeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialArmordyeTmp
|
|
case "minecraft:crafting_special_banneraddpattern":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBanneraddpatternTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBanneraddpatternTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBanneraddpatternTmp
|
|
case "minecraft:crafting_special_bannerduplicate":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBannerduplicateTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBannerduplicateTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBannerduplicateTmp
|
|
case "minecraft:crafting_special_bookcloning":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBookcloningTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBookcloningTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialBookcloningTmp
|
|
case "minecraft:crafting_special_firework_rocket":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkRocketTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkRocketTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkRocketTmp
|
|
case "minecraft:crafting_special_firework_star":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarTmp
|
|
case "minecraft:crafting_special_firework_star_fade":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarFadeTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarFadeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialFireworkStarFadeTmp
|
|
case "minecraft:crafting_special_mapcloning":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapcloningTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapcloningTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapcloningTmp
|
|
case "minecraft:crafting_special_mapextending":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapextendingTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapextendingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialMapextendingTmp
|
|
case "minecraft:crafting_special_repairitem":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialRepairitemTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialRepairitemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialRepairitemTmp
|
|
case "minecraft:crafting_special_shielddecoration":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShielddecorationTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShielddecorationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShielddecorationTmp
|
|
case "minecraft:crafting_special_shulkerboxcoloring":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShulkerboxcoloringTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShulkerboxcoloringTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialShulkerboxcoloringTmp
|
|
case "minecraft:crafting_special_suspiciousstew":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialSuspiciousstewTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialSuspiciousstewTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialSuspiciousstewTmp
|
|
case "minecraft:crafting_special_tippedarrow":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialTippedarrowTmp MinecraftSimpleRecipeFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialTippedarrowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftCraftingSpecialTippedarrowTmp
|
|
case "minecraft:smelting":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp MinecraftSmeltingFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmeltingTmp
|
|
case "minecraft:smithing_transform":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTransformTmp struct {
|
|
Template Ingredient
|
|
Base Ingredient
|
|
Addition Ingredient
|
|
Result Slot
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTransformTmp.Template.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTransformTmp.Base.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTransformTmp.Addition.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTransformTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTransformTmp
|
|
case "minecraft:smithing_trim":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTrimTmp struct {
|
|
Template Ingredient
|
|
Base Ingredient
|
|
Addition Ingredient
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTrimTmp.Template.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTrimTmp.Base.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTrimTmp.Addition.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmithingTrimTmp
|
|
case "minecraft:smoking":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp MinecraftSmeltingFormat
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftSmokingTmp
|
|
case "minecraft:stonecutting":
|
|
var PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp struct {
|
|
Group string
|
|
Ingredient Ingredient
|
|
Result Slot
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Group, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Ingredient.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp.Result.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesElement.Data = PlayToClientPacketDeclareRecipesRecipesElementDataMinecraftStonecuttingTmp
|
|
}
|
|
ret.Recipes = append(ret.Recipes, PlayToClientPacketDeclareRecipesRecipesElement)
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketDeclareRecipesRecipesInnerTypeReverseMap = map[string]int32{"minecraft:crafting_shaped": 0, "minecraft:crafting_shapeless": 1, "minecraft:crafting_special_bannerduplicate": 10, "minecraft:crafting_special_shielddecoration": 11, "minecraft:crafting_special_shulkerboxcoloring": 12, "minecraft:crafting_special_suspiciousstew": 13, "minecraft:crafting_special_repairitem": 14, "minecraft:smelting": 15, "minecraft:blasting": 16, "minecraft:smoking": 17, "minecraft:campfire_cooking": 18, "minecraft:stonecutting": 19, "minecraft:crafting_special_armordye": 2, "minecraft:smithing_transform": 20, "minecraft:smithing_trim": 21, "minecraft:crafting_decorated_pot": 22, "minecraft:crafting_special_bookcloning": 3, "minecraft:crafting_special_mapcloning": 4, "minecraft:crafting_special_mapextending": 5, "minecraft:crafting_special_firework_rocket": 6, "minecraft:crafting_special_firework_star": 7, "minecraft:crafting_special_firework_star_fade": 8, "minecraft:crafting_special_tippedarrow": 9}
|
|
|
|
func (ret *PlayToClientPacketDeclareRecipes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareRecipesRecipes := range len(ret.Recipes) {
|
|
err = proto_base.EncodeString(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var vPlayToClientPacketDeclareRecipesRecipesInnerType int32
|
|
vPlayToClientPacketDeclareRecipesRecipesInnerType, err = proto_base.ErroringIndex(PlayToClientPacketDeclareRecipesRecipesInnerTypeReverseMap, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToClientPacketDeclareRecipesRecipesInnerType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Type {
|
|
case "minecraft:blasting":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:campfire_cooking":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_decorated_pot":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_shaped":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
Group string
|
|
Category int32
|
|
GridWidth int32
|
|
GridHeight int32
|
|
Ingredients [][]Ingredient
|
|
Result Slot
|
|
ShowNotification bool
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Category)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketDeclareRecipesRecipesInnerData.GridWidth)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketDeclareRecipesRecipesInnerData.GridHeight)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients) {
|
|
for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInner := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients]) {
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerInnerEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients][iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInner]
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketDeclareRecipesRecipesInnerData.ShowNotification)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_shapeless":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
Group string
|
|
Category int32
|
|
Ingredients []Ingredient
|
|
Result Slot
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Category)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients := range len(PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients) {
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredients[iPlayToClientPacketDeclareRecipesRecipesInnerDataIngredients]
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientsInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_armordye":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_banneraddpattern":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_bannerduplicate":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_bookcloning":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_firework_rocket":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_firework_star":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_firework_star_fade":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_mapcloning":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_mapextending":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_repairitem":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_shielddecoration":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_shulkerboxcoloring":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_suspiciousstew":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:crafting_special_tippedarrow":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSimpleRecipeFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:smelting":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:smithing_transform":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
Template Ingredient
|
|
Base Ingredient
|
|
Addition Ingredient
|
|
Result Slot
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataTemplateEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Template
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataTemplateEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataBaseEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Base
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataBaseEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataAdditionEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Addition
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataAdditionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:smithing_trim":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
Template Ingredient
|
|
Base Ingredient
|
|
Addition Ingredient
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataTemplateEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Template
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataTemplateEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataBaseEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Base
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataBaseEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataAdditionEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Addition
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataAdditionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:smoking":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(MinecraftSmeltingFormat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "minecraft:stonecutting":
|
|
PlayToClientPacketDeclareRecipesRecipesInnerData, ok := ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Data.(struct {
|
|
Group string
|
|
Ingredient Ingredient
|
|
Result Slot
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketDeclareRecipesRecipesInnerData.Group)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Ingredient
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataIngredientEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp := PlayToClientPacketDeclareRecipesRecipesInnerData.Result
|
|
err = PlayToClientPacketDeclareRecipesRecipesInnerDataResultEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketDifficulty struct {
|
|
Difficulty uint8
|
|
DifficultyLocked bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketDifficulty) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DifficultyLocked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketDifficulty) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Difficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DifficultyLocked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEndCombatEvent struct {
|
|
Duration int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEndCombatEvent) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Duration, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEndCombatEvent) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Duration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEnterCombatEvent struct {
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEnterCombatEvent) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEnterCombatEvent) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityDestroy struct {
|
|
EntityIds []int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityDestroy) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketEntityDestroyEntityIds int32
|
|
lPlayToClientPacketEntityDestroyEntityIds, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityIds = []int32{}
|
|
for range lPlayToClientPacketEntityDestroyEntityIds {
|
|
var PlayToClientPacketEntityDestroyEntityIdsElement int32
|
|
PlayToClientPacketEntityDestroyEntityIdsElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityIds = append(ret.EntityIds, PlayToClientPacketEntityDestroyEntityIdsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityDestroy) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.EntityIds)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityDestroyEntityIds := range len(ret.EntityIds) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityIds[iPlayToClientPacketEntityDestroyEntityIds])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityEffect struct {
|
|
EntityId int32
|
|
EffectId int32
|
|
Amplifier int32
|
|
Duration int32
|
|
Flags uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EffectId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Amplifier, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Duration, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Amplifier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Duration)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityEquipment struct {
|
|
EntityId int32
|
|
Equipments []struct {
|
|
Slot int8
|
|
Item Slot
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityEquipment) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Equipments = []struct {
|
|
Slot int8
|
|
Item Slot
|
|
}{}
|
|
for {
|
|
var PlayToClientPacketEntityEquipmentEquipmentsHeader uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityEquipmentEquipmentsHeader)
|
|
if err == io.EOF {
|
|
err = nil
|
|
break
|
|
}
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = r.Seek(-1, io.SeekCurrent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityEquipmentEquipmentsHasMore := PlayToClientPacketEntityEquipmentEquipmentsHeader&128 != 0
|
|
var PlayToClientPacketEntityEquipmentEquipmentsElement struct {
|
|
Slot int8
|
|
Item Slot
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityEquipmentEquipmentsElement.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketEntityEquipmentEquipmentsElement.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Equipments = append(ret.Equipments, PlayToClientPacketEntityEquipmentEquipmentsElement)
|
|
if !PlayToClientPacketEntityEquipmentEquipmentsHasMore {
|
|
break
|
|
}
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityEquipmentEquipments, PlayToClientPacketEntityEquipmentEquipmentsElem := range ret.Equipments {
|
|
if iPlayToClientPacketEntityEquipmentEquipments != len(ret.Equipments)-1 {
|
|
err = binary.Write(w, binary.BigEndian, int8(uint8(PlayToClientPacketEntityEquipmentEquipmentsElem.Slot)|128))
|
|
if err != nil {
|
|
return
|
|
}
|
|
} else {
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketEntityEquipmentEquipmentsElem.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
PlayToClientPacketEntityEquipmentEquipmentsItemEncTmp := PlayToClientPacketEntityEquipmentEquipmentsElem.Item
|
|
err = PlayToClientPacketEntityEquipmentEquipmentsItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityHeadRotation struct {
|
|
EntityId int32
|
|
HeadYaw int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityHeadRotation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HeadYaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityHeadRotation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HeadYaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityLook struct {
|
|
EntityId int32
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityLook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityLook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityMetadata struct {
|
|
EntityId int32
|
|
Metadata EntityMetadata
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityMetadata) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Metadata.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityMetadata) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityMetadataMetadataEncTmp := ret.Metadata
|
|
err = PlayToClientPacketEntityMetadataMetadataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityMoveLook struct {
|
|
EntityId int32
|
|
DX int16
|
|
DY int16
|
|
DZ int16
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityMoveLook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityMoveLook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntitySoundEffect struct {
|
|
Sound ItemSoundHolder
|
|
SoundCategory SoundSource
|
|
EntityId int32
|
|
Volume float32
|
|
Pitch float32
|
|
Seed int64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntitySoundEffect) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Sound.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SoundCategory.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Seed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntitySoundEffect) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketEntitySoundEffectSoundEncTmp := ret.Sound
|
|
err = PlayToClientPacketEntitySoundEffectSoundEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntitySoundEffectSoundCategoryEncTmp := ret.SoundCategory
|
|
err = PlayToClientPacketEntitySoundEffectSoundCategoryEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Seed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityStatus struct {
|
|
EntityId int32
|
|
EntityStatus int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityStatus) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityStatus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityStatus) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityStatus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityTeleport struct {
|
|
EntityId int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw int8
|
|
Pitch int8
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityTeleport) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityTeleport) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityUpdateAttributes struct {
|
|
EntityId int32
|
|
Properties []struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}
|
|
}
|
|
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap = map[int32]string{0: "generic.armor", 1: "generic.armor_toughness", 10: "generic.follow_range", 11: "generic.gravity", 12: "generic.jump_strength", 13: "generic.knockback_resistance", 14: "generic.luck", 15: "generic.max_absorption", 16: "generic.max_health", 17: "generic.movement_speed", 18: "generic.safe_fall_distance", 19: "generic.scale", 2: "generic.attack_damage", 20: "zombie.spawn_reinforcements", 21: "generic.step_height", 3: "generic.attack_knockback", 4: "generic.attack_speed", 5: "player.block_break_speed", 6: "player.block_interaction_range", 7: "player.entity_interaction_range", 8: "generic.fall_damage_multiplier", 9: "generic.flying_speed"}
|
|
|
|
func (ret *PlayToClientPacketEntityUpdateAttributes) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketEntityUpdateAttributesProperties int32
|
|
lPlayToClientPacketEntityUpdateAttributesProperties, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Properties = []struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}{}
|
|
for range lPlayToClientPacketEntityUpdateAttributesProperties {
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElement struct {
|
|
Key string
|
|
Value float64
|
|
Modifiers []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
}
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey int32
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Key, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap, PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElement.Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers int32
|
|
lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = []struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}{}
|
|
for range lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers {
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement struct {
|
|
Uuid uuid.UUID
|
|
Amount float64
|
|
Operation int8
|
|
}
|
|
_, err = io.ReadFull(r, PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Amount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Operation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = append(PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers, PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement)
|
|
}
|
|
ret.Properties = append(ret.Properties, PlayToClientPacketEntityUpdateAttributesPropertiesElement)
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap = map[string]int32{"generic.armor": 0, "generic.armor_toughness": 1, "generic.follow_range": 10, "generic.gravity": 11, "generic.jump_strength": 12, "generic.knockback_resistance": 13, "generic.luck": 14, "generic.max_absorption": 15, "generic.max_health": 16, "generic.movement_speed": 17, "generic.safe_fall_distance": 18, "generic.scale": 19, "generic.attack_damage": 2, "zombie.spawn_reinforcements": 20, "generic.step_height": 21, "generic.attack_knockback": 3, "generic.attack_speed": 4, "player.block_break_speed": 5, "player.block_interaction_range": 6, "player.entity_interaction_range": 7, "generic.fall_damage_multiplier": 8, "generic.flying_speed": 9}
|
|
|
|
func (ret *PlayToClientPacketEntityUpdateAttributes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Properties)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityUpdateAttributesProperties := range len(ret.Properties) {
|
|
var vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey int32
|
|
vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers := range len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers) {
|
|
_, err = w.Write(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Amount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Operation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketEntityVelocity struct {
|
|
EntityId int32
|
|
Velocity Vec3i16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketEntityVelocity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Velocity.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketEntityVelocity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketEntityVelocityVelocityEncTmp := ret.Velocity
|
|
err = PlayToClientPacketEntityVelocityVelocityEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketExperience struct {
|
|
ExperienceBar float32
|
|
Level int32
|
|
TotalExperience int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketExperience) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ExperienceBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Level, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TotalExperience, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketExperience) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ExperienceBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Level)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.TotalExperience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketExplosion struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Radius float32
|
|
AffectedBlockOffsets []struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}
|
|
PlayerMotionX float32
|
|
PlayerMotionY float32
|
|
PlayerMotionZ float32
|
|
BlockInteractionType int32
|
|
SmallExplosionParticle Particle
|
|
LargeExplosionParticle Particle
|
|
Sound ItemSoundHolder
|
|
}
|
|
|
|
func (ret *PlayToClientPacketExplosion) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Radius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketExplosionAffectedBlockOffsets int32
|
|
lPlayToClientPacketExplosionAffectedBlockOffsets, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AffectedBlockOffsets = []struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}{}
|
|
for range lPlayToClientPacketExplosionAffectedBlockOffsets {
|
|
var PlayToClientPacketExplosionAffectedBlockOffsetsElement struct {
|
|
X int8
|
|
Y int8
|
|
Z int8
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionAffectedBlockOffsetsElement.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.AffectedBlockOffsets = append(ret.AffectedBlockOffsets, PlayToClientPacketExplosionAffectedBlockOffsetsElement)
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.PlayerMotionZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockInteractionType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SmallExplosionParticle.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.LargeExplosionParticle.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
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.Radius)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.AffectedBlockOffsets)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketExplosionAffectedBlockOffsets := range len(ret.AffectedBlockOffsets) {
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.AffectedBlockOffsets[iPlayToClientPacketExplosionAffectedBlockOffsets].Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PlayerMotionZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.BlockInteractionType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketExplosionSmallExplosionParticleEncTmp := ret.SmallExplosionParticle
|
|
err = PlayToClientPacketExplosionSmallExplosionParticleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketExplosionLargeExplosionParticleEncTmp := ret.LargeExplosionParticle
|
|
err = PlayToClientPacketExplosionLargeExplosionParticleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketExplosionSoundEncTmp := ret.Sound
|
|
err = PlayToClientPacketExplosionSoundEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketFacePlayer struct {
|
|
FeetEyes int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
IsEntity bool
|
|
EntityId any
|
|
EntityFeetEyes any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketFacePlayer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.FeetEyes, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsEntity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
var PlayToClientPacketFacePlayerEntityIdTrueTmp int32
|
|
PlayToClientPacketFacePlayerEntityIdTrueTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId = PlayToClientPacketFacePlayerEntityIdTrueTmp
|
|
default:
|
|
var PlayToClientPacketFacePlayerEntityIdTmp struct {
|
|
}
|
|
ret.EntityId = PlayToClientPacketFacePlayerEntityIdTmp
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
var PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp int32
|
|
PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp
|
|
default:
|
|
var PlayToClientPacketFacePlayerEntityFeetEyesTmp struct {
|
|
}
|
|
ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketFacePlayer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.FeetEyes)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsEntity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
PlayToClientPacketFacePlayerEntityId, ok := ret.EntityId.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.IsEntity {
|
|
case true:
|
|
PlayToClientPacketFacePlayerEntityFeetEyes, ok := ret.EntityFeetEyes.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityFeetEyes)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.EntityFeetEyes.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketGameStateChange struct {
|
|
Reason uint8
|
|
GameMode float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketGameStateChange) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.GameMode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketGameStateChange) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Reason)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.GameMode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketHeldItemSlot struct {
|
|
Slot int8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketHeldItemSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketHideMessage struct {
|
|
Id int32
|
|
Signature any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketHideMessage) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Id, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Id {
|
|
case 0:
|
|
var PlayToClientPacketHideMessageSignature0Tmp [256]byte
|
|
_, err = r.Read(PlayToClientPacketHideMessageSignature0Tmp[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Signature = PlayToClientPacketHideMessageSignature0Tmp
|
|
default:
|
|
var PlayToClientPacketHideMessageSignatureTmp struct {
|
|
}
|
|
ret.Signature = PlayToClientPacketHideMessageSignatureTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketHideMessage) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Id {
|
|
case 0:
|
|
PlayToClientPacketHideMessageSignature, ok := ret.Signature.([256]byte)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
arr := PlayToClientPacketHideMessageSignature
|
|
_, err = w.Write(arr[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Signature.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketHurtAnimation struct {
|
|
EntityId int32
|
|
Yaw float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketHurtAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketHurtAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketInitializeWorldBorder struct {
|
|
X float64
|
|
Z float64
|
|
OldDiameter float64
|
|
NewDiameter float64
|
|
Speed int32
|
|
PortalTeleportBoundary int32
|
|
WarningBlocks int32
|
|
WarningTime int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketInitializeWorldBorder) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OldDiameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.NewDiameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Speed, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PortalTeleportBoundary, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningBlocks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WarningTime, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketInitializeWorldBorder) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OldDiameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.NewDiameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Speed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.PortalTeleportBoundary)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.WarningBlocks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.WarningTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketKeepAlive) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketKickDisconnect struct {
|
|
Reason nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketKickDisconnect) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Reason.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketKickDisconnect) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketKickDisconnectReasonEncTmp := ret.Reason
|
|
err = PlayToClientPacketKickDisconnectReasonEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketLogin struct {
|
|
EntityId int32
|
|
IsHardcore bool
|
|
WorldNames []string
|
|
MaxPlayers int32
|
|
ViewDistance int32
|
|
SimulationDistance int32
|
|
ReducedDebugInfo bool
|
|
EnableRespawnScreen bool
|
|
DoLimitedCrafting bool
|
|
WorldState PlayToClientSpawnInfo
|
|
EnforcesSecureChat bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketLogin) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsHardcore)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketLoginWorldNames int32
|
|
lPlayToClientPacketLoginWorldNames, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WorldNames = []string{}
|
|
for range lPlayToClientPacketLoginWorldNames {
|
|
var PlayToClientPacketLoginWorldNamesElement string
|
|
PlayToClientPacketLoginWorldNamesElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WorldNames = append(ret.WorldNames, PlayToClientPacketLoginWorldNamesElement)
|
|
}
|
|
ret.MaxPlayers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ViewDistance, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SimulationDistance, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ReducedDebugInfo)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableRespawnScreen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DoLimitedCrafting)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.WorldState.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnforcesSecureChat)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketLogin) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsHardcore)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.WorldNames)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketLoginWorldNames := range len(ret.WorldNames) {
|
|
err = proto_base.EncodeString(w, ret.WorldNames[iPlayToClientPacketLoginWorldNames])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MaxPlayers)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SimulationDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ReducedDebugInfo)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableRespawnScreen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DoLimitedCrafting)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketLoginWorldStateEncTmp := ret.WorldState
|
|
err = PlayToClientPacketLoginWorldStateEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnforcesSecureChat)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMap struct {
|
|
ItemDamage int32
|
|
Scale int8
|
|
Locked bool
|
|
Icons *[]struct {
|
|
Type int32
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *nbt.Anon
|
|
}
|
|
Columns uint8
|
|
Rows any
|
|
X any
|
|
Y any
|
|
Data any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMap) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ItemDamage, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Locked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketMapIconsPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketMapIconsPresent {
|
|
var PlayToClientPacketMapIconsPresentValue []struct {
|
|
Type int32
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *nbt.Anon
|
|
}
|
|
var lPlayToClientPacketMapIcons int32
|
|
lPlayToClientPacketMapIcons, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapIconsPresentValue = []struct {
|
|
Type int32
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *nbt.Anon
|
|
}{}
|
|
for range lPlayToClientPacketMapIcons {
|
|
var PlayToClientPacketMapIconsElement struct {
|
|
Type int32
|
|
X int8
|
|
Z int8
|
|
Direction uint8
|
|
DisplayName *nbt.Anon
|
|
}
|
|
PlayToClientPacketMapIconsElement.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketMapIconsElementDisplayNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElementDisplayNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketMapIconsElementDisplayNamePresent {
|
|
var PlayToClientPacketMapIconsElementDisplayNamePresentValue nbt.Anon
|
|
err = PlayToClientPacketMapIconsElementDisplayNamePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapIconsElement.DisplayName = &PlayToClientPacketMapIconsElementDisplayNamePresentValue
|
|
}
|
|
PlayToClientPacketMapIconsPresentValue = append(PlayToClientPacketMapIconsPresentValue, PlayToClientPacketMapIconsElement)
|
|
}
|
|
ret.Icons = &PlayToClientPacketMapIconsPresentValue
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Columns)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapRows0Tmp struct {
|
|
}
|
|
ret.Rows = PlayToClientPacketMapRows0Tmp
|
|
default:
|
|
var PlayToClientPacketMapRowsTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapRowsTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rows = PlayToClientPacketMapRowsTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapX0Tmp struct {
|
|
}
|
|
ret.X = PlayToClientPacketMapX0Tmp
|
|
default:
|
|
var PlayToClientPacketMapXTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapXTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToClientPacketMapXTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapY0Tmp struct {
|
|
}
|
|
ret.Y = PlayToClientPacketMapY0Tmp
|
|
default:
|
|
var PlayToClientPacketMapYTmp uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapYTmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToClientPacketMapYTmp
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
var PlayToClientPacketMapData0Tmp struct {
|
|
}
|
|
ret.Data = PlayToClientPacketMapData0Tmp
|
|
default:
|
|
var PlayToClientPacketMapDataTmp []byte
|
|
var lPlayToClientPacketMapData int32
|
|
lPlayToClientPacketMapData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapDataTmp, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = PlayToClientPacketMapDataTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketMap) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ItemDamage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Scale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Locked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Icons != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Icons != nil {
|
|
err = proto_base.EncodeVarInt(w, int32(len(*ret.Icons)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapIcons := range len(*ret.Icons) {
|
|
err = proto_base.EncodeVarInt(w, (*ret.Icons)[iPlayToClientPacketMapIcons].Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if (*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName != nil {
|
|
PlayToClientPacketMapIconsInnerDisplayNameEncTmp := *(*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName
|
|
err = PlayToClientPacketMapIconsInnerDisplayNameEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Columns)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Rows.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Rows.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Rows.(uint8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.X.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.X.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X.(uint8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Y.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Y.(uint8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y.(uint8))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Columns {
|
|
case 0:
|
|
_, ok := ret.Data.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data.([]byte)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Data.([]byte))))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.Data.([]byte))
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMapChunk struct {
|
|
X int32
|
|
Z int32
|
|
Heightmaps nbt.Anon
|
|
ChunkData []byte
|
|
BlockEntities []ChunkBlockEntity
|
|
SkyLightMask []int64
|
|
BlockLightMask []int64
|
|
EmptySkyLightMask []int64
|
|
EmptyBlockLightMask []int64
|
|
SkyLight [][]uint8
|
|
BlockLight [][]uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMapChunk) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Heightmaps.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapChunkChunkData int32
|
|
lPlayToClientPacketMapChunkChunkData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkData, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapChunkChunkData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketMapChunkBlockEntities int32
|
|
lPlayToClientPacketMapChunkBlockEntities, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockEntities = []ChunkBlockEntity{}
|
|
for range lPlayToClientPacketMapChunkBlockEntities {
|
|
var PlayToClientPacketMapChunkBlockEntitiesElement ChunkBlockEntity
|
|
err = PlayToClientPacketMapChunkBlockEntitiesElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockEntities = append(ret.BlockEntities, PlayToClientPacketMapChunkBlockEntitiesElement)
|
|
}
|
|
var lPlayToClientPacketMapChunkSkyLightMask int32
|
|
lPlayToClientPacketMapChunkSkyLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLightMask = []int64{}
|
|
for range lPlayToClientPacketMapChunkSkyLightMask {
|
|
var PlayToClientPacketMapChunkSkyLightMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkSkyLightMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLightMask = append(ret.SkyLightMask, PlayToClientPacketMapChunkSkyLightMaskElement)
|
|
}
|
|
var lPlayToClientPacketMapChunkBlockLightMask int32
|
|
lPlayToClientPacketMapChunkBlockLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLightMask = []int64{}
|
|
for range lPlayToClientPacketMapChunkBlockLightMask {
|
|
var PlayToClientPacketMapChunkBlockLightMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBlockLightMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLightMask = append(ret.BlockLightMask, PlayToClientPacketMapChunkBlockLightMaskElement)
|
|
}
|
|
var lPlayToClientPacketMapChunkEmptySkyLightMask int32
|
|
lPlayToClientPacketMapChunkEmptySkyLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptySkyLightMask = []int64{}
|
|
for range lPlayToClientPacketMapChunkEmptySkyLightMask {
|
|
var PlayToClientPacketMapChunkEmptySkyLightMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkEmptySkyLightMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptySkyLightMask = append(ret.EmptySkyLightMask, PlayToClientPacketMapChunkEmptySkyLightMaskElement)
|
|
}
|
|
var lPlayToClientPacketMapChunkEmptyBlockLightMask int32
|
|
lPlayToClientPacketMapChunkEmptyBlockLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptyBlockLightMask = []int64{}
|
|
for range lPlayToClientPacketMapChunkEmptyBlockLightMask {
|
|
var PlayToClientPacketMapChunkEmptyBlockLightMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkEmptyBlockLightMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptyBlockLightMask = append(ret.EmptyBlockLightMask, PlayToClientPacketMapChunkEmptyBlockLightMaskElement)
|
|
}
|
|
var lPlayToClientPacketMapChunkSkyLight int32
|
|
lPlayToClientPacketMapChunkSkyLight, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLight = [][]uint8{}
|
|
for range lPlayToClientPacketMapChunkSkyLight {
|
|
var PlayToClientPacketMapChunkSkyLightElement []uint8
|
|
var lPlayToClientPacketMapChunkSkyLightElement int32
|
|
lPlayToClientPacketMapChunkSkyLightElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapChunkSkyLightElement = []uint8{}
|
|
for range lPlayToClientPacketMapChunkSkyLightElement {
|
|
var PlayToClientPacketMapChunkSkyLightElementElement uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkSkyLightElementElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapChunkSkyLightElement = append(PlayToClientPacketMapChunkSkyLightElement, PlayToClientPacketMapChunkSkyLightElementElement)
|
|
}
|
|
ret.SkyLight = append(ret.SkyLight, PlayToClientPacketMapChunkSkyLightElement)
|
|
}
|
|
var lPlayToClientPacketMapChunkBlockLight int32
|
|
lPlayToClientPacketMapChunkBlockLight, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLight = [][]uint8{}
|
|
for range lPlayToClientPacketMapChunkBlockLight {
|
|
var PlayToClientPacketMapChunkBlockLightElement []uint8
|
|
var lPlayToClientPacketMapChunkBlockLightElement int32
|
|
lPlayToClientPacketMapChunkBlockLightElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapChunkBlockLightElement = []uint8{}
|
|
for range lPlayToClientPacketMapChunkBlockLightElement {
|
|
var PlayToClientPacketMapChunkBlockLightElementElement uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBlockLightElementElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketMapChunkBlockLightElement = append(PlayToClientPacketMapChunkBlockLightElement, PlayToClientPacketMapChunkBlockLightElementElement)
|
|
}
|
|
ret.BlockLight = append(ret.BlockLight, PlayToClientPacketMapChunkBlockLightElement)
|
|
}
|
|
return
|
|
}
|
|
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
|
|
}
|
|
PlayToClientPacketMapChunkHeightmapsEncTmp := ret.Heightmaps
|
|
err = PlayToClientPacketMapChunkHeightmapsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ChunkData)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.ChunkData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockEntities)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkBlockEntities := range len(ret.BlockEntities) {
|
|
PlayToClientPacketMapChunkBlockEntitiesInnerEncTmp := ret.BlockEntities[iPlayToClientPacketMapChunkBlockEntities]
|
|
err = PlayToClientPacketMapChunkBlockEntitiesInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLightMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkSkyLightMask := range len(ret.SkyLightMask) {
|
|
err = binary.Write(w, binary.BigEndian, ret.SkyLightMask[iPlayToClientPacketMapChunkSkyLightMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLightMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkBlockLightMask := range len(ret.BlockLightMask) {
|
|
err = binary.Write(w, binary.BigEndian, ret.BlockLightMask[iPlayToClientPacketMapChunkBlockLightMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.EmptySkyLightMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkEmptySkyLightMask := range len(ret.EmptySkyLightMask) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EmptySkyLightMask[iPlayToClientPacketMapChunkEmptySkyLightMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.EmptyBlockLightMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkEmptyBlockLightMask := range len(ret.EmptyBlockLightMask) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EmptyBlockLightMask[iPlayToClientPacketMapChunkEmptyBlockLightMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkSkyLight := range len(ret.SkyLight) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight])))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkSkyLightInner := range len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight]) {
|
|
err = binary.Write(w, binary.BigEndian, ret.SkyLight[iPlayToClientPacketMapChunkSkyLight][iPlayToClientPacketMapChunkSkyLightInner])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkBlockLight := range len(ret.BlockLight) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight])))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMapChunkBlockLightInner := range len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight]) {
|
|
err = binary.Write(w, binary.BigEndian, ret.BlockLight[iPlayToClientPacketMapChunkBlockLight][iPlayToClientPacketMapChunkBlockLightInner])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketMultiBlockChange struct {
|
|
ChunkCoordinates struct {
|
|
X int32
|
|
Z int32
|
|
Y int32
|
|
}
|
|
Records []int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketMultiBlockChange) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked uint64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkCoordinates.Y = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked >> 0 & 1048575)
|
|
if ret.ChunkCoordinates.Y >= 1<<19 {
|
|
ret.ChunkCoordinates.Y -= 1 << 20
|
|
}
|
|
ret.ChunkCoordinates.Z = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked >> 20 & 4194303)
|
|
if ret.ChunkCoordinates.Z >= 1<<21 {
|
|
ret.ChunkCoordinates.Z -= 1 << 22
|
|
}
|
|
ret.ChunkCoordinates.X = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked >> 42 & 4194303)
|
|
if ret.ChunkCoordinates.X >= 1<<21 {
|
|
ret.ChunkCoordinates.X -= 1 << 22
|
|
}
|
|
var lPlayToClientPacketMultiBlockChangeRecords int32
|
|
lPlayToClientPacketMultiBlockChangeRecords, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Records = []int32{}
|
|
for range lPlayToClientPacketMultiBlockChangeRecords {
|
|
var PlayToClientPacketMultiBlockChangeRecordsElement int32
|
|
PlayToClientPacketMultiBlockChangeRecordsElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) {
|
|
var PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked uint64
|
|
PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.Y) & 0xFFFFF) << 0x0
|
|
PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.Z) & 0x3FFFFF) << 0x14
|
|
PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.X) & 0x3FFFFF) << 0x2A
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Records)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) {
|
|
err = proto_base.EncodeVarInt(w, ret.Records[iPlayToClientPacketMultiBlockChangeRecords])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketNbtQueryResponse struct {
|
|
TransactionId int32
|
|
Nbt nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketNbtQueryResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Nbt.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketNbtQueryResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketNbtQueryResponseNbtEncTmp := ret.Nbt
|
|
err = PlayToClientPacketNbtQueryResponseNbtEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenBook struct {
|
|
Hand int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenBook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenBook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenHorseWindow struct {
|
|
WindowId ContainerID
|
|
NbSlots int32
|
|
EntityId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenHorseWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NbSlots, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenHorseWindow) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketOpenHorseWindowWindowIdEncTmp := ret.WindowId
|
|
err = PlayToClientPacketOpenHorseWindowWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.NbSlots)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenSignEntity struct {
|
|
Location Position
|
|
IsFrontText bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenSignEntity) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsFrontText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenSignEntity) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketOpenSignEntityLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketOpenSignEntityLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsFrontText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketOpenWindow struct {
|
|
WindowId int32
|
|
InventoryType int32
|
|
WindowTitle nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketOpenWindow) Decode(r io.ReadSeeker) (err error) {
|
|
ret.WindowId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.InventoryType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.WindowTitle.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketOpenWindow) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.InventoryType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketOpenWindowWindowTitleEncTmp := ret.WindowTitle
|
|
err = PlayToClientPacketOpenWindowWindowTitleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPing struct {
|
|
Id int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPingResponse struct {
|
|
Id int64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPingResponse) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPingResponse) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerChat struct {
|
|
SenderUuid uuid.UUID
|
|
Index int32
|
|
Signature *[256]byte
|
|
PlainMessage string
|
|
Timestamp int64
|
|
Salt int64
|
|
PreviousMessages PreviousMessages
|
|
UnsignedChatContent *nbt.Anon
|
|
FilterType int32
|
|
FilterTypeMask any
|
|
Type int32
|
|
NetworkName nbt.Anon
|
|
NetworkTargetName *nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPlayerChat) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.SenderUuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Index, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketPlayerChatSignaturePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatSignaturePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerChatSignaturePresent {
|
|
var PlayToClientPacketPlayerChatSignaturePresentValue [256]byte
|
|
_, err = r.Read(PlayToClientPacketPlayerChatSignaturePresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Signature = &PlayToClientPacketPlayerChatSignaturePresentValue
|
|
}
|
|
ret.PlainMessage, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Timestamp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Salt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.PreviousMessages.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketPlayerChatUnsignedChatContentPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatUnsignedChatContentPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerChatUnsignedChatContentPresent {
|
|
var PlayToClientPacketPlayerChatUnsignedChatContentPresentValue nbt.Anon
|
|
err = PlayToClientPacketPlayerChatUnsignedChatContentPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.UnsignedChatContent = &PlayToClientPacketPlayerChatUnsignedChatContentPresentValue
|
|
}
|
|
ret.FilterType, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.FilterType {
|
|
case 2:
|
|
var PlayToClientPacketPlayerChatFilterTypeMask2Tmp []int64
|
|
var lPlayToClientPacketPlayerChatFilterTypeMask2Tmp int32
|
|
lPlayToClientPacketPlayerChatFilterTypeMask2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerChatFilterTypeMask2Tmp = []int64{}
|
|
for range lPlayToClientPacketPlayerChatFilterTypeMask2Tmp {
|
|
var PlayToClientPacketPlayerChatFilterTypeMask2TmpElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatFilterTypeMask2TmpElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerChatFilterTypeMask2Tmp = append(PlayToClientPacketPlayerChatFilterTypeMask2Tmp, PlayToClientPacketPlayerChatFilterTypeMask2TmpElement)
|
|
}
|
|
ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMask2Tmp
|
|
default:
|
|
var PlayToClientPacketPlayerChatFilterTypeMaskTmp struct {
|
|
}
|
|
ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMaskTmp
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NetworkName.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketPlayerChatNetworkTargetNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatNetworkTargetNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerChatNetworkTargetNamePresent {
|
|
var PlayToClientPacketPlayerChatNetworkTargetNamePresentValue nbt.Anon
|
|
err = PlayToClientPacketPlayerChatNetworkTargetNamePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NetworkTargetName = &PlayToClientPacketPlayerChatNetworkTargetNamePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPlayerChat) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.SenderUuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Index)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Signature != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Signature != nil {
|
|
arr := *ret.Signature
|
|
_, err = w.Write(arr[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeString(w, ret.PlainMessage)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Timestamp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Salt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerChatPreviousMessagesEncTmp := ret.PreviousMessages
|
|
err = PlayToClientPacketPlayerChatPreviousMessagesEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.UnsignedChatContent != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.UnsignedChatContent != nil {
|
|
PlayToClientPacketPlayerChatUnsignedChatContentEncTmp := *ret.UnsignedChatContent
|
|
err = PlayToClientPacketPlayerChatUnsignedChatContentEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.FilterType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.FilterType {
|
|
case 2:
|
|
PlayToClientPacketPlayerChatFilterTypeMask, ok := ret.FilterTypeMask.([]int64)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketPlayerChatFilterTypeMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketPlayerChatFilterTypeMask := range len(PlayToClientPacketPlayerChatFilterTypeMask) {
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerChatFilterTypeMask[iPlayToClientPacketPlayerChatFilterTypeMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.FilterTypeMask.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerChatNetworkNameEncTmp := ret.NetworkName
|
|
err = PlayToClientPacketPlayerChatNetworkNameEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.NetworkTargetName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.NetworkTargetName != nil {
|
|
PlayToClientPacketPlayerChatNetworkTargetNameEncTmp := *ret.NetworkTargetName
|
|
err = PlayToClientPacketPlayerChatNetworkTargetNameEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerInfo struct {
|
|
Action uint8
|
|
Data []struct {
|
|
Uuid uuid.UUID
|
|
Player any
|
|
ChatSession any
|
|
Gamemode any
|
|
Listed any
|
|
Latency any
|
|
DisplayName any
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPlayerInfo) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketPlayerInfoData int32
|
|
lPlayToClientPacketPlayerInfoData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Data = []struct {
|
|
Uuid uuid.UUID
|
|
Player any
|
|
ChatSession any
|
|
Gamemode any
|
|
Listed any
|
|
Latency any
|
|
DisplayName any
|
|
}{}
|
|
for range lPlayToClientPacketPlayerInfoData {
|
|
var PlayToClientPacketPlayerInfoDataElement struct {
|
|
Uuid uuid.UUID
|
|
Player any
|
|
ChatSession any
|
|
Gamemode any
|
|
Listed any
|
|
Latency any
|
|
DisplayName any
|
|
}
|
|
_, err = io.ReadFull(r, PlayToClientPacketPlayerInfoDataElement.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action&0x1 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp GameProfile
|
|
err = PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementPlayerTmp struct {
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTmp
|
|
}
|
|
switch ret.Action&0x2 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp ChatSession
|
|
err = PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementChatSessionTmp struct {
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTmp
|
|
}
|
|
switch ret.Action&0x4 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp int32
|
|
PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementGamemodeTmp struct {
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTmp
|
|
}
|
|
switch ret.Action&0x8 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementListedTrueTmp int32
|
|
PlayToClientPacketPlayerInfoDataElementListedTrueTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTrueTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementListedTmp struct {
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTmp
|
|
}
|
|
switch ret.Action&0x10 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp int32
|
|
PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementLatencyTmp struct {
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTmp
|
|
}
|
|
switch ret.Action&0x20 != 0 {
|
|
case true:
|
|
var PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp *nbt.Anon
|
|
var PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresent {
|
|
var PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresentValue nbt.Anon
|
|
err = PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp = &PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmpPresentValue
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp
|
|
default:
|
|
var PlayToClientPacketPlayerInfoDataElementDisplayNameTmp struct {
|
|
}
|
|
PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTmp
|
|
}
|
|
ret.Data = append(ret.Data, PlayToClientPacketPlayerInfoDataElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPlayerInfo) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Data)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketPlayerInfoData := range len(ret.Data) {
|
|
_, err = w.Write(ret.Data[iPlayToClientPacketPlayerInfoData].Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action&0x1 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerPlayer, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(GameProfile)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataInnerPlayerEncTmp := PlayToClientPacketPlayerInfoDataInnerPlayer
|
|
err = PlayToClientPacketPlayerInfoDataInnerPlayerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&0x2 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerChatSession, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(ChatSession)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerInfoDataInnerChatSessionEncTmp := PlayToClientPacketPlayerInfoDataInnerChatSession
|
|
err = PlayToClientPacketPlayerInfoDataInnerChatSessionEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&0x4 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerGamemode, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerGamemode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&0x8 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerListed, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerListed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&0x10 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerLatency, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerLatency)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action&0x20 != 0 {
|
|
case true:
|
|
PlayToClientPacketPlayerInfoDataInnerDisplayName, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(*nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerDisplayName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketPlayerInfoDataInnerDisplayName != nil {
|
|
PlayToClientPacketPlayerInfoDataInnerDisplayNameEncTmp := *PlayToClientPacketPlayerInfoDataInnerDisplayName
|
|
err = PlayToClientPacketPlayerInfoDataInnerDisplayNameEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerRemove struct {
|
|
Players []uuid.UUID
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPlayerRemove) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketPlayerRemovePlayers int32
|
|
lPlayToClientPacketPlayerRemovePlayers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Players = []uuid.UUID{}
|
|
for range lPlayToClientPacketPlayerRemovePlayers {
|
|
var PlayToClientPacketPlayerRemovePlayersElement uuid.UUID
|
|
_, err = io.ReadFull(r, PlayToClientPacketPlayerRemovePlayersElement[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Players = append(ret.Players, PlayToClientPacketPlayerRemovePlayersElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPlayerRemove) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Players)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketPlayerRemovePlayers := range len(ret.Players) {
|
|
_, err = w.Write(ret.Players[iPlayToClientPacketPlayerRemovePlayers][:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPlayerlistHeader struct {
|
|
Header nbt.Anon
|
|
Footer nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPlayerlistHeader) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Header.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Footer.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPlayerlistHeader) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketPlayerlistHeaderHeaderEncTmp := ret.Header
|
|
err = PlayToClientPacketPlayerlistHeaderHeaderEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPlayerlistHeaderFooterEncTmp := ret.Footer
|
|
err = PlayToClientPacketPlayerlistHeaderFooterEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketPosition struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
Flags PlayToClientPositionUpdateRelatives
|
|
TeleportId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketPosition) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Flags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TeleportId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketPosition) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketPositionFlagsEncTmp := ret.Flags
|
|
err = PlayToClientPacketPositionFlagsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.TeleportId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketProfilelessChat struct {
|
|
Message nbt.Anon
|
|
Type int32
|
|
Name nbt.Anon
|
|
Target *nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketProfilelessChat) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Message.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Name.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketProfilelessChatTargetPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketProfilelessChatTargetPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketProfilelessChatTargetPresent {
|
|
var PlayToClientPacketProfilelessChatTargetPresentValue nbt.Anon
|
|
err = PlayToClientPacketProfilelessChatTargetPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Target = &PlayToClientPacketProfilelessChatTargetPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketProfilelessChat) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketProfilelessChatMessageEncTmp := ret.Message
|
|
err = PlayToClientPacketProfilelessChatMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketProfilelessChatNameEncTmp := ret.Name
|
|
err = PlayToClientPacketProfilelessChatNameEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Target != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Target != nil {
|
|
PlayToClientPacketProfilelessChatTargetEncTmp := *ret.Target
|
|
err = PlayToClientPacketProfilelessChatTargetEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRelEntityMove struct {
|
|
EntityId int32
|
|
DX int16
|
|
DY int16
|
|
DZ int16
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketRelEntityMove) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketRelEntityMove) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.DZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRemoveEntityEffect struct {
|
|
EntityId int32
|
|
EffectId int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketRemoveEntityEffect) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EffectId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketRemoveEntityEffect) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketResetScore struct {
|
|
EntityName string
|
|
ObjectiveName *string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketResetScore) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketResetScoreObjectiveNamePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketResetScoreObjectiveNamePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketResetScoreObjectiveNamePresent {
|
|
var PlayToClientPacketResetScoreObjectiveNamePresentValue string
|
|
PlayToClientPacketResetScoreObjectiveNamePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ObjectiveName = &PlayToClientPacketResetScoreObjectiveNamePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketResetScore) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.EntityName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ObjectiveName != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.ObjectiveName != nil {
|
|
err = proto_base.EncodeString(w, *ret.ObjectiveName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketRespawn struct {
|
|
WorldState PlayToClientSpawnInfo
|
|
CopyMetadata uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketRespawn) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WorldState.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CopyMetadata)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketRespawn) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketRespawnWorldStateEncTmp := ret.WorldState
|
|
err = PlayToClientPacketRespawnWorldStateEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CopyMetadata)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardDisplayObjective struct {
|
|
Position int32
|
|
Name string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketScoreboardDisplayObjective) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Position, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketScoreboardDisplayObjective) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Position)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardObjective struct {
|
|
Name string
|
|
Action int8
|
|
DisplayText any
|
|
Type any
|
|
NumberFormat any
|
|
Styling any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketScoreboardObjective) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveDisplayText0Tmp nbt.Anon
|
|
err = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveDisplayText2Tmp nbt.Anon
|
|
err = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveDisplayTextTmp struct {
|
|
}
|
|
ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayTextTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveType0Tmp int32
|
|
PlayToClientPacketScoreboardObjectiveType0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveType0Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveType2Tmp int32
|
|
PlayToClientPacketScoreboardObjectiveType2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveType2Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveTypeTmp struct {
|
|
}
|
|
ret.Type = PlayToClientPacketScoreboardObjectiveTypeTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp *int32
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresent {
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresentValue int32
|
|
PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresentValue, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp = &PlayToClientPacketScoreboardObjectiveNumberFormat0TmpPresentValue
|
|
}
|
|
ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp *int32
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresent {
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresentValue int32
|
|
PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresentValue, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp = &PlayToClientPacketScoreboardObjectiveNumberFormat2TmpPresentValue
|
|
}
|
|
ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveNumberFormatTmp struct {
|
|
}
|
|
ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormatTmp
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketScoreboardObjectiveStyling0Tmp any
|
|
switch ret.NumberFormat {
|
|
case 1:
|
|
var PlayToClientPacketScoreboardObjectiveStyling0Tmp1Tmp nbt.Anon
|
|
err = PlayToClientPacketScoreboardObjectiveStyling0Tmp1Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling0Tmp1Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveStyling0Tmp2Tmp nbt.Anon
|
|
err = PlayToClientPacketScoreboardObjectiveStyling0Tmp2Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling0Tmp2Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveStyling0TmpTmp struct {
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling0TmpTmp
|
|
}
|
|
ret.Styling = PlayToClientPacketScoreboardObjectiveStyling0Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveStyling2Tmp any
|
|
switch ret.NumberFormat {
|
|
case 1:
|
|
var PlayToClientPacketScoreboardObjectiveStyling2Tmp1Tmp nbt.Anon
|
|
err = PlayToClientPacketScoreboardObjectiveStyling2Tmp1Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling2Tmp1Tmp
|
|
case 2:
|
|
var PlayToClientPacketScoreboardObjectiveStyling2Tmp2Tmp nbt.Anon
|
|
err = PlayToClientPacketScoreboardObjectiveStyling2Tmp2Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling2Tmp2Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveStyling2TmpTmp struct {
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling2TmpTmp
|
|
}
|
|
ret.Styling = PlayToClientPacketScoreboardObjectiveStyling2Tmp
|
|
default:
|
|
var PlayToClientPacketScoreboardObjectiveStylingTmp struct {
|
|
}
|
|
ret.Styling = PlayToClientPacketScoreboardObjectiveStylingTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketScoreboardObjective) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveDisplayTextEncTmp := PlayToClientPacketScoreboardObjectiveDisplayText
|
|
err = PlayToClientPacketScoreboardObjectiveDisplayTextEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveDisplayTextEncTmp := PlayToClientPacketScoreboardObjectiveDisplayText
|
|
err = PlayToClientPacketScoreboardObjectiveDisplayTextEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.DisplayText.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketScoreboardObjectiveType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketScoreboardObjectiveType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Type.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketScoreboardObjectiveNumberFormat != nil {
|
|
err = proto_base.EncodeVarInt(w, *PlayToClientPacketScoreboardObjectiveNumberFormat)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketScoreboardObjectiveNumberFormat != nil {
|
|
err = proto_base.EncodeVarInt(w, *PlayToClientPacketScoreboardObjectiveNumberFormat)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.NumberFormat.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketScoreboardObjectiveStyling, ok := ret.Styling.(any)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
switch ret.NumberFormat {
|
|
case 1:
|
|
PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingEncTmp := PlayToClientPacketScoreboardObjectiveStyling
|
|
err = PlayToClientPacketScoreboardObjectiveStylingEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingEncTmp := PlayToClientPacketScoreboardObjectiveStyling
|
|
err = PlayToClientPacketScoreboardObjectiveStylingEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := PlayToClientPacketScoreboardObjectiveStyling.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveStyling, ok := ret.Styling.(any)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
switch ret.NumberFormat {
|
|
case 1:
|
|
PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingEncTmp := PlayToClientPacketScoreboardObjectiveStyling
|
|
err = PlayToClientPacketScoreboardObjectiveStylingEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketScoreboardObjectiveStylingEncTmp := PlayToClientPacketScoreboardObjectiveStyling
|
|
err = PlayToClientPacketScoreboardObjectiveStylingEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := PlayToClientPacketScoreboardObjectiveStyling.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Styling.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketScoreboardScore struct {
|
|
ItemName string
|
|
ScoreName string
|
|
Value int32
|
|
DisplayName *nbt.Anon
|
|
NumberFormat *int32
|
|
Styling any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketScoreboardScore) Decode(r io.ReadSeeker) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketScoreboardScore) Encode(w io.Writer) (err error) {
|
|
err = proto_base.ToDoError
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSelectAdvancementTab struct {
|
|
Id *string
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSelectAdvancementTab) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToClientPacketSelectAdvancementTabIdPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketSelectAdvancementTabIdPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketSelectAdvancementTabIdPresent {
|
|
var PlayToClientPacketSelectAdvancementTabIdPresentValue string
|
|
PlayToClientPacketSelectAdvancementTabIdPresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Id = &PlayToClientPacketSelectAdvancementTabIdPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSelectAdvancementTab) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Id != nil {
|
|
err = proto_base.EncodeString(w, *ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketServerData struct {
|
|
Motd nbt.Anon
|
|
IconBytes *ByteArray
|
|
}
|
|
|
|
func (ret *PlayToClientPacketServerData) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Motd.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketServerDataIconBytesPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketServerDataIconBytesPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketServerDataIconBytesPresent {
|
|
var PlayToClientPacketServerDataIconBytesPresentValue ByteArray
|
|
err = PlayToClientPacketServerDataIconBytesPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.IconBytes = &PlayToClientPacketServerDataIconBytesPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketServerData) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketServerDataMotdEncTmp := ret.Motd
|
|
err = PlayToClientPacketServerDataMotdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IconBytes != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.IconBytes != nil {
|
|
PlayToClientPacketServerDataIconBytesEncTmp := *ret.IconBytes
|
|
err = PlayToClientPacketServerDataIconBytesEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetCooldown struct {
|
|
ItemID int32
|
|
CooldownTicks int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetCooldown) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ItemID, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CooldownTicks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetCooldown) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ItemID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.CooldownTicks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetPassengers struct {
|
|
EntityId int32
|
|
Passengers []int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetPassengers) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketSetPassengersPassengers int32
|
|
lPlayToClientPacketSetPassengersPassengers, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Passengers = []int32{}
|
|
for range lPlayToClientPacketSetPassengersPassengers {
|
|
var PlayToClientPacketSetPassengersPassengersElement int32
|
|
PlayToClientPacketSetPassengersPassengersElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Passengers = append(ret.Passengers, PlayToClientPacketSetPassengersPassengersElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetPassengers) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Passengers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketSetPassengersPassengers := range len(ret.Passengers) {
|
|
err = proto_base.EncodeVarInt(w, ret.Passengers[iPlayToClientPacketSetPassengersPassengers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetProjectilePower struct {
|
|
Id int32
|
|
Power Vec3f64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetProjectilePower) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Id, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Power.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetProjectilePower) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSetProjectilePowerPowerEncTmp := ret.Power
|
|
err = PlayToClientPacketSetProjectilePowerPowerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetSlot struct {
|
|
WindowId ContainerID
|
|
StateId int32
|
|
Slot int16
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.StateId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetSlot) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketSetSlotWindowIdEncTmp := ret.WindowId
|
|
err = PlayToClientPacketSetSlotWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.StateId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSetSlotItemEncTmp := ret.Item
|
|
err = PlayToClientPacketSetSlotItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetTickingState struct {
|
|
TickRate float32
|
|
IsFrozen bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetTickingState) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.TickRate)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsFrozen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetTickingState) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.TickRate)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsFrozen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetTitleSubtitle struct {
|
|
Text nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetTitleSubtitle) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Text.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetTitleSubtitle) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketSetTitleSubtitleTextEncTmp := ret.Text
|
|
err = PlayToClientPacketSetTitleSubtitleTextEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetTitleText struct {
|
|
Text nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetTitleText) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Text.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetTitleText) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketSetTitleTextTextEncTmp := ret.Text
|
|
err = PlayToClientPacketSetTitleTextTextEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSetTitleTime struct {
|
|
FadeIn int32
|
|
Stay int32
|
|
FadeOut int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSetTitleTime) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.FadeIn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Stay)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FadeOut)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSetTitleTime) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.FadeIn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Stay)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FadeOut)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSimulationDistance struct {
|
|
Distance int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSimulationDistance) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Distance, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSimulationDistance) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Distance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSoundEffect struct {
|
|
Sound ItemSoundHolder
|
|
SoundCategory SoundSource
|
|
X int32
|
|
Y int32
|
|
Z int32
|
|
Volume float32
|
|
Pitch float32
|
|
Seed int64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSoundEffect) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Sound.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.SoundCategory.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Seed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSoundEffect) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketSoundEffectSoundEncTmp := ret.Sound
|
|
err = PlayToClientPacketSoundEffectSoundEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSoundEffectSoundCategoryEncTmp := ret.SoundCategory
|
|
err = PlayToClientPacketSoundEffectSoundCategoryEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Volume)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Seed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntity struct {
|
|
EntityId int32
|
|
ObjectUUID uuid.UUID
|
|
Type int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Pitch int8
|
|
Yaw int8
|
|
HeadPitch int8
|
|
ObjectData int32
|
|
Velocity Vec3i16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = io.ReadFull(r, ret.ObjectUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.HeadPitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ObjectData, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Velocity.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(ret.ObjectUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.HeadPitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ObjectData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketSpawnEntityVelocityEncTmp := ret.Velocity
|
|
err = PlayToClientPacketSpawnEntityVelocityEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnEntityExperienceOrb struct {
|
|
EntityId int32
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Count int16
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnEntityExperienceOrb) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Count)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSpawnEntityExperienceOrb) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Count)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSpawnPosition struct {
|
|
Location Position
|
|
Angle float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSpawnPosition) Decode(r io.ReadSeeker) (err error) {
|
|
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) {
|
|
PlayToClientPacketSpawnPositionLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketSpawnPositionLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Angle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStartConfiguration struct {
|
|
}
|
|
|
|
func (ret *PlayToClientPacketStartConfiguration) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketStartConfiguration) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStatistics struct {
|
|
Entries []struct {
|
|
CategoryId int32
|
|
StatisticId int32
|
|
Value int32
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketStatistics) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketStatisticsEntries int32
|
|
lPlayToClientPacketStatisticsEntries, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = []struct {
|
|
CategoryId int32
|
|
StatisticId int32
|
|
Value int32
|
|
}{}
|
|
for range lPlayToClientPacketStatisticsEntries {
|
|
var PlayToClientPacketStatisticsEntriesElement struct {
|
|
CategoryId int32
|
|
StatisticId int32
|
|
Value int32
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.CategoryId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.StatisticId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketStatisticsEntriesElement.Value, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Entries = append(ret.Entries, PlayToClientPacketStatisticsEntriesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketStatistics) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketStatisticsEntries := range len(ret.Entries) {
|
|
err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].CategoryId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].StatisticId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].Value)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStepTick struct {
|
|
TickSteps int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketStepTick) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TickSteps, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketStepTick) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TickSteps)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketStopSound struct {
|
|
Flags int8
|
|
Source any
|
|
Sound any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketStopSound) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
var PlayToClientPacketStopSoundSource1Tmp int32
|
|
PlayToClientPacketStopSoundSource1Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSource1Tmp
|
|
case 3:
|
|
var PlayToClientPacketStopSoundSource3Tmp int32
|
|
PlayToClientPacketStopSoundSource3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSource3Tmp
|
|
default:
|
|
var PlayToClientPacketStopSoundSourceTmp struct {
|
|
}
|
|
ret.Source = PlayToClientPacketStopSoundSourceTmp
|
|
}
|
|
switch ret.Flags {
|
|
case 2:
|
|
var PlayToClientPacketStopSoundSound2Tmp string
|
|
PlayToClientPacketStopSoundSound2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sound = PlayToClientPacketStopSoundSound2Tmp
|
|
case 3:
|
|
var PlayToClientPacketStopSoundSound3Tmp string
|
|
PlayToClientPacketStopSoundSound3Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sound = PlayToClientPacketStopSoundSound3Tmp
|
|
default:
|
|
var PlayToClientPacketStopSoundSoundTmp struct {
|
|
}
|
|
ret.Sound = PlayToClientPacketStopSoundSoundTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketStopSound) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Flags {
|
|
case 1:
|
|
PlayToClientPacketStopSoundSource, ok := ret.Source.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketStopSoundSource, ok := ret.Source.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Source.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Flags {
|
|
case 2:
|
|
PlayToClientPacketStopSoundSound, ok := ret.Sound.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 3:
|
|
PlayToClientPacketStopSoundSound, ok := ret.Sound.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Sound.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketSystemChat struct {
|
|
Content nbt.Anon
|
|
IsActionBar bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketSystemChat) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Content.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsActionBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketSystemChat) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketSystemChatContentEncTmp := ret.Content
|
|
err = PlayToClientPacketSystemChatContentEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsActionBar)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTabComplete struct {
|
|
TransactionId int32
|
|
Start int32
|
|
Length int32
|
|
Matches []struct {
|
|
Match string
|
|
Tooltip *nbt.Anon
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Start, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Length, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketTabCompleteMatches int32
|
|
lPlayToClientPacketTabCompleteMatches, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Matches = []struct {
|
|
Match string
|
|
Tooltip *nbt.Anon
|
|
}{}
|
|
for range lPlayToClientPacketTabCompleteMatches {
|
|
var PlayToClientPacketTabCompleteMatchesElement struct {
|
|
Match string
|
|
Tooltip *nbt.Anon
|
|
}
|
|
PlayToClientPacketTabCompleteMatchesElement.Match, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketTabCompleteMatchesElementTooltipPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTabCompleteMatchesElementTooltipPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketTabCompleteMatchesElementTooltipPresent {
|
|
var PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue nbt.Anon
|
|
err = PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTabCompleteMatchesElement.Tooltip = &PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue
|
|
}
|
|
ret.Matches = append(ret.Matches, PlayToClientPacketTabCompleteMatchesElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTabComplete) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Start)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Length)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Matches)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTabCompleteMatches := range len(ret.Matches) {
|
|
err = proto_base.EncodeString(w, ret.Matches[iPlayToClientPacketTabCompleteMatches].Match)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil {
|
|
PlayToClientPacketTabCompleteMatchesInnerTooltipEncTmp := *ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip
|
|
err = PlayToClientPacketTabCompleteMatchesInnerTooltipEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTags struct {
|
|
Tags []struct {
|
|
TagType string
|
|
Tags Tags
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTags) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToClientPacketTagsTags int32
|
|
lPlayToClientPacketTagsTags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Tags = []struct {
|
|
TagType string
|
|
Tags Tags
|
|
}{}
|
|
for range lPlayToClientPacketTagsTags {
|
|
var PlayToClientPacketTagsTagsElement struct {
|
|
TagType string
|
|
Tags Tags
|
|
}
|
|
PlayToClientPacketTagsTagsElement.TagType, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToClientPacketTagsTagsElement.Tags.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Tags = append(ret.Tags, PlayToClientPacketTagsTagsElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTags) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Tags)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTagsTags := range len(ret.Tags) {
|
|
err = proto_base.EncodeString(w, ret.Tags[iPlayToClientPacketTagsTags].TagType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTagsTagsInnerTagsEncTmp := ret.Tags[iPlayToClientPacketTagsTags].Tags
|
|
err = PlayToClientPacketTagsTagsInnerTagsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTeams struct {
|
|
Team string
|
|
Mode int8
|
|
Name any
|
|
FriendlyFire any
|
|
NameTagVisibility any
|
|
CollisionRule any
|
|
Formatting any
|
|
Prefix any
|
|
Suffix any
|
|
Players any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTeams) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Team, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsName0Tmp nbt.Anon
|
|
err = PlayToClientPacketTeamsName0Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsName0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsName2Tmp nbt.Anon
|
|
err = PlayToClientPacketTeamsName2Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsName2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsNameTmp struct {
|
|
}
|
|
ret.Name = PlayToClientPacketTeamsNameTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsFriendlyFire0Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsFriendlyFire0Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFire0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsFriendlyFire2Tmp int8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsFriendlyFire2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFire2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsFriendlyFireTmp struct {
|
|
}
|
|
ret.FriendlyFire = PlayToClientPacketTeamsFriendlyFireTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsNameTagVisibility0Tmp string
|
|
PlayToClientPacketTeamsNameTagVisibility0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibility0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsNameTagVisibility2Tmp string
|
|
PlayToClientPacketTeamsNameTagVisibility2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibility2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsNameTagVisibilityTmp struct {
|
|
}
|
|
ret.NameTagVisibility = PlayToClientPacketTeamsNameTagVisibilityTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsCollisionRule0Tmp string
|
|
PlayToClientPacketTeamsCollisionRule0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRule0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsCollisionRule2Tmp string
|
|
PlayToClientPacketTeamsCollisionRule2Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRule2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsCollisionRuleTmp struct {
|
|
}
|
|
ret.CollisionRule = PlayToClientPacketTeamsCollisionRuleTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsFormatting0Tmp int32
|
|
PlayToClientPacketTeamsFormatting0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Formatting = PlayToClientPacketTeamsFormatting0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsFormatting2Tmp int32
|
|
PlayToClientPacketTeamsFormatting2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Formatting = PlayToClientPacketTeamsFormatting2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsFormattingTmp struct {
|
|
}
|
|
ret.Formatting = PlayToClientPacketTeamsFormattingTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsPrefix0Tmp nbt.Anon
|
|
err = PlayToClientPacketTeamsPrefix0Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefix0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsPrefix2Tmp nbt.Anon
|
|
err = PlayToClientPacketTeamsPrefix2Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefix2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsPrefixTmp struct {
|
|
}
|
|
ret.Prefix = PlayToClientPacketTeamsPrefixTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsSuffix0Tmp nbt.Anon
|
|
err = PlayToClientPacketTeamsSuffix0Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffix0Tmp
|
|
case 2:
|
|
var PlayToClientPacketTeamsSuffix2Tmp nbt.Anon
|
|
err = PlayToClientPacketTeamsSuffix2Tmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffix2Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsSuffixTmp struct {
|
|
}
|
|
ret.Suffix = PlayToClientPacketTeamsSuffixTmp
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
var PlayToClientPacketTeamsPlayers0Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers0Tmp int32
|
|
lPlayToClientPacketTeamsPlayers0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers0Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers0Tmp {
|
|
var PlayToClientPacketTeamsPlayers0TmpElement string
|
|
PlayToClientPacketTeamsPlayers0TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers0Tmp = append(PlayToClientPacketTeamsPlayers0Tmp, PlayToClientPacketTeamsPlayers0TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers0Tmp
|
|
case 3:
|
|
var PlayToClientPacketTeamsPlayers3Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers3Tmp int32
|
|
lPlayToClientPacketTeamsPlayers3Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers3Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers3Tmp {
|
|
var PlayToClientPacketTeamsPlayers3TmpElement string
|
|
PlayToClientPacketTeamsPlayers3TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers3Tmp = append(PlayToClientPacketTeamsPlayers3Tmp, PlayToClientPacketTeamsPlayers3TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers3Tmp
|
|
case 4:
|
|
var PlayToClientPacketTeamsPlayers4Tmp []string
|
|
var lPlayToClientPacketTeamsPlayers4Tmp int32
|
|
lPlayToClientPacketTeamsPlayers4Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers4Tmp = []string{}
|
|
for range lPlayToClientPacketTeamsPlayers4Tmp {
|
|
var PlayToClientPacketTeamsPlayers4TmpElement string
|
|
PlayToClientPacketTeamsPlayers4TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPlayers4Tmp = append(PlayToClientPacketTeamsPlayers4Tmp, PlayToClientPacketTeamsPlayers4TmpElement)
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayers4Tmp
|
|
default:
|
|
var PlayToClientPacketTeamsPlayersTmp struct {
|
|
}
|
|
ret.Players = PlayToClientPacketTeamsPlayersTmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTeams) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Team)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsName, ok := ret.Name.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsNameEncTmp := PlayToClientPacketTeamsName
|
|
err = PlayToClientPacketTeamsNameEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsName, ok := ret.Name.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsNameEncTmp := PlayToClientPacketTeamsName
|
|
err = PlayToClientPacketTeamsNameEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Name.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsFriendlyFire, ok := ret.FriendlyFire.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsFriendlyFire)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsFriendlyFire, ok := ret.FriendlyFire.(int8)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsFriendlyFire)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.FriendlyFire.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsNameTagVisibility, ok := ret.NameTagVisibility.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsNameTagVisibility)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsNameTagVisibility, ok := ret.NameTagVisibility.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsNameTagVisibility)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.NameTagVisibility.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsCollisionRule, ok := ret.CollisionRule.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsCollisionRule)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsCollisionRule, ok := ret.CollisionRule.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsCollisionRule)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.CollisionRule.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsFormatting, ok := ret.Formatting.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsFormatting)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsFormatting, ok := ret.Formatting.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsFormatting)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Formatting.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsPrefix, ok := ret.Prefix.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPrefixEncTmp := PlayToClientPacketTeamsPrefix
|
|
err = PlayToClientPacketTeamsPrefixEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsPrefix, ok := ret.Prefix.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsPrefixEncTmp := PlayToClientPacketTeamsPrefix
|
|
err = PlayToClientPacketTeamsPrefixEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Prefix.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsSuffix, ok := ret.Suffix.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsSuffixEncTmp := PlayToClientPacketTeamsSuffix
|
|
err = PlayToClientPacketTeamsSuffixEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToClientPacketTeamsSuffix, ok := ret.Suffix.(nbt.Anon)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToClientPacketTeamsSuffixEncTmp := PlayToClientPacketTeamsSuffix
|
|
err = PlayToClientPacketTeamsSuffixEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Suffix.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mode {
|
|
case 0:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 3:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case 4:
|
|
PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Players.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTileEntityData struct {
|
|
Location Position
|
|
Action int32
|
|
NbtData nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTileEntityData) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.NbtData.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTileEntityData) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketTileEntityDataLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketTileEntityDataLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTileEntityDataNbtDataEncTmp := ret.NbtData
|
|
err = PlayToClientPacketTileEntityDataNbtDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketTradeList struct {
|
|
WindowId ContainerID
|
|
Trades []struct {
|
|
InputItem1 struct {
|
|
ItemId int32
|
|
ItemCount int32
|
|
AddedComponentCount int32
|
|
Components []SlotComponent
|
|
}
|
|
OutputItem Slot
|
|
InputItem2 *struct {
|
|
ItemId int32
|
|
ItemCount int32
|
|
AddedComponentCount int32
|
|
Components []SlotComponent
|
|
}
|
|
TradeDisabled bool
|
|
NbTradeUses int32
|
|
MaximumNbTradeUses int32
|
|
Xp int32
|
|
SpecialPrice int32
|
|
PriceMultiplier float32
|
|
Demand int32
|
|
}
|
|
VillagerLevel int32
|
|
Experience int32
|
|
IsRegularVillager bool
|
|
CanRestock bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketTradeList) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketTradeListTrades int32
|
|
lPlayToClientPacketTradeListTrades, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Trades = []struct {
|
|
InputItem1 struct {
|
|
ItemId int32
|
|
ItemCount int32
|
|
AddedComponentCount int32
|
|
Components []SlotComponent
|
|
}
|
|
OutputItem Slot
|
|
InputItem2 *struct {
|
|
ItemId int32
|
|
ItemCount int32
|
|
AddedComponentCount int32
|
|
Components []SlotComponent
|
|
}
|
|
TradeDisabled bool
|
|
NbTradeUses int32
|
|
MaximumNbTradeUses int32
|
|
Xp int32
|
|
SpecialPrice int32
|
|
PriceMultiplier float32
|
|
Demand int32
|
|
}{}
|
|
for range lPlayToClientPacketTradeListTrades {
|
|
var PlayToClientPacketTradeListTradesElement struct {
|
|
InputItem1 struct {
|
|
ItemId int32
|
|
ItemCount int32
|
|
AddedComponentCount int32
|
|
Components []SlotComponent
|
|
}
|
|
OutputItem Slot
|
|
InputItem2 *struct {
|
|
ItemId int32
|
|
ItemCount int32
|
|
AddedComponentCount int32
|
|
Components []SlotComponent
|
|
}
|
|
TradeDisabled bool
|
|
NbTradeUses int32
|
|
MaximumNbTradeUses int32
|
|
Xp int32
|
|
SpecialPrice int32
|
|
PriceMultiplier float32
|
|
Demand int32
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem1.ItemId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem1.ItemCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem1.AddedComponentCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketTradeListTradesElementInputItem1Components int32
|
|
lPlayToClientPacketTradeListTradesElementInputItem1Components = PlayToClientPacketTradeListTradesElement.InputItem1.AddedComponentCount
|
|
PlayToClientPacketTradeListTradesElement.InputItem1.Components = []SlotComponent{}
|
|
for range lPlayToClientPacketTradeListTradesElementInputItem1Components {
|
|
var PlayToClientPacketTradeListTradesElementInputItem1ComponentsElement SlotComponent
|
|
err = PlayToClientPacketTradeListTradesElementInputItem1ComponentsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem1.Components = append(PlayToClientPacketTradeListTradesElement.InputItem1.Components, PlayToClientPacketTradeListTradesElementInputItem1ComponentsElement)
|
|
}
|
|
err = PlayToClientPacketTradeListTradesElement.OutputItem.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToClientPacketTradeListTradesElementInputItem2Present bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElementInputItem2Present)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToClientPacketTradeListTradesElementInputItem2Present {
|
|
var PlayToClientPacketTradeListTradesElementInputItem2PresentValue struct {
|
|
ItemId int32
|
|
ItemCount int32
|
|
AddedComponentCount int32
|
|
Components []SlotComponent
|
|
}
|
|
PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElementInputItem2PresentValue.AddedComponentCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketTradeListTradesElementInputItem2Components int32
|
|
lPlayToClientPacketTradeListTradesElementInputItem2Components = PlayToClientPacketTradeListTradesElementInputItem2PresentValue.AddedComponentCount
|
|
PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Components = []SlotComponent{}
|
|
for range lPlayToClientPacketTradeListTradesElementInputItem2Components {
|
|
var PlayToClientPacketTradeListTradesElementInputItem2ComponentsElement SlotComponent
|
|
err = PlayToClientPacketTradeListTradesElementInputItem2ComponentsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Components = append(PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Components, PlayToClientPacketTradeListTradesElementInputItem2ComponentsElement)
|
|
}
|
|
PlayToClientPacketTradeListTradesElement.InputItem2 = &PlayToClientPacketTradeListTradesElementInputItem2PresentValue
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.TradeDisabled)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.NbTradeUses)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.MaximumNbTradeUses)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Xp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.SpecialPrice)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.PriceMultiplier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Demand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Trades = append(ret.Trades, PlayToClientPacketTradeListTradesElement)
|
|
}
|
|
ret.VillagerLevel, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Experience, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsRegularVillager)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CanRestock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketTradeList) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketTradeListWindowIdEncTmp := ret.WindowId
|
|
err = PlayToClientPacketTradeListWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Trades)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTradeListTrades := range len(ret.Trades) {
|
|
err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.AddedComponentCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTradeListTradesInnerInputItem1Components := range len(ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.Components) {
|
|
PlayToClientPacketTradeListTradesInnerInputItem1ComponentsInnerEncTmp := ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.Components[iPlayToClientPacketTradeListTradesInnerInputItem1Components]
|
|
err = PlayToClientPacketTradeListTradesInnerInputItem1ComponentsInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
PlayToClientPacketTradeListTradesInnerOutputItemEncTmp := ret.Trades[iPlayToClientPacketTradeListTrades].OutputItem
|
|
err = PlayToClientPacketTradeListTradesInnerOutputItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil {
|
|
err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).AddedComponentCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketTradeListTradesInnerInputItem2Components := range len((*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).Components) {
|
|
PlayToClientPacketTradeListTradesInnerInputItem2ComponentsInnerEncTmp := (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).Components[iPlayToClientPacketTradeListTradesInnerInputItem2Components]
|
|
err = PlayToClientPacketTradeListTradesInnerInputItem2ComponentsInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].TradeDisabled)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].NbTradeUses)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].MaximumNbTradeUses)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Xp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].SpecialPrice)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].PriceMultiplier)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Demand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.VillagerLevel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Experience)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsRegularVillager)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CanRestock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUnloadChunk struct {
|
|
ChunkZ int32
|
|
ChunkX int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUnloadChunk) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUnloadChunk) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUnlockRecipes struct {
|
|
Action int32
|
|
CraftingBookOpen bool
|
|
FilteringCraftable bool
|
|
SmeltingBookOpen bool
|
|
FilteringSmeltable bool
|
|
BlastFurnaceOpen bool
|
|
FilteringBlastFurnace bool
|
|
SmokerBookOpen bool
|
|
FilteringSmoker bool
|
|
Recipes1 []string
|
|
Recipes2 any
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUnlockRecipes) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FilteringCraftable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SmeltingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FilteringSmeltable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.BlastFurnaceOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FilteringBlastFurnace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SmokerBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FilteringSmoker)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketUnlockRecipesRecipes1 int32
|
|
lPlayToClientPacketUnlockRecipesRecipes1, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes1 = []string{}
|
|
for range lPlayToClientPacketUnlockRecipesRecipes1 {
|
|
var PlayToClientPacketUnlockRecipesRecipes1Element string
|
|
PlayToClientPacketUnlockRecipesRecipes1Element, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipes1 = append(ret.Recipes1, PlayToClientPacketUnlockRecipesRecipes1Element)
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToClientPacketUnlockRecipesRecipes20Tmp []string
|
|
var lPlayToClientPacketUnlockRecipesRecipes20Tmp int32
|
|
lPlayToClientPacketUnlockRecipesRecipes20Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUnlockRecipesRecipes20Tmp = []string{}
|
|
for range lPlayToClientPacketUnlockRecipesRecipes20Tmp {
|
|
var PlayToClientPacketUnlockRecipesRecipes20TmpElement string
|
|
PlayToClientPacketUnlockRecipesRecipes20TmpElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUnlockRecipesRecipes20Tmp = append(PlayToClientPacketUnlockRecipesRecipes20Tmp, PlayToClientPacketUnlockRecipesRecipes20TmpElement)
|
|
}
|
|
ret.Recipes2 = PlayToClientPacketUnlockRecipesRecipes20Tmp
|
|
default:
|
|
var PlayToClientPacketUnlockRecipesRecipes2Tmp struct {
|
|
}
|
|
ret.Recipes2 = PlayToClientPacketUnlockRecipesRecipes2Tmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUnlockRecipes) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CraftingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilteringCraftable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SmeltingBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilteringSmeltable)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.BlastFurnaceOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilteringBlastFurnace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SmokerBookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilteringSmoker)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes1)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUnlockRecipesRecipes1 := range len(ret.Recipes1) {
|
|
err = proto_base.EncodeString(w, ret.Recipes1[iPlayToClientPacketUnlockRecipesRecipes1])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToClientPacketUnlockRecipesRecipes2, ok := ret.Recipes2.([]string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketUnlockRecipesRecipes2)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUnlockRecipesRecipes2 := range len(PlayToClientPacketUnlockRecipesRecipes2) {
|
|
err = proto_base.EncodeString(w, PlayToClientPacketUnlockRecipesRecipes2[iPlayToClientPacketUnlockRecipesRecipes2])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
default:
|
|
_, ok := ret.Recipes2.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateHealth struct {
|
|
Health float32
|
|
Food int32
|
|
FoodSaturation float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateHealth) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Health)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Food, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FoodSaturation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateHealth) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Health)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Food)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FoodSaturation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateLight struct {
|
|
ChunkX int32
|
|
ChunkZ int32
|
|
SkyLightMask []int64
|
|
BlockLightMask []int64
|
|
EmptySkyLightMask []int64
|
|
EmptyBlockLightMask []int64
|
|
SkyLight [][]uint8
|
|
BlockLight [][]uint8
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateLight) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ChunkX, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkZ, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketUpdateLightSkyLightMask int32
|
|
lPlayToClientPacketUpdateLightSkyLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLightMask = []int64{}
|
|
for range lPlayToClientPacketUpdateLightSkyLightMask {
|
|
var PlayToClientPacketUpdateLightSkyLightMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightSkyLightMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLightMask = append(ret.SkyLightMask, PlayToClientPacketUpdateLightSkyLightMaskElement)
|
|
}
|
|
var lPlayToClientPacketUpdateLightBlockLightMask int32
|
|
lPlayToClientPacketUpdateLightBlockLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLightMask = []int64{}
|
|
for range lPlayToClientPacketUpdateLightBlockLightMask {
|
|
var PlayToClientPacketUpdateLightBlockLightMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightBlockLightMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLightMask = append(ret.BlockLightMask, PlayToClientPacketUpdateLightBlockLightMaskElement)
|
|
}
|
|
var lPlayToClientPacketUpdateLightEmptySkyLightMask int32
|
|
lPlayToClientPacketUpdateLightEmptySkyLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptySkyLightMask = []int64{}
|
|
for range lPlayToClientPacketUpdateLightEmptySkyLightMask {
|
|
var PlayToClientPacketUpdateLightEmptySkyLightMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightEmptySkyLightMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptySkyLightMask = append(ret.EmptySkyLightMask, PlayToClientPacketUpdateLightEmptySkyLightMaskElement)
|
|
}
|
|
var lPlayToClientPacketUpdateLightEmptyBlockLightMask int32
|
|
lPlayToClientPacketUpdateLightEmptyBlockLightMask, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptyBlockLightMask = []int64{}
|
|
for range lPlayToClientPacketUpdateLightEmptyBlockLightMask {
|
|
var PlayToClientPacketUpdateLightEmptyBlockLightMaskElement int64
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightEmptyBlockLightMaskElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EmptyBlockLightMask = append(ret.EmptyBlockLightMask, PlayToClientPacketUpdateLightEmptyBlockLightMaskElement)
|
|
}
|
|
var lPlayToClientPacketUpdateLightSkyLight int32
|
|
lPlayToClientPacketUpdateLightSkyLight, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SkyLight = [][]uint8{}
|
|
for range lPlayToClientPacketUpdateLightSkyLight {
|
|
var PlayToClientPacketUpdateLightSkyLightElement []uint8
|
|
var lPlayToClientPacketUpdateLightSkyLightElement int32
|
|
lPlayToClientPacketUpdateLightSkyLightElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUpdateLightSkyLightElement = []uint8{}
|
|
for range lPlayToClientPacketUpdateLightSkyLightElement {
|
|
var PlayToClientPacketUpdateLightSkyLightElementElement uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightSkyLightElementElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUpdateLightSkyLightElement = append(PlayToClientPacketUpdateLightSkyLightElement, PlayToClientPacketUpdateLightSkyLightElementElement)
|
|
}
|
|
ret.SkyLight = append(ret.SkyLight, PlayToClientPacketUpdateLightSkyLightElement)
|
|
}
|
|
var lPlayToClientPacketUpdateLightBlockLight int32
|
|
lPlayToClientPacketUpdateLightBlockLight, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.BlockLight = [][]uint8{}
|
|
for range lPlayToClientPacketUpdateLightBlockLight {
|
|
var PlayToClientPacketUpdateLightBlockLightElement []uint8
|
|
var lPlayToClientPacketUpdateLightBlockLightElement int32
|
|
lPlayToClientPacketUpdateLightBlockLightElement, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUpdateLightBlockLightElement = []uint8{}
|
|
for range lPlayToClientPacketUpdateLightBlockLightElement {
|
|
var PlayToClientPacketUpdateLightBlockLightElementElement uint8
|
|
err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightBlockLightElementElement)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketUpdateLightBlockLightElement = append(PlayToClientPacketUpdateLightBlockLightElement, PlayToClientPacketUpdateLightBlockLightElementElement)
|
|
}
|
|
ret.BlockLight = append(ret.BlockLight, PlayToClientPacketUpdateLightBlockLightElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateLight) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLightMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightSkyLightMask := range len(ret.SkyLightMask) {
|
|
err = binary.Write(w, binary.BigEndian, ret.SkyLightMask[iPlayToClientPacketUpdateLightSkyLightMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLightMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightBlockLightMask := range len(ret.BlockLightMask) {
|
|
err = binary.Write(w, binary.BigEndian, ret.BlockLightMask[iPlayToClientPacketUpdateLightBlockLightMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.EmptySkyLightMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightEmptySkyLightMask := range len(ret.EmptySkyLightMask) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EmptySkyLightMask[iPlayToClientPacketUpdateLightEmptySkyLightMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.EmptyBlockLightMask)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightEmptyBlockLightMask := range len(ret.EmptyBlockLightMask) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EmptyBlockLightMask[iPlayToClientPacketUpdateLightEmptyBlockLightMask])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightSkyLight := range len(ret.SkyLight) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight])))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightSkyLightInner := range len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight]) {
|
|
err = binary.Write(w, binary.BigEndian, ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight][iPlayToClientPacketUpdateLightSkyLightInner])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightBlockLight := range len(ret.BlockLight) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight])))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketUpdateLightBlockLightInner := range len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight]) {
|
|
err = binary.Write(w, binary.BigEndian, ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight][iPlayToClientPacketUpdateLightBlockLightInner])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateTime struct {
|
|
Age int64
|
|
Time int64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateTime) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Age)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateTime) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Age)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateViewDistance struct {
|
|
ViewDistance int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateViewDistance) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ViewDistance, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateViewDistance) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketUpdateViewPosition struct {
|
|
ChunkX int32
|
|
ChunkZ int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketUpdateViewPosition) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ChunkX, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChunkZ, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketUpdateViewPosition) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ChunkX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChunkZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketVehicleMove struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketVehicleMove) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketVehicleMove) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWindowItems struct {
|
|
WindowId ContainerID
|
|
StateId int32
|
|
Items []Slot
|
|
CarriedItem Slot
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWindowItems) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.StateId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToClientPacketWindowItemsItems int32
|
|
lPlayToClientPacketWindowItemsItems, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Items = []Slot{}
|
|
for range lPlayToClientPacketWindowItemsItems {
|
|
var PlayToClientPacketWindowItemsItemsElement Slot
|
|
err = PlayToClientPacketWindowItemsItemsElement.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Items = append(ret.Items, PlayToClientPacketWindowItemsItemsElement)
|
|
}
|
|
err = ret.CarriedItem.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWindowItems) Encode(w io.Writer) (err error) {
|
|
PlayToClientPacketWindowItemsWindowIdEncTmp := ret.WindowId
|
|
err = PlayToClientPacketWindowItemsWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.StateId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Items)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToClientPacketWindowItemsItems := range len(ret.Items) {
|
|
PlayToClientPacketWindowItemsItemsInnerEncTmp := ret.Items[iPlayToClientPacketWindowItemsItems]
|
|
err = PlayToClientPacketWindowItemsItemsInnerEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
PlayToClientPacketWindowItemsCarriedItemEncTmp := ret.CarriedItem
|
|
err = PlayToClientPacketWindowItemsCarriedItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorderCenter struct {
|
|
X float64
|
|
Z float64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldBorderCenter) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldBorderCenter) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorderLerpSize struct {
|
|
OldDiameter float64
|
|
NewDiameter float64
|
|
Speed int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldBorderLerpSize) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.OldDiameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.NewDiameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Speed, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldBorderLerpSize) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.OldDiameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.NewDiameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Speed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorderSize struct {
|
|
Diameter float64
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldBorderSize) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Diameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldBorderSize) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Diameter)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorderWarningDelay struct {
|
|
WarningTime int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldBorderWarningDelay) Decode(r io.ReadSeeker) (err error) {
|
|
ret.WarningTime, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldBorderWarningDelay) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.WarningTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldBorderWarningReach struct {
|
|
WarningBlocks int32
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldBorderWarningReach) Decode(r io.ReadSeeker) (err error) {
|
|
ret.WarningBlocks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldBorderWarningReach) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.WarningBlocks)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldEvent struct {
|
|
EffectId int32
|
|
Location Position
|
|
Data int32
|
|
Global bool
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldEvent) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Data)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Global)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldEvent) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.EffectId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketWorldEventLocationEncTmp := ret.Location
|
|
err = PlayToClientPacketWorldEventLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Data)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Global)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToClientPacketWorldParticles struct {
|
|
LongDistance bool
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
OffsetX float32
|
|
OffsetY float32
|
|
OffsetZ float32
|
|
VelocityOffset float32
|
|
Amount int32
|
|
Particle Particle
|
|
}
|
|
|
|
func (ret *PlayToClientPacketWorldParticles) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.LongDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.VelocityOffset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Amount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Particle.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToClientPacketWorldParticles) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.LongDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.VelocityOffset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Amount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToClientPacketWorldParticlesParticleEncTmp := ret.Particle
|
|
err = PlayToClientPacketWorldParticlesParticleEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var PlayToServerPacketNameMap = map[int32]string{0x00: "teleport_confirm", 0x01: "query_block_nbt", 0x02: "set_difficulty", 0x03: "message_acknowledgement", 0x04: "chat_command", 0x05: "chat_command_signed", 0x06: "chat_message", 0x07: "chat_session_update", 0x08: "chunk_batch_received", 0x09: "client_command", 0x0a: "settings", 0x0b: "tab_complete", 0x0c: "configuration_acknowledged", 0x0d: "enchant_item", 0x0e: "window_click", 0x0f: "close_window", 0x10: "set_slot_state", 0x11: "cookie_response", 0x12: "custom_payload", 0x13: "debug_sample_subscription", 0x14: "edit_book", 0x15: "query_entity_nbt", 0x16: "use_entity", 0x17: "generate_structure", 0x18: "keep_alive", 0x19: "lock_difficulty", 0x1a: "position", 0x1b: "position_look", 0x1c: "look", 0x1d: "flying", 0x1e: "vehicle_move", 0x1f: "steer_boat", 0x20: "pick_item", 0x21: "ping_request", 0x22: "craft_recipe_request", 0x23: "abilities", 0x24: "block_dig", 0x25: "entity_action", 0x26: "steer_vehicle", 0x27: "pong", 0x28: "recipe_book", 0x29: "displayed_recipe", 0x2a: "name_item", 0x2b: "resource_pack_receive", 0x2c: "advancement_tab", 0x2d: "select_trade", 0x2e: "set_beacon_effect", 0x2f: "held_item_slot", 0x30: "update_command_block", 0x31: "update_command_block_minecart", 0x32: "set_creative_slot", 0x33: "update_jigsaw_block", 0x34: "update_structure_block", 0x35: "update_sign", 0x36: "arm_animation", 0x37: "spectate", 0x38: "block_place", 0x39: "use_item"}
|
|
|
|
func (ret *PlayToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToServerPacketNameKey int32
|
|
PlayToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(PlayToServerPacketNameMap, PlayToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
var PlayToServerPacketParamsAbilitiesTmp PlayToServerPacketAbilities
|
|
err = PlayToServerPacketParamsAbilitiesTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsAbilitiesTmp
|
|
case "advancement_tab":
|
|
var PlayToServerPacketParamsAdvancementTabTmp PlayToServerPacketAdvancementTab
|
|
err = PlayToServerPacketParamsAdvancementTabTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsAdvancementTabTmp
|
|
case "arm_animation":
|
|
var PlayToServerPacketParamsArmAnimationTmp PlayToServerPacketArmAnimation
|
|
err = PlayToServerPacketParamsArmAnimationTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsArmAnimationTmp
|
|
case "block_dig":
|
|
var PlayToServerPacketParamsBlockDigTmp PlayToServerPacketBlockDig
|
|
err = PlayToServerPacketParamsBlockDigTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsBlockDigTmp
|
|
case "block_place":
|
|
var PlayToServerPacketParamsBlockPlaceTmp PlayToServerPacketBlockPlace
|
|
err = PlayToServerPacketParamsBlockPlaceTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsBlockPlaceTmp
|
|
case "chat_command":
|
|
var PlayToServerPacketParamsChatCommandTmp PlayToServerPacketChatCommand
|
|
err = PlayToServerPacketParamsChatCommandTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsChatCommandTmp
|
|
case "chat_command_signed":
|
|
var PlayToServerPacketParamsChatCommandSignedTmp PlayToServerPacketChatCommandSigned
|
|
err = PlayToServerPacketParamsChatCommandSignedTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsChatCommandSignedTmp
|
|
case "chat_message":
|
|
var PlayToServerPacketParamsChatMessageTmp PlayToServerPacketChatMessage
|
|
err = PlayToServerPacketParamsChatMessageTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsChatMessageTmp
|
|
case "chat_session_update":
|
|
var PlayToServerPacketParamsChatSessionUpdateTmp PlayToServerPacketChatSessionUpdate
|
|
err = PlayToServerPacketParamsChatSessionUpdateTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsChatSessionUpdateTmp
|
|
case "chunk_batch_received":
|
|
var PlayToServerPacketParamsChunkBatchReceivedTmp PlayToServerPacketChunkBatchReceived
|
|
err = PlayToServerPacketParamsChunkBatchReceivedTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsChunkBatchReceivedTmp
|
|
case "client_command":
|
|
var PlayToServerPacketParamsClientCommandTmp PlayToServerPacketClientCommand
|
|
err = PlayToServerPacketParamsClientCommandTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsClientCommandTmp
|
|
case "close_window":
|
|
var PlayToServerPacketParamsCloseWindowTmp PlayToServerPacketCloseWindow
|
|
err = PlayToServerPacketParamsCloseWindowTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCloseWindowTmp
|
|
case "configuration_acknowledged":
|
|
var PlayToServerPacketParamsConfigurationAcknowledgedTmp PlayToServerPacketConfigurationAcknowledged
|
|
err = PlayToServerPacketParamsConfigurationAcknowledgedTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsConfigurationAcknowledgedTmp
|
|
case "cookie_response":
|
|
var PlayToServerPacketParamsCookieResponseTmp PlayToServerPacketCommonCookieResponse
|
|
err = PlayToServerPacketParamsCookieResponseTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCookieResponseTmp
|
|
case "craft_recipe_request":
|
|
var PlayToServerPacketParamsCraftRecipeRequestTmp PlayToServerPacketCraftRecipeRequest
|
|
err = PlayToServerPacketParamsCraftRecipeRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCraftRecipeRequestTmp
|
|
case "custom_payload":
|
|
var PlayToServerPacketParamsCustomPayloadTmp PlayToServerPacketCustomPayload
|
|
err = PlayToServerPacketParamsCustomPayloadTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsCustomPayloadTmp
|
|
case "debug_sample_subscription":
|
|
var PlayToServerPacketParamsDebugSampleSubscriptionTmp PlayToServerPacketDebugSampleSubscription
|
|
err = PlayToServerPacketParamsDebugSampleSubscriptionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsDebugSampleSubscriptionTmp
|
|
case "displayed_recipe":
|
|
var PlayToServerPacketParamsDisplayedRecipeTmp PlayToServerPacketDisplayedRecipe
|
|
err = PlayToServerPacketParamsDisplayedRecipeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsDisplayedRecipeTmp
|
|
case "edit_book":
|
|
var PlayToServerPacketParamsEditBookTmp PlayToServerPacketEditBook
|
|
err = PlayToServerPacketParamsEditBookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsEditBookTmp
|
|
case "enchant_item":
|
|
var PlayToServerPacketParamsEnchantItemTmp PlayToServerPacketEnchantItem
|
|
err = PlayToServerPacketParamsEnchantItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsEnchantItemTmp
|
|
case "entity_action":
|
|
var PlayToServerPacketParamsEntityActionTmp PlayToServerPacketEntityAction
|
|
err = PlayToServerPacketParamsEntityActionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsEntityActionTmp
|
|
case "flying":
|
|
var PlayToServerPacketParamsFlyingTmp PlayToServerPacketFlying
|
|
err = PlayToServerPacketParamsFlyingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsFlyingTmp
|
|
case "generate_structure":
|
|
var PlayToServerPacketParamsGenerateStructureTmp PlayToServerPacketGenerateStructure
|
|
err = PlayToServerPacketParamsGenerateStructureTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsGenerateStructureTmp
|
|
case "held_item_slot":
|
|
var PlayToServerPacketParamsHeldItemSlotTmp PlayToServerPacketHeldItemSlot
|
|
err = PlayToServerPacketParamsHeldItemSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsHeldItemSlotTmp
|
|
case "keep_alive":
|
|
var PlayToServerPacketParamsKeepAliveTmp PlayToServerPacketKeepAlive
|
|
err = PlayToServerPacketParamsKeepAliveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsKeepAliveTmp
|
|
case "lock_difficulty":
|
|
var PlayToServerPacketParamsLockDifficultyTmp PlayToServerPacketLockDifficulty
|
|
err = PlayToServerPacketParamsLockDifficultyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsLockDifficultyTmp
|
|
case "look":
|
|
var PlayToServerPacketParamsLookTmp PlayToServerPacketLook
|
|
err = PlayToServerPacketParamsLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsLookTmp
|
|
case "message_acknowledgement":
|
|
var PlayToServerPacketParamsMessageAcknowledgementTmp PlayToServerPacketMessageAcknowledgement
|
|
err = PlayToServerPacketParamsMessageAcknowledgementTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsMessageAcknowledgementTmp
|
|
case "name_item":
|
|
var PlayToServerPacketParamsNameItemTmp PlayToServerPacketNameItem
|
|
err = PlayToServerPacketParamsNameItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsNameItemTmp
|
|
case "pick_item":
|
|
var PlayToServerPacketParamsPickItemTmp PlayToServerPacketPickItem
|
|
err = PlayToServerPacketParamsPickItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsPickItemTmp
|
|
case "ping_request":
|
|
var PlayToServerPacketParamsPingRequestTmp PlayToServerPacketPingRequest
|
|
err = PlayToServerPacketParamsPingRequestTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsPingRequestTmp
|
|
case "pong":
|
|
var PlayToServerPacketParamsPongTmp PlayToServerPacketPong
|
|
err = PlayToServerPacketParamsPongTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsPongTmp
|
|
case "position":
|
|
var PlayToServerPacketParamsPositionTmp PlayToServerPacketPosition
|
|
err = PlayToServerPacketParamsPositionTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsPositionTmp
|
|
case "position_look":
|
|
var PlayToServerPacketParamsPositionLookTmp PlayToServerPacketPositionLook
|
|
err = PlayToServerPacketParamsPositionLookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsPositionLookTmp
|
|
case "query_block_nbt":
|
|
var PlayToServerPacketParamsQueryBlockNbtTmp PlayToServerPacketQueryBlockNbt
|
|
err = PlayToServerPacketParamsQueryBlockNbtTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsQueryBlockNbtTmp
|
|
case "query_entity_nbt":
|
|
var PlayToServerPacketParamsQueryEntityNbtTmp PlayToServerPacketQueryEntityNbt
|
|
err = PlayToServerPacketParamsQueryEntityNbtTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsQueryEntityNbtTmp
|
|
case "recipe_book":
|
|
var PlayToServerPacketParamsRecipeBookTmp PlayToServerPacketRecipeBook
|
|
err = PlayToServerPacketParamsRecipeBookTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsRecipeBookTmp
|
|
case "resource_pack_receive":
|
|
var PlayToServerPacketParamsResourcePackReceiveTmp PlayToServerPacketResourcePackReceive
|
|
err = PlayToServerPacketParamsResourcePackReceiveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsResourcePackReceiveTmp
|
|
case "select_trade":
|
|
var PlayToServerPacketParamsSelectTradeTmp PlayToServerPacketSelectTrade
|
|
err = PlayToServerPacketParamsSelectTradeTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSelectTradeTmp
|
|
case "set_beacon_effect":
|
|
var PlayToServerPacketParamsSetBeaconEffectTmp PlayToServerPacketSetBeaconEffect
|
|
err = PlayToServerPacketParamsSetBeaconEffectTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSetBeaconEffectTmp
|
|
case "set_creative_slot":
|
|
var PlayToServerPacketParamsSetCreativeSlotTmp PlayToServerPacketSetCreativeSlot
|
|
err = PlayToServerPacketParamsSetCreativeSlotTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSetCreativeSlotTmp
|
|
case "set_difficulty":
|
|
var PlayToServerPacketParamsSetDifficultyTmp PlayToServerPacketSetDifficulty
|
|
err = PlayToServerPacketParamsSetDifficultyTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSetDifficultyTmp
|
|
case "set_slot_state":
|
|
var PlayToServerPacketParamsSetSlotStateTmp PlayToServerPacketSetSlotState
|
|
err = PlayToServerPacketParamsSetSlotStateTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSetSlotStateTmp
|
|
case "settings":
|
|
var PlayToServerPacketParamsSettingsTmp PlayToServerPacketCommonSettings
|
|
err = PlayToServerPacketParamsSettingsTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSettingsTmp
|
|
case "spectate":
|
|
var PlayToServerPacketParamsSpectateTmp PlayToServerPacketSpectate
|
|
err = PlayToServerPacketParamsSpectateTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSpectateTmp
|
|
case "steer_boat":
|
|
var PlayToServerPacketParamsSteerBoatTmp PlayToServerPacketSteerBoat
|
|
err = PlayToServerPacketParamsSteerBoatTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSteerBoatTmp
|
|
case "steer_vehicle":
|
|
var PlayToServerPacketParamsSteerVehicleTmp PlayToServerPacketSteerVehicle
|
|
err = PlayToServerPacketParamsSteerVehicleTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsSteerVehicleTmp
|
|
case "tab_complete":
|
|
var PlayToServerPacketParamsTabCompleteTmp PlayToServerPacketTabComplete
|
|
err = PlayToServerPacketParamsTabCompleteTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTabCompleteTmp
|
|
case "teleport_confirm":
|
|
var PlayToServerPacketParamsTeleportConfirmTmp PlayToServerPacketTeleportConfirm
|
|
err = PlayToServerPacketParamsTeleportConfirmTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsTeleportConfirmTmp
|
|
case "update_command_block":
|
|
var PlayToServerPacketParamsUpdateCommandBlockTmp PlayToServerPacketUpdateCommandBlock
|
|
err = PlayToServerPacketParamsUpdateCommandBlockTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateCommandBlockTmp
|
|
case "update_command_block_minecart":
|
|
var PlayToServerPacketParamsUpdateCommandBlockMinecartTmp PlayToServerPacketUpdateCommandBlockMinecart
|
|
err = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp
|
|
case "update_jigsaw_block":
|
|
var PlayToServerPacketParamsUpdateJigsawBlockTmp PlayToServerPacketUpdateJigsawBlock
|
|
err = PlayToServerPacketParamsUpdateJigsawBlockTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateJigsawBlockTmp
|
|
case "update_sign":
|
|
var PlayToServerPacketParamsUpdateSignTmp PlayToServerPacketUpdateSign
|
|
err = PlayToServerPacketParamsUpdateSignTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateSignTmp
|
|
case "update_structure_block":
|
|
var PlayToServerPacketParamsUpdateStructureBlockTmp PlayToServerPacketUpdateStructureBlock
|
|
err = PlayToServerPacketParamsUpdateStructureBlockTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUpdateStructureBlockTmp
|
|
case "use_entity":
|
|
var PlayToServerPacketParamsUseEntityTmp PlayToServerPacketUseEntity
|
|
err = PlayToServerPacketParamsUseEntityTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUseEntityTmp
|
|
case "use_item":
|
|
var PlayToServerPacketParamsUseItemTmp PlayToServerPacketUseItem
|
|
err = PlayToServerPacketParamsUseItemTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsUseItemTmp
|
|
case "vehicle_move":
|
|
var PlayToServerPacketParamsVehicleMoveTmp PlayToServerPacketVehicleMove
|
|
err = PlayToServerPacketParamsVehicleMoveTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsVehicleMoveTmp
|
|
case "window_click":
|
|
var PlayToServerPacketParamsWindowClickTmp PlayToServerPacketWindowClick
|
|
err = PlayToServerPacketParamsWindowClickTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = PlayToServerPacketParamsWindowClickTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var PlayToServerPacketNameReverseMap = map[string]int32{"teleport_confirm": 0x00, "query_block_nbt": 0x01, "set_difficulty": 0x02, "message_acknowledgement": 0x03, "chat_command": 0x04, "chat_command_signed": 0x05, "chat_message": 0x06, "chat_session_update": 0x07, "chunk_batch_received": 0x08, "client_command": 0x09, "settings": 0x0a, "tab_complete": 0x0b, "configuration_acknowledged": 0x0c, "enchant_item": 0x0d, "window_click": 0x0e, "close_window": 0x0f, "set_slot_state": 0x10, "cookie_response": 0x11, "custom_payload": 0x12, "debug_sample_subscription": 0x13, "edit_book": 0x14, "query_entity_nbt": 0x15, "use_entity": 0x16, "generate_structure": 0x17, "keep_alive": 0x18, "lock_difficulty": 0x19, "position": 0x1a, "position_look": 0x1b, "look": 0x1c, "flying": 0x1d, "vehicle_move": 0x1e, "steer_boat": 0x1f, "pick_item": 0x20, "ping_request": 0x21, "craft_recipe_request": 0x22, "abilities": 0x23, "block_dig": 0x24, "entity_action": 0x25, "steer_vehicle": 0x26, "pong": 0x27, "recipe_book": 0x28, "displayed_recipe": 0x29, "name_item": 0x2a, "resource_pack_receive": 0x2b, "advancement_tab": 0x2c, "select_trade": 0x2d, "set_beacon_effect": 0x2e, "held_item_slot": 0x2f, "update_command_block": 0x30, "update_command_block_minecart": 0x31, "set_creative_slot": 0x32, "update_jigsaw_block": 0x33, "update_structure_block": 0x34, "update_sign": 0x35, "arm_animation": 0x36, "spectate": 0x37, "block_place": 0x38, "use_item": 0x39}
|
|
|
|
func (ret *PlayToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vPlayToServerPacketName int32
|
|
vPlayToServerPacketName, err = proto_base.ErroringIndex(PlayToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vPlayToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "abilities":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAbilities)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "advancement_tab":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAdvancementTab)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "arm_animation":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketArmAnimation)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_dig":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockDig)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "block_place":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockPlace)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_command":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommand)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_command_signed":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommandSigned)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_message":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatMessage)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chat_session_update":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatSessionUpdate)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "chunk_batch_received":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChunkBatchReceived)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "client_command":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketClientCommand)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "close_window":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCloseWindow)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "configuration_acknowledged":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketConfigurationAcknowledged)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "cookie_response":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonCookieResponse)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "craft_recipe_request":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftRecipeRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "custom_payload":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCustomPayload)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "debug_sample_subscription":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDebugSampleSubscription)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "displayed_recipe":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDisplayedRecipe)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "edit_book":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEditBook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "enchant_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEnchantItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "entity_action":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEntityAction)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "flying":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketFlying)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "generate_structure":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketGenerateStructure)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "held_item_slot":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketHeldItemSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "keep_alive":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketKeepAlive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "lock_difficulty":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLockDifficulty)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "look":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "message_acknowledgement":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketMessageAcknowledgement)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "name_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketNameItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "pick_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping_request":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPingRequest)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "pong":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPong)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPosition)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "position_look":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPositionLook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "query_block_nbt":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryBlockNbt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "query_entity_nbt":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryEntityNbt)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "recipe_book":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketRecipeBook)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "resource_pack_receive":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketResourcePackReceive)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "select_trade":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectTrade)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_beacon_effect":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetBeaconEffect)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_creative_slot":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetCreativeSlot)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_difficulty":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetDifficulty)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "set_slot_state":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetSlotState)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "settings":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonSettings)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "spectate":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSpectate)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "steer_boat":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerBoat)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "steer_vehicle":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerVehicle)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "tab_complete":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTabComplete)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "teleport_confirm":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTeleportConfirm)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_command_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_command_block_minecart":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlockMinecart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_jigsaw_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateJigsawBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_sign":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateSign)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "update_structure_block":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateStructureBlock)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "use_entity":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseEntity)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "use_item":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseItem)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "vehicle_move":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketVehicleMove)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "window_click":
|
|
PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketWindowClick)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
PlayToServerPacketParamsEncTmp := PlayToServerPacketParams
|
|
err = PlayToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketAbilities struct {
|
|
Flags int8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketAbilities) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketAbilities) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketAdvancementTab struct {
|
|
Action int32
|
|
TabId any
|
|
}
|
|
|
|
func (ret *PlayToServerPacketAdvancementTab) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
var PlayToServerPacketAdvancementTabTabId0Tmp string
|
|
PlayToServerPacketAdvancementTabTabId0Tmp, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.TabId = PlayToServerPacketAdvancementTabTabId0Tmp
|
|
case 1:
|
|
var PlayToServerPacketAdvancementTabTabId1Tmp struct {
|
|
}
|
|
ret.TabId = PlayToServerPacketAdvancementTabTabId1Tmp
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketAdvancementTab) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Action {
|
|
case 0:
|
|
PlayToServerPacketAdvancementTabTabId, ok := ret.TabId.(string)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, PlayToServerPacketAdvancementTabTabId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 1:
|
|
_, ok := ret.TabId.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketArmAnimation struct {
|
|
Hand int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketArmAnimation) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketArmAnimation) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketBlockDig struct {
|
|
Status int32
|
|
Location Position
|
|
Face int8
|
|
Sequence int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketBlockDig) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Status, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Face)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sequence, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketBlockDig) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Status)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketBlockDigLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketBlockDigLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Face)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Sequence)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketBlockPlace struct {
|
|
Hand int32
|
|
Location Position
|
|
Direction int32
|
|
CursorX float32
|
|
CursorY float32
|
|
CursorZ float32
|
|
InsideBlock bool
|
|
Sequence int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketBlockPlace) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Direction, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.CursorZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.InsideBlock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sequence, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketBlockPlace) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketBlockPlaceLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketBlockPlaceLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Direction)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.CursorZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.InsideBlock)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Sequence)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChatCommand struct {
|
|
Command string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketChatCommand) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Command, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketChatCommand) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Command)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChatCommandSigned struct {
|
|
Command string
|
|
Timestamp int64
|
|
Salt int64
|
|
ArgumentSignatures []struct {
|
|
ArgumentName string
|
|
Signature [256]byte
|
|
}
|
|
MessageCount int32
|
|
Acknowledged [3]byte
|
|
}
|
|
|
|
func (ret *PlayToServerPacketChatCommandSigned) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Command, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Timestamp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Salt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToServerPacketChatCommandSignedArgumentSignatures int32
|
|
lPlayToServerPacketChatCommandSignedArgumentSignatures, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ArgumentSignatures = []struct {
|
|
ArgumentName string
|
|
Signature [256]byte
|
|
}{}
|
|
for range lPlayToServerPacketChatCommandSignedArgumentSignatures {
|
|
var PlayToServerPacketChatCommandSignedArgumentSignaturesElement struct {
|
|
ArgumentName string
|
|
Signature [256]byte
|
|
}
|
|
PlayToServerPacketChatCommandSignedArgumentSignaturesElement.ArgumentName, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = r.Read(PlayToServerPacketChatCommandSignedArgumentSignaturesElement.Signature[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ArgumentSignatures = append(ret.ArgumentSignatures, PlayToServerPacketChatCommandSignedArgumentSignaturesElement)
|
|
}
|
|
ret.MessageCount, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = r.Read(ret.Acknowledged[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketChatCommandSigned) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Command)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Timestamp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Salt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ArgumentSignatures)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToServerPacketChatCommandSignedArgumentSignatures := range len(ret.ArgumentSignatures) {
|
|
err = proto_base.EncodeString(w, ret.ArgumentSignatures[iPlayToServerPacketChatCommandSignedArgumentSignatures].ArgumentName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
arr := ret.ArgumentSignatures[iPlayToServerPacketChatCommandSignedArgumentSignatures].Signature
|
|
_, err = w.Write(arr[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MessageCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
arr := ret.Acknowledged
|
|
_, err = w.Write(arr[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChatMessage struct {
|
|
Message string
|
|
Timestamp int64
|
|
Salt int64
|
|
Signature *[256]byte
|
|
Offset int32
|
|
Acknowledged [3]byte
|
|
}
|
|
|
|
func (ret *PlayToServerPacketChatMessage) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Message, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Timestamp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Salt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToServerPacketChatMessageSignaturePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketChatMessageSignaturePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketChatMessageSignaturePresent {
|
|
var PlayToServerPacketChatMessageSignaturePresentValue [256]byte
|
|
_, err = r.Read(PlayToServerPacketChatMessageSignaturePresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Signature = &PlayToServerPacketChatMessageSignaturePresentValue
|
|
}
|
|
ret.Offset, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = r.Read(ret.Acknowledged[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketChatMessage) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Message)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Timestamp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Salt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Signature != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Signature != nil {
|
|
arr := *ret.Signature
|
|
_, err = w.Write(arr[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Offset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
arr := ret.Acknowledged
|
|
_, err = w.Write(arr[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChatSessionUpdate struct {
|
|
SessionUUID uuid.UUID
|
|
ExpireTime int64
|
|
PublicKey ByteArray
|
|
Signature ByteArray
|
|
}
|
|
|
|
func (ret *PlayToServerPacketChatSessionUpdate) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.SessionUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ExpireTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.PublicKey.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Signature.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketChatSessionUpdate) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.SessionUUID[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ExpireTime)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketChatSessionUpdatePublicKeyEncTmp := ret.PublicKey
|
|
err = PlayToServerPacketChatSessionUpdatePublicKeyEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketChatSessionUpdateSignatureEncTmp := ret.Signature
|
|
err = PlayToServerPacketChatSessionUpdateSignatureEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketChunkBatchReceived struct {
|
|
ChunksPerTick float32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketChunkBatchReceived) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChunksPerTick)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketChunkBatchReceived) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ChunksPerTick)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketClientCommand struct {
|
|
ActionId int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketClientCommand) Decode(r io.ReadSeeker) (err error) {
|
|
ret.ActionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketClientCommand) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.ActionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCloseWindow struct {
|
|
WindowId ContainerID
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCloseWindow) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCloseWindow) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketCloseWindowWindowIdEncTmp := ret.WindowId
|
|
err = PlayToServerPacketCloseWindowWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToServerPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketCommonAddResourcePackPromptMessagePresent {
|
|
var PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
PlayToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = PlayToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var PlayToServerPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketCommonCookieResponseValuePresent {
|
|
var PlayToServerPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = PlayToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &PlayToServerPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
PlayToServerPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = PlayToServerPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToServerPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketCommonRemoveResourcePackUuidPresent {
|
|
var PlayToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, PlayToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &PlayToServerPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lPlayToServerPacketCommonSelectKnownPacksPacks int32
|
|
lPlayToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lPlayToServerPacketCommonSelectKnownPacksPacks {
|
|
var PlayToServerPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
PlayToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, PlayToServerPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = PlayToServerPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketConfigurationAcknowledged struct {
|
|
}
|
|
|
|
func (ret *PlayToServerPacketConfigurationAcknowledged) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketConfigurationAcknowledged) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCraftRecipeRequest struct {
|
|
WindowId int8
|
|
Recipe string
|
|
MakeAll bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCraftRecipeRequest) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Recipe, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.MakeAll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCraftRecipeRequest) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Recipe)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.MakeAll)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketCustomPayload struct {
|
|
Channel string
|
|
Data proto_base.RestBuffer
|
|
}
|
|
|
|
func (ret *PlayToServerPacketCustomPayload) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Channel, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Data.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketCustomPayload) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Channel)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketCustomPayloadDataEncTmp := ret.Data
|
|
err = PlayToServerPacketCustomPayloadDataEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketDebugSampleSubscription struct {
|
|
Type int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketDebugSampleSubscription) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Type, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketDebugSampleSubscription) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Type)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketDisplayedRecipe struct {
|
|
RecipeId string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketDisplayedRecipe) Decode(r io.ReadSeeker) (err error) {
|
|
ret.RecipeId, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketDisplayedRecipe) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.RecipeId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEditBook struct {
|
|
Hand int32
|
|
Pages []string
|
|
Title *string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketEditBook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToServerPacketEditBookPages int32
|
|
lPlayToServerPacketEditBookPages, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Pages = []string{}
|
|
for range lPlayToServerPacketEditBookPages {
|
|
var PlayToServerPacketEditBookPagesElement string
|
|
PlayToServerPacketEditBookPagesElement, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Pages = append(ret.Pages, PlayToServerPacketEditBookPagesElement)
|
|
}
|
|
var PlayToServerPacketEditBookTitlePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketEditBookTitlePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketEditBookTitlePresent {
|
|
var PlayToServerPacketEditBookTitlePresentValue string
|
|
PlayToServerPacketEditBookTitlePresentValue, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Title = &PlayToServerPacketEditBookTitlePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketEditBook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Pages)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToServerPacketEditBookPages := range len(ret.Pages) {
|
|
err = proto_base.EncodeString(w, ret.Pages[iPlayToServerPacketEditBookPages])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Title != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Title != nil {
|
|
err = proto_base.EncodeString(w, *ret.Title)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEnchantItem struct {
|
|
WindowId int8
|
|
Enchantment int8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketEnchantItem) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Enchantment)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketEnchantItem) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Enchantment)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketEntityAction struct {
|
|
EntityId int32
|
|
ActionId int32
|
|
JumpBoost int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketEntityAction) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ActionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.JumpBoost, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketEntityAction) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ActionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.JumpBoost)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketFlying struct {
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketFlying) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketFlying) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketGenerateStructure struct {
|
|
Location Position
|
|
Levels int32
|
|
KeepJigsaws bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketGenerateStructure) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Levels, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepJigsaws)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketGenerateStructure) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketGenerateStructureLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketGenerateStructureLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Levels)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepJigsaws)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketHeldItemSlot struct {
|
|
SlotId int16
|
|
}
|
|
|
|
func (ret *PlayToServerPacketHeldItemSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.SlotId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketHeldItemSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.SlotId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketKeepAlive struct {
|
|
KeepAliveId int64
|
|
}
|
|
|
|
func (ret *PlayToServerPacketKeepAlive) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketKeepAlive) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketLockDifficulty struct {
|
|
Locked bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketLockDifficulty) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Locked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketLockDifficulty) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Locked)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketLook struct {
|
|
Yaw float32
|
|
Pitch float32
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketLook) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketLook) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketMessageAcknowledgement struct {
|
|
Count int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketMessageAcknowledgement) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Count, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketMessageAcknowledgement) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Count)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketNameItem struct {
|
|
Name string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketNameItem) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketNameItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPickItem struct {
|
|
Slot int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketPickItem) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Slot, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketPickItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPingRequest struct {
|
|
Id int64
|
|
}
|
|
|
|
func (ret *PlayToServerPacketPingRequest) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketPingRequest) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPong struct {
|
|
Id int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketPong) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketPong) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPosition struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketPosition) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketPosition) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketPositionLook struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
OnGround bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketPositionLook) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketPositionLook) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OnGround)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketQueryBlockNbt struct {
|
|
TransactionId int32
|
|
Location Position
|
|
}
|
|
|
|
func (ret *PlayToServerPacketQueryBlockNbt) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketQueryBlockNbt) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketQueryBlockNbtLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketQueryBlockNbtLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketQueryEntityNbt struct {
|
|
TransactionId int32
|
|
EntityId int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketQueryEntityNbt) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketQueryEntityNbt) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketRecipeBook struct {
|
|
BookId int32
|
|
BookOpen bool
|
|
FilterActive bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketRecipeBook) Decode(r io.ReadSeeker) (err error) {
|
|
ret.BookId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.BookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.FilterActive)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketRecipeBook) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.BookId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.BookOpen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.FilterActive)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketResourcePackReceive struct {
|
|
Uuid uuid.UUID
|
|
Result int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketResourcePackReceive) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Result, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Result)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSelectTrade struct {
|
|
Slot int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSelectTrade) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Slot, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSelectTrade) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetBeaconEffect struct {
|
|
PrimaryEffect *int32
|
|
SecondaryEffect *int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSetBeaconEffect) Decode(r io.ReadSeeker) (err error) {
|
|
var PlayToServerPacketSetBeaconEffectPrimaryEffectPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectPrimaryEffectPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketSetBeaconEffectPrimaryEffectPresent {
|
|
var PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue int32
|
|
PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PrimaryEffect = &PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue
|
|
}
|
|
var PlayToServerPacketSetBeaconEffectSecondaryEffectPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectSecondaryEffectPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if PlayToServerPacketSetBeaconEffectSecondaryEffectPresent {
|
|
var PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue int32
|
|
PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SecondaryEffect = &PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSetBeaconEffect) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.PrimaryEffect != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PrimaryEffect != nil {
|
|
err = proto_base.EncodeVarInt(w, *ret.PrimaryEffect)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SecondaryEffect != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.SecondaryEffect != nil {
|
|
err = proto_base.EncodeVarInt(w, *ret.SecondaryEffect)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetCreativeSlot struct {
|
|
Slot int16
|
|
Item Slot
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSetCreativeSlot) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSetCreativeSlot) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketSetCreativeSlotItemEncTmp := ret.Item
|
|
err = PlayToServerPacketSetCreativeSlotItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetDifficulty struct {
|
|
NewDifficulty uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSetDifficulty) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.NewDifficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSetDifficulty) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.NewDifficulty)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSetSlotState struct {
|
|
SlotId int32
|
|
WindowId int32
|
|
State bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSetSlotState) Decode(r io.ReadSeeker) (err error) {
|
|
ret.SlotId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.WindowId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.State)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSetSlotState) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.SlotId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.WindowId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.State)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSpectate struct {
|
|
Target uuid.UUID
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSpectate) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Target[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSpectate) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Target[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSteerBoat struct {
|
|
LeftPaddle bool
|
|
RightPaddle bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSteerBoat) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.LeftPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.RightPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSteerBoat) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.LeftPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.RightPaddle)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketSteerVehicle struct {
|
|
Sideways float32
|
|
Forward float32
|
|
Jump uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketSteerVehicle) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Sideways)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forward)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Jump)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketSteerVehicle) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Sideways)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forward)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Jump)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTabComplete struct {
|
|
TransactionId int32
|
|
Text string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketTabComplete) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TransactionId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketTabComplete) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TransactionId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketTeleportConfirm struct {
|
|
TeleportId int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketTeleportConfirm) Decode(r io.ReadSeeker) (err error) {
|
|
ret.TeleportId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketTeleportConfirm) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.TeleportId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateCommandBlock struct {
|
|
Location Position
|
|
Command string
|
|
Mode int32
|
|
Flags uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateCommandBlock) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Command, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateCommandBlock) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketUpdateCommandBlockLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketUpdateCommandBlockLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Command)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateCommandBlockMinecart struct {
|
|
EntityId int32
|
|
Command string
|
|
TrackOutput bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateCommandBlockMinecart) Decode(r io.ReadSeeker) (err error) {
|
|
ret.EntityId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Command, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.TrackOutput)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateCommandBlockMinecart) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.EntityId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Command)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.TrackOutput)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateJigsawBlock struct {
|
|
Location Position
|
|
Name string
|
|
Target string
|
|
Pool string
|
|
FinalState string
|
|
JointType string
|
|
SelectionPriority int32
|
|
PlacementPriority int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateJigsawBlock) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Target, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Pool, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.FinalState, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.JointType, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.SelectionPriority, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PlacementPriority, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateJigsawBlock) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketUpdateJigsawBlockLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketUpdateJigsawBlockLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Target)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Pool)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.FinalState)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.JointType)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.SelectionPriority)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.PlacementPriority)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateSign struct {
|
|
Location Position
|
|
IsFrontText bool
|
|
Text1 string
|
|
Text2 string
|
|
Text3 string
|
|
Text4 string
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateSign) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.IsFrontText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text1, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text2, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text3, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Text4, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateSign) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketUpdateSignLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketUpdateSignLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.IsFrontText)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text1)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text2)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text3)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Text4)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUpdateStructureBlock struct {
|
|
Location Position
|
|
Action int32
|
|
Mode int32
|
|
Name string
|
|
OffsetX int8
|
|
OffsetY int8
|
|
OffsetZ int8
|
|
SizeX int8
|
|
SizeY int8
|
|
SizeZ int8
|
|
Mirror int32
|
|
Rotation int32
|
|
Metadata string
|
|
Integrity float32
|
|
Seed int32
|
|
Flags uint8
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUpdateStructureBlock) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.Location.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Action, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SizeX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SizeY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SizeZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mirror, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Rotation, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Metadata, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Integrity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Seed, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUpdateStructureBlock) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketUpdateStructureBlockLocationEncTmp := ret.Location
|
|
err = PlayToServerPacketUpdateStructureBlockLocationEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Action)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.OffsetZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SizeX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SizeY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SizeZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mirror)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Rotation)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Metadata)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Integrity)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Seed)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Flags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUseEntity struct {
|
|
Target int32
|
|
Mouse int32
|
|
X any
|
|
Y any
|
|
Z any
|
|
Hand any
|
|
Sneaking bool
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUseEntity) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Target, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mouse, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityX2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityX2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.X = PlayToServerPacketUseEntityX2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityXTmp struct {
|
|
}
|
|
ret.X = PlayToServerPacketUseEntityXTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityY2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityY2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Y = PlayToServerPacketUseEntityY2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityYTmp struct {
|
|
}
|
|
ret.Y = PlayToServerPacketUseEntityYTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
var PlayToServerPacketUseEntityZ2Tmp float32
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityZ2Tmp)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Z = PlayToServerPacketUseEntityZ2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityZTmp struct {
|
|
}
|
|
ret.Z = PlayToServerPacketUseEntityZTmp
|
|
}
|
|
switch ret.Mouse {
|
|
case 0:
|
|
var PlayToServerPacketUseEntityHand0Tmp int32
|
|
PlayToServerPacketUseEntityHand0Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHand0Tmp
|
|
case 2:
|
|
var PlayToServerPacketUseEntityHand2Tmp int32
|
|
PlayToServerPacketUseEntityHand2Tmp, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHand2Tmp
|
|
default:
|
|
var PlayToServerPacketUseEntityHandTmp struct {
|
|
}
|
|
ret.Hand = PlayToServerPacketUseEntityHandTmp
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Sneaking)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUseEntity) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Target)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mouse)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityX, ok := ret.X.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityX)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.X.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityY, ok := ret.Y.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityY)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Y.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 2:
|
|
PlayToServerPacketUseEntityZ, ok := ret.Z.(float32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityZ)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Z.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
switch ret.Mouse {
|
|
case 0:
|
|
PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case 2:
|
|
PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
_, ok := ret.Hand.(struct {
|
|
})
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Sneaking)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketUseItem struct {
|
|
Hand int32
|
|
Sequence int32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketUseItem) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Hand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Sequence, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketUseItem) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, ret.Hand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Sequence)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketVehicleMove struct {
|
|
X float64
|
|
Y float64
|
|
Z float64
|
|
Yaw float32
|
|
Pitch float32
|
|
}
|
|
|
|
func (ret *PlayToServerPacketVehicleMove) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketVehicleMove) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.X)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Y)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Z)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Yaw)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Pitch)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type PlayToServerPacketWindowClick struct {
|
|
WindowId ContainerID
|
|
StateId int32
|
|
Slot int16
|
|
MouseButton int8
|
|
Mode int32
|
|
ChangedSlots []struct {
|
|
Location int16
|
|
Item Slot
|
|
}
|
|
CursorItem Slot
|
|
}
|
|
|
|
func (ret *PlayToServerPacketWindowClick) Decode(r io.ReadSeeker) (err error) {
|
|
err = ret.WindowId.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.StateId, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.MouseButton)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Mode, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var lPlayToServerPacketWindowClickChangedSlots int32
|
|
lPlayToServerPacketWindowClickChangedSlots, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChangedSlots = []struct {
|
|
Location int16
|
|
Item Slot
|
|
}{}
|
|
for range lPlayToServerPacketWindowClickChangedSlots {
|
|
var PlayToServerPacketWindowClickChangedSlotsElement struct {
|
|
Location int16
|
|
Item Slot
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickChangedSlotsElement.Location)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = PlayToServerPacketWindowClickChangedSlotsElement.Item.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChangedSlots = append(ret.ChangedSlots, PlayToServerPacketWindowClickChangedSlotsElement)
|
|
}
|
|
err = ret.CursorItem.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *PlayToServerPacketWindowClick) Encode(w io.Writer) (err error) {
|
|
PlayToServerPacketWindowClickWindowIdEncTmp := ret.WindowId
|
|
err = PlayToServerPacketWindowClickWindowIdEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.StateId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Slot)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.MouseButton)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Mode)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.ChangedSlots)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iPlayToServerPacketWindowClickChangedSlots := range len(ret.ChangedSlots) {
|
|
err = binary.Write(w, binary.BigEndian, ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Location)
|
|
if err != nil {
|
|
return
|
|
}
|
|
PlayToServerPacketWindowClickChangedSlotsInnerItemEncTmp := ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item
|
|
err = PlayToServerPacketWindowClickChangedSlotsInnerItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
PlayToServerPacketWindowClickCursorItemEncTmp := ret.CursorItem
|
|
err = PlayToServerPacketWindowClickCursorItemEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var StatusToClientPacketNameMap = map[int32]string{0x00: "server_info", 0x01: "ping"}
|
|
|
|
func (ret *StatusToClientPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var StatusToClientPacketNameKey int32
|
|
StatusToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(StatusToClientPacketNameMap, StatusToClientPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
var StatusToClientPacketParamsPingTmp StatusToClientPacketPing
|
|
err = StatusToClientPacketParamsPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToClientPacketParamsPingTmp
|
|
case "server_info":
|
|
var StatusToClientPacketParamsServerInfoTmp StatusToClientPacketServerInfo
|
|
err = StatusToClientPacketParamsServerInfoTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToClientPacketParamsServerInfoTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var StatusToClientPacketNameReverseMap = map[string]int32{"server_info": 0x00, "ping": 0x01}
|
|
|
|
func (ret *StatusToClientPacket) Encode(w io.Writer) (err error) {
|
|
var vStatusToClientPacketName int32
|
|
vStatusToClientPacketName, err = proto_base.ErroringIndex(StatusToClientPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vStatusToClientPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToClientPacketParamsEncTmp := StatusToClientPacketParams
|
|
err = StatusToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "server_info":
|
|
StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketServerInfo)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToClientPacketParamsEncTmp := StatusToClientPacketParams
|
|
err = StatusToClientPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *StatusToClientPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var StatusToClientPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if StatusToClientPacketCommonAddResourcePackPromptMessagePresent {
|
|
var StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
StatusToClientPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = StatusToClientPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *StatusToClientPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *StatusToClientPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var StatusToClientPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if StatusToClientPacketCommonCookieResponseValuePresent {
|
|
var StatusToClientPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = StatusToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &StatusToClientPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
StatusToClientPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = StatusToClientPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *StatusToClientPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var StatusToClientPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if StatusToClientPacketCommonRemoveResourcePackUuidPresent {
|
|
var StatusToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, StatusToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &StatusToClientPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *StatusToClientPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lStatusToClientPacketCommonSelectKnownPacksPacks int32
|
|
lStatusToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lStatusToClientPacketCommonSelectKnownPacksPacks {
|
|
var StatusToClientPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
StatusToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
StatusToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
StatusToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, StatusToClientPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iStatusToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *StatusToClientPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *StatusToClientPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
StatusToClientPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = StatusToClientPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *StatusToClientPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketPing struct {
|
|
Time int64
|
|
}
|
|
|
|
func (ret *StatusToClientPacketPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToClientPacketServerInfo struct {
|
|
Response string
|
|
}
|
|
|
|
func (ret *StatusToClientPacketServerInfo) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Response, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToClientPacketServerInfo) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Response)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacket struct {
|
|
Name string
|
|
Params any
|
|
}
|
|
|
|
var StatusToServerPacketNameMap = map[int32]string{0x00: "ping_start", 0x01: "ping"}
|
|
|
|
func (ret *StatusToServerPacket) Decode(r io.ReadSeeker) (err error) {
|
|
var StatusToServerPacketNameKey int32
|
|
StatusToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Name, err = proto_base.ErroringIndex(StatusToServerPacketNameMap, StatusToServerPacketNameKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
var StatusToServerPacketParamsPingTmp StatusToServerPacketPing
|
|
err = StatusToServerPacketParamsPingTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToServerPacketParamsPingTmp
|
|
case "ping_start":
|
|
var StatusToServerPacketParamsPingStartTmp StatusToServerPacketPingStart
|
|
err = StatusToServerPacketParamsPingStartTmp.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Params = StatusToServerPacketParamsPingStartTmp
|
|
}
|
|
return
|
|
}
|
|
|
|
var StatusToServerPacketNameReverseMap = map[string]int32{"ping_start": 0x00, "ping": 0x01}
|
|
|
|
func (ret *StatusToServerPacket) Encode(w io.Writer) (err error) {
|
|
var vStatusToServerPacketName int32
|
|
vStatusToServerPacketName, err = proto_base.ErroringIndex(StatusToServerPacketNameReverseMap, ret.Name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, vStatusToServerPacketName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch ret.Name {
|
|
case "ping":
|
|
StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPing)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToServerPacketParamsEncTmp := StatusToServerPacketParams
|
|
err = StatusToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "ping_start":
|
|
StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPingStart)
|
|
if !ok {
|
|
err = proto_base.BadTypeError
|
|
return
|
|
}
|
|
StatusToServerPacketParamsEncTmp := StatusToServerPacketParams
|
|
err = StatusToServerPacketParamsEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketCommonAddResourcePack struct {
|
|
Uuid uuid.UUID
|
|
Url string
|
|
Hash string
|
|
Forced bool
|
|
PromptMessage *nbt.Anon
|
|
}
|
|
|
|
func (ret *StatusToServerPacketCommonAddResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
_, err = io.ReadFull(r, ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Url, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Hash, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var StatusToServerPacketCommonAddResourcePackPromptMessagePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonAddResourcePackPromptMessagePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if StatusToServerPacketCommonAddResourcePackPromptMessagePresent {
|
|
var StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
|
|
err = StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.PromptMessage = &StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
|
|
_, err = w.Write(ret.Uuid[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Hash)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Forced)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.PromptMessage != nil {
|
|
StatusToServerPacketCommonAddResourcePackPromptMessageEncTmp := *ret.PromptMessage
|
|
err = StatusToServerPacketCommonAddResourcePackPromptMessageEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketCommonCookieRequest struct {
|
|
Cookie string
|
|
}
|
|
|
|
func (ret *StatusToServerPacketCommonCookieRequest) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Cookie, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Cookie)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketCommonCookieResponse struct {
|
|
Key string
|
|
Value *ByteArray
|
|
}
|
|
|
|
func (ret *StatusToServerPacketCommonCookieResponse) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var StatusToServerPacketCommonCookieResponseValuePresent bool
|
|
err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonCookieResponseValuePresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if StatusToServerPacketCommonCookieResponseValuePresent {
|
|
var StatusToServerPacketCommonCookieResponseValuePresentValue ByteArray
|
|
err = StatusToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Value = &StatusToServerPacketCommonCookieResponseValuePresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.Value != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Value != nil {
|
|
StatusToServerPacketCommonCookieResponseValueEncTmp := *ret.Value
|
|
err = StatusToServerPacketCommonCookieResponseValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketCommonRemoveResourcePack struct {
|
|
Uuid *uuid.UUID
|
|
}
|
|
|
|
func (ret *StatusToServerPacketCommonRemoveResourcePack) Decode(r io.ReadSeeker) (err error) {
|
|
var StatusToServerPacketCommonRemoveResourcePackUuidPresent bool
|
|
err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonRemoveResourcePackUuidPresent)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if StatusToServerPacketCommonRemoveResourcePackUuidPresent {
|
|
var StatusToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
|
|
_, err = io.ReadFull(r, StatusToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Uuid = &StatusToServerPacketCommonRemoveResourcePackUuidPresentValue
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if ret.Uuid != nil {
|
|
_, err = w.Write((*ret.Uuid)[:])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketCommonSelectKnownPacks struct {
|
|
Packs []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
}
|
|
|
|
func (ret *StatusToServerPacketCommonSelectKnownPacks) Decode(r io.ReadSeeker) (err error) {
|
|
var lStatusToServerPacketCommonSelectKnownPacksPacks int32
|
|
lStatusToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = []struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}{}
|
|
for range lStatusToServerPacketCommonSelectKnownPacksPacks {
|
|
var StatusToServerPacketCommonSelectKnownPacksPacksElement struct {
|
|
Namespace string
|
|
Id string
|
|
Version string
|
|
}
|
|
StatusToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
StatusToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
StatusToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Packs = append(ret.Packs, StatusToServerPacketCommonSelectKnownPacksPacksElement)
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for iStatusToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
|
|
err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Namespace)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Version)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketCommonSettings struct {
|
|
Locale string
|
|
ViewDistance int8
|
|
ChatFlags int32
|
|
ChatColors bool
|
|
SkinParts uint8
|
|
MainHand int32
|
|
EnableTextFiltering bool
|
|
EnableServerListing bool
|
|
}
|
|
|
|
func (ret *StatusToServerPacketCommonSettings) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Locale, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.ChatFlags, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.MainHand, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Locale)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.ChatFlags)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.ChatColors)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.SkinParts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.MainHand)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketCommonStoreCookie struct {
|
|
Key string
|
|
Value ByteArray
|
|
}
|
|
|
|
func (ret *StatusToServerPacketCommonStoreCookie) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Key, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = ret.Value.Decode(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Key)
|
|
if err != nil {
|
|
return
|
|
}
|
|
StatusToServerPacketCommonStoreCookieValueEncTmp := ret.Value
|
|
err = StatusToServerPacketCommonStoreCookieValueEncTmp.Encode(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketCommonTransfer struct {
|
|
Host string
|
|
Port int32
|
|
}
|
|
|
|
func (ret *StatusToServerPacketCommonTransfer) Decode(r io.ReadSeeker) (err error) {
|
|
ret.Host, err = proto_base.DecodeString(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.Port, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
|
|
err = proto_base.EncodeString(w, ret.Host)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = proto_base.EncodeVarInt(w, ret.Port)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketPing struct {
|
|
Time int64
|
|
}
|
|
|
|
func (ret *StatusToServerPacketPing) Decode(r io.ReadSeeker) (err error) {
|
|
err = binary.Read(r, binary.BigEndian, &ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketPing) Encode(w io.Writer) (err error) {
|
|
err = binary.Write(w, binary.BigEndian, ret.Time)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
type StatusToServerPacketPingStart struct {
|
|
}
|
|
|
|
func (ret *StatusToServerPacketPingStart) Decode(r io.ReadSeeker) (err error) {
|
|
return
|
|
}
|
|
func (ret *StatusToServerPacketPingStart) Encode(w io.Writer) (err error) {
|
|
return
|
|
}
|