new server

controllers/connection.go

@@ -0,0 +1,55 @@
+package controllers
+
+import (
+	"log"
+	"server/models"
+
+	"github.com/gorilla/websocket"
+)
+
+func (h *Hub) readLoop(conn *websocket.Conn) {
+	handMessage := models.Message{Type: MSG_WELCOME}
+	_ = conn.WriteMessage(websocket.BinaryMessage, handMessage.Encode())
+
+	var player *models.Player
+
+	defer func() {
+		if player != nil {
+			h.removePlayer(player.ID)
+			log.Println("Player left:", player.ID)
+		}
+		conn.Close()
+	}()
+
+	for {
+		_, bytes, err := conn.ReadMessage()
+		if err != nil {
+			return
+		}
+
+		msg, err := models.Decode(bytes)
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+
+		switch msg.Type {
+
+		case MSG_WELCOME:
+			if player != nil {
+				continue
+			}
+			player = h.handShake(msg.Payload, conn)
+			log.Println("Player joined:", player.ID)
+
+		case MSG_INPUT:
+			if player == nil {
+				continue
+			}
+			reader := models.NewReader(msg.Payload)
+			x := reader.ReadF32()
+			y := reader.ReadF32()
+			h.updatePosition(x, y, player)
+		}
+	}
+}

controllers/hub.go

@@ -1,17 +1,15 @@
 package controllers
 
 import (
-	"bytes"
 	"log"
 	"net/http"
 	"server/models"
-
-	"github.com/gorilla/websocket"
+	"sync"
 )
 
 type Hub struct {
-	Players      map[uint32]*models.Player
-	ServerBuffer []byte
+	Players map[uint32]*models.Player
+	Mu      sync.RWMutex
 }
 
 func NewHub() *Hub {
@@ -20,55 +18,9 @@ func NewHub() *Hub {
 	}
 }
 
-func (h *Hub) readLoop(conn *websocket.Conn) {
-	p := &models.Player{
-		ID:     uint32(len(h.Players) + 1),
-		Conn:   conn,
-		InputX: 0,
-		InputZ: 0,
-	}
-
-	log.Println("Player connected:", p.ID)
-
-	h.Players[p.ID] = p
-
-	defer func() {
-		delete(h.Players, p.ID)
-
-		p.Conn.Close()
-		log.Println("Player disconnected:", p.ID)
-	}()
-
-	for {
-		_, data, err := p.Conn.ReadMessage()
-		if err != nil {
-			return
-		}
-
-		if len(data) < 8 {
-			continue
-		}
-
-		buf := bytes.NewReader(data)
-		log.Println(buf)
-	}
-}
-
-func (h *Hub) ws(w http.ResponseWriter, r *http.Request) {
-	upgrader := websocket.Upgrader{
-		CheckOrigin: func(r *http.Request) bool { return true },
-	}
-
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	go h.readLoop(conn)
-}
-
 func (h *Hub) Start() {
+	go h.updateWorld()
 	http.HandleFunc("/ws", h.ws)
+	log.Println("Server listen port 8080")
 	log.Fatal(http.ListenAndServe(":8080", nil))
 }

controllers/players.go

@@ -0,0 +1,43 @@
+package controllers
+
+import (
+	"server/models"
+
+	"github.com/gorilla/websocket"
+)
+
+func (h *Hub) handShake(msg []byte, conn *websocket.Conn) *models.Player {
+	reader := models.NewReader(msg)
+	newID := reader.ReadU32()
+	name := reader.ReadString()
+
+	player := &models.Player{
+		Entity: models.Entity{
+			Type: models.EntityPlayer,
+			ID:   newID,
+		},
+		Name: name,
+		Conn: conn,
+	}
+
+	h.Mu.Lock()
+	h.Players[player.ID] = player
+	h.Mu.Unlock()
+
+	return player
+}
+
+func (h *Hub) updatePosition(x, y float32, player *models.Player) {
+	h.Mu.Lock()
+	defer h.Mu.Unlock()
+
+	player.X = x
+	player.Y = y
+}
+
+func (h *Hub) removePlayer(id uint32) {
+	h.Mu.Lock()
+	defer h.Mu.Unlock()
+
+	delete(h.Players, id)
+}

controllers/protocol.go

@@ -0,0 +1,7 @@
+package controllers
+
+const (
+	MSG_WELCOME  = 0
+	MSG_INPUT    = 1
+	MSG_SNAPSHOT = 2
+)

controllers/world.go

@@ -0,0 +1,46 @@
+package controllers
+
+import (
+	"server/models"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+func (h *Hub) broadcastSnapshot() {
+	h.Mu.RLock()
+	defer h.Mu.RUnlock()
+
+	w := models.Writer{}
+	w.WriteU16(uint16(len(h.Players)))
+
+	for _, p := range h.Players {
+		w.WriteU32(p.ID)
+		w.WriteU8(uint8(models.EntityPlayer))
+		w.WriteF32(p.X)
+		w.WriteF32(p.Y)
+		w.WriteF32(p.Z)
+		w.WriteF32(p.Yaw)
+	}
+
+	msg := models.Message{
+		Type:    MSG_SNAPSHOT,
+		Version: 1,
+		Payload: w.Bytes(),
+	}
+
+	for _, p := range h.Players {
+		if p.Conn != nil {
+			_ = p.Conn.WriteMessage(websocket.BinaryMessage, msg.Encode())
+		}
+	}
+}
+
+func (h *Hub) updateWorld() {
+	ticker := time.NewTicker(50 * time.Millisecond)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		h.broadcastSnapshot()
+	}
+}

controllers/ws.go

@@ -0,0 +1,22 @@
+package controllers
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/gorilla/websocket"
+)
+
+func (h *Hub) ws(w http.ResponseWriter, r *http.Request) {
+	upgrader := websocket.Upgrader{
+		CheckOrigin: func(r *http.Request) bool { return true },
+	}
+
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	go h.readLoop(conn)
+}