me when i dont use vcs properly

api/account.go

@@ -40,7 +40,7 @@ func (a *Account) doMcApiRequest(method string, url string, from any, to any) (e
 	r.Header.Set("Content-Type", "application/json")
 	r.Header.Set("Accept", "application/json")
 	r.Header.Set("x-xbl-contract-version", "1")
-	r.Header.Set("Authorization", fmt.Sprintf("Bearer %s", a.Ygg))
+	r.Header.Set("Authorization", "Bearer "+a.Ygg)
 
 	resp, err := http.DefaultClient.Do(r)
 	if err != nil {

client/modules/config_ignorer.go

@@ -19,12 +19,12 @@ func (c *ConfigIgnorer) Default(event any) (err error) {
 	return
 }
 
-func (c *ConfigIgnorer) OnKnownPacks(packet v1_21_8.PacketCommonSelectKnownPacks) (err error) {
+func (c *ConfigIgnorer) OnKnownPacks(packet *v1_21_8.PacketCommonSelectKnownPacks) (err error) {
 	return c.Send(packet)
 }
 
 func (c *ConfigIgnorer) OnFinish(_ v1_21_8.ConfigurationToClientPacketFinishConfiguration) (err error) {
-	err = c.Send(v1_21_8.ConfigurationToServerPacketFinishConfiguration{})
+	err = c.Send(&v1_21_8.ConfigurationToServerPacketFinishConfiguration{})
 	if err != nil {
 		return
 	}
@@ -33,18 +33,18 @@ func (c *ConfigIgnorer) OnFinish(_ v1_21_8.ConfigurationToClientPacketFinishConf
 	return
 }
 
-func (c *ConfigIgnorer) OnPing(packet v1_21_8.ConfigurationToClientPacketPing) (err error) {
+func (c *ConfigIgnorer) OnPing(packet *v1_21_8.ConfigurationToClientPacketPing) (err error) {
-	err = c.Send(v1_21_8.ConfigurationToServerPacketPong(packet))
+	err = c.Send(&v1_21_8.ConfigurationToServerPacketPong{Id: packet.Id})
 	return
 }
 
-func (c *ConfigIgnorer) OnKeepAlive(packet v1_21_8.ConfigurationToClientPacketKeepAlive) (err error) {
+func (c *ConfigIgnorer) OnKeepAlive(packet *v1_21_8.ConfigurationToClientPacketKeepAlive) (err error) {
-	err = c.Send(v1_21_8.ConfigurationToServerPacketKeepAlive(packet))
+	err = c.Send(&v1_21_8.ConfigurationToServerPacketKeepAlive{KeepAliveId: packet.KeepAliveId})
 	return
 }
 
 func IgnoreConfig(c *proto.Conn) (err error) {
-	err = c.Start(&ConfigIgnorer{c})
+	err = c.StartOne(&ConfigIgnorer{c})
 	if err != nil {
 		err = errors.Join(err, errors.New("failed to ignore config"))
 	}

client/modules/login.go

@@ -26,10 +26,10 @@ type LoginClient struct {
 	*proto.Conn
 	Account *api.Account
 
-	GivenAccount v1_21_8.LoginToClientPacketSuccess
+	GivenAccount *v1_21_8.LoginToClientPacketSuccess
 }
 
-func (s *LoginClient) Default(event any) (err error) {
+func (s *LoginClient) Default(event event.Default) (err error) {
 	err = fmt.Errorf("unexpected event: %#v", event)
 	return
 }
@@ -47,12 +47,13 @@ func (s *LoginClient) OnStart(_ event.OnStart) (err error) {
 	if err != nil {
 		return
 	}
+	s.ProtocolVersion = int32(versionData.Version)
 	port, err := strconv.Atoi(portStr)
 	if err != nil {
 		return
 	}
-	err = s.Send(v1_21_8.HandshakingToServerPacketSetProtocol{
+	err = s.Send(&v1_21_8.HandshakingToServerPacketSetProtocol{
-		ProtocolVersion: int32(versionData.Version),
+		ProtocolVersion: s.ProtocolVersion,
 		ServerHost:      host,
 		ServerPort:      uint16(port),
 		NextState:       int32(proto_base.Login),
@@ -61,11 +62,11 @@ func (s *LoginClient) OnStart(_ event.OnStart) (err error) {
 		return
 	}
 	s.State = proto_base.Login
-	err = s.Send(v1_21_8.LoginToServerPacketLoginStart{Username: s.Account.Name, PlayerUUID: s.Account.Uuid})
+	err = s.Send(&v1_21_8.LoginToServerPacketLoginStart{Username: s.Account.Name, PlayerUUID: s.Account.Uuid})
 	return
 }
 
-func (s *LoginClient) OnCompress(compress v1_21_8.LoginToClientPacketCompress) (err error) {
+func (s *LoginClient) OnCompress(compress *v1_21_8.LoginToClientPacketCompress) (err error) {
 	s.CompressionThreshold = int32(compress.Threshold)
 	return
 }
@@ -104,7 +105,7 @@ func (s *LoginClient) OnEncrypt(packet v1_21_8.LoginToClientPacketEncryptionBegi
 	if err != nil {
 		return
 	}
-	err = s.Send(v1_21_8.LoginToServerPacketEncryptionBegin{SharedSecret: sharedSecretEnc, VerifyToken: verifyTokenEnc})
+	err = s.Send(&v1_21_8.LoginToServerPacketEncryptionBegin{SharedSecret: sharedSecretEnc, VerifyToken: verifyTokenEnc})
 	if err != nil {
 		return
 	}
@@ -126,9 +127,9 @@ func (s *LoginClient) OnEncrypt(packet v1_21_8.LoginToClientPacketEncryptionBegi
 
 }
 
-func (s *LoginClient) OnSuccess(success v1_21_8.LoginToClientPacketSuccess) (err error) {
+func (s *LoginClient) OnSuccess(success *v1_21_8.LoginToClientPacketSuccess) (err error) {
 	s.GivenAccount = success
-	err = s.Send(v1_21_8.LoginToServerPacketLoginAcknowledged{})
+	err = s.Send(&v1_21_8.LoginToServerPacketLoginAcknowledged{})
 	if err != nil {
 		return
 	}
@@ -138,7 +139,7 @@ func (s *LoginClient) OnSuccess(success v1_21_8.LoginToClientPacketSuccess) (err
 }
 
 func Login(c *proto.Conn, account *api.Account) (err error) {
-	err = c.Start(&LoginClient{
+	err = c.StartOne(&LoginClient{
 		Conn:    c,
 		Account: account,
 	})
@@ -153,7 +154,7 @@ func ConnectAndLogin(connectTo string, account *api.Account) (c *proto.Conn, err
 	if err != nil {
 		return
 	}
-	err = c.Start(&LoginClient{
+	err = c.StartOne(&LoginClient{
 		Conn:    c,
 		Account: account,
 	})

client/modules/status.go

@@ -33,7 +33,7 @@ func (s *StatusClient) OnStart(_ event.OnStart) (err error) {
 	if err != nil {
 		return
 	}
-	err = s.Send(v1_21_8.HandshakingToServerPacketSetProtocol{
+	err = s.Send(&v1_21_8.HandshakingToServerPacketSetProtocol{
 		ProtocolVersion: int32(versionData.Version),
 		ServerHost:      parts[0],
 		ServerPort:      uint16(port),
@@ -43,7 +43,7 @@ func (s *StatusClient) OnStart(_ event.OnStart) (err error) {
 		return
 	}
 	s.State = proto_base.Status
-	err = s.Send(v1_21_8.StatusToServerPacketPingStart{})
+	err = s.Send(&v1_21_8.StatusToServerPacketPingStart{})
 	return
 }
 

data/minecraft-data/data/pc/1.21.8/protocol.json

@@ -8541,6 +8541,11 @@
             }
           ]
         ],
+        "packet_bundle_delimiter": [
+          "container",
+          [
+          ]
+        ],
         "packet": [
           "container",
           [
@@ -8696,7 +8701,7 @@
                 {
                   "compareTo": "name",
                   "fields": {
-                    "bundle_delimiter": "void",
+                    "bundle_delimiter": "packet_bundle_delimiter",
                     "spawn_entity": "packet_spawn_entity",
                     "animation": "packet_animation",
                     "statistics": "packet_statistics",

event/event_bus.go

@@ -25,7 +25,7 @@ func FindHandlers(insts []any) (handlers map[reflect.Type][]reflect.Value) {
 			method := t.Method(i)
 			if strings.HasPrefix(method.Name, "On") {
 				if method.Type.NumIn() != 2 || method.Type.NumOut() != 1 || method.Type.Out(0) != reflect.TypeFor[error]() {
-					fmt.Println("Invalid event handler signature:", method.Name)
+					fmt.Println("Invalid event handler signature:", t.String(), ".", method.Name)
 					continue
 				}
 			} else {

proto/connection.go

@@ -9,15 +9,26 @@ import (
 
 	"github.com/admin-else/strom/event"
 	"github.com/admin-else/strom/proto_base"
-	"github.com/admin-else/strom/proto_generated"
 )
 
 var BadPacketTypeError = errors.New("bad packet type")
+var BadPacketIdError = errors.New("bad packet id")
 
 // UnCodablePacket represents a packet that could not be decoded due to proto_generated not supporting all packets.
 type UnCodablePacket struct {
-	Err  error
+	Err       error
-	Data []byte
+	Data      []byte
+	Direction proto_base.Direction
+}
+
+func (u *UnCodablePacket) Encode(w io.Writer) (err error) {
+	_, err = w.Write(u.Data)
+	return
+}
+
+func (u *UnCodablePacket) Decode(r io.Reader) (err error) {
+	err = errors.New("how did you even get here")
+	return
 }
 
 type Conn struct {
@@ -28,27 +39,33 @@ type Conn struct {
 	State                            proto_base.State
 	Actor                            proto_base.Actor
 	Version                          string
+	ProtocolVersion                  int32
 	DontDecodePacketsWithoutHandlers bool
 }
 
-func (c *Conn) Send(packet any) (err error) {
+func (c *Conn) Send(packet proto_base.EncodeDecodeAble) (err error) {
-	var rawPacketBytes []byte
 	switch packet := packet.(type) {
-	case UnCodablePacket:
+	case *UnCodablePacket:
-		rawPacketBytes = packet.Data
+		err = c.SendRaw(packet.Data)
 	default:
-		packetIdentifier := proto_generated.TypeToPacketIdentifier(c.Version, c.Actor.SendDirection(), c.State, packet)
+		i, ok := LookupPacketInfoByTypeAndMore(packet, c.State)
-		if packetIdentifier == "" {
+		if !ok {
 			err = BadPacketTypeError
-			return
 		}
-		rawPacketBuffer := bytes.NewBuffer(nil)
+		var packetBuff = bytes.NewBuffer(nil)
-		err = proto_generated.EncodePacket(c.Version, c.Actor.SendDirection(), c.State, packetIdentifier, packet, rawPacketBuffer)
+		err = proto_base.EncodeVarInt(packetBuff, i.PacketId)
 		if err != nil {
 			return
 		}
-		rawPacketBytes = rawPacketBuffer.Bytes()
+		err = packet.Encode(packetBuff)
+		if err != nil {
+			return
+		}
+		err = c.SendRaw(packetBuff.Bytes())
 	}
+	return
+}
+func (c *Conn) SendRaw(rawPacketBytes []byte) (err error) {
 	var packetBytes []byte
 	if c.CompressionThreshold > 0 {
 		packetBuffer := bytes.NewBuffer(nil)
@@ -83,7 +100,7 @@ func (c *Conn) Send(packet any) (err error) {
 	return
 }
 
-func (c *Conn) Receive() (packet any, err error) {
+func (c *Conn) ReceiveRaw() (packetBytes []byte, err error) {
 	rawPacketLen, err := proto_base.DecodeVarInt(c.R)
 	if err != nil {
 		return
@@ -93,7 +110,6 @@ func (c *Conn) Receive() (packet any, err error) {
 		return
 	}
 	rawPacketBuffer := bytes.NewBuffer(rawPacketBytes)
-	var packetBytes []byte
 	if c.CompressionThreshold > 0 {
 		var packetLen int32
 		packetLen, err = proto_base.DecodeVarInt(rawPacketBuffer)
@@ -120,10 +136,27 @@ func (c *Conn) Receive() (packet any, err error) {
 	} else {
 		packetBytes = rawPacketBytes
 	}
-	packetBuff := bytes.NewBuffer(packetBytes)
+	return
-	packet, err = proto_generated.DecodePacket(c.Version, c.Actor.ReceiveDirection(), c.State, packetBuff)
+}
+
+func (c *Conn) Receive() (packet proto_base.EncodeDecodeAble, err error) {
+	packetBytes, err := c.ReceiveRaw()
 	if err != nil {
-		packet = UnCodablePacket{Err: err, Data: packetBytes}
+		return
+	}
+	b := bytes.NewBuffer(packetBytes)
+	id, err := proto_base.DecodeVarInt(b)
+	if err != nil {
+		return
+	}
+	packet, ok := LookUpTypeByPacketInfoAndCopyType(c.Actor.ReceiveDirection(), c.State, id, c.ProtocolVersion)
+	if !ok {
+		packet = &UnCodablePacket{Err: BadPacketIdError, Data: packetBytes, Direction: c.Actor.ReceiveDirection()}
+		return
+	}
+	err = packet.Decode(b)
+	if err != nil {
+		packet = &UnCodablePacket{Err: err, Data: packetBytes, Direction: c.Actor.ReceiveDirection()}
 		err = nil
 	}
 	return

proto/packet_lookup.go

@@ -0,0 +1,71 @@
+package proto
+
+import (
+	"reflect"
+
+	"github.com/admin-else/strom/proto_base"
+	"github.com/admin-else/strom/proto_generated"
+)
+
+// I know this is in-performant and i dont care until it becomes a problem for somebody it will stay like this and it is pretty easy to make caches or simular to speed this up so yeah
+
+func LookUpTypeByPacketInfo(direction proto_base.Direction, state proto_base.State, pid, version int32) (p proto_base.PacketInfo, ok bool) {
+	for _, pin := range proto_generated.Packets {
+		if pin.Direction != direction || pin.State != state || pin.ProtocolVersion != version || pin.PacketId != pid {
+			continue
+		}
+		return pin, true
+	}
+	return
+}
+
+func LookUpTypeByPacketInfoAndCopyType(direction proto_base.Direction, state proto_base.State, pid, version int32) (p proto_base.EncodeDecodeAble, ok bool) {
+	i, ok := LookUpTypeByPacketInfo(direction, state, pid, version)
+	if !ok {
+		return
+	}
+	p = reflect.New(reflect.TypeOf(i.Type).Elem()).Interface().(proto_base.EncodeDecodeAble)
+	return
+}
+
+func LookupPacketInfoByType(packet proto_base.EncodeDecodeAble) (p proto_base.PacketInfo, ok bool) {
+	switch packet := packet.(type) {
+	case *UnCodablePacket:
+		p = proto_base.PacketInfo{
+			Type:            &UnCodablePacket{},
+			Name:            "undecodeable",
+			Direction:       packet.Direction,
+			State:           -1,
+			PacketId:        -1,
+			ProtocolVersion: -1,
+		}
+	default:
+		for _, p := range proto_generated.Packets {
+			if reflect.TypeOf(p.Type) == reflect.TypeOf(packet) {
+				return p, true
+			}
+		}
+	}
+	return
+}
+
+func LookupPacketInfoByTypeAndMore(packet proto_base.EncodeDecodeAble, state proto_base.State) (p proto_base.PacketInfo, ok bool) {
+	switch packet := packet.(type) {
+	case *UnCodablePacket:
+		p = proto_base.PacketInfo{
+			Type:            &UnCodablePacket{},
+			Name:            "undecodeable",
+			Direction:       packet.Direction,
+			State:           -1,
+			PacketId:        -1,
+			ProtocolVersion: -1,
+		}
+	default:
+		for _, p := range proto_generated.Packets {
+			if state == p.State && reflect.TypeOf(p.Type) == reflect.TypeOf(packet) {
+				return p, true
+			}
+		}
+	}
+	return
+}

proto_base/base_types.go

@@ -4,7 +4,6 @@ import (
 	"encoding/binary"
 	"errors"
 	"io"
-	"reflect"
 )
 
 type Direction int
@@ -213,10 +212,10 @@ type EncodeDecodeAble interface {
 }
 
 type PacketInfo struct {
-	Type            reflect.Type
+	Type            EncodeDecodeAble
 	Name            string
 	Direction       Direction
 	State           State
-	PacketId        int
+	PacketId        int32
-	ProtocolVersion int
+	ProtocolVersion int32
 }

proto_generator/helper_generator.go

@@ -79,14 +79,13 @@ func CollectPacketInfo(versions []string) (packetInfos []PacketInfo, err error)
 }
 
 func GeneratePacketInfoFile(versions []string) (err error) {
-	var packetInfos []PacketInfo
+	packetInfos, err := CollectPacketInfo(versions)
-	packetInfos, err = CollectPacketInfo(versions)
 	if err != nil {
 		return
 	}
 
 	f := NewFile("proto_generated")
-	imports := []string{"reflect", "github.com/admin-else/strom/proto_base"}
+	imports := []string{"github.com/admin-else/strom/proto_base"}
 	for _, v := range versions {
 		vUnderscore := strings.ReplaceAll(v, ".", "_")
 		imports = append(imports, "github.com/admin-else/strom/proto_generated/v"+vUnderscore)
@@ -109,8 +108,8 @@ func GeneratePacketInfoFile(versions []string) (err error) {
 		packetId, _ := strconv.ParseInt(p.PacketId, 0, 32)
 		protocolVersion, _ := strconv.Atoi(p.ProtocolVersion)
 
-		packetInfoExprs = append(packetInfoExprs, CompLit(Selector("proto_base", "PacketInfo"), []ast.Expr{
+		packetInfoExprs = append(packetInfoExprs, CompLit(nil, []ast.Expr{
-			KeyValueExpr(Ident("Type"), Call(Selector("reflect", "TypeOf"), CompLit(typeExpr, nil))),
+			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)),

proto_generator/main.go

@@ -28,10 +28,6 @@ type Protocol struct {
 	Handshaking, Status, Login, Configuration, Play State
 }
 
-type Settings struct {
-	ReplaceWithTodoNames []string
-}
-
 type ContainerStackEntry struct {
 	Data []struct {
 		Name string
@@ -43,7 +39,6 @@ type ContainerStackEntry struct {
 
 type Generator struct {
 	// These persist the entire generate-call
-	Settings         Settings
 	Natives          map[string]ExprGeneratorFunc
 	DecoderNatives   map[string]FunctionGeneratorFunc
 	EncoderNatives   map[string]FunctionGeneratorFunc
@@ -202,10 +197,6 @@ func (g *Generator) GenerateTypes(prefix string, types Types) (err error) {
 	g.CurrentlyGeneratingTypesPrefix = prefix
 	for _, k := range OrderedKeys(types.Types) {
 		v := types.Types[k]
-		if slices.Contains(g.Settings.ReplaceWithTodoNames, k) {
-			v = "todo"
-		}
-
 		g.Depth = 0
 		e, err2 := g.VisitType(v)
 		if errors.Is(err2, ToDoError) {
@@ -232,9 +223,7 @@ func (g *Generator) GenerateTypes(prefix string, types Types) (err error) {
 		s, err2 := g.VisitDecoder(retExpr, v, tName)
 		if err2 != nil {
 			s = ToDoStmts
-			if !errors.Is(err2, ToDoError) {
+			fmt.Println("failed to make decoder for", k, err2)
-				fmt.Println("failed to make decoder for", k, err2)
-			}
 		}
 		decodeFunction.Body = NewBlock(append(s, Return()))
 		AppendDecl(g.File, decodeFunction)
@@ -246,13 +235,10 @@ func (g *Generator) GenerateTypes(prefix string, types Types) (err error) {
 		s, err2 = g.VisitEncoder(retExpr, v, tName)
 		if err2 != nil {
 			s = ToDoStmts
-			if !errors.Is(err2, ToDoError) {
+			fmt.Println("failed to make encoder for", k, err2)
-				fmt.Println("failed to make encoder for", k, err2)
-			}
 		}
 		encodeFunction.Body = NewBlock(append(s, Return()))
 		AppendDecl(g.File, encodeFunction)
-
 	}
 	return
 }
@@ -300,9 +286,6 @@ func Generate(version string, w io.Writer) (err error) {
 
 	g := &Generator{Protocol: protocol}
 
-	// These have annoying edge cases that would require me to implement a whole new compareTo parser
-	g.Settings.ReplaceWithTodoNames = []string{}
-
 	g.File = NewFile("v" + strings.ReplaceAll(version, ".", "_"))
 	AppendDecl(g.File, Import("encoding/binary", "io", "github.com/admin-else/strom/proto_base", "github.com/admin-else/strom/nbt", "github.com/google/uuid"))
 	g.RegisterNatives()
@@ -322,7 +305,7 @@ func generateVersion(v string) (err error) {
 	if err != nil {
 		return
 	}
-	f, err := os.Create("proto_generated/v" + vUnderscore + "/proto_base.go")
+	f, err := os.Create("proto_generated/v" + vUnderscore + "/proto.go")
 	if err != nil {
 		return
 	}

server/server.go

@@ -4,7 +4,6 @@ import (
 	"log"
 	"net"
 
-	"github.com/admin-else/strom/event"
 	"github.com/admin-else/strom/proto"
 	"github.com/admin-else/strom/proto_base"
 )
@@ -12,6 +11,7 @@ import (
 func Servee(c net.Conn) (ret *proto.Conn) {
 	ret = &proto.Conn{}
 	ret.Version = "1.21.8"
+	ret.ProtocolVersion = 772
 	ret.State = proto_base.Handshaking
 	ret.CompressionThreshold = -1
 	ret.Actor = proto_base.Server
@@ -21,17 +21,17 @@ func Servee(c net.Conn) (ret *proto.Conn) {
 	return
 }
 
-func ServeClient(cNet net.Conn, factory func(c *proto.Conn) (h event.HandlerInst, err error)) (err error) {
+func ServeClient(cNet net.Conn, factory func(c *proto.Conn) (h any, err error)) (err error) {
 	c := Servee(cNet)
 	h, err := factory(c)
 	if err != nil {
 		return
 	}
-	err = c.Start(h)
+	err = c.StartOne(h)
 	return
 }
 
-func StartServerWithFactory(listenAddr string, factory func(c *proto.Conn) (h event.HandlerInst, err error)) (err error) {
+func StartServerWithFactory(listenAddr string, factory func(c *proto.Conn) (h any, err error)) (err error) {
 	l, err := net.Listen("tcp", listenAddr)
 	if err != nil {
 		return

server/server_modules/login_server.go

@@ -34,7 +34,7 @@ type LoginServer struct {
 	CompressionThreshold int32
 }
 
-func (l *LoginServer) OnHandshake(packet v1_21_8.HandshakingToServerPacketSetProtocol) (err error) {
+func (l *LoginServer) OnHandshake(packet *v1_21_8.HandshakingToServerPacketSetProtocol) (err error) {
 	l.State = proto_base.State(packet.NextState)
 	if packet.NextState != int32(proto_base.Login) {
 		err = UnexpectedNextStateError{proto_base.State(packet.NextState)}
@@ -44,7 +44,7 @@ func (l *LoginServer) OnHandshake(packet v1_21_8.HandshakingToServerPacketSetPro
 }
 
 func (l *LoginServer) SetCompressionThreshold(threshold int32) (err error) {
-	err = l.Send(v1_21_8.LoginToClientPacketCompress{Threshold: threshold})
+	err = l.Send(&v1_21_8.LoginToClientPacketCompress{Threshold: threshold})
 	if err != nil {
 		return
 	}
@@ -52,7 +52,7 @@ func (l *LoginServer) SetCompressionThreshold(threshold int32) (err error) {
 	return
 }
 
-func (l *LoginServer) OnLoginStart(packet v1_21_8.LoginToServerPacketLoginStart) (err error) {
+func (l *LoginServer) OnLoginStart(packet *v1_21_8.LoginToServerPacketLoginStart) (err error) {
 	l.Requested = NameAndUUID{packet.Username, packet.PlayerUUID}
 	//err = l.SetCompressionThreshold(l.CompressionThreshold)
 	//if err != nil {
@@ -61,7 +61,7 @@ func (l *LoginServer) OnLoginStart(packet v1_21_8.LoginToServerPacketLoginStart)
 	if l.Given == nil {
 		l.Given = &l.Requested
 	}
-	err = l.Send(v1_21_8.LoginToClientPacketSuccess{
+	err = l.Send(&v1_21_8.LoginToClientPacketSuccess{
 		Uuid:       l.Given.UUID,
 		Username:   l.Given.Name,
 		Properties: nil,
@@ -69,13 +69,13 @@ func (l *LoginServer) OnLoginStart(packet v1_21_8.LoginToServerPacketLoginStart)
 	return
 }
 
-func (l *LoginServer) OnLoginAcknowledged(_ v1_21_8.LoginToServerPacketLoginAcknowledged) (err error) {
+func (l *LoginServer) OnLoginAcknowledged(_ *v1_21_8.LoginToServerPacketLoginAcknowledged) (err error) {
 	l.State = proto_base.Configuration
 	err = event.HandlerDone
 	return
 }
 
-func (l *LoginServer) Default(event any) (err error) {
+func (l *LoginServer) OnDefault(event event.Default) (err error) {
 	err = fmt.Errorf("unexpected event during login: %#v", event)
 	fmt.Println(err)
 	return
@@ -92,7 +92,7 @@ func (l *LoginServer) OnCycle(_ event.OnLoopCycle) (err error) {
 func ServeLogin(c *proto.Conn) (ret *LoginServer, err error) {
 	ret = &LoginServer{Conn: c}
 	ret.CompressionThreshold = 256
-	err = ret.Start(ret)
+	err = ret.StartOne(ret)
 	return
 }
 
@@ -102,6 +102,6 @@ func ServeLoginWithOtherAccount(c *proto.Conn, a *api.Account) (ret *LoginServer
 		UUID: a.Uuid,
 	}}
 	ret.CompressionThreshold = 256
-	err = ret.Start(ret)
+	err = ret.StartOne(ret)
 	return
 }

server/server_modules/status.go

@@ -37,12 +37,12 @@ func (p *StatusServer) Default(_ any) (err error) {
 	return
 }
 
-func (p *StatusServer) OnStatusRequest(_ v1_21_8.StatusToServerPacketPingStart) (err error) {
+func (p *StatusServer) OnStatusRequest(_ *v1_21_8.StatusToServerPacketPingStart) (err error) {
-	return p.Send(v1_21_8.StatusToClientPacketServerInfo{Response: p.Status})
+	return p.Send(&v1_21_8.StatusToClientPacketServerInfo{Response: p.Status})
 }
 
-func (p *StatusServer) OnStatusPing(packet v1_21_8.StatusToServerPacketPing) (err error) {
+func (p *StatusServer) OnStatusPing(packet *v1_21_8.StatusToServerPacketPing) (err error) {
-	return p.Send(v1_21_8.StatusToClientPacketPing(packet))
+	return p.Send(&v1_21_8.StatusToClientPacketPing{Time: packet.Time})
 }
 
 func ServeStatus(c *proto.Conn, s StatusResponse) (err error) {
@@ -54,6 +54,6 @@ func ServeStatus(c *proto.Conn, s StatusResponse) (err error) {
 		Conn:   c,
 		Status: string(status),
 	}
-	err = server.Start(server)
+	err = server.StartOne(server)
 	return
 }

tools/uncodeable_packet_hunter_proxy/main.go

@@ -11,7 +11,6 @@ import (
 	"github.com/admin-else/strom/event"
 	"github.com/admin-else/strom/proto"
 	"github.com/admin-else/strom/proto_base"
-	"github.com/admin-else/strom/proto_generated"
 	"github.com/admin-else/strom/proto_generated/v1_21_8"
 	"github.com/admin-else/strom/server"
 	"github.com/admin-else/strom/server/server_modules"
@@ -23,7 +22,11 @@ type ProxyClient struct {
 }
 
 func (p *ProxyClient) OnDefault(event event.Default) (err error) {
-	err = p.Server.Send(event.Val)
+	packet, isPacket := event.Val.(proto_base.EncodeDecodeAble)
+	if !isPacket {
+		return
+	}
+	err = p.Server.Send(packet)
 	return
 }
 
@@ -49,8 +52,12 @@ type Proxy struct {
 	Client *ProxyClient
 }
 
-func (p *Proxy) Default(event any) (err error) {
+func (p *Proxy) OnDefault(event event.Default) (err error) {
-	err = p.Client.Send(event)
+	packet, isPacket := event.Val.(proto_base.EncodeDecodeAble)
+	if !isPacket {
+		return
+	}
+	err = p.Client.Send(packet)
 	return
 }
 
@@ -62,8 +69,8 @@ func (p *Proxy) OnStart(_ event.OnStart) (err error) {
 	return
 }
 
-func (p *Proxy) OnFinishConfiguration(packet v1_21_8.ConfigurationToServerPacketFinishConfiguration) (err error) {
+func (p *Proxy) OnFinishConfiguration(packet *v1_21_8.ConfigurationToServerPacketFinishConfiguration) (err error) {
-	err = p.Default(packet)
+	err = p.OnDefault(event.Default{Val: packet})
 	if err != nil {
 		return
 	}
@@ -73,7 +80,7 @@ func (p *Proxy) OnFinishConfiguration(packet v1_21_8.ConfigurationToServerPacket
 }
 
 func (p *Proxy) OnUnCodeAble(packet proto.UnCodablePacket) (err error) {
-	err = p.Default(packet)
+	err = p.OnDefault(event.Default{Val: packet})
 	if err != nil {
 		return
 	}