refactor package

pkg/protocol/slot/codecs.go

@@ -0,0 +1,163 @@
+// Code generated by github.com/go-mc/packetizer; DO NOT EDIT.
+
+package slot
+
+import (
+	"errors"
+	"io"
+
+	"github.com/Tnze/go-mc/net/packet"
+)
+
+func (c *AddedHashedComponent) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (*packet.VarInt)(&c.Type).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (*packet.Int)(&c.DataHash).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c AddedHashedComponent) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (*packet.VarInt)(&c.Type).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (*packet.Int)(&c.DataHash).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *HashedSlot) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (*packet.Boolean)(&c.HasItem).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	if c.HasItem {
+		temp, err = (*packet.VarInt)(&c.ItemID).ReadFrom(r)
+		n += temp
+		if err != nil {
+			return n, err
+		}
+	}
+	if c.HasItem {
+		temp, err = (*packet.VarInt)(&c.ItemCount).ReadFrom(r)
+		n += temp
+		if err != nil {
+			return n, err
+		}
+	}
+	if c.HasItem {
+		temp, err = (&c.AddComponents).ReadFrom(r)
+		n += temp
+		if err != nil {
+			return n, err
+		}
+	}
+	if c.HasItem {
+		temp, err = (*Int32VarIntVarIntArray)(&c.RemovedComponents).ReadFrom(r)
+		n += temp
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, err
+}
+
+func (c HashedSlot) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (*packet.Boolean)(&c.HasItem).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	if c.HasItem {
+		temp, err = (*packet.VarInt)(&c.ItemID).WriteTo(w)
+		n += temp
+		if err != nil {
+			return n, err
+		}
+	}
+	if c.HasItem {
+		temp, err = (*packet.VarInt)(&c.ItemCount).WriteTo(w)
+		n += temp
+		if err != nil {
+			return n, err
+		}
+	}
+	if c.HasItem {
+		temp, err = (&c.AddComponents).WriteTo(w)
+		n += temp
+		if err != nil {
+			return n, err
+		}
+	}
+	if c.HasItem {
+		temp, err = (*Int32VarIntVarIntArray)(&c.RemovedComponents).WriteTo(w)
+		n += temp
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, err
+}
+
+// Int32VarIntVarIntArray a utility type for encoding/decoding packet.VarInt -> int32[packet.VarInt] slice.
+type Int32VarIntVarIntArray []int32
+
+func (a Int32VarIntVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	nn, err := packet.VarInt(size).WriteTo(w)
+	if err != nil {
+		return n, err
+	}
+	n += nn
+	for i := 0; i < size; i++ {
+		nn, err := packet.VarInt(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *Int32VarIntVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	nn, err := size.ReadFrom(r)
+	n += nn
+	if err != nil {
+		return n, err
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	if cap(*a) >= int(size) {
+		*a = (*a)[:int(size)]
+	} else {
+		*a = make(Int32VarIntVarIntArray, int(size))
+	}
+
+	for i := 0; i < int(size); i++ {
+		nn, err = (*packet.VarInt)(&(*a)[i]).ReadFrom(r)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+
+	return n, err
+}

pkg/protocol/slot/component.go

@@ -0,0 +1,23 @@
+package slot
+
+import pk "github.com/Tnze/go-mc/net/packet"
+
+type Component interface {
+	Type() ComponentID
+	ID() string
+
+	pk.Field
+}
+
+type ComponentID int32
+type componentCreator func() Component
+
+var components = make(map[ComponentID]componentCreator)
+
+func ComponentFromID(id ComponentID) Component {
+	return components[id]()
+}
+
+func RegisterComponent(c componentCreator) {
+	components[c().Type()] = c
+}

pkg/protocol/slot/display/recipe/codecs.go

@@ -0,0 +1,275 @@
+// Code generated by github.com/go-mc/packetizer; DO NOT EDIT.
+
+package recipe
+
+import (
+	"io"
+
+	"github.com/Tnze/go-mc/net/packet"
+)
+
+func (c *Shapeless) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = packet.Array(&c.Ingredients).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c Shapeless) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = packet.Array(&c.Ingredients).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *Shaped) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (*packet.VarInt)(&c.Width).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (*packet.VarInt)(&c.Height).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = packet.Array(&c.Ingredients).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c Shaped) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (*packet.VarInt)(&c.Width).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (*packet.VarInt)(&c.Height).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = packet.Array(&c.Ingredients).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *Furnace) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Ingredient).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Fuel).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (*packet.VarInt)(&c.CookingTime).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (*packet.Float)(&c.Experience).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c Furnace) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Ingredient).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Fuel).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (*packet.VarInt)(&c.CookingTime).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (*packet.Float)(&c.Experience).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *Stonecutter) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Ingredient).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c Stonecutter) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Ingredient).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *Smithing) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Template).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Base).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Addition).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c Smithing) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Template).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Base).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Addition).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Result).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.CraftingStation).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}

pkg/protocol/slot/display/recipe/recipe_display.go

@@ -0,0 +1,118 @@
+package recipe
+
+import (
+	"io"
+
+	"git.konjactw.dev/patyhank/minego/codec/slot/display/slot"
+	pk "github.com/Tnze/go-mc/net/packet"
+)
+
+type DisplayType int32
+
+const (
+	DisplayCraftingShapeless DisplayType = 0 + iota
+	DisplayCraftingShaped
+	DisplayFurnace
+	DisplayStonecutter
+	DisplaySmithing
+)
+
+type Display struct {
+	Display RecipeDisplay
+}
+
+func (d Display) WriteTo(w io.Writer) (n int64, err error) {
+	pk.VarInt(d.Display.RecipeType()).WriteTo(w)
+	return d.Display.WriteTo(w)
+}
+
+func (d *Display) ReadFrom(r io.Reader) (n int64, err error) {
+	var displayType DisplayType
+	_, err = (*pk.VarInt)(&displayType).ReadFrom(r)
+	if err != nil {
+		return
+	}
+	switch displayType {
+	case DisplayCraftingShapeless:
+		d.Display = new(Shapeless)
+	case DisplayCraftingShaped:
+		d.Display = new(Shaped)
+	case DisplayFurnace:
+		d.Display = new(Furnace)
+	case DisplayStonecutter:
+		d.Display = new(Stonecutter)
+	case DisplaySmithing:
+		d.Display = new(Smithing)
+	}
+	if d.Display != nil {
+		return d.Display.ReadFrom(r)
+	}
+	return
+}
+
+type RecipeDisplay interface {
+	RecipeType() DisplayType
+	pk.Field
+}
+
+//codec:gen
+type Shapeless struct {
+	Ingredients     []slot.Display
+	Result          slot.Display
+	CraftingStation slot.Display
+}
+
+func (i Shapeless) RecipeType() DisplayType {
+	return DisplayCraftingShapeless
+}
+
+//codec:gen
+type Shaped struct {
+	Width           int32 `mc:"VarInt"`
+	Height          int32 `mc:"VarInt"`
+	Ingredients     []slot.Display
+	Result          slot.Display
+	CraftingStation slot.Display
+}
+
+func (i Shaped) RecipeType() DisplayType {
+	return DisplayCraftingShaped
+}
+
+//codec:gen
+type Furnace struct {
+	Ingredient      slot.Display
+	Fuel            slot.Display
+	Result          slot.Display
+	CraftingStation slot.Display
+	CookingTime     int32 `mc:"VarInt"`
+	Experience      float32
+}
+
+func (i Furnace) RecipeType() DisplayType {
+	return DisplayFurnace
+}
+
+//codec:gen
+type Stonecutter struct {
+	Ingredient      slot.Display
+	Result          slot.Display
+	CraftingStation slot.Display
+}
+
+func (i Stonecutter) RecipeType() DisplayType {
+	return DisplayStonecutter
+}
+
+//codec:gen
+type Smithing struct {
+	Template        slot.Display
+	Base            slot.Display
+	Addition        slot.Display
+	Result          slot.Display
+	CraftingStation slot.Display
+}
+
+func (i Smithing) RecipeType() DisplayType {
+	return DisplaySmithing
+}

pkg/protocol/slot/display/slot/codecs.go

@@ -0,0 +1,154 @@
+// Code generated by github.com/go-mc/packetizer; DO NOT EDIT.
+
+package slot
+
+import (
+	"io"
+
+	"github.com/Tnze/go-mc/net/packet"
+)
+
+func (c *Item) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (*packet.VarInt)(&c.ID).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c Item) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (*packet.VarInt)(&c.ID).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *ItemStack) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.ItemStack).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c ItemStack) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.ItemStack).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *Tag) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Tag).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c Tag) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Tag).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *SmithingTrim) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Base).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Trim).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Remainder).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c SmithingTrim) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Base).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Trim).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Remainder).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *WithRemainder) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Ingredient).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Remainder).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c WithRemainder) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = (&c.Ingredient).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	temp, err = (&c.Remainder).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+func (c *Composite) ReadFrom(r io.Reader) (n int64, err error) {
+	var temp int64
+	temp, err = packet.Array(&c.Displays).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}
+
+func (c Composite) WriteTo(w io.Writer) (n int64, err error) {
+	var temp int64
+	temp, err = packet.Array(&c.Displays).WriteTo(w)
+	n += temp
+	if err != nil {
+		return n, err
+	}
+	return n, err
+}

pkg/protocol/slot/display/slot/slot_display.go

@@ -0,0 +1,135 @@
+package slot
+
+import (
+	"io"
+
+	"git.konjactw.dev/patyhank/minego/pkg/protocol/slot"
+	pk "github.com/Tnze/go-mc/net/packet"
+)
+
+type DisplayType int32
+
+const (
+	DisplayEmpty DisplayType = iota
+	DisplayItem
+	DisplayItemStack
+	DisplayTag
+	DisplaySmithingTrim
+	DisplayWithRemainder
+	DisplayComposite
+)
+
+type Display struct {
+	SlotDisplay
+}
+
+func (s Display) WriteTo(w io.Writer) (n int64, err error) {
+	pk.VarInt(s.SlotDisplay.SlotDisplayType()).WriteTo(w)
+	s.SlotDisplay.WriteTo(w)
+	return
+}
+
+func (s *Display) ReadFrom(r io.Reader) (n int64, err error) {
+	var displayType DisplayType
+	_, err = (*pk.VarInt)(&displayType).ReadFrom(r)
+	if err != nil {
+		return
+	}
+	switch displayType {
+	case DisplayEmpty:
+		return
+	case DisplayItem:
+		var item Item
+		if _, err = item.ReadFrom(r); err != nil {
+			return
+		}
+	case DisplayItemStack:
+		var itemStack ItemStack
+		if _, err = itemStack.ReadFrom(r); err != nil {
+			return
+		}
+	case DisplayTag:
+		var tag Tag
+		if _, err = tag.ReadFrom(r); err != nil {
+			return
+		}
+	case DisplaySmithingTrim:
+		var trim SmithingTrim
+		if _, err = trim.ReadFrom(r); err != nil {
+			return
+		}
+	case DisplayWithRemainder:
+		var remainder WithRemainder
+		if _, err = remainder.ReadFrom(r); err != nil {
+			return
+		}
+	case DisplayComposite:
+		var composite Composite
+		if _, err = composite.ReadFrom(r); err != nil {
+			return
+		}
+	}
+	return
+}
+
+type SlotDisplay interface {
+	SlotDisplayType() DisplayType
+	pk.Field
+}
+
+//codec:gen
+type Item struct {
+	ID int32 `mc:"VarInt"`
+}
+
+func (i Item) SlotDisplayType() DisplayType {
+	return DisplayItem
+}
+
+//codec:gen
+type ItemStack struct {
+	ItemStack slot.Slot
+}
+
+func (i ItemStack) SlotDisplayType() DisplayType {
+	return DisplayItemStack
+}
+
+//codec:gen
+type Tag struct {
+	Tag pk.Identifier
+}
+
+func (i Tag) SlotDisplayType() DisplayType {
+	return DisplayTag
+}
+
+//codec:gen
+type SmithingTrim struct {
+	Base      Display
+	Trim      Display
+	Remainder Display
+}
+
+func (i SmithingTrim) SlotDisplayType() DisplayType {
+	return DisplaySmithingTrim
+}
+
+//codec:gen
+type WithRemainder struct {
+	Ingredient Display
+	Remainder  Display
+}
+
+func (i WithRemainder) SlotDisplayType() DisplayType {
+	return DisplayWithRemainder
+}
+
+//codec:gen
+type Composite struct {
+	Displays []Display
+}
+
+func (i Composite) SlotDisplayType() DisplayType {
+	return DisplayComposite
+}

pkg/protocol/slot/hashed_item.go

@@ -0,0 +1,20 @@
+package slot
+
+//codec:gen
+type AddedHashedComponent struct {
+	Type     int32 `mc:"VarInt"`
+	DataHash int32
+}
+
+//codec:gen
+type HashedSlot struct {
+	HasItem bool
+	//opt:optional:HasItem
+	ItemID int32 `mc:"VarInt"`
+	//opt:optional:HasItem
+	ItemCount int32 `mc:"VarInt"`
+	//opt:optional:HasItem
+	AddComponents AddedHashedComponent
+	//opt:optional:HasItem
+	RemovedComponents []int32 `mc:"VarInt"`
+}

pkg/protocol/slot/item_stack.go

@@ -0,0 +1,111 @@
+package slot
+
+import (
+	"io"
+
+	pk "github.com/Tnze/go-mc/net/packet"
+)
+
+type Slot struct {
+	Count           int32
+	ItemID          int32
+	AddComponent    []Component
+	RemoveComponent []ComponentID
+}
+
+func (s *Slot) WriteTo(w io.Writer) (n int64, err error) {
+	temp, err := pk.VarInt(s.Count).WriteTo(w)
+	if s.Count <= 0 || err != nil {
+		return temp, err
+	}
+	n += temp
+	temp, err = pk.VarInt(s.ItemID).WriteTo(w)
+	n += temp
+	if err != nil {
+		return temp, err
+	}
+
+	temp, err = pk.VarInt(len(s.AddComponent)).WriteTo(w)
+	n += temp
+	if err != nil {
+		return temp, err
+	}
+	for _, c := range s.AddComponent {
+		temp, err = pk.VarInt(c.Type()).WriteTo(w)
+		n += temp
+		if err != nil {
+			return temp, err
+		}
+		temp, err = c.WriteTo(w)
+		n += temp
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	temp, err = pk.VarInt(len(s.RemoveComponent)).WriteTo(w)
+	n += temp
+	if err != nil {
+		return temp, err
+	}
+	for _, id := range s.RemoveComponent {
+		temp, err = pk.VarInt(id).WriteTo(w)
+		n += temp
+		if err != nil {
+			return temp, err
+		}
+	}
+	return temp, nil
+}
+
+func (s *Slot) ReadFrom(r io.Reader) (n int64, err error) {
+	temp, err := (*pk.VarInt)(&s.Count).ReadFrom(r)
+	if s.Count <= 0 || err != nil {
+		return temp, err
+	}
+	n += temp
+	temp, err = (*pk.VarInt)(&s.ItemID).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return temp, err
+	}
+
+	addLens := int32(0)
+	temp, err = (*pk.VarInt)(&addLens).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return temp, err
+	}
+	var id int32
+	for i := int32(0); i < addLens; i++ {
+		temp, err = (*pk.VarInt)(&id).ReadFrom(r)
+		n += temp
+		if err != nil {
+			return temp, err
+		}
+		c := ComponentFromID(ComponentID(id))
+
+		temp, err = c.ReadFrom(r)
+		n += temp
+		if err != nil {
+			return temp, err
+		}
+	}
+
+	removeLens := int32(0)
+	temp, err = (*pk.VarInt)(&removeLens).ReadFrom(r)
+	n += temp
+	if err != nil {
+		return temp, err
+	}
+
+	for i := int32(0); i < removeLens; i++ {
+		temp, err = (*pk.VarInt)(&id).ReadFrom(r)
+		n += temp
+		if err != nil {
+			return temp, err
+		}
+	}
+
+	return n, nil
+}

pkg/protocol/slot/trade_item.go

@@ -0,0 +1,41 @@
+package slot
+
+import (
+	"io"
+
+	pk "github.com/Tnze/go-mc/net/packet"
+)
+
+type TradeSlot struct {
+	ID         int32
+	Count      int32
+	Components []Component
+}
+
+func (t TradeSlot) WriteTo(w io.Writer) (n int64, err error) {
+	pk.VarInt(t.ID).WriteTo(w)
+	pk.VarInt(t.Count).WriteTo(w)
+	pk.VarInt(len(t.Components)).WriteTo(w)
+	for _, component := range t.Components {
+		pk.VarInt(component.Type()).WriteTo(w)
+		component.WriteTo(w)
+	}
+	return
+}
+
+func (t *TradeSlot) ReadFrom(r io.Reader) (n int64, err error) {
+	(*pk.VarInt)(&t.ID).ReadFrom(r)
+	(*pk.VarInt)(&t.Count).ReadFrom(r)
+	var lens pk.VarInt
+	lens.ReadFrom(r)
+	t.Components = make([]Component, lens)
+	for i := range t.Components {
+		var id pk.VarInt
+		id.ReadFrom(r)
+		c := ComponentFromID(ComponentID(id))
+		c.ReadFrom(r)
+		t.Components[i] = c
+	}
+
+	return
+}