yess

.gitignore

@@ -1,2 +1,3 @@
 .devres/
 .idea/
+.failed_packets/

proto/connection.go

@@ -17,7 +17,6 @@ var BadPacketTypeError = errors.New("bad packet type")
 // UnCodablePacket represents a packet that could not be decoded due to proto_generated not supporting all packets.
 type UnCodablePacket struct {
 	Err  error
-	Partial any
 	Data []byte
 }
 
@@ -125,7 +124,7 @@ func (c *Conn) Receive() (packet any, err error) {
 	packetBuff := bytes.NewBuffer(packetBytes)
 	packet, err = proto_generated.DecodePacket(c.Version, c.Actor.ReceiveDirection(), c.State, packetBuff)
 	if err != nil {
-		packet = UnCodablePacket{Err: err, Data: packetBytes, Partial: packet}
+		packet = UnCodablePacket{Err: err, Data: packetBytes}
 		err = nil
 	}
 	return

proto_base/base_types.go

@@ -13,6 +13,21 @@ const (
 	ToClient
 )
 
+func (d Direction) String() string {
+	switch d {
+	case ToServer:
+		return "ToServer"
+	case ToClient:
+		return "ToClient"
+	default:
+		return "Unknown"
+	}
+}
+
+func (d Direction) Opposite() Direction {
+	return d ^ 1
+}
+
 type State int
 
 const (

proto_generated/version_switcher.go

@@ -1,10 +1,9 @@
 package proto_generated
 
 import (
-	"io"
-
 	"github.com/admin-else/strom/proto_base"
 	"github.com/admin-else/strom/proto_generated/v1_21_8"
+	"io"
 )
 
 func PacketIdentifierToType(v string, d proto_base.Direction, s proto_base.State, i string) (t any) {

proto_generator/main.go

@@ -205,6 +205,7 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error {
 		if slices.Contains(g.Settings.ReplaceWithTodoNames, k) {
 			v = "todo"
 		}
+
 		g.Depth = 0
 		e, err := g.VisitType(v)
 		if errors.Is(err, ToDoError) {

proto_generator/native_compare_to.go

@@ -9,7 +9,7 @@ import (
 	"github.com/go-viper/mapstructure/v2"
 )
 
-func ParseCompareTo(g *Generator, compareTo string) (e ast.Expr, err error) {
+func (g *Generator) ParseCompareTo(compareTo string) (e ast.Expr, err error) {
 	parts := strings.Split(compareTo, "/")
 	downPrefixCount := 0
 	for _, part := range parts {

proto_generator/native_decoder.go

@@ -110,6 +110,7 @@ func OptionDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s
 func ArrayDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
 	var data struct {
 		CountType any
+		Count     string
 		Type      any
 	}
 	lName := "l" + CamelCase(name)
@@ -117,14 +118,28 @@ func ArrayDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s
 	if err != nil {
 		return
 	}
-	countType, err := g.VisitType(data.CountType)
+	var s2 []ast.Stmt
+	countType, err := g.VisitNameAndData("varint", nil)
+	if data.CountType != nil {
+		countType, err = g.VisitType(data.CountType)
 		if err != nil {
 			return
 		}
-	s2, err := g.VisitDecoder(Ident(lName), data.CountType, name)
+		s2, err = g.VisitDecoder(Ident(lName), data.CountType, name)
 		if err != nil {
 			return
 		}
+	} else {
+		var n int
+		n, err = strconv.Atoi(data.Count)
+		var e ast.Expr
+		if err == nil {
+			e = NumLit(n)
+		} else {
+			e, err = g.ParseCompareTo(data.Count)
+		}
+		s2 = append(s2, Assign121(Ident(lName), e))
+	}
 
 	normalType, err := g.VisitType(data.Type)
 	if err != nil {
@@ -223,7 +238,7 @@ func SwitchDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s
 	if err != nil {
 		return
 	}
-	compareToExpr, err := ParseCompareTo(g, data.CompareTo)
+	compareToExpr, err := g.ParseCompareTo(data.CompareTo)
 	if err != nil {
 		return
 	}

proto_generator/native_encoder.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"errors"
 	"go/ast"
 	"go/token"
 
@@ -66,20 +65,20 @@ func SimpleTypeEncoder(_ *Generator, data ast.Expr, _ any, _ string) (s []ast.St
 func ArrayEncoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
 	var data struct {
 		CountType any
+		Count     string
 		Type      any
 	}
 	err = mapstructure.Decode(dataRaw, &data)
 	if err != nil {
 		return
 	}
+	if data.CountType == nil {
+		data.CountType = "varint"
+	}
 	ct, err := g.VisitType(data.CountType)
 	if err != nil {
 		return
 	}
-	_, ok := ct.(*ast.Ident)
-	if !ok {
-		err = errors.New("array count type must be simple type otherwise wtf")
-	}
 	iName := "i" + name
 	s, err = g.VisitEncoder(varToSet, data.Type, name)
 	s1, err := g.VisitEncoder(Call(ct, Call(Ident("len"), varToSet)), data.CountType, name)
@@ -174,7 +173,7 @@ func SwitchEncoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s
 	if err != nil {
 		return
 	}
-	compareToExpr, err := ParseCompareTo(g, data.CompareTo)
+	compareToExpr, err := g.ParseCompareTo(data.CompareTo)
 	if err != nil {
 		return
 	}

server/server.go

@@ -51,8 +51,8 @@ func StartServerWithOnConn(listenAddr string, onConn func(c *proto.Conn) (err er
 	if err != nil {
 		return
 	}
-	var cNet net.Conn
 	for {
+		var cNet net.Conn
 		cNet, err = l.Accept()
 		if err != nil {
 			return