add EntityMetadataLoop handling

proto_generator/native_decoder.go

@@ -561,6 +561,57 @@ func VoidDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s [
 	return
 }
 
+func EntityMetadataLoopDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
+	var data protodef.EntityMetadataLoop
+	err = mapstructure.Decode(dataRaw, &data)
+	if err != nil {
+		return
+	}
+
+	innerType, err := g.VisitType(data.Type)
+	if err != nil {
+		return
+	}
+
+	assignVts := Assign121(varToSet, Call(Ident("make"), MapType(Ident("uint8"), innerType)))
+	idVar := VarStmt("id", Ident("uint8"))
+
+	decodeIdStatements, err := g.VisitDecoder(Ident("id"), "u8", name)
+	endCheck := If(Equals(Ident("id"), NumLit(data.EndVal)), NewBlockEllipsis(Break()))
+	declEntry := VarStmt("entry", innerType)
+	decodingEntryStmts, err := g.VisitDecoder(Ident("entry"), data.Type, name+"Inner")
+	if err != nil {
+		return
+	}
+	assignEntry := Assign121(Index(varToSet, Ident("id")), Ident("entry"))
+
+	var loopStmts []ast.Stmt
+	loopStmts = append(loopStmts, decodeIdStatements...)
+	loopStmts = append(loopStmts, endCheck)
+	loopStmts = append(loopStmts, declEntry)
+	loopStmts = append(loopStmts, decodingEntryStmts...)
+	loopStmts = append(loopStmts, assignEntry)
+
+	s = Stmts(assignVts, idVar, ForStmt(nil, nil, nil, NewBlock(loopStmts)))
+	/*
+		vts = make(map[uint8]{{data.type}})
+		var id uint8
+		for  {
+			err = binary.Read(r, binary.BigEndian, &id)
+			if err != nil {
+				return
+			}
+			if id == {{data.EndId}} {
+				return
+			}
+			var data {{type(data.type)}}
+			{{unpack(data.type)}}
+			vts[id] = data
+		}
+	*/
+	return
+}
+
 func (g *Generator) RegisterDecoderNatives() {
 	g.DecoderNatives = map[string]FunctionGeneratorFunc{
 		"container": ContainerDecoder,
@@ -596,7 +647,7 @@ func (g *Generator) RegisterDecoderNatives() {
 
 		"registryEntryHolder":      RegistryEntryHolderDecoder,
 		"registryEntryHolderSet":   ToDoDecoder, // RegistryEntryHolderSetDecoder
-		"entityMetadataLoop":       ToDoDecoder,
+		"entityMetadataLoop":       EntityMetadataLoopDecoder,
 		"topBitSetTerminatedArray": ToDoDecoder,
 		"todo":                     ToDoDecoder,
 	}

proto_generator/native_encoder.go

@@ -356,6 +356,46 @@ func VoidEncoder(_ *Generator, _ ast.Expr, _ any, _ string) (s []ast.Stmt, err e
 	return
 }
 
+func EntityMetadataLoopEncoder(g *Generator, vts ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
+	var data protodef.EntityMetadataLoop
+	err = mapstructure.Decode(dataRaw, &data)
+	if err != nil {
+		return
+	}
+
+	/*
+		for k, v := range vts.Val {
+			WriteU8(w, uint8(k))
+			WriteData(w, v)
+		}
+		WriteU8(w, 0xFF)
+	*/
+
+	encodeid, err := g.VisitEncoder(Ident("k"), "u8", name)
+	if err != nil {
+		return
+	}
+	encodeV, err := g.VisitEncoder(Ident("v"), data.Type, name)
+	if err != nil {
+		return
+	}
+	var innerstmts []ast.Stmt
+	innerstmts = append(innerstmts, encodeid...)
+	innerstmts = append(innerstmts, encodeV...)
+
+	forStmt := ForRangeKV(Ident("k"), Ident("v"), vts, NewBlock(innerstmts))
+
+	encodeEndId, err := g.VisitEncoder(Call(Ident("uint8"), NumLit(data.EndVal)), "u8", name)
+	if err != nil {
+		return
+	}
+
+	s = append(s, forStmt)
+	s = append(s, encodeEndId...)
+
+	return
+}
+
 func (g *Generator) RegisterEncoderNatives() {
 	g.EncoderNatives = map[string]FunctionGeneratorFunc{
 		"container": ContainerEncoder,
@@ -391,7 +431,7 @@ func (g *Generator) RegisterEncoderNatives() {
 
 		"registryEntryHolder":      RegistryEntryHolderEncoder,
 		"registryEntryHolderSet":   ToDoEncoder,
-		"entityMetadataLoop":       ToDoEncoder,
+		"entityMetadataLoop":       EntityMetadataLoopEncoder,
 		"topBitSetTerminatedArray": ToDoEncoder,
 		"todo":                     ToDoEncoder,
 	}

proto_generator/native_type.go

@@ -175,6 +175,20 @@ func VoidType(_ *Generator, _ any) (e ast.Expr, err error) {
 	return
 }
 
+func EntityMetadataLoopType(g *Generator, v any) (e ast.Expr, err error) {
+	var data protodef.EntityMetadataLoop
+	err = mapstructure.Decode(v, &data)
+	if err != nil {
+		return
+	}
+	innerType, err := g.VisitType(data.Type)
+	if err != nil {
+		return
+	}
+	e = MapType(Ident("byte"), innerType)
+	return
+}
+
 func (g *Generator) RegisterNatives() {
 	g.Natives = map[string]ExprGeneratorFunc{
 		"container":                VisitContainerType,
@@ -200,7 +214,7 @@ func (g *Generator) RegisterNatives() {
 		"f64":                      MakeIdentVisitor("float64"),
 		"registryEntryHolder":      MakeIdentVisitor("any"), // Go really fucking needs good tagged unions
 		"registryEntryHolderSet":   MakeIdentVisitor("any"),
-		"entityMetadataLoop":       VisitToDoType,
+		"entityMetadataLoop":       EntityMetadataLoopType,
 		"option":                   VisitOptionType,
 		"switch":                   MakeIdentVisitor("any"),
 		"UUID":                     MakeSelectorVisitor("uuid", "UUID"),

proto_generator/printer.go

@@ -329,6 +329,12 @@ func NewBlockEllipsis(statements ...ast.Stmt) *ast.BlockStmt {
 	}
 }
 
+func Break() *ast.BranchStmt {
+	return &ast.BranchStmt{
+		Tok: token.BREAK,
+	}
+}
+
 //func MergeBlocks(blocks ...*ast.BlockStmt) *ast.BlockStmt {
 //	list := make([]ast.Stmt, 0)
 //	for _, block := range blocks {
@@ -382,7 +388,16 @@ func ForRange(K, X ast.Expr, block *ast.BlockStmt) *ast.RangeStmt {
 		Tok:   token.DEFINE, // ":=" token
 		Body:  block,
 	}
+}
 
+func ForRangeKV(K, V, X ast.Expr, block *ast.BlockStmt) *ast.RangeStmt {
+	return &ast.RangeStmt{
+		Key:   K,
+		Value: V,
+		X:     X,
+		Tok:   token.DEFINE,
+		Body:  block,
+	}
 }
 
 func Index(X, I ast.Expr) *ast.IndexExpr {
@@ -525,3 +540,12 @@ func Grouping(e ast.Expr) *ast.ParenExpr {
 		X: e,
 	}
 }
+
+func ForStmt(init ast.Stmt, cond ast.Expr, post ast.Stmt, body *ast.BlockStmt) *ast.ForStmt {
+	return &ast.ForStmt{
+		Init: init,
+		Cond: cond,
+		Post: post,
+		Body: body,
+	}
+}

proto_generator/protodef/types.go

@@ -64,4 +64,9 @@ type (
 		Flags []string
 		Type  any
 	}
+
+	EntityMetadataLoop struct {
+		EndVal int
+		Type   any
+	}
 )