Refactoring

Author: Tom32i

demo-server.go

@@ -4,44 +4,50 @@ import (
 	"flag"
 	"log"
 	"math"
-	"github.com/Tom32i/netcode/internal/codec"
-	"github.com/Tom32i/netcode/internal/server"
+	netcode "github.com/Tom32i/netcode/go"
+	"github.com/gorilla/websocket"
+	"net/http"
 	"time"
 )
 
-type DemoServer struct {
-	server *server.Server
+type Demo struct {
+	room *netcode.Room
 }
 
 func main() {
 	port := flag.Int("port", 8002, "Port to run on")
 
 	flag.Parse()
 
-	encoder := codec.CreateBinaryEncoder([]*codec.RegisteredCodec{
-		{0, "id", codec.UInt8Codec{}},
-		{1, "ping", codec.LongUIntCodec{6}},
-		{2, "pong", codec.LongUIntCodec{6}},
-		{3, "inverse", codec.BooleanCodec{}},
-		{4, "greeting", codec.StringLongCodec{}},
-		{5, "total", codec.UInt8Codec{}},
-	}, codec.UInt8Codec{})
+	encoder := netcode.CreateBinaryEncoder([]*netcode.RegisteredCodec{
+		{0, "id", netcode.UInt8Codec{}},
+		{1, "ping", netcode.LongUIntCodec{6}},
+		{2, "pong", netcode.LongUIntCodec{6}},
+		{3, "inverse", netcode.BooleanCodec{}},
+		{4, "greeting", netcode.StringLongCodec{}},
+		{5, "total", netcode.UInt8Codec{}},
+	}, netcode.UInt8Codec{})
 
-	clients := server.CreateClientDirectory(uint(math.Pow(2, 8)))
-	server := server.CreateServer(*port, encoder, clients)
-
-	demo := DemoServer{&server}
+	clients := netcode.CreateClientDirectory(uint(math.Pow(2, 8)))
+	room := netcode.CreateRoom(clients, encoder)
+	demo := Demo{room}
 
 	go demo.run()
 
-	demo.server.Start()
+	netcode.Start(*port, "/", func (socket *websocket.Conn, request *http.Request) {
+		err := room.Join(socket)
+
+		if err != nil {
+			log.Fatal(err)
+		}
+	})
 }
 
-func (demo *DemoServer) run() {
+func (demo *Demo) run() {
 	log.Printf("Demo is running")
 	for {
 		select {
-		case m := <-demo.server.In:
+		case m := <-demo.room.In:
 			switch m.Message.Name {
 			case "ping":
 				demo.handlePing(m.Client, m.Message)
@@ -50,43 +56,43 @@ func (demo *DemoServer) run() {
 			default:
 				log.Printf("[client #%d] '%s': %v", m.Client.ID, m.Message.Name, m.Message.Data)
 			}
-		case e := <-demo.server.Out:
+		case e := <-demo.room.Out:
 			switch e.Name {
 			case "client:join":
-				demo.onClientJoin(e.Data.(*server.Client))
+				demo.onClientJoin(e.Data.(*netcode.Client))
 			case "client:leave":
-				demo.onClientLeave(e.Data.(*server.Client))
+				demo.onClientLeave(e.Data.(*netcode.Client))
 			default:
 				log.Printf("event '%s': %v", e.Name, e.Data)
 			}
 		}
 	}
 }
 
-func (demo *DemoServer) broadcastTotal() {
-	message := codec.Message{"total", uint8(demo.server.Clients.Count())}
-	buf := demo.server.Encoder.Encode(message)
-	demo.server.Clients.ForEach(func(c *server.Client) { c.Write(buf) })
+func (demo *Demo) broadcastTotal() {
+	message := &netcode.Message{"total", uint8(demo.room.Clients.Count())}
+	buf := demo.room.Encoder.Encode(message)
+	demo.room.Clients.ForEach(func(c *netcode.Client) { c.Write(buf) })
 }
 
-func (demo *DemoServer) onClientJoin(c *server.Client) {
+func (demo *Demo) onClientJoin(c *netcode.Client) {
 	log.Printf("Client #%d joined.", c.ID)
-	c.Send(codec.Message{"id", uint8(c.ID)})
+	c.Send(&netcode.Message{"id", uint8(c.ID)})
 	demo.broadcastTotal()
 }
 
-func (demo *DemoServer) onClientLeave(c *server.Client) {
+func (demo *Demo) onClientLeave(c *netcode.Client) {
 	log.Printf("Client #%d left.", c.ID)
 	demo.broadcastTotal()
 }
 
-func (demo *DemoServer) handlePing(c *server.Client, m codec.Message) {
+func (demo *Demo) handlePing(c *netcode.Client, m *netcode.Message) {
 	log.Printf("[client #%d] ping %d", c.ID, m.Data)
-	c.Send(codec.Message{"pong", uint(time.Now().UnixMilli())})
-	c.Send(codec.Message{"inverse", true})
+	c.Send(&netcode.Message{"pong", uint(time.Now().UnixMilli())})
+	c.Send(&netcode.Message{"inverse", true})
 }
 
-func (demo *DemoServer) handleGreeting(c *server.Client, m codec.Message) {
+func (demo *Demo) handleGreeting(c *netcode.Client, m *netcode.Message) {
 	log.Printf("Client #%d greets you: '%s'", c.ID, m.Data)
-	c.Send(codec.Message{"greeting", "Hello, I'm server! 😊 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut imperdiet molestie libero, ut sollicitudin tortor dignissim quis. Nulla iaculis nisi turpis, a malesuada nibh faucibus a. Nunc tellus lorem, varius sit amet tellus eu, dictum consectetur nulla."})
+	c.Send(&netcode.Message{"greeting", "Hello, I'm server! 😊 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut imperdiet molestie libero, ut sollicitudin tortor dignissim quis. Nulla iaculis nisi turpis, a malesuada nibh faucibus a. Nunc tellus lorem, varius sit amet tellus eu, dictum consectetur nulla."})
 }

internal/server/client.go go/client.gointernal/server/client.go renamed to go/client.go

@@ -1,8 +1,6 @@
-package server
+package netcode
 
 import (
-	"github.com/Tom32i/netcode/internal/codec"
-	//"github.com/Tom32i/netcode/internal/security"
 	//"github.com/google/uuid"
 	"github.com/gorilla/websocket"
 	"log"
@@ -11,27 +9,27 @@ import (
 type Client struct {
 	ID uint
 	//uuid    uuid.UUID
-	IP string
+	// IP strings
 	//token   security.Token
-	in      chan ClientMessage
+	In      chan ClientMessage
 	socket  *websocket.Conn
-	encoder *codec.BinaryEncoder
+	encoder *BinaryEncoder
 }
 
 type ClientMessage struct {
 	Client  *Client
-	Message codec.Message
+	Message *Message
 }
 
-func (c *Client) Send(message codec.Message) {
+func (c *Client) Send(message *Message) {
 	c.Write(c.encoder.Encode(message))
 }
 
 func (c *Client) Write(data []byte) {
 	c.socket.WriteMessage(websocket.BinaryMessage, data)
 }
 
-func (c *Client) run(onClose func(*Client)) {
+func (c *Client) Run(onClose func(*Client)) {
 	defer func() {
 		c.socket.Close()
 		onClose(c)
@@ -47,6 +45,6 @@ func (c *Client) run(onClose func(*Client)) {
 			break
 		}
 
-		c.in <- ClientMessage{c, c.encoder.Decode(data)}
+		c.In <- ClientMessage{c, c.encoder.Decode(data)}
 	}
 }

go/client_directory.go

@@ -0,0 +1,63 @@
+package netcode
+
+import (
+    "errors"
+)
+
+type ClientDirectory struct {
+    List map[uint]*Client
+    max     uint
+}
+
+func (d *ClientDirectory) generateId() (uint, error) {
+    for id := uint(0); id < d.max; id++ {
+        _, ok := d.List[id]
+
+        if !ok {
+            return id, nil
+        }
+    }
+
+    return uint(0), errors.New("Client limit reached!")
+}
+
+func (d *ClientDirectory) Add(c *Client) error {
+    id, err := d.generateId()
+
+    if err != nil {
+        return err
+    }
+
+    c.ID = id
+
+    d.List[c.ID] = c
+
+    return nil
+}
+
+func (d *ClientDirectory) Remove(c *Client) {
+    delete(d.List, c.ID)
+}
+
+func (d *ClientDirectory) Count() int {
+    return len(d.List)
+}
+
+func (d *ClientDirectory) ForEach(callback func(*Client)) {
+    for _, c := range d.List {
+        callback(c)
+    }
+}
+
+func (d *ClientDirectory) ForOther(client *Client, callback func(*Client)) {
+    for _, c := range d.List {
+        if c.ID != client.ID {
+            callback(c)
+        }
+    }
+}
+
+
+func CreateClientDirectory(max uint) *ClientDirectory {
+	return &ClientDirectory{make(map[uint]*Client), max}
+}

internal/codec/bool.go go/codec_bool.gointernal/codec/bool.go renamed to go/codec_bool.go

@@ -1,4 +1,4 @@
-package codec
+package netcode
 
 import (
 	"bytes"
@@ -7,14 +7,14 @@ import (
 type BooleanCodec struct {
 }
 
-func (c BooleanCodec) encode(buffer *bytes.Buffer, data any) {
+func (c BooleanCodec) Encode(buffer *bytes.Buffer, data any) {
 	if data.(bool) {
 		buffer.WriteByte(1)
 	} else {
 		buffer.WriteByte(0)
 	}
 }
 
-func (c BooleanCodec) decode(buffer *bytes.Buffer) any {
+func (c BooleanCodec) Decode(buffer *bytes.Buffer) any {
 	return buffer.Next(1)[0] > 0
 }

internal/codec/string.go go/codec_string.gointernal/codec/string.go renamed to go/codec_string.go

@@ -1,4 +1,4 @@
-package codec
+package netcode
 
 import (
 	"bytes"
@@ -7,13 +7,13 @@ import (
 type StringCodec struct {
 }
 
-func (c StringCodec) encode(buffer *bytes.Buffer, data any) {
+func (c StringCodec) Encode(buffer *bytes.Buffer, data any) {
 	length := len(data.(string))
 	buffer.WriteByte(uint8(length))
 	buffer.WriteString(data.(string))
 }
 
-func (c StringCodec) decode(buffer *bytes.Buffer) any {
+func (c StringCodec) Decode(buffer *bytes.Buffer) any {
 	length := int(buffer.Next(1)[0])
 
 	return string(buffer.Next(length))

internal/codec/string_long.go go/codec_string_long.gointernal/codec/string_long.go renamed to go/codec_string_long.go

@@ -1,4 +1,4 @@
-package codec
+package netcode
 
 import (
 	"bytes"
@@ -8,7 +8,7 @@ import (
 type StringLongCodec struct {
 }
 
-func (c StringLongCodec) encode(buffer *bytes.Buffer, data any) {
+func (c StringLongCodec) Encode(buffer *bytes.Buffer, data any) {
 	length := len(data.(string))
 
 	b := make([]byte, 2)
@@ -18,7 +18,7 @@ func (c StringLongCodec) encode(buffer *bytes.Buffer, data any) {
 	buffer.WriteString(data.(string))
 }
 
-func (c StringLongCodec) decode(buffer *bytes.Buffer) any {
+func (c StringLongCodec) Decode(buffer *bytes.Buffer) any {
 	length := binary.BigEndian.Uint16(buffer.Next(2))
 
 	return string(buffer.Next(int(length)))

internal/codec/uint16.go go/codec_uint16.gointernal/codec/uint16.go renamed to go/codec_uint16.go

@@ -1,4 +1,4 @@
-package codec
+package netcode
 
 import (
 	"bytes"
@@ -8,12 +8,12 @@ import (
 type UInt16Codec struct {
 }
 
-func (c UInt16Codec) encode(buffer *bytes.Buffer, data any) {
+func (c UInt16Codec) Encode(buffer *bytes.Buffer, data any) {
 	b := make([]byte, 2)
 	binary.BigEndian.PutUint16(b, data.(uint16))
 	buffer.Write(b)
 }
 
-func (c UInt16Codec) decode(buffer *bytes.Buffer) any {
+func (c UInt16Codec) Decode(buffer *bytes.Buffer) any {
 	return binary.BigEndian.Uint16(buffer.Next(2))
 }

go/codec_uint8.go

@@ -0,0 +1,16 @@
+package netcode
+
+import (
+	"bytes"
+)
+
+type UInt8Codec struct {
+}
+
+func (c UInt8Codec) Encode(buffer *bytes.Buffer, data any) {
+	buffer.WriteByte(data.(uint8))
+}
+
+func (c UInt8Codec) Decode(buffer *bytes.Buffer) any {
+	return buffer.Next(1)[0]
+}

internal/codec/uint_long.go go/codec_uint_long.gointernal/codec/uint_long.go renamed to go/codec_uint_long.go

@@ -1,4 +1,4 @@
-package codec
+package netcode
 
 import (
 	"bytes"
@@ -10,7 +10,7 @@ type LongUIntCodec struct {
 	ByteLength int
 }
 
-func (c LongUIntCodec) encode(buffer *bytes.Buffer, data any) {
+func (c LongUIntCodec) Encode(buffer *bytes.Buffer, data any) {
 	format := fmt.Sprintf("%%0%ds", c.ByteLength*8)
 	value := strconv.FormatUint(uint64(data.(uint)), 2)
 	value = fmt.Sprintf(format, value)
@@ -21,7 +21,7 @@ func (c LongUIntCodec) encode(buffer *bytes.Buffer, data any) {
 	}
 }
 
-func (c LongUIntCodec) decode(buffer *bytes.Buffer) any {
+func (c LongUIntCodec) Decode(buffer *bytes.Buffer) any {
 	var buf = new(bytes.Buffer)
 	parts := buffer.Next(c.ByteLength)
 

internal/codec/unit32.go go/codec_unit32.gointernal/codec/unit32.go renamed to go/codec_unit32.go

@@ -1,4 +1,4 @@
-package codec
+package netcode
 
 import (
 	"bytes"
@@ -8,12 +8,12 @@ import (
 type UInt32Codec struct {
 }
 
-func (c UInt32Codec) encode(buffer *bytes.Buffer, data any) {
+func (c UInt32Codec) Encode(buffer *bytes.Buffer, data any) {
 	b := make([]byte, 4)
 	binary.BigEndian.PutUint32(b, data.(uint32))
 	buffer.Write(b)
 }
 
-func (c UInt32Codec) decode(buffer *bytes.Buffer) any {
+func (c UInt32Codec) Decode(buffer *bytes.Buffer) any {
 	return binary.BigEndian.Uint32(buffer.Next(4))
 }