fix

Reviewed-on: #5

go.mod

@@ -2,4 +2,7 @@ module server
 
 go 1.25.0
 
-require github.com/gorilla/websocket v1.5.3
+require (
+	github.com/gorilla/websocket v1.5.3
+	github.com/telegram-mini-apps/init-data-golang v1.5.0
+)

go.sum

@@ -1,2 +1,4 @@
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/telegram-mini-apps/init-data-golang v1.5.0 h1:rtpsmQ/nihkicPvnrdRXmHHtTnPvG1FmxMRZJwMKPz0=
+github.com/telegram-mini-apps/init-data-golang v1.5.0/go.mod h1:GG4HnRx9ocjD4MjjzOw7gf9Ptm0NvFbDr5xqnfFOYuY=

main.go

@@ -1,191 +1,102 @@
 package main
 
 import (
-	"bytes"
+	"fmt"
-	"encoding/binary"
 	"log"
-	"math/rand"
 	"net/http"
-	"sync"
+	"server/src/controllers"
-	"time"
+	"server/src/models"
 
 	"github.com/gorilla/websocket"
 )
 
-const (
+var upgrader = websocket.Upgrader{
-	PacketHandshake uint8 = 0
-	PacketWorld     uint8 = 1
-
-	TickRate = 30
-	Speed    = 5.0
-
-	SpawnMinX   = -5.0
-	SpawnMaxX   = 5.0
-	SpawnMinZ   = -5.0
-	SpawnMaxZ   = 5.0
-	SpawnRadius = 1.5
-)
-
-type Player struct {
-	ID uint32
-
-	X float32
-	Y float32
-	Z float32
-
-	InputX float32
-	InputZ float32
-
-	Conn *websocket.Conn
-}
-
-var (
-	upgrader = websocket.Upgrader{
 	CheckOrigin: func(r *http.Request) bool { return true },
 }
 
-	players   = make(map[uint32]*Player)
+func ServeWS(room *controllers.Room, w http.ResponseWriter, r *http.Request) {
-	playersMu sync.Mutex
-	nextID    uint32 = 1
-)
-
-func main() {
-	rand.Seed(time.Now().UnixNano())
-
-	http.HandleFunc("/ws", handleWS)
-
-	go gameLoop()
-
-	log.Println("Server running on :8080")
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}
-
-func handleWS(w http.ResponseWriter, r *http.Request) {
 	conn, err := upgrader.Upgrade(w, r, nil)
 	if err != nil {
+		log.Println("Failed to upgrade connection:", err)
 		return
 	}
 
-	playersMu.Lock()
+	var auth models.AuthMessage
-	id := nextID
+	if err := conn.ReadJSON(&auth); err != nil || auth.Type != "auth" {
-	nextID++
+		log.Println("Invalid auth message. Connection closed!")
+		conn.Close()
+		return
+	}
 
-	x, z := randomSpawnPosition()
+	data, err := controllers.VerifyTelegramInitData(auth.InitData, "7697757472:AAESD9HfkWwbIZe-HXR7IazUShr69hZTLmE")
+	if err != nil {
+		log.Println("initData is empty. Connection closed!")
+		conn.Close()
+		return
+	}
 
-	player := &Player{
+	userID := data.User.ID
-		ID:   id,
+	username := data.User.Username
-		X:    x,
+
-		Y:    0,
+	if username == "" {
-		Z:    z,
+		username = data.User.FirstName
+	}
+
+	log.Printf("Player %d connected!", userID)
+
+	player := &models.Player{
+		ID:       userID,
+		Username: username,
 		Conn:     conn,
-	}
+		X:        180,
-	players[id] = player
+		Y:        320,
-	playersMu.Unlock()
-
-	{
-		buf := new(bytes.Buffer)
-		binary.Write(buf, binary.LittleEndian, PacketHandshake)
-		binary.Write(buf, binary.LittleEndian, id)
-		conn.WriteMessage(websocket.BinaryMessage, buf.Bytes())
 	}
 
-	log.Println("Player connected:", id, "spawn at", x, z)
+	room.Players[player.ID] = player
 
-	go readLoop(player)
+	player.Conn.WriteJSON(map[string]any{
+		"type": "init",
+		"payload": map[string]string{
+			"id": fmt.Sprintf("%d", player.ID),
+		},
+	})
+
+	go readLoop(room, player)
 }
 
-func randomSpawnPosition() (float32, float32) {
+func readLoop(room *controllers.Room, player *models.Player) {
-	for i := 0; i < 20; i++ {
-		x := rand.Float32()*(SpawnMaxX-SpawnMinX) + SpawnMinX
-		z := rand.Float32()*(SpawnMaxZ-SpawnMinZ) + SpawnMinZ
-
-		if isSpawnFree(x, z) {
-			return x, z
-		}
-	}
-
-	// fallback
-	return 0, 0
-}
-
-func isSpawnFree(x, z float32) bool {
-	for _, p := range players {
-		dx := p.X - x
-		dz := p.Z - z
-		if dx*dx+dz*dz < SpawnRadius*SpawnRadius {
-			return false
-		}
-	}
-	return true
-}
-
-func readLoop(p *Player) {
 	defer func() {
-		playersMu.Lock()
+		log.Printf("Player %d disconnected!", player.ID)
-		delete(players, p.ID)
+		delete(room.Players, player.ID)
-		playersMu.Unlock()
+		player.Conn.Close()
-
-		p.Conn.Close()
-		log.Println("Player disconnected:", p.ID)
 	}()
 
 	for {
-		_, data, err := p.Conn.ReadMessage()
+		var msg models.StateMessage
+		err := player.Conn.ReadJSON(&msg)
 		if err != nil {
 			return
 		}
 
-		if len(data) < 8 {
+		switch msg.Type {
-			continue
+		case models.InputMsgType:
+			var input models.InputMessage = msg.Payload.(models.InputMessage)
+			player.X = input.DX
+			player.Y = input.DY
+			room.Input <- input
 		}
-
-		buf := bytes.NewReader(data)
-		binary.Read(buf, binary.LittleEndian, &p.InputX)
-		binary.Read(buf, binary.LittleEndian, &p.InputZ)
 	}
 }
 
-func gameLoop() {
+func main() {
-	ticker := time.NewTicker(time.Second / TickRate)
+	room := controllers.NewRoom()
-	defer ticker.Stop()
 
-	dt := float32(1.0 / TickRate)
+	go room.Run()
 
-	for range ticker.C {
+	http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
-		update(dt)
+		ServeWS(room, w, r)
-		broadcast()
+	})
-	}
+
-}
+	log.Println("Server started on :8080")
-
+	log.Fatal(http.ListenAndServe(":8080", nil))
-func update(dt float32) {
-	playersMu.Lock()
-	defer playersMu.Unlock()
-
-	for _, p := range players {
-		p.X += p.InputX * Speed * dt
-		p.Z += p.InputZ * Speed * dt
-	}
-}
-
-func broadcast() {
-	playersMu.Lock()
-	defer playersMu.Unlock()
-
-	buf := new(bytes.Buffer)
-
-	binary.Write(buf, binary.LittleEndian, PacketWorld)
-	binary.Write(buf, binary.LittleEndian, uint16(len(players)))
-
-	for _, p := range players {
-		binary.Write(buf, binary.LittleEndian, p.ID)
-		binary.Write(buf, binary.LittleEndian, p.X)
-		binary.Write(buf, binary.LittleEndian, p.Y)
-		binary.Write(buf, binary.LittleEndian, p.Z)
-	}
-
-	data := buf.Bytes()
-
-	for _, p := range players {
-		p.Conn.WriteMessage(websocket.BinaryMessage, data)
-	}
 }

src/controllers/room.go

@@ -0,0 +1,83 @@
+package controllers
+
+import (
+	"server/src/models"
+	"sync"
+	"time"
+)
+
+type Room struct {
+	Players map[int64]*models.Player
+	Input   chan models.InputMessage
+	mu      sync.Mutex
+}
+
+func NewRoom() *Room {
+	return &Room{
+		Players: make(map[int64]*models.Player),
+		Input:   make(chan models.InputMessage, 128),
+	}
+}
+
+func (r *Room) update() {
+	for {
+		select {
+		case input := <-r.Input:
+			r.mu.Lock()
+			p := r.Players[input.PlayerID]
+			if p != nil {
+				p.DX = input.DX
+				p.DY = input.DY
+			}
+			r.mu.Unlock()
+		default:
+			goto DONE
+		}
+	}
+DONE:
+
+	// 2️⃣ двигаем игроков
+	r.mu.Lock()
+	for _, p := range r.Players {
+		p.X += p.DX * 4
+		p.Y += p.DY * 4
+	}
+	r.mu.Unlock()
+}
+
+func (r *Room) broadcast() {
+	r.mu.Lock()
+
+	state := make(map[int64]map[string]any, len(r.Players))
+	for id, p := range r.Players {
+		state[id] = map[string]any{
+			"x":    p.X,
+			"y":    p.Y,
+			"name": p.Username,
+		}
+	}
+
+	r.mu.Unlock()
+
+	msg := models.StateMessage{
+		Type: "input",
+		Payload: map[string]any{
+			"players": state,
+		},
+	}
+
+	// отправляем БЕЗ mutex — важно
+	for _, p := range r.Players {
+		_ = p.Conn.WriteJSON(msg)
+	}
+}
+
+func (r *Room) Run() {
+	ticker := time.NewTicker(time.Second / 30)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		r.update()
+		r.broadcast()
+	}
+}

src/controllers/telegram.go

@@ -0,0 +1,16 @@
+package controllers
+
+import (
+	"time"
+
+	initdata "github.com/telegram-mini-apps/init-data-golang"
+)
+
+func VerifyTelegramInitData(initData, botToken string) (initdata.InitData, error) {
+	expIn := 24 * time.Hour
+	err := initdata.Validate(initData, botToken, expIn)
+	if err != nil {
+		return initdata.InitData{}, err
+	}
+	return initdata.Parse(initData)
+}

src/models/auth.go

@@ -0,0 +1,6 @@
+package models
+
+type AuthMessage struct {
+	Type     string `json:"type"`
+	InitData string `json:"initData"`
+}

src/models/player.go

@@ -0,0 +1,14 @@
+package models
+
+import (
+	"github.com/gorilla/websocket"
+)
+
+type Player struct {
+	ID       int64
+	Username string
+	Conn     *websocket.Conn
+
+	X, Y   float64
+	DX, DY float64
+}

src/models/protocol.go

@@ -0,0 +1,19 @@
+package models
+
+type MsgType string
+
+const (
+	InputMsgType MsgType = "input"
+	ChatMsgType  MsgType = "chat"
+)
+
+type InputMessage struct {
+	PlayerID int64
+	DX       float64 `json:"dx"`
+	DY       float64 `json:"dy"`
+}
+
+type StateMessage struct {
+	Type    MsgType `json:"type"`
+	Payload any     `json:"payload"`
+}