Fix other code for compatible with new go-mc/net packet

bot/world/chunk.go

@@ -3,6 +3,7 @@ package world
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"math"
 
 	"github.com/Tnze/go-mc/data/block"
@@ -41,13 +42,13 @@ func perBits(bpb byte) uint {
 	}
 }
 
-func readSection(data pk.DecodeReader) (s Section, err error) {
+func readSection(data io.Reader) (s Section, err error) {
 	var nonAirBlockCount pk.Short
-	if err := nonAirBlockCount.Decode(data); err != nil {
+	if _, err := nonAirBlockCount.ReadFrom(data); err != nil {
 		return nil, fmt.Errorf("block count: %w", err)
 	}
 	var bpb pk.UnsignedByte
-	if err := bpb.Decode(data); err != nil {
+	if _, err := bpb.ReadFrom(data); err != nil {
 		return nil, fmt.Errorf("bits per block: %w", err)
 	}
 	// If bpb values greater than or equal to 9, use directSection.
@@ -57,14 +58,14 @@ func readSection(data pk.DecodeReader) (s Section, err error) {
 	if bpb <= maxPaletteBits {
 		// read palettes
 		var length pk.VarInt
-		if err := length.Decode(data); err != nil {
+		if _, err := length.ReadFrom(data); err != nil {
 			return nil, fmt.Errorf("palette length: %w", err)
 		}
 		palettes = make([]BlockStatus, length)
 		palettesIndex = make(map[BlockStatus]int, length)
 		for i := 0; i < int(length); i++ {
 			var v pk.VarInt
-			if err := v.Decode(data); err != nil {
+			if _, err := v.ReadFrom(data); err != nil {
 				return nil, fmt.Errorf("read palettes[%d] error: %w", i, err)
 			}
 			palettes[i] = BlockStatus(v)
@@ -74,7 +75,7 @@ func readSection(data pk.DecodeReader) (s Section, err error) {
 
 	// read data array
 	var dataLen pk.VarInt
-	if err := dataLen.Decode(data); err != nil {
+	if _, err := dataLen.ReadFrom(data); err != nil {
 		return nil, fmt.Errorf("read data array length error: %w", err)
 	}
 	if int(dataLen) < 16*16*16*int(bpb)/64 {
@@ -83,7 +84,7 @@ func readSection(data pk.DecodeReader) (s Section, err error) {
 	dataArray := make([]uint64, dataLen)
 	for i := 0; i < int(dataLen); i++ {
 		var v pk.Long
-		if err := v.Decode(data); err != nil {
+		if _, err := v.ReadFrom(data); err != nil {
 			return nil, fmt.Errorf("read dataArray[%d] error: %w", i, err)
 		}
 		dataArray[i] = uint64(v)

bot/world/entity/entity.go

@@ -1,11 +1,10 @@
 package entity
 
 import (
-	"bytes"
+	"io"
 
 	"github.com/Tnze/go-mc/data/entity"
 	item "github.com/Tnze/go-mc/data/item"
-	"github.com/Tnze/go-mc/nbt"
 	pk "github.com/Tnze/go-mc/net/packet"
 	"github.com/google/uuid"
 )
@@ -49,53 +48,48 @@ type Slot struct {
 	Present bool
 	ItemID  item.ID
 	Count   int8
-	NBT     interface{}
+	NBT     pk.NBT
+}
+
+type SlotNBT struct {
+	data interface{}
 }
 
 //Decode implement packet.FieldDecoder interface
-func (s *Slot) Decode(r pk.DecodeReader) error {
-	if err := (*pk.Boolean)(&s.Present).Decode(r); err != nil {
-		return err
+func (s *Slot) ReadFrom(r io.Reader) (int64, error) {
+	var itemID pk.VarInt
+	n, err := pk.Tuple{
+		(*pk.Boolean)(&s.Present),
+		pk.Opt{
+			Has: (*pk.Boolean)(&s.Present),
+			Field: pk.Tuple{
+				&itemID,
+				(*pk.Byte)(&s.Count),
+				&s.NBT,
+			},
+		},
+	}.ReadFrom(r)
+	if err != nil {
+		return n, err
 	}
-	if s.Present {
-		var itemID pk.VarInt
-		if err := itemID.Decode(r); err != nil {
-			return err
-		}
-		s.ItemID = item.ID(itemID)
-		if err := (*pk.Byte)(&s.Count).Decode(r); err != nil {
-			return err
-		}
-		if err := nbt.NewDecoder(r).Decode(&s.NBT); err != nil {
-			return err
-		}
-	}
-	return nil
+	s.ItemID = item.ID(itemID)
+	return n, nil
 }
 
-func (s Slot) Encode() []byte {
-	if !s.Present {
-		return pk.Boolean(false).Encode()
-	}
-
-	var b bytes.Buffer
-	b.Write(pk.Boolean(true).Encode())
-	b.Write(pk.VarInt(s.ItemID).Encode())
-	b.Write(pk.Byte(s.Count).Encode())
-
-	if s.NBT != nil {
-		if err := nbt.NewEncoder(&b).Encode(s.NBT); err != nil {
-			panic(err)
-		}
-	} else {
-		if _, err := b.Write([]byte{nbt.TagEnd}); err != nil {
-			panic(err)
-		}
-	}
-
-	return b.Bytes()
+func (s Slot) WriteTo(w io.Writer) (int64, error) {
+	return pk.Tuple{
+		pk.Boolean(s.Present),
+		pk.Opt{
+			Has: (*pk.Boolean)(&s.Present),
+			Field: pk.Tuple{
+				pk.VarInt(s.ItemID),
+				pk.Byte(s.Count),
+				s.NBT,
+			},
+		},
+	}.WriteTo(w)
 }
 
 func (s Slot) String() string {
-	return item.ByID[item.ID(s.ItemID)].DisplayName
+	return item.ByID[s.ItemID].DisplayName
 }