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

net/ptypes/chunk.go

@@ -2,8 +2,8 @@
 package ptypes
 
 import (
-	"bytes"
-	"fmt"
+	"io"
+	"math"
 
 	"github.com/Tnze/go-mc/bot/world/entity"
 	"github.com/Tnze/go-mc/nbt"
@@ -17,96 +17,53 @@ type ChunkData struct {
 	PrimaryBitMask pk.VarInt
 	Heightmaps     struct{}
 	Biomes         biomesData
-	Data           chunkData
+	Data           pk.ByteArray
 	BlockEntities  blockEntities
 }
 
-func (p *ChunkData) Decode(pkt pk.Packet) error {
-	r := bytes.NewReader(pkt.Data)
-	if err := p.X.Decode(r); err != nil {
-		return fmt.Errorf("decode X: %v", err)
-	}
-	if err := p.Z.Decode(r); err != nil {
-		return fmt.Errorf("decode Z: %v", err)
-	}
-	if err := p.FullChunk.Decode(r); err != nil {
-		return fmt.Errorf("full chunk: %v", err)
-	}
-	if err := p.PrimaryBitMask.Decode(r); err != nil {
-		return fmt.Errorf("bit mask: %v", err)
-	}
-	if err := (pk.NBT{V: &p.Heightmaps}).Decode(r); err != nil {
-		return fmt.Errorf("heightmaps: %v", err)
-	}
-
-	// Biomes data is only present for full chunks.
-	if p.FullChunk {
-		if err := p.Biomes.Decode(r); err != nil {
-			return fmt.Errorf("heightmaps: %v", err)
-		}
-	}
-
-	if err := p.Data.Decode(r); err != nil {
-		return fmt.Errorf("data: %v", err)
-	}
-	if err := p.BlockEntities.Decode(r); err != nil {
-		return fmt.Errorf("block entities: %v", err)
-	}
-	return nil
+func (p *ChunkData) ReadFrom(r io.Reader) (int64, error) {
+	return pk.Tuple{
+		&p.X,
+		&p.Z,
+		&p.FullChunk,
+		&p.PrimaryBitMask,
+		&pk.NBT{V: &p.Heightmaps},
+		pk.Opt{Has: &p.FullChunk, Field: &p.Biomes},
+		&p.Data,
+		&p.BlockEntities,
+	}.ReadFrom(r)
 }
 
 type biomesData struct {
 	data []pk.VarInt
 }
 
-func (b *biomesData) Decode(r pk.DecodeReader) error {
-	var BiomesDataNums pk.VarInt // Number of Biomes Data
-	if err := BiomesDataNums.Decode(r); err != nil {
-		return err
-	}
-	b.data = make([]pk.VarInt, BiomesDataNums)
-
-	for i := 0; i < int(BiomesDataNums); i++ {
-		var d pk.VarInt
-		if err := d.Decode(r); err != nil {
-			return err
-		}
-		b.data[i] = d
-	}
-
-	return nil
+func (b *biomesData) ReadFrom(r io.Reader) (int64, error) {
+	var n pk.VarInt // Number of Biomes Data
+	return pk.Tuple{
+		&n, pk.Ary{Len: &n, Ary: []pk.VarInt{}},
+	}.ReadFrom(r)
 }
 
-type chunkData []byte
 type blockEntities []entity.BlockEntity
 
 // Decode implement net.packet.FieldDecoder
-func (c *chunkData) Decode(r pk.DecodeReader) error {
-	var sz pk.VarInt
-	if err := sz.Decode(r); err != nil {
-		return err
-	}
-	*c = make([]byte, sz)
-	if _, err := r.Read(*c); err != nil {
-		return err
-	}
-	return nil
-}
-
-// Decode implement net.packet.FieldDecoder
-func (b *blockEntities) Decode(r pk.DecodeReader) error {
+func (b *blockEntities) ReadFrom(r io.Reader) (n int64, err error) {
 	var sz pk.VarInt // Number of BlockEntities
-	if err := sz.Decode(r); err != nil {
-		return err
+	if nn, err := sz.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
 	}
 	*b = make(blockEntities, sz)
-	decoder := nbt.NewDecoder(r)
+	lr := &io.LimitedReader{R: r, N: math.MaxInt64}
+	d := nbt.NewDecoder(lr)
 	for i := 0; i < int(sz); i++ {
-		if err := decoder.Decode(&(*b)[i]); err != nil {
-			return err
+		if err := d.Decode(&(*b)[i]); err != nil {
+			return math.MaxInt64 - lr.N, err
 		}
 	}
-	return nil
+	return math.MaxInt64 - lr.N, nil
 }
 
 // TileEntityData describes a change to a tile entity.
@@ -116,13 +73,10 @@ type TileEntityData struct {
 	Data   entity.BlockEntity
 }
 
-func (p *TileEntityData) Decode(pkt pk.Packet) error {
-	r := bytes.NewReader(pkt.Data)
-	if err := p.Pos.Decode(r); err != nil {
-		return fmt.Errorf("position: %v", err)
-	}
-	if err := p.Action.Decode(r); err != nil {
-		return fmt.Errorf("action: %v", err)
-	}
-	return nbt.NewDecoder(r).Decode(&p.Data)
+func (p *TileEntityData) ReadFrom(r io.Reader) (int64, error) {
+	return pk.Tuple{
+		&p.Pos,
+		&p.Action,
+		&pk.NBT{V: &p.Data},
+	}.ReadFrom(r)
 }