lil refactor

messages7/cl_start_info.go

@@ -3,6 +3,7 @@ package messages7
 import (
 	"slices"
 
+	"github.com/teeworlds-go/teeworlds/network7"
 	"github.com/teeworlds-go/teeworlds/packer"
 )
 
@@ -30,7 +31,23 @@ type ClStartInfo struct {
 	ColorEyes             int
 }
 
-func (info *ClStartInfo) Pack() []byte {
+func (info ClStartInfo) MsgId() int {
+	return network7.MsgGameClStartInfo
+}
+
+func (info ClStartInfo) MsgType() network7.MsgType {
+	return network7.TypeNet
+}
+
+func (info ClStartInfo) System() bool {
+	return false
+}
+
+func (info ClStartInfo) Vital() bool {
+	return true
+}
+
+func (info ClStartInfo) Pack() []byte {
 	return slices.Concat(
 		packer.PackStr(info.Name),
 		packer.PackStr(info.Clan),

messages7/ctrl_connect.go

@@ -0,0 +1,35 @@
+package messages7
+
+import (
+	"slices"
+
+	"github.com/teeworlds-go/teeworlds/network7"
+)
+
+type CtrlConnect struct {
+	Token [4]byte
+}
+
+func (msg CtrlConnect) MsgId() int {
+	return network7.MsgCtrlConnect
+}
+
+func (msg CtrlConnect) MsgType() network7.MsgType {
+	return network7.TypeControl
+}
+
+func (msg CtrlConnect) System() bool {
+	return false
+}
+
+func (msg CtrlConnect) Vital() bool {
+	return false
+}
+
+func (msg CtrlConnect) Pack() []byte {
+	return slices.Concat(
+		[]byte{network7.MsgCtrlConnect},
+		msg.Token[:],
+		[]byte{512: 0},
+	)
+}

messages7/ctrl_token.go

@@ -0,0 +1,38 @@
+package messages7
+
+// this message is shared between client and server
+// but this implementation is assuming we are sending from a client
+
+import (
+	"slices"
+
+	"github.com/teeworlds-go/teeworlds/network7"
+)
+
+type CtrlToken struct {
+	Token [4]byte
+}
+
+func (msg CtrlToken) MsgId() int {
+	return network7.MsgCtrlToken
+}
+
+func (msg CtrlToken) MsgType() network7.MsgType {
+	return network7.TypeControl
+}
+
+func (msg CtrlToken) System() bool {
+	return false
+}
+
+func (msg CtrlToken) Vital() bool {
+	return false
+}
+
+func (msg CtrlToken) Pack() []byte {
+	return slices.Concat(
+		[]byte{network7.MsgCtrlToken},
+		msg.Token[:],
+		[]byte{512: 0},
+	)
+}

messages7/enter_game.go

@@ -0,0 +1,28 @@
+package messages7
+
+import (
+	"github.com/teeworlds-go/teeworlds/network7"
+)
+
+type EnterGame struct {
+}
+
+func (msg EnterGame) MsgId() int {
+	return network7.MsgSysEnterGame
+}
+
+func (msg EnterGame) MsgType() network7.MsgType {
+	return network7.TypeNet
+}
+
+func (msg EnterGame) System() bool {
+	return true
+}
+
+func (msg EnterGame) Vital() bool {
+	return true
+}
+
+func (msg EnterGame) Pack() []byte {
+	return []byte{}
+}

messages7/info.go

@@ -0,0 +1,33 @@
+package messages7
+
+import (
+	"github.com/teeworlds-go/teeworlds/network7"
+)
+
+type Info struct {
+}
+
+func (msg Info) MsgId() int {
+	return network7.MsgSysInfo
+}
+
+func (info Info) MsgType() network7.MsgType {
+	return network7.TypeNet
+}
+
+func (msg Info) System() bool {
+	return true
+}
+
+func (msg Info) Vital() bool {
+	return true
+}
+
+func (msg Info) Pack() []byte {
+	return []byte{
+		0x30, 0x2E, 0x37, 0x20, 0x38, 0x30, 0x32, 0x66,
+		0x31, 0x62, 0x65, 0x36, 0x30, 0x61, 0x30, 0x35, 0x36, 0x36, 0x35, 0x66,
+		0x00, 0x6D, 0x79, 0x5F, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64,
+		0x5F, 0x31, 0x32, 0x33, 0x00, 0x85, 0x1C, 0x00,
+	}
+}

messages7/net_message.go

@@ -0,0 +1,11 @@
+package messages7
+
+import "github.com/teeworlds-go/teeworlds/network7"
+
+type NetMessage interface {
+	MsgId() int
+	MsgType() network7.MsgType
+	System() bool
+	Vital() bool
+	Pack() []byte
+}

messages7/ready.go

@@ -0,0 +1,28 @@
+package messages7
+
+import (
+	"github.com/teeworlds-go/teeworlds/network7"
+)
+
+type Ready struct {
+}
+
+func (msg Ready) MsgId() int {
+	return network7.MsgSysReady
+}
+
+func (msg Ready) MsgType() network7.MsgType {
+	return network7.TypeNet
+}
+
+func (msg Ready) System() bool {
+	return true
+}
+
+func (msg Ready) Vital() bool {
+	return true
+}
+
+func (msg Ready) Pack() []byte {
+	return []byte{}
+}

messages7/sv_client_info.go

@@ -1,6 +1,9 @@
 package messages7
 
-import "github.com/teeworlds-go/teeworlds/packer"
+import (
+	"github.com/teeworlds-go/teeworlds/network7"
+	"github.com/teeworlds-go/teeworlds/packer"
+)
 
 type SvClientInfo struct {
 	ClientId              int
@@ -29,6 +32,22 @@ type SvClientInfo struct {
 	Silent                bool
 }
 
+func (info *SvClientInfo) MsgId() int {
+	return network7.MsgGameSvClientInfo
+}
+
+func (info *SvClientInfo) MsgType() network7.MsgType {
+	return network7.TypeNet
+}
+
+func (info *SvClientInfo) System() bool {
+	return false
+}
+
+func (info *SvClientInfo) Vital() bool {
+	return true
+}
+
 func (info *SvClientInfo) Unpack(u *packer.Unpacker) {
 	info.ClientId = u.GetInt()
 	info.Local = u.GetInt() != 0

network7/network7.go

@@ -3,22 +3,28 @@ package network7
 const (
 	MaxClients = 64
 
-	MsgCtrlKeepAlive ControlMsg = 0x00
+	MsgCtrlKeepAlive = 0x00
-	MsgCtrlConnect   ControlMsg = 0x01
+	MsgCtrlConnect   = 0x01
-	MsgCtrlAccept    ControlMsg = 0x02
+	MsgCtrlAccept    = 0x02
-	MsgCtrlToken     ControlMsg = 0x05
+	MsgCtrlToken     = 0x05
-	MsgCtrlClose     ControlMsg = 0x04
+	MsgCtrlClose     = 0x04
 
-	MsgSysMapChange  NetMsg = 2
+	MsgSysInfo       = 1
-	MsgSysConReady   NetMsg = 5
+	MsgSysMapChange  = 2
-	MsgSysSnapSingle NetMsg = 8
+	MsgSysConReady   = 5
+	MsgSysSnapSingle = 8
+	MsgSysReady      = 18
+	MsgSysEnterGame  = 19
 
-	MsgGameSvMotd       NetMsg = 1
+	MsgGameSvMotd       = 1
-	MsgGameSvChat       NetMsg = 3
+	MsgGameSvChat       = 3
-	MsgGameReadyToEnter NetMsg = 8
+	MsgGameReadyToEnter = 8
-	MsgGameSvClientInfo NetMsg = 18
+	MsgGameSvClientInfo = 18
-	MsgGameClStartInfo  NetMsg = 27
+	MsgGameClStartInfo  = 27
+
+	TypeControl  MsgType = 1
+	TypeNet      MsgType = 2
+	TypeConnless MsgType = 3
 )
 
-type ControlMsg int
+type MsgType int
-type NetMsg int

packer/packer.go

@@ -2,8 +2,6 @@ package packer
 
 import (
 	"slices"
-
-	"github.com/teeworlds-go/teeworlds/network7"
 )
 
 type Unpacker struct {
@@ -127,10 +125,6 @@ func PackBool(b bool) []byte {
 	return []byte{0x00}
 }
 
-func PackMsg(msg network7.NetMsg) []byte {
-	return PackInt(int(msg))
-}
-
 func PackInt(num int) []byte {
 	res := []byte{0x00}
 	idx := 0

protocol7/connection.go

@@ -12,7 +12,6 @@ import (
 	"github.com/teeworlds-go/teeworlds/messages7"
 	"github.com/teeworlds-go/teeworlds/network7"
 	"github.com/teeworlds-go/teeworlds/packer"
-	"github.com/teeworlds-go/teeworlds/packet7"
 )
 
 type Player struct {
@@ -36,17 +35,38 @@ type Connection struct {
 	Players []Player
 }
 
-func (c *Connection) SendCtrlToken(myToken []byte) {
+func (connection *Connection) BuildResponse() *Packet {
-	header := []byte{0x04, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff}
+	return &Packet{
-	ctrlToken := append([]byte{0x05}, myToken...)
+		Header: PacketHeader{
-	zeros := []byte{512: 0}
+			Flags: PacketFlags{
-	data := slices.Concat(header, ctrlToken, zeros)
+				Connless:    false,
-	c.Conn.Write(data)
+				Compression: false,
+				Resend:      false,
+				Control:     false,
+			},
+			Ack:       connection.Ack,
+			NumChunks: 0, // will be set in Packet.Pack()
+			Token:     connection.ServerToken,
+		},
+	}
+}
+
+func (connection *Connection) CtrlToken() *Packet {
+	response := connection.BuildResponse()
+	response.Header.Flags.Control = true
+	response.Messages = append(
+		response.Messages,
+		messages7.CtrlToken{
+			Token: connection.ClientToken,
+		},
+	)
+
+	return response
 }
 
 func (c *Connection) SendCtrlMsg(data []byte) {
-	header := packet7.PacketHeader{
+	header := PacketHeader{
-		Flags: packet7.PacketFlags{
+		Flags: PacketFlags{
 			Connless:    false,
 			Compression: false,
 			Resend:      false,
@@ -65,75 +85,8 @@ func (c *Connection) SendKeepAlive() {
 	c.SendCtrlMsg([]byte{byte(network7.MsgCtrlKeepAlive)})
 }
 
-func (c *Connection) SendReady() {
+func (client *Connection) MsgStartInfo() messages7.ClStartInfo {
-	ready := []byte{0x40, 0x01, 0x02, 0x25}
+	return messages7.ClStartInfo{
-
-	c.Sequence++
-	c.SendPacket(ready, 1)
-}
-
-type ChunkArgs struct {
-	MsgId   network7.NetMsg
-	System  bool
-	Flags   chunk7.ChunkFlags
-	Payload []byte
-}
-
-func (client *Connection) PackChunk(c ChunkArgs) []byte {
-	c.MsgId <<= 1
-	if c.System {
-		c.MsgId |= 1
-	}
-
-	client.Sequence++
-	msgAndSys := packer.PackMsg(c.MsgId)
-
-	chunkHeader := chunk7.ChunkHeader{
-		Flags: c.Flags,
-		Size:  len(msgAndSys) + len(c.Payload),
-		Seq:   client.Sequence,
-	}
-
-	data := slices.Concat(
-		chunkHeader.Pack(),
-		msgAndSys,
-		c.Payload,
-	)
-
-	fmt.Printf("packed chunk: %x\n", data)
-
-	return data
-}
-
-func (client *Connection) SendPacket(payload []byte, numChunks int) {
-	header := packet7.PacketHeader{
-		Flags: packet7.PacketFlags{
-			Connless:    false,
-			Compression: false,
-			Resend:      false,
-			Control:     false,
-		},
-		Ack:       client.Ack,
-		NumChunks: numChunks,
-		Token:     client.ServerToken,
-	}
-
-	packet := slices.Concat(header.Pack(), payload)
-	client.Conn.Write(packet)
-}
-
-func (client *Connection) SendInfo() {
-	info := []byte{0x40, 0x28, 0x01, 0x03, 0x30, 0x2E, 0x37, 0x20, 0x38, 0x30, 0x32, 0x66,
-		0x31, 0x62, 0x65, 0x36, 0x30, 0x61, 0x30, 0x35, 0x36, 0x36, 0x35, 0x66,
-		0x00, 0x6D, 0x79, 0x5F, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64,
-		0x5F, 0x31, 0x32, 0x33, 0x00, 0x85, 0x1C, 0x00}
-
-	client.Sequence++
-	client.SendPacket(info, 1)
-}
-
-func (client *Connection) SendStartInfo() {
-	info := messages7.ClStartInfo{
 		Name:                  "gopher",
 		Clan:                  "",
 		Country:               0,
@@ -156,24 +109,6 @@ func (client *Connection) SendStartInfo() {
 		ColorFeet:             0,
 		ColorEyes:             0,
 	}
-
-	payload := client.PackChunk(ChunkArgs{
-		MsgId: network7.MsgGameClStartInfo,
-		Flags: chunk7.ChunkFlags{
-			Vital: true,
-		},
-		Payload: info.Pack(),
-	})
-
-	client.SendPacket(payload, 1)
-}
-
-func (client *Connection) SendEnterGame() {
-	enter := []byte{
-		0x40, 0x01, 0x04, 0x27,
-	}
-
-	client.SendPacket(enter, 1)
 }
 
 func byteSliceToString(s []byte) string {
@@ -184,17 +119,17 @@ func byteSliceToString(s []byte) string {
 	return string(s)
 }
 
-func (client *Connection) OnSystemMsg(msg network7.NetMsg, chunk chunk7.Chunk, u *packer.Unpacker) {
+func (connection *Connection) OnSystemMsg(msg int, chunk chunk7.Chunk, u *packer.Unpacker, response *Packet) {
 	if msg == network7.MsgSysMapChange {
 		fmt.Println("got map change")
-		client.SendReady()
+		response.Messages = append(response.Messages, messages7.Ready{})
 	} else if msg == network7.MsgSysConReady {
 		fmt.Println("got ready")
-		client.SendStartInfo()
+		response.Messages = append(response.Messages, connection.MsgStartInfo())
 	} else if msg == network7.MsgSysSnapSingle {
 		// tick := u.GetInt()
 		// fmt.Printf("got snap single tick=%d\n", tick)
-		client.SendKeepAlive()
+		connection.SendKeepAlive()
 	} else {
 		fmt.Printf("unknown system message id=%d data=%x\n", msg, chunk.Data)
 	}
@@ -209,10 +144,10 @@ func (client *Connection) OnMotd(motd string) {
 	fmt.Printf("[motd] %s\n", motd)
 }
 
-func (client *Connection) OnGameMsg(msg network7.NetMsg, chunk chunk7.Chunk, u *packer.Unpacker) {
+func (client *Connection) OnGameMsg(msg int, chunk chunk7.Chunk, u *packer.Unpacker, response *Packet) {
 	if msg == network7.MsgGameReadyToEnter {
 		fmt.Println("got ready to enter")
-		client.SendEnterGame()
+		response.Messages = append(response.Messages, messages7.EnterGame{})
 	} else if msg == network7.MsgGameSvMotd {
 		motd := u.GetString()
 		if motd != "" {
@@ -234,7 +169,7 @@ func (client *Connection) OnGameMsg(msg network7.NetMsg, chunk chunk7.Chunk, u *
 	}
 }
 
-func (client *Connection) OnMessage(chunk chunk7.Chunk) {
+func (client *Connection) OnMessage(chunk chunk7.Chunk, response *Packet) {
 	// fmt.Printf("got chunk size=%d data=%v\n", chunk.Header.Size, chunk.Data)
 
 	if chunk.Header.Flags.Vital {
@@ -250,36 +185,47 @@ func (client *Connection) OnMessage(chunk chunk7.Chunk) {
 	msg >>= 1
 
 	if sys {
-		client.OnSystemMsg(network7.NetMsg(msg), chunk, &u)
+		client.OnSystemMsg(msg, chunk, &u, response)
 	} else {
-		client.OnGameMsg(network7.NetMsg(msg), chunk, &u)
+		client.OnGameMsg(msg, chunk, &u, response)
 	}
 }
 
-func (client *Connection) OnPacketPayload(header []byte, data []byte) {
+func (connection *Connection) OnPacketPayload(header []byte, data []byte, response *Packet) (*Packet, error) {
 	chunks := chunk7.UnpackChunks(data)
 
 	for _, c := range chunks {
-		client.OnMessage(c)
+		connection.OnMessage(c, response)
 	}
+	return response, nil
+
 }
 
-func (client *Connection) OnPacket(data []byte) {
+// the response packet might be nil even if there is no error
-	header := packet7.PacketHeader{}
+func (connection *Connection) OnPacket(data []byte) (*Packet, error) {
+	header := PacketHeader{}
 	headerRaw := data[:7]
 	payload := data[7:]
 	header.Unpack(headerRaw)
+	response := connection.BuildResponse()
 
 	if header.Flags.Control {
-		ctrlMsg := network7.ControlMsg(payload[0])
+		ctrlMsg := int(payload[0])
 		fmt.Printf("got ctrl msg %d\n", ctrlMsg)
 		if ctrlMsg == network7.MsgCtrlToken {
-			copy(client.ServerToken[:], payload[1:5])
+			copy(connection.ServerToken[:], payload[1:5])
-			fmt.Printf("got server token %x\n", client.ServerToken)
+			response.Header.Token = connection.ServerToken
-			client.SendCtrlMsg(slices.Concat([]byte{byte(network7.MsgCtrlConnect)}, client.ClientToken[:]))
+			fmt.Printf("got server token %x\n", connection.ServerToken)
+			response.Messages = append(
+				response.Messages,
+				messages7.CtrlConnect{
+					Token: connection.ClientToken,
+				},
+			)
 		} else if ctrlMsg == network7.MsgCtrlAccept {
 			fmt.Println("got accept")
-			client.SendInfo()
+			// TODO: don't hardcode info
+			response.Messages = append(response.Messages, messages7.Info{})
 		} else if ctrlMsg == network7.MsgCtrlClose {
 			// TODO: get length from packet header to determine if a reason is set or not
 			// len(data) -> is 1400 (maxPacketLen)
@@ -291,7 +237,12 @@ func (client *Connection) OnPacket(data []byte) {
 		} else {
 			fmt.Printf("unknown control message: %x\n", data)
 		}
-		return
+
+		if len(response.Messages) == 0 {
+			return nil, nil
+		}
+
+		return response, nil
 	}
 
 	if header.Flags.Compression {
@@ -300,9 +251,10 @@ func (client *Connection) OnPacket(data []byte) {
 		payload, err = huff.Decompress(payload)
 		if err != nil {
 			fmt.Printf("huffman error: %v\n", err)
-			return
+			return nil, nil
 		}
 	}
 
-	client.OnPacketPayload(headerRaw, payload)
+	response, err := connection.OnPacketPayload(headerRaw, payload, response)
+	return response, err
 }

protocol7/packet.go

@@ -1,6 +1,13 @@
-package packet7
+package protocol7
 
-import "slices"
+import (
+	"slices"
+
+	"github.com/teeworlds-go/teeworlds/chunk7"
+	"github.com/teeworlds-go/teeworlds/messages7"
+	"github.com/teeworlds-go/teeworlds/network7"
+	"github.com/teeworlds-go/teeworlds/packer"
+)
 
 const (
 	packetFlagControl     = 1
@@ -26,6 +33,72 @@ type PacketHeader struct {
 	ResponseToken [4]byte
 }
 
+type Packet struct {
+	Header   PacketHeader
+	Messages []messages7.NetMessage
+}
+
+func PackChunk(msg messages7.NetMessage, connection *Connection) []byte {
+	if msg.MsgType() == network7.TypeControl {
+		return msg.Pack()
+	}
+
+	msgId := msg.MsgId() << 1
+	if msg.System() {
+		msgId |= 1
+	}
+
+	if msg.Vital() {
+		connection.Sequence++
+	}
+
+	msgAndSys := packer.PackInt(msgId)
+	payload := msg.Pack()
+
+	// TODO: support resend
+	chunkHeader := chunk7.ChunkHeader{
+		Flags: chunk7.ChunkFlags{
+			Vital: msg.Vital(),
+		},
+		Size: len(msgAndSys) + len(payload),
+		Seq:  connection.Sequence,
+	}
+
+	data := slices.Concat(
+		chunkHeader.Pack(),
+		msgAndSys,
+		payload,
+	)
+
+	return data
+}
+
+func (packet *Packet) Pack(connection *Connection) []byte {
+	payload := []byte{}
+	control := false
+
+	for _, msg := range packet.Messages {
+		payload = append(payload, PackChunk(msg, connection)...)
+		if msg.MsgType() == network7.TypeControl {
+			control = true
+		}
+	}
+
+	packet.Header.NumChunks = len(packet.Messages)
+
+	if control {
+		packet.Header.Flags.Connless = false
+		packet.Header.Flags.Compression = false
+		packet.Header.Flags.Resend = false
+		packet.Header.Flags.Control = true
+	}
+
+	return slices.Concat(
+		packet.Header.Pack(),
+		payload,
+	)
+}
+
 func (header *PacketHeader) Pack() []byte {
 	flags := 0
 	if header.Flags.Control {

protocol7/packet_test.go

@@ -1,4 +1,4 @@
-package packet7
+package protocol7
 
 import (
 	"reflect"

teeworlds.go

@@ -60,13 +60,20 @@ func main() {
 
 	go readNetwork(ch, client.Conn)
 
-	client.SendCtrlToken([]byte{0xff, 0xff, 0xff, 0xff})
+	packet := client.CtrlToken()
+	conn.Write(packet.Pack(client))
 
 	for {
 		time.Sleep(10_000_000)
 		select {
 		case msg := <-ch:
-			client.OnPacket(msg)
+			packet, err = client.OnPacket(msg)
+			if err != nil {
+				panic(err)
+			}
+			if packet != nil {
+				conn.Write(packet.Pack(client))
+			}
 		default:
 			// do nothing
 		}