stuff

client/config_ignorer.go

@@ -1,4 +1,4 @@
-package modules
+package client
 
 import (
 	"errors"

client/login.go

@@ -1,4 +1,4 @@
-package modules
+package client
 
 import (
 	"crypto/rand"
@@ -11,7 +11,6 @@ import (
 	"strconv"
 
 	"github.com/admin-else/strom/api"
-	"github.com/admin-else/strom/client"
 	"github.com/admin-else/strom/crypto"
 	"github.com/admin-else/strom/event"
 	"github.com/admin-else/strom/proto"
@@ -157,7 +156,7 @@ func Login(c *proto.Conn, account *api.Account) (err error) {
 }
 
 func ConnectAndLogin(connectTo string, account *api.Account) (c *proto.Conn, err error) {
-	c, err = client.Connect(connectTo)
+	c, err = Connect(connectTo)
 	if err != nil {
 		return
 	}

client/status.go

@@ -1,4 +1,4 @@
-package modules
+package client
 
 import (
 	"fmt"

client/timer.go

@@ -1,6 +1,9 @@
-package modules
+package client
 
-import "time"
+import (
+	"slices"
+	"time"
+)
 
 type IntervalTask struct {
 	F           func() error
@@ -33,18 +36,15 @@ func (t *Timer) Tick() (err error) {
 		}
 		t.Interval[i] = task
 	}
-	var triggerLater []OnceTask
-	for _, task := range t.Once {
+	for i, task := range t.Once {
 		if task.Trigger.After(time.Now()) {
 			err = task.F()
 			if err != nil {
 				return
 			}
-		} else {
-			triggerLater = append(triggerLater, task)
+			slices.Delete(t.Once, i, i)
 		}
 	}
-	t.Once = triggerLater
 	return
 }
 

data/registry.go

@@ -0,0 +1,20 @@
+package data
+
+import (
+	"embed"
+
+	"github.com/admin-else/strom/nbt"
+)
+
+//go:embed registry/*
+var Registry embed.FS
+
+func LoadRegistry(name string) (n *nbt.Tag, err error) {
+	r, err := Registry.Open("registry/" + name + ".nbt")
+	if err != nil {
+		return
+	}
+	defer r.Close()
+	n, err = nbt.ReadFile(r)
+	return
+}

level/packet.go

@@ -60,7 +60,7 @@ func UnpackSingleValuePalette(r io.Reader, numberOfEntries int) (data []int32, e
 	}
 	data = make([]int32, numberOfEntries)
 	for i := range data {
-		data[i] = int32(entry)
+		data[i] = entry
 	}
 	return
 }

nbt/file.go

@@ -7,21 +7,18 @@ import (
 
 func WriteFile(file io.Writer, n Tag) (err error) {
 	gzw := gzip.NewWriter(file)
-	if err != nil {
-		return
-	}
 	defer gzw.Close()
 	err = n.Encode(gzw)
 	return
 }
 
-func ReadFile(file io.Reader) (err error, n Tag) {
+func ReadFile(file io.Reader) (n *Tag, err error) {
 	r, err := gzip.NewReader(file)
 	if err != nil {
 		return
 	}
 	defer r.Close()
-	t := &Tag{}
-	err = t.Decode(r)
+	n = &Tag{}
+	err = n.Decode(r)
 	return
 }

proto/connection.go

@@ -67,7 +67,7 @@ func (c *Conn) SetVersion(version string) (err error) {
 }
 
 func (c *Conn) Send(packet proto_base.EncodeDecodeAble) (err error) {
-	//fmt.Println("send:", packet)
+	slog.Debug("send", "actor", c.Actor, "packet", fmt.Sprintf("%#v", packet))
 	switch packet := packet.(type) {
 	case *UnCodablePacket:
 		err = c.SendRaw(packet.Data)
@@ -124,7 +124,7 @@ func (c *Conn) OnTick(_ event.Tick) (err error) {
 	if err != nil {
 		return
 	}
-	slog.Debug("packet", "actor", c.Actor, "packet", fmt.Sprintf("%#v", packet))
+	slog.Debug("receive", "actor", c.Actor, "packet", fmt.Sprintf("%#v", packet))
 	err = c.Loop.Fire(packet)
 	return
 }

proto/testdata/fuzz/FuzzConn/08307d8a6eaaaf56

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\x05\x000000")

proto/testdata/fuzz/FuzzConn/582528ddfad69eb5

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0")

proto/testdata/fuzz/FuzzConn/8727b16d337d7b81

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("00")

proto/testdata/fuzz/FuzzConn/998444ddd2dfb8f1

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\x040000")

proto/testdata/fuzz/FuzzConn/a08445a85261adfb

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\x0400000")

proto/testdata/fuzz/FuzzConn/e31fe72d9d1b54f1

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\x86\x00000000")

proto/testdata/fuzz/FuzzPlayPackets/d276c59373082446

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("80\x00\x01\x05\x01\x010\x01\x00")

proto_base/base_types.go

@@ -6,6 +6,10 @@ import (
 	"io"
 )
 
+var (
+	UnimplementedErr = errors.New("unimplemented")
+)
+
 type Direction int
 
 const (
@@ -218,6 +222,29 @@ type EncodeDecodeAble interface {
 	Decode(r io.Reader) (err error)
 }
 
+type LpVec3d struct {
+	X, Y, Z float64
+}
+
+func (v LpVec3d) Encode(w io.Writer) (err error) {
+	err = UnimplementedErr
+	return
+}
+
+func (v LpVec3d) Decode(r io.Reader) (err error) {
+	err = UnimplementedErr
+	return
+}
+
+type Void struct{}
+
+func (v Void) Encode(w io.Writer) (err error) {
+	return
+}
+func (v Void) Decode(r io.Reader) (err error) {
+	return
+}
+
 type PacketInfo struct {
 	Type            EncodeDecodeAble
 	Name            string

proto_generator/helper_generator.go

@@ -15,6 +15,7 @@ type TypesInfo struct {
 
 type PacketInfo struct {
 	TName, Name, Direction, State, PacketId, ProtocolVersion, MinecraftVersion string
+	PacketDef                                                                  any
 }
 
 func GeneratePacketInfoFile(versions []string, packetInfos []PacketInfo) (err error) {
@@ -31,10 +32,8 @@ func GeneratePacketInfoFile(versions []string, packetInfos []PacketInfo) (err er
 		vUnderscore := "v" + strings.ReplaceAll(p.MinecraftVersion, ".", "_")
 		typeName := p.TName
 		var typeExpr ast.Expr
-		if typeName == "struct{}" {
-			typeExpr = &ast.StructType{Fields: &ast.FieldList{}}
-		} else if strings.HasPrefix(typeName, "proto_base.") {
-			typeExpr = Selector("proto_base", strings.TrimPrefix(typeName, "proto_base."))
+		if p.PacketDef == "void" {
+			typeExpr = Selector("proto_base", "Void")
 		} else {
 			typeExpr = Selector(vUnderscore, typeName)
 		}
@@ -46,7 +45,7 @@ func GeneratePacketInfoFile(versions []string, packetInfos []PacketInfo) (err er
 			KeyValueExpr(Ident("Type"), AddrOf(CompLit(typeExpr, nil))),
 			KeyValueExpr(Ident("Name"), StrLit(p.Name)),
 			KeyValueExpr(Ident("Direction"), Selector("proto_base", p.Direction)),
-			KeyValueExpr(Ident("state"), Selector("proto_base", p.State)),
+			KeyValueExpr(Ident("State"), Selector("proto_base", p.State)),
 			KeyValueExpr(Ident("PacketId"), NumLit(int(packetId))),
 			KeyValueExpr(Ident("ProtocolVersion"), NumLit(protocolVersion)),
 		}))

proto_generator/main.go

@@ -293,6 +293,7 @@ func (g *Generator) GenerateProtocol(protocol Protocol, version string) (err err
 				v2 := v2.(string)
 				typeName := prefix + CamelCase(v2)
 				g.packetInfos = append(g.packetInfos, PacketInfo{
+					PacketDef:        v2,
 					TName:            typeName,
 					Name:             k2,
 					Direction:        types.Direction,
@@ -378,7 +379,7 @@ func GenerateVersions(versions []string) (err error) {
 }
 
 func main() {
-	err := GenerateVersions([]string{"1.21.8"})
+	err := GenerateVersions([]string{"1.21.8", "1.21.9", "1.21.11"})
 	if err != nil {
 		panic(err)
 	}

proto_generator/native_decoder.go

@@ -532,6 +532,7 @@ func (g *Generator) RegisterDecoderNatives() {
 		"varlong":         VarLongDecoder,
 		"anonymousNbt":    DefaultDecoder,
 		"anonOptionalNbt": DefaultDecoder, // I have no idea what the difference is between these two
+		"lpVec3":          DefaultDecoder,
 		"UUID":            UUIDDecoder,
 		"restBuffer":      DefaultDecoder,
 

proto_generator/native_encoder.go

@@ -359,6 +359,7 @@ func (g *Generator) RegisterEncoderNatives() {
 		"anonOptionalNbt": DefaultEncoder, // I have no idea what the difference is between these two
 		"UUID":            UUIDEncoder,
 		"restBuffer":      DefaultEncoder,
+		"lpVec3":          DefaultEncoder,
 		"string":          StringEncoder,
 
 		"f32":  SimpleTypeEncoder,

proto_generator/native_type.go

@@ -194,5 +194,6 @@ func (g *Generator) RegisterNatives() {
 		"bitflags":                 VisitBitFlagsType,
 		"topBitSetTerminatedArray": VisitToDoType,
 		"todo":                     VisitToDoType,
+		"lpVec3":                   MakeSelectorVisitor("proto_base", "LpVec3d"),
 	}
 }

server/config_server.go

@@ -0,0 +1,80 @@
+package server
+
+import (
+	"fmt"
+	"log/slog"
+
+	"github.com/admin-else/strom/data"
+	"github.com/admin-else/strom/event"
+	"github.com/admin-else/strom/nbt"
+	"github.com/admin-else/strom/proto"
+	"github.com/admin-else/strom/proto_base"
+	"github.com/admin-else/strom/proto_generated/v1_21_8"
+)
+
+type ConfigServer struct {
+	*proto.Conn
+}
+
+func (c *ConfigServer) Default(event event.Anything) (err error) {
+	slog.Debug("Config server", "packet", fmt.Sprintf("%#v", event.Val))
+	return
+}
+
+func (c *ConfigServer) OnStart(_ event.OnStart) (err error) {
+	n, err := data.LoadRegistry(c.Version)
+	if err != nil {
+		return
+	}
+	for _, p := range n.Value.(map[string]any)["Registries"].([]any) {
+		packet := &v1_21_8.ConfigurationToClientPacketRegistryData{Id: p.(map[string]any)["Id"].(string)}
+		for _, entry := range p.(map[string]any)["Entries"].([]any) {
+			entryTyped := entry.(map[string]any)
+			packet.Entries = append(packet.Entries, struct {
+				Key   string
+				Value *nbt.Anon
+			}{entryTyped["TagType"].(string), &nbt.Anon{Value: entryTyped["Value"]}})
+		}
+		err = c.Send(packet)
+		if err != nil {
+			return
+		}
+	}
+	tagsPacket := &v1_21_8.ConfigurationToClientPacketTags{}
+	for _, p := range n.Value.(map[string]any)["Tags"].([]any) {
+		p := p.(map[string]any)
+		tags := v1_21_8.Tags{}
+		for _, entry := range p["Entries"].([]any) {
+			entry := entry.(map[string]any)
+			tags.Val = append(tags.Val, struct {
+				TagName string
+				Entries []int32
+			}{
+				TagName: entry["TagName"].(string),
+				Entries: entry["Entries"].([]int32),
+			})
+		}
+		tagsPacket.Tags = append(tagsPacket.Tags, struct {
+			TagType string
+			Tags    v1_21_8.Tags
+		}{TagType: p["TagType"].(string), Tags: tags})
+	}
+	err = c.Send(tagsPacket)
+	if err != nil {
+		return
+	}
+	err = c.Send(&v1_21_8.ConfigurationToClientPacketFinishConfiguration{})
+	return
+}
+
+func (c *ConfigServer) OnFinishConfiguration(_ *v1_21_8.ConfigurationToServerPacketFinishConfiguration) (err error) {
+	c.SetState(proto_base.Play)
+	err = event.HandlerDoneErr{}
+	return
+}
+
+func ServeConfig(c *proto.Conn) (err error) {
+	cs := &ConfigServer{c}
+	err = cs.Start(cs)
+	return
+}

tools/print_nbt/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"os"
+
+	"github.com/admin-else/strom/nbt"
+)
+
+var (
+	FileFlag = flag.String("file", "", "The NBT file to print")
+)
+
+func mainE() (err error) {
+	flag.Parse()
+	f, err := os.Open(*FileFlag)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	n, err := nbt.ReadFile(f)
+	if err != nil {
+		return
+	}
+	b, err := json.MarshalIndent(n, "", "  ")
+	if err != nil {
+		return
+	}
+	_, err = os.Stdout.Write(b)
+	return
+}
+
+func main() {
+	err := mainE()
+	if err != nil {
+		panic(err)
+	}
+}

tools/registry_data_hunter/main.go

@@ -3,14 +3,14 @@ package main
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"log/slog"
+	"os"
 
 	"github.com/admin-else/strom/api"
 	"github.com/admin-else/strom/client"
-	"github.com/admin-else/strom/client/modules"
 	"github.com/admin-else/strom/data"
 	"github.com/admin-else/strom/event"
+	"github.com/admin-else/strom/nbt"
 	"github.com/admin-else/strom/proto"
 	"github.com/admin-else/strom/proto_base"
 	"github.com/admin-else/strom/proto_generated/v1_21_8"
@@ -26,7 +26,12 @@ func wontFail[T any](v T, err error) T {
 }
 
 var (
-	CompatibleProtocolVersion = wontFail(data.LookUpVersionByName("1.21.8")).Version
+	// Edit these two
+
+	SaveAs  = "1.21.8"
+	Version = "1.21.8"
+
+	CompatibleProtocolVersion = wontFail(data.LookUpVersionByName(Version)).Version
 	FinishedConfigErr         = errors.New("finished configuration")
 )
 
@@ -40,6 +45,7 @@ var Status = wontFail(json.Marshal(server.StatusResponse{
 
 type Proxy struct {
 	Client, Servee *proto.Conn
+	Data           nbt.Tag
 }
 
 func (p *Proxy) OnAnything(e event.Anything) (err error) {
@@ -51,7 +57,6 @@ func (p *Proxy) OnAnything(e event.Anything) (err error) {
 	if !ok {
 		return
 	}
-	slog.Debug("packet", "type", packetInfo.Name, "packet", fmt.Sprintf("%#v", packet))
 	switch packetInfo.Direction {
 	case proto_base.ToServer:
 		err = p.Client.Send(packet)
@@ -61,12 +66,32 @@ func (p *Proxy) OnAnything(e event.Anything) (err error) {
 	return
 }
 
-func (p *Proxy) OnFinishConfiguration(_ *v1_21_8.ConfigurationToServerPacketFinishConfiguration) (err error) {
+func (p *Proxy) OnFinishConfiguration(_ *v1_21_8.ConfigurationToClientPacketFinishConfiguration) (err error) {
 	err = FinishedConfigErr
 	return
 }
 
 func (p *Proxy) OnData(data *v1_21_8.ConfigurationToClientPacketRegistryData) (err error) {
+	d := p.Data.Value.(map[string]any)["Registries"].([]any)
+	var entries []any
+	for _, entry := range data.Entries {
+		entries = append(entries, map[string]any{"TagType": entry.Key, "Value": entry.Value.Value})
+	}
+	d = append(d, map[string]any{"Id": data.Id, "Entries": entries})
+	p.Data.Value.(map[string]any)["Registries"] = d
+	return
+}
+
+func (p *Proxy) OnTags(data *v1_21_8.ConfigurationToClientPacketTags) (err error) {
+	var tags []any
+	for _, tag := range data.Tags {
+		var entries []any
+		for _, entry := range tag.Tags.Val {
+			entries = append(entries, map[string]any{"TagName": entry.TagName, "Entries": entry.Entries})
+		}
+		tags = append(tags, map[string]any{"TagType": tag.TagType, "Entries": entries})
+	}
+	p.Data.Value.(map[string]any)["Tags"] = tags
 	return
 }
 
@@ -83,7 +108,7 @@ func handleClient(c *proto.Conn) (err error) {
 		return
 	}
 	defer sockPuppet.Close()
-	err = sockPuppet.Start(&modules.LoginClient{
+	err = sockPuppet.Start(&client.LoginClient{
 		Conn:    sockPuppet,
 		Account: acc,
 	})
@@ -92,6 +117,7 @@ func handleClient(c *proto.Conn) (err error) {
 	}
 	errChan := make(chan error)
 	p := &Proxy{Client: sockPuppet, Servee: c}
+	p.Data.Value = map[string]any{"Registries": []any{}}
 	go func() {
 		errChan <- p.Client.Start(p)
 	}()
@@ -99,6 +125,12 @@ func handleClient(c *proto.Conn) (err error) {
 		errChan <- p.Servee.Start(p)
 	}()
 	err = <-errChan
+	f, err := os.Create("data/registry/" + SaveAs + ".nbt")
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	err = nbt.WriteFile(f, p.Data)
 	return
 }
 

tools/uncodeable_packet_hunter_proxy/main.go

@@ -1,4 +1,3 @@
-// THIS THING IS BROKEN
 package main
 
 import (
@@ -8,7 +7,7 @@ import (
 	"os"
 
 	"github.com/admin-else/strom/api"
-	"github.com/admin-else/strom/client/modules"
+	"github.com/admin-else/strom/client"
 	"github.com/admin-else/strom/event"
 	"github.com/admin-else/strom/proto"
 	"github.com/admin-else/strom/proto_base"
@@ -39,7 +38,7 @@ func (p *ProxyClient) OnStart(_ event.OnStart) (err error) {
 	return
 }
 
-func (p *ProxyClient) OnUnCodeAble(packet proto.UnCodablePacket) (err error) {
+func (p *ProxyClient) OnUnCodeAble(packet *proto.UnCodablePacket) (err error) {
 	err = p.OnDefault(event.Unhandled{Val: packet})
 	if err != nil {
 		return
@@ -80,7 +79,7 @@ func (p *Proxy) OnFinishConfiguration(packet *v1_21_8.ConfigurationToServerPacke
 	return
 }
 
-func (p *Proxy) OnUnCodeAble(packet proto.UnCodablePacket) (err error) {
+func (p *Proxy) OnUnCodeAble(packet *proto.UnCodablePacket) (err error) {
 	err = p.OnDefault(event.Unhandled{Val: packet})
 	if err != nil {
 		return
@@ -109,7 +108,7 @@ func TestFailedPacket%10X(t *testing.T) {
 }
 `
 
-func SaveUnCodeAbleAsTest(d proto_base.Direction, packet proto.UnCodablePacket) {
+func SaveUnCodeAbleAsTest(d proto_base.Direction, packet *proto.UnCodablePacket) {
 	hUntrimmed := sha256.Sum256(packet.Data)
 	h := hUntrimmed[:8]
 	f, err := os.Create(fmt.Sprintf(".failed_packets/%v_%10x_test.go", len(packet.Data), h))
@@ -145,7 +144,7 @@ func main() {
 		if err != nil {
 			return
 		}
-		c, err := modules.ConnectAndLogin("127.0.0.1:25566", acc)
+		c, err := client.ConnectAndLogin("127.0.0.1:25566", acc)
 		if err != nil {
 			return
 		}