codecs update

CLAUDE.md

@@ -1,114 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-MinEGO is a Go-based Minecraft protocol implementation that generates packet codecs and data components for Minecraft Java Edition protocol version 1.21.6 (protocol 771). The project uses code generation to create serialization/deserialization code for Minecraft network packets and item components.
-
-## Architecture
-
-The project follows a modular architecture centered around code generation:
-
-- **`codec/data/component/`** - Contains Go structs for all Minecraft item components (e.g., damage, enchantments, custom_name). Each component implements the `slot.Component` interface with Type() and ID() methods.
-- **`codec/data/packet/game/`** - Contains client and server packet definitions following the Minecraft protocol specification
-- **`codec/data/slot/`** - Core slot/item stack implementation and component registration system
-- **`net/`** - Network layer implementation (currently empty)
-- **Protocol Reference** - `codec/data/packet/protocol.wiki` contains the complete Minecraft protocol specification from wiki.vg
-
-## Code Generation System
-
-The project uses a custom code generator called `packetizer` that processes Go structs marked with `//codec:gen` comments. This generates the necessary ReadFrom/WriteTo methods for network serialization.
-
-Key patterns:
-- Structs marked with `//codec:gen` will have codecs auto-generated
-- Structs marked with `//codec:ignore` are excluded from generation
-- Components must implement `Type() slot.ComponentID` and `ID() string` methods
-- Components are registered in `codec/data/component/components.go` using `slot.RegisterComponent()`
-
-## Development Commands
-
-### Code Generation
-```bash
-# Generate packet codecs (run from project root)
-./gen-packet.sh
-# This runs: packetizer ./codec
-```
-
-### Standard Go Commands
-```bash
-# Build the project
-go build
-
-# Run tests (if any exist)
-go test ./...
-
-# Format code
-go fmt ./...
-
-# Get dependencies
-go mod tidy
-```
-
-## Dependencies
-
-- **github.com/Tnze/go-mc** - Core Minecraft protocol library (uses forked version)
-- **packetizer** - Custom code generation tool (available at /root/go/bin/packetizer)
-
-## Working with Components
-
-When adding new Minecraft item components:
-1. Create the struct in `codec/data/component/` following existing patterns
-2. Add `//codec:gen` comment above the struct
-3. Implement `Type()` and `ID()` methods with correct component ID and namespace
-4. Register the component in `components.go` init() function
-5. Run `./gen-packet.sh` to generate codecs
-
-## Working with Packets
-
-When adding new packet types:
-1. Define the packet struct in appropriate `client/` or `server/` directory
-2. Add `//codec:gen` comment for auto-generation
-3. Register the packet in the appropriate packets map
-4. Run `./gen-packet.sh` to generate codecs
-
-## Module Path
-
-The project uses `git.konjactw.dev/patyhank/minego` as its module path and includes a replace directive for the go-mc dependency pointing to a custom fork.
-
-## Code Generation Tasks
-
-- **Java to Go Packet Conversion**: 
-  * Task to implement Game State packets by converting Java code from `~/GoProjects/mc-network-source/network/protocol/game` to Go structs
-  * Focus on maintaining the same read/write logic during translation
-  * Ensure packet structures match the original Java implementation
-  * Use packetizer for automatic codec generation
-
-## Reference Notes
-
-- PacketID Reference:
-  * In `/root/go/pkg/mod/git.konjactw.dev/patyhank/go-mc@v1.20.3-0.20250618004758-a3d57fde34e8/data/packetid/packetid.go`, you can find all packet IDs (excluding handshake stage)
-
-## Packet Serialization Techniques
-
-- 對於Optional封包資料 簡易的格式可以使用pk.Option[XXX,*XXX] 的方法 比較複雜的需要自己實作一個ReadFrom&WriteTo 並且移除codec:gen的標記
-
-### Example
-
-```go
-// ExampleTypeFull full example for codec generator
-//
-//codec:gen
-type ExampleTypeFull struct {
-	PlayerID         int32 `mc:"VarInt"`
-	PlayerName       string
-	UUID             uuid.UUID      `mc:"UUID"`
-	ResourceLocation string         `mc:"Identifier"`
-	Data             nbt.RawMessage `mc:"NBT"`
-	ByteData         []byte         `mc:"ByteArray"`
-	Health           float32
-	Balance          float64
-	Message          chat.Message
-	SentMessages     []chat.Message
-}
-```

codec/component/codecs.go

@@ -3602,50 +3602,6 @@ func (c WrittenBookPage) WriteTo(w io.Writer) (n int64, err error) {
 	return n, err
 }
 
-// Int32VarIntArray a utility type for encoding/decoding packet.Int -> int32[packet.VarInt] slice.
-type Int32VarIntArray []int32
-
-func (a Int32VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
-	size := len(a)
-	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
-		return n, err
-	} else {
-		n += nn
-	}
-	for i := 0; i < size; i++ {
-		nn, err := packet.Int(a[i]).WriteTo(w)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-	}
-	return n, nil
-}
-
-func (a *Int32VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
-	var size packet.VarInt
-	if nn, err := size.ReadFrom(r); err != nil {
-		return nn, err
-	} else {
-		n += nn
-	}
-	if size < 0 {
-		return n, errors.New("array length less than zero")
-	}
-
-	for i := 0; i < int(size); i++ {
-		var elem packet.Int
-		if nn, err := elem.ReadFrom(r); err != nil {
-			return n, err
-		} else {
-			n += nn
-		}
-		*a = append(*a, int32(elem))
-	}
-
-	return n, err
-}
-
 // Int32PrefixedArrayVarIntArray a utility type for encoding/decoding packet.Int -> int32[packet.VarInt] slice.
 type Int32PrefixedArrayVarIntArray []int32
 
@@ -3690,6 +3646,50 @@ func (a *Int32PrefixedArrayVarIntArray) ReadFrom(r io.Reader) (n int64, err erro
 	return n, err
 }
 
+// Float32VarIntArray a utility type for encoding/decoding packet.Float -> float32[packet.VarInt] slice.
+type Float32VarIntArray []float32
+
+func (a Float32VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
+		return n, err
+	} else {
+		n += nn
+	}
+	for i := 0; i < size; i++ {
+		nn, err := packet.Float(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *Float32VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	if nn, err := size.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	for i := 0; i < int(size); i++ {
+		var elem packet.Float
+		if nn, err := elem.ReadFrom(r); err != nil {
+			return n, err
+		} else {
+			n += nn
+		}
+		*a = append(*a, float32(elem))
+	}
+
+	return n, err
+}
+
 // BoolVarIntArray a utility type for encoding/decoding packet.Boolean -> bool[packet.VarInt] slice.
 type BoolVarIntArray []bool
 
@@ -3822,10 +3822,10 @@ func (a *Int32VarIntVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
 	return n, err
 }
 
-// Float32VarIntArray a utility type for encoding/decoding packet.Float -> float32[packet.VarInt] slice.
-type Float32VarIntArray []float32
+// Int32VarIntArray a utility type for encoding/decoding packet.Int -> int32[packet.VarInt] slice.
+type Int32VarIntArray []int32
 
-func (a Float32VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+func (a Int32VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
 	size := len(a)
 	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
 		return n, err
@@ -3833,7 +3833,7 @@ func (a Float32VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
 		n += nn
 	}
 	for i := 0; i < size; i++ {
-		nn, err := packet.Float(a[i]).WriteTo(w)
+		nn, err := packet.Int(a[i]).WriteTo(w)
 		n += nn
 		if err != nil {
 			return n, err
@@ -3842,7 +3842,7 @@ func (a Float32VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
 	return n, nil
 }
 
-func (a *Float32VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+func (a *Int32VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
 	var size packet.VarInt
 	if nn, err := size.ReadFrom(r); err != nil {
 		return nn, err
@@ -3854,13 +3854,13 @@ func (a *Float32VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
 	}
 
 	for i := 0; i < int(size); i++ {
-		var elem packet.Float
+		var elem packet.Int
 		if nn, err := elem.ReadFrom(r); err != nil {
 			return n, err
 		} else {
 			n += nn
 		}
-		*a = append(*a, float32(elem))
+		*a = append(*a, int32(elem))
 	}
 
 	return n, err

codec/packet/configuration/client/codecs.go

@@ -343,50 +343,6 @@ func (c ConfigUpdateEnabledFeatures) WriteTo(w io.Writer) (n int64, err error) {
 	return n, err
 }
 
-// Int8VarIntArray a utility type for encoding/decoding packet.Byte -> int8[packet.VarInt] slice.
-type Int8VarIntArray []int8
-
-func (a Int8VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
-	size := len(a)
-	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
-		return n, err
-	} else {
-		n += nn
-	}
-	for i := 0; i < size; i++ {
-		nn, err := packet.Byte(a[i]).WriteTo(w)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-	}
-	return n, nil
-}
-
-func (a *Int8VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
-	var size packet.VarInt
-	if nn, err := size.ReadFrom(r); err != nil {
-		return nn, err
-	} else {
-		n += nn
-	}
-	if size < 0 {
-		return n, errors.New("array length less than zero")
-	}
-
-	for i := 0; i < int(size); i++ {
-		var elem packet.Byte
-		if nn, err := elem.ReadFrom(r); err != nil {
-			return n, err
-		} else {
-			n += nn
-		}
-		*a = append(*a, int8(elem))
-	}
-
-	return n, err
-}
-
 // StringIdentifierVarIntArray a utility type for encoding/decoding packet.Identifier -> string[packet.VarInt] slice.
 type StringIdentifierVarIntArray []string
 
@@ -430,3 +386,47 @@ func (a *StringIdentifierVarIntArray) ReadFrom(r io.Reader) (n int64, err error)
 
 	return n, err
 }
+
+// Int8VarIntArray a utility type for encoding/decoding packet.Byte -> int8[packet.VarInt] slice.
+type Int8VarIntArray []int8
+
+func (a Int8VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
+		return n, err
+	} else {
+		n += nn
+	}
+	for i := 0; i < size; i++ {
+		nn, err := packet.Byte(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *Int8VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	if nn, err := size.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	for i := 0; i < int(size); i++ {
+		var elem packet.Byte
+		if nn, err := elem.ReadFrom(r); err != nil {
+			return n, err
+		} else {
+			n += nn
+		}
+		*a = append(*a, int8(elem))
+	}
+
+	return n, err
+}

codec/packet/game/client/codecs.go

@@ -7157,138 +7157,6 @@ func (c Waypoint) WriteTo(w io.Writer) (n int64, err error) {
 	return n, err
 }
 
-// Int8VarIntArray a utility type for encoding/decoding packet.Byte -> int8[packet.VarInt] slice.
-type Int8VarIntArray []int8
-
-func (a Int8VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
-	size := len(a)
-	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
-		return n, err
-	} else {
-		n += nn
-	}
-	for i := 0; i < size; i++ {
-		nn, err := packet.Byte(a[i]).WriteTo(w)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-	}
-	return n, nil
-}
-
-func (a *Int8VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
-	var size packet.VarInt
-	if nn, err := size.ReadFrom(r); err != nil {
-		return nn, err
-	} else {
-		n += nn
-	}
-	if size < 0 {
-		return n, errors.New("array length less than zero")
-	}
-
-	for i := 0; i < int(size); i++ {
-		var elem packet.Byte
-		if nn, err := elem.ReadFrom(r); err != nil {
-			return n, err
-		} else {
-			n += nn
-		}
-		*a = append(*a, int8(elem))
-	}
-
-	return n, err
-}
-
-// StringVarIntArray a utility type for encoding/decoding packet.String -> string[packet.VarInt] slice.
-type StringVarIntArray []string
-
-func (a StringVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
-	size := len(a)
-	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
-		return n, err
-	} else {
-		n += nn
-	}
-	for i := 0; i < size; i++ {
-		nn, err := packet.String(a[i]).WriteTo(w)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-	}
-	return n, nil
-}
-
-func (a *StringVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
-	var size packet.VarInt
-	if nn, err := size.ReadFrom(r); err != nil {
-		return nn, err
-	} else {
-		n += nn
-	}
-	if size < 0 {
-		return n, errors.New("array length less than zero")
-	}
-
-	for i := 0; i < int(size); i++ {
-		var elem packet.String
-		if nn, err := elem.ReadFrom(r); err != nil {
-			return n, err
-		} else {
-			n += nn
-		}
-		*a = append(*a, string(elem))
-	}
-
-	return n, err
-}
-
-// StringIdentifierVarIntArray a utility type for encoding/decoding packet.Identifier -> string[packet.VarInt] slice.
-type StringIdentifierVarIntArray []string
-
-func (a StringIdentifierVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
-	size := len(a)
-	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
-		return n, err
-	} else {
-		n += nn
-	}
-	for i := 0; i < size; i++ {
-		nn, err := packet.Identifier(a[i]).WriteTo(w)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-	}
-	return n, nil
-}
-
-func (a *StringIdentifierVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
-	var size packet.VarInt
-	if nn, err := size.ReadFrom(r); err != nil {
-		return nn, err
-	} else {
-		n += nn
-	}
-	if size < 0 {
-		return n, errors.New("array length less than zero")
-	}
-
-	for i := 0; i < int(size); i++ {
-		var elem packet.Identifier
-		if nn, err := elem.ReadFrom(r); err != nil {
-			return n, err
-		} else {
-			n += nn
-		}
-		*a = append(*a, string(elem))
-	}
-
-	return n, err
-}
-
 // Int32VarIntVarIntArray a utility type for encoding/decoding packet.VarInt -> int32[packet.VarInt] slice.
 type Int32VarIntVarIntArray []int32
 
@@ -7333,138 +7201,6 @@ func (a *Int32VarIntVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
 	return n, err
 }
 
-// Int8ByteVarIntArray a utility type for encoding/decoding packet.Byte -> int8[packet.VarInt] slice.
-type Int8ByteVarIntArray []int8
-
-func (a Int8ByteVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
-	size := len(a)
-	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
-		return n, err
-	} else {
-		n += nn
-	}
-	for i := 0; i < size; i++ {
-		nn, err := packet.Byte(a[i]).WriteTo(w)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-	}
-	return n, nil
-}
-
-func (a *Int8ByteVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
-	var size packet.VarInt
-	if nn, err := size.ReadFrom(r); err != nil {
-		return nn, err
-	} else {
-		n += nn
-	}
-	if size < 0 {
-		return n, errors.New("array length less than zero")
-	}
-
-	for i := 0; i < int(size); i++ {
-		var elem packet.Byte
-		if nn, err := elem.ReadFrom(r); err != nil {
-			return n, err
-		} else {
-			n += nn
-		}
-		*a = append(*a, int8(elem))
-	}
-
-	return n, err
-}
-
-// Int64VarIntArray a utility type for encoding/decoding packet.Long -> int64[packet.VarInt] slice.
-type Int64VarIntArray []int64
-
-func (a Int64VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
-	size := len(a)
-	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
-		return n, err
-	} else {
-		n += nn
-	}
-	for i := 0; i < size; i++ {
-		nn, err := packet.Long(a[i]).WriteTo(w)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-	}
-	return n, nil
-}
-
-func (a *Int64VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
-	var size packet.VarInt
-	if nn, err := size.ReadFrom(r); err != nil {
-		return nn, err
-	} else {
-		n += nn
-	}
-	if size < 0 {
-		return n, errors.New("array length less than zero")
-	}
-
-	for i := 0; i < int(size); i++ {
-		var elem packet.Long
-		if nn, err := elem.ReadFrom(r); err != nil {
-			return n, err
-		} else {
-			n += nn
-		}
-		*a = append(*a, int64(elem))
-	}
-
-	return n, err
-}
-
-// UuidUUIDUUIDVarIntArray a utility type for encoding/decoding packet.UUID -> uuid.UUID[packet.VarInt] slice.
-type UuidUUIDUUIDVarIntArray []uuid.UUID
-
-func (a UuidUUIDUUIDVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
-	size := len(a)
-	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
-		return n, err
-	} else {
-		n += nn
-	}
-	for i := 0; i < size; i++ {
-		nn, err := packet.UUID(a[i]).WriteTo(w)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-	}
-	return n, nil
-}
-
-func (a *UuidUUIDUUIDVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
-	var size packet.VarInt
-	if nn, err := size.ReadFrom(r); err != nil {
-		return nn, err
-	} else {
-		n += nn
-	}
-	if size < 0 {
-		return n, errors.New("array length less than zero")
-	}
-
-	for i := 0; i < int(size); i++ {
-		var elem packet.UUID
-		if nn, err := elem.ReadFrom(r); err != nil {
-			return n, err
-		} else {
-			n += nn
-		}
-		*a = append(*a, uuid.UUID(elem))
-	}
-
-	return n, err
-}
-
 // Int64VarLongVarIntArray a utility type for encoding/decoding packet.VarLong -> int64[packet.VarInt] slice.
 type Int64VarLongVarIntArray []int64
 
@@ -7552,3 +7288,267 @@ func (a *StringStringVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
 
 	return n, err
 }
+
+// StringVarIntArray a utility type for encoding/decoding packet.String -> string[packet.VarInt] slice.
+type StringVarIntArray []string
+
+func (a StringVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
+		return n, err
+	} else {
+		n += nn
+	}
+	for i := 0; i < size; i++ {
+		nn, err := packet.String(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *StringVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	if nn, err := size.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	for i := 0; i < int(size); i++ {
+		var elem packet.String
+		if nn, err := elem.ReadFrom(r); err != nil {
+			return n, err
+		} else {
+			n += nn
+		}
+		*a = append(*a, string(elem))
+	}
+
+	return n, err
+}
+
+// Int8ByteVarIntArray a utility type for encoding/decoding packet.Byte -> int8[packet.VarInt] slice.
+type Int8ByteVarIntArray []int8
+
+func (a Int8ByteVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
+		return n, err
+	} else {
+		n += nn
+	}
+	for i := 0; i < size; i++ {
+		nn, err := packet.Byte(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *Int8ByteVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	if nn, err := size.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	for i := 0; i < int(size); i++ {
+		var elem packet.Byte
+		if nn, err := elem.ReadFrom(r); err != nil {
+			return n, err
+		} else {
+			n += nn
+		}
+		*a = append(*a, int8(elem))
+	}
+
+	return n, err
+}
+
+// Int8VarIntArray a utility type for encoding/decoding packet.Byte -> int8[packet.VarInt] slice.
+type Int8VarIntArray []int8
+
+func (a Int8VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
+		return n, err
+	} else {
+		n += nn
+	}
+	for i := 0; i < size; i++ {
+		nn, err := packet.Byte(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *Int8VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	if nn, err := size.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	for i := 0; i < int(size); i++ {
+		var elem packet.Byte
+		if nn, err := elem.ReadFrom(r); err != nil {
+			return n, err
+		} else {
+			n += nn
+		}
+		*a = append(*a, int8(elem))
+	}
+
+	return n, err
+}
+
+// Int64VarIntArray a utility type for encoding/decoding packet.Long -> int64[packet.VarInt] slice.
+type Int64VarIntArray []int64
+
+func (a Int64VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
+		return n, err
+	} else {
+		n += nn
+	}
+	for i := 0; i < size; i++ {
+		nn, err := packet.Long(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *Int64VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	if nn, err := size.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	for i := 0; i < int(size); i++ {
+		var elem packet.Long
+		if nn, err := elem.ReadFrom(r); err != nil {
+			return n, err
+		} else {
+			n += nn
+		}
+		*a = append(*a, int64(elem))
+	}
+
+	return n, err
+}
+
+// StringIdentifierVarIntArray a utility type for encoding/decoding packet.Identifier -> string[packet.VarInt] slice.
+type StringIdentifierVarIntArray []string
+
+func (a StringIdentifierVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
+		return n, err
+	} else {
+		n += nn
+	}
+	for i := 0; i < size; i++ {
+		nn, err := packet.Identifier(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *StringIdentifierVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	if nn, err := size.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	for i := 0; i < int(size); i++ {
+		var elem packet.Identifier
+		if nn, err := elem.ReadFrom(r); err != nil {
+			return n, err
+		} else {
+			n += nn
+		}
+		*a = append(*a, string(elem))
+	}
+
+	return n, err
+}
+
+// UuidUUIDUUIDVarIntArray a utility type for encoding/decoding packet.UUID -> uuid.UUID[packet.VarInt] slice.
+type UuidUUIDUUIDVarIntArray []uuid.UUID
+
+func (a UuidUUIDUUIDVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
+	size := len(a)
+	if nn, err := packet.VarInt(size).WriteTo(w); err != nil {
+		return n, err
+	} else {
+		n += nn
+	}
+	for i := 0; i < size; i++ {
+		nn, err := packet.UUID(a[i]).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (a *UuidUUIDUUIDVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
+	var size packet.VarInt
+	if nn, err := size.ReadFrom(r); err != nil {
+		return nn, err
+	} else {
+		n += nn
+	}
+	if size < 0 {
+		return n, errors.New("array length less than zero")
+	}
+
+	for i := 0; i < int(size); i++ {
+		var elem packet.UUID
+		if nn, err := elem.ReadFrom(r); err != nil {
+			return n, err
+		} else {
+			n += nn
+		}
+		*a = append(*a, uuid.UUID(elem))
+	}
+
+	return n, err
+}

codec/packet/game/server/set_structure_block.go

@@ -17,7 +17,7 @@ type SetStructureBlock struct {
 	Rotation                  int32 `mc:"VarInt"`
 	Metadata                  string
 	Integrity                 float32
-	Seed                      int32 `mc:"VarLong"`
+	Seed                      int64 `mc:"VarLong"`
 	Flags                     int8
 }