api/handler/handler.go

@@ -30,6 +30,7 @@ func HostGameHandler(c *gin.Context) {
 	passphrase := lobby.Passphrase.String()
 	info := api.PlayerInfo{
 		PlayerID:   &player.Uuid,
+		LobbyID:    &lobby.Uuid,
 		Passphrase: &passphrase,
 	}
 	c.Header("Access-Control-Allow-Origin", "*")
@@ -53,14 +54,15 @@ func GetLobbyForPassphraseHandler(c *gin.Context) {
 		return
 	}
 
-	passphrase := api.Passphrase{
+	lobbyInfo := api.LobbyInfo{
-		Value: (*string)(&lobby.Passphrase),
+		ID: &lobby.Uuid,
 	}
 
 	c.Header("Access-Control-Allow-Origin", "*")
-	c.IndentedJSON(http.StatusOK, passphrase)
+	c.IndentedJSON(http.StatusOK, lobbyInfo)
 }
 
+// TODO: this will be replaced by the JoinGameHandler()
 func JoinPrivateGame(c *gin.Context) {
 	limiter.Take()
 
@@ -75,7 +77,8 @@ func JoinPrivateGame(c *gin.Context) {
 
 	if req.Passphrase != nil &&
 		*req.Passphrase != "" &&
-		req.PlayerID != nil { //is reconnect
+		req.PlayerID != nil &&
+		req.LobbyID != nil { //is reconnect
 		lobby := u.FindExistingPrivateLobby(utils.Passphrase(*req.Passphrase))
 		var found bool
 		if lobby != nil {
@@ -87,6 +90,7 @@ func JoinPrivateGame(c *gin.Context) {
 				http.StatusOK,
 				api.PlayerInfo{
 					PlayerID:   req.PlayerID,
+					LobbyID:    req.LobbyID,
 					Passphrase: req.Passphrase,
 				})
 			return
@@ -110,6 +114,7 @@ func JoinPrivateGame(c *gin.Context) {
 
 	info := api.PlayerInfo{
 		PlayerID:   &player.Uuid,
+		LobbyID:    &lobby.Uuid,
 		Passphrase: req.Passphrase,
 	}
 	c.Header("Access-Control-Allow-Origin", "*")
@@ -119,22 +124,25 @@ func JoinPrivateGame(c *gin.Context) {
 func JoinGameHandler(c *gin.Context) {
 	limiter.Take()
 
-	passphrase := api.Passphrase{}
+	id := c.Param("id")
-	err := c.ShouldBindJSON(&passphrase)
+	idAsUUID, err := uuid.Parse(id)
 	if err != nil {
 		c.IndentedJSON(http.StatusBadRequest, nil)
 		return
 	}
 
+	passphrase := api.Passphrase{}
+	c.ShouldBindJSON(&passphrase)
+
 	u := lobbies.GetUsher()
-	lobby := u.FindExistingPrivateLobby(utils.Passphrase(*passphrase.Value))
+	lobby := u.GetLobbyByID(idAsUUID)
 	if lobby == nil {
 		c.IndentedJSON(http.StatusNotFound, nil)
 		return
 	}
 
-	lobbyInfo := api.Passphrase{
+	lobbyInfo := api.LobbyInfo{
-		Value: (*string)(&lobby.Passphrase),
+		ID: &lobby.Uuid,
 	}
 
 	c.IndentedJSON(http.StatusOK, lobbyInfo)

api/handler/handler_test.go

@@ -9,12 +9,13 @@ import (
 	"testing"
 
 	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 )
 
 func Test_GetLobbyFromPassphraseHandler(t *testing.T) {
 	var passphraseURLParameter string
-	var receivedPhrase string
+	var hostedLobbyId uuid.UUID
 
 	t.Run("host a lobby", func(t *testing.T) {
 		r1 := httptest.NewRecorder()
@@ -29,7 +30,8 @@ func Test_GetLobbyFromPassphraseHandler(t *testing.T) {
 		err := json.Unmarshal(r1.Body.Bytes(), &playerInfo)
 		assert.NoError(t, err)
 
-		receivedPhrase = *playerInfo.Passphrase
+		receivedPhrase := *playerInfo.Passphrase
+		hostedLobbyId = *playerInfo.LobbyID
 
 		passphrase := utils.NewPassphraseFromString(receivedPhrase)
 		passphraseURLParameter = passphrase.AsURLParam()
@@ -46,10 +48,10 @@ func Test_GetLobbyFromPassphraseHandler(t *testing.T) {
 
 		engine.ServeHTTP(r2, getLobbyRequest)
 
-		passhrase := api.Passphrase{}
+		lobbyInfo := api.LobbyInfo{}
-		err := json.Unmarshal(r2.Body.Bytes(), &passhrase)
+		err := json.Unmarshal(r2.Body.Bytes(), &lobbyInfo)
 		assert.NoError(t, err)
 
-		assert.Equal(t, http.StatusOK, r2.Code)
+		assert.Equal(t, hostedLobbyId, *lobbyInfo.ID)
 	})
 }

api/handler/websocket.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"log"
 	"mchess_server/api"
-	"mchess_server/utils"
 	"net/http"
 
 	"mchess_server/lobbies"
@@ -24,6 +23,7 @@ var upgrader = gorillaws.Upgrader{
 func RegisterWebSocketConnection(c *gin.Context) {
 	limiter.Take()
 
+	log.Println(c.Request)
 	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
 	if err != nil {
 		log.Println(err)
@@ -55,7 +55,7 @@ func waitForAndHandlePlayerID(ctx context.Context, conn *gorillaws.Conn) {
 		return
 	}
 
-	lobby := lobbies.GetLobbyRegistry().GetLobbyByPassphrase(utils.NewPassphraseFromString(*info.Passphrase))
+	lobby := lobbies.GetLobbyRegistry().GetLobbyByUUID(*info.LobbyID)
 	if lobby == nil {
 		conn.WriteMessage(msgType, []byte("lobby not found"))
 		conn.Close()
@@ -68,13 +68,11 @@ func waitForAndHandlePlayerID(ctx context.Context, conn *gorillaws.Conn) {
 		conn.Close()
 		return
 	}
-
+	if player.Conn.HasWebsocketConnection() {
+		player.Conn.Close("closing existing connection")
+	}
 	lobby.Game.SetWebsocketConnectionFor(ctx, player, conn)
-
+	log.Println("player after setting connection: ", player)
-	log.Println("player after setting connection: ")
-	log.Println("id: ", player.Uuid)
-	log.Println("color: ", player.GetColor())
-	log.Println("Connection: ", player.Conn.ID)
 }
 
 func ConnectWsForGame(c *gin.Context) {

api/lobby_info.go

@@ -0,0 +1,7 @@
+package api
+
+import "github.com/google/uuid"
+
+type LobbyInfo struct {
+	ID *uuid.UUID `json:"id,omitempty"`
+}

api/player_info.go

@@ -4,5 +4,6 @@ import "github.com/google/uuid"
 
 type PlayerInfo struct {
 	PlayerID   *uuid.UUID `json:"playerID,omitempty"`
+	LobbyID    *uuid.UUID `json:"lobbyID,omitempty"`
 	Passphrase *string    `json:"passphrase,omitempty"`
 }

chess/game.go

@@ -105,7 +105,7 @@ func (game *Game) Handle() {
 				log.Println("Error while reading message:", err)
 				return
 			}
-			log.Println("Player ", game.currentTurnPlayer.color.String(), " moved:\n", receivedMove)
+			log.Println("Player ", game.currentTurnPlayer, " moved:\n", receivedMove)
 
 			game.gameState = CheckMove
 		case CheckMove:
@@ -117,7 +117,7 @@ func (game *Game) Handle() {
 					log.Println("Error marshalling 'colorDetermined' message for player 1", err)
 					return
 				}
-				game.currentTurnPlayer.writeMessage(string(invalidMoveMessage))
+				game.currentTurnPlayer.writeMessage(invalidMoveMessage)
 				game.gameState = PlayerToMove
 				continue
 			}
@@ -181,16 +181,15 @@ func (game Game) notifyPlayersAboutGameStart() error {
 		return err
 	}
 
-	game.GetPlayer1().writeMessage(string(colorDeterminedPlayer1))
+	game.GetPlayer1().writeMessage(colorDeterminedPlayer1)
 	game.GetPlayer1().SendBoardState(types.Move{}, game.board.PGN(), types.White)
 
-	game.GetPlayer2().writeMessage(string(colorDeterminedPlayer2))
+	game.GetPlayer2().writeMessage(colorDeterminedPlayer2)
 	game.GetPlayer2().SendBoardState(types.Move{}, game.board.PGN(), types.White)
 	return nil
 }
 
 func (game Game) broadcastMove(move types.Move) error {
-	log.Println("broadcast move")
 	err := game.GetPlayer1().SendBoardState(move, game.board.PGN(), game.currentTurnPlayer.GetColor())
 	if err != nil {
 		return err
@@ -223,7 +222,3 @@ func (game *Game) playerDisconnected(p *Player) {
 func (game *Game) SetWebsocketConnectionFor(ctx context.Context, p *Player, ws *gorillaws.Conn) {
 	p.SetWebsocketConnectionAndSendBoardState(ctx, ws, &game.board)
 }
-
-func (game *Game) SendBoardStateTo(p *Player) {
-	p.SendBoardState(game.board.getLastMove(), game.board.PGN(), game.board.colorToMove)
-}

chess/player.go

@@ -36,7 +36,6 @@ func (p Player) hasWebsocketConnection() bool {
 
 func (p *Player) SetWebsocketConnection(ctx context.Context, ws *gorillaws.Conn) {
 	p.Conn.SetWebsocketConnection(ws)
-	p.Conn.SetForColor(p.color)
 }
 
 func (p *Player) SetWebsocketConnectionAndSendBoardState(
@@ -50,7 +49,6 @@ func (p *Player) SetWebsocketConnectionAndSendBoardState(
 
 func (p *Player) SetColor(color types.ChessColor) {
 	p.color = color
-	p.Conn.SetForColor(p.color)
 }
 
 func (p *Player) GetColor() types.ChessColor {
@@ -89,8 +87,11 @@ func (p *Player) SendBoardState(move types.Move, boardPosition string, turnColor
 		return err
 	}
 
-	p.writeMessage(string(messageToSend))
+	err = p.writeMessage(messageToSend)
-
+	if err != nil {
+		log.Println("Error during message writing:", err)
+		return err
+	}
 	return nil
 }
 
@@ -105,8 +106,11 @@ func (p *Player) SendMoveAndPosition(move types.Move, boardPosition string) erro
 		return err
 	}
 
-	p.writeMessage(string(messageToSend))
+	err = p.writeMessage(messageToSend)
-
+	if err != nil {
+		log.Println("Error during message writing:", err)
+		return err
+	}
 	return nil
 }
 
@@ -120,20 +124,26 @@ func (p *Player) SendGameEnded(reason GameEndedReason) error {
 		log.Println("Error while marshalling: ", err)
 		return err
 	}
-	p.writeMessage(string(messageToSend))
+	err = p.writeMessage(messageToSend)
-
+	if err != nil {
+		log.Println("Error during message writing:", err)
+		return err
+	}
 	return nil
 }
 
-func (p *Player) writeMessage(msg string) {
+func (p *Player) writeMessage(msg []byte) error {
-	p.Conn.Write(msg)
+	return p.Conn.Write(msg)
 }
 
 func (p *Player) ReadMove() (types.Move, error) {
-	receivedMessage := p.readMessage()
+	receivedMessage, err := p.readMessage()
+	if err != nil {
+		return types.Move{}, err
+	}
 
 	var msg api.WebsocketMessage
-	err := json.Unmarshal(receivedMessage, &msg)
+	err = json.Unmarshal(receivedMessage, &msg)
 	if err != nil {
 		return types.Move{}, err
 	}
@@ -145,9 +155,9 @@ func (p *Player) ReadMove() (types.Move, error) {
 	return *msg.Move, nil
 }
 
-func (p *Player) readMessage() []byte {
+func (p *Player) readMessage() ([]byte, error) {
-	msg := p.Conn.Read()
+	msg, err := p.Conn.Read()
-	log.Printf("Reading message from %s: %s", p.color.String(), string(msg))
+	log.Printf("Reading message: %s from player %s", string(msg), p.Uuid.String())
 
-	return msg
+	return msg, err
 }

connection/message_buffer.go

@@ -50,7 +50,7 @@ func (b *MessageBuffer) Insert(msg string) {
 	b.cond.Broadcast()
 }
 
-func (b *MessageBuffer) Get() string {
+func (b *MessageBuffer) Get() (string, error) {
 	b.cond.L.Lock()
 	defer b.cond.L.Unlock()
 
@@ -69,7 +69,7 @@ func (b *MessageBuffer) Get() string {
 	}
 	b.getIndex = b.incrementAndWrapIndex(b.getIndex)
 
-	return msg.content
+	return msg.content, nil
 }
 
 func (b MessageBuffer) incrementAndWrapIndex(index int) int {

connection/message_buffer_test.go

@@ -66,7 +66,8 @@ func Test_MessageBuffer_GetWaitsForFirstData(t *testing.T) {
 		buf.Insert("delayed-message")
 	}()
 
-	msg := buf.Get()
+	msg, err := buf.Get()
+	assert.NoError(t, err)
 
 	endTime := time.Now()
 
@@ -78,7 +79,8 @@ func Test_MessageBuffer_GetWaitsForNewData(t *testing.T) {
 	buf := newMessageBuffer(2)
 
 	buf.Insert("message-1")
-	msg := buf.Get()
+	msg, err := buf.Get()
+	assert.NoError(t, err)
 	assert.Equal(t, "message-1", msg)
 
 	go func() {
@@ -87,7 +89,8 @@ func Test_MessageBuffer_GetWaitsForNewData(t *testing.T) {
 		buf.Insert("delayed-message")
 	}()
 
-	msg = buf.Get()
+	msg, err = buf.Get()
+	assert.NoError(t, err)
 	assert.Equal(t, "delayed-message", msg)
 }
 
@@ -114,7 +117,8 @@ func Test_MessageBuffer_IndexesAreCorrectAfterOverwritingOldData(t *testing.T) {
 		},
 		buf.messages)
 
-	msg := buf.Get()
+	msg, err := buf.Get()
+	assert.NoError(t, err)
 	assert.Equal(t, "message-2", msg)
 }
 
@@ -122,11 +126,13 @@ func Test_MessageBuffer_GetWaitsForNewDataIfOldOneWasAlreadyGotten(t *testing.T)
 	buf := newMessageBuffer(2)
 
 	buf.Insert(message1)
-	msg := buf.Get()
+	msg, err := buf.Get()
+	assert.NoError(t, err)
 	assert.Equal(t, message1, msg)
 
 	buf.Insert(message2)
-	msg = buf.Get()
+	msg, err = buf.Get()
+	assert.NoError(t, err)
 	assert.Equal(t, message2, msg)
 
 	go func() {
@@ -134,7 +140,8 @@ func Test_MessageBuffer_GetWaitsForNewDataIfOldOneWasAlreadyGotten(t *testing.T)
 		buf.Insert(message3)
 	}()
 
-	msg = buf.Get()
+	msg, err = buf.Get()
+	assert.NoError(t, err)
 	assert.Equal(t, message3, msg)
 
 }
@@ -150,8 +157,9 @@ func Test_MessageBuffer_InsertCatchesUpWithRead(t *testing.T) {
 	buf.Insert(message6)
 	buf.Insert(message7)
 
-	msg := buf.Get()
+	msg, err := buf.Get()
 
+	assert.NoError(t, err)
 	assert.Equal(t, message3, msg)
 }
 
@@ -164,7 +172,7 @@ func Test_MessageBuffer_FuckShitUp(t *testing.T) {
 	var readMsg = make([]string, 0)
 	go func() {
 		for i := 0; i < size*10; i++ {
-			msg := buf.Get()
+			msg, _ := buf.Get()
 			if msg == "99" {
 				break
 			}

connection/type.go

@@ -3,27 +3,24 @@ package connection
 import (
 	"context"
 	"log"
-	"mchess_server/types"
+	"sync"
 
-	"github.com/google/uuid"
 	gorillaws "github.com/gorilla/websocket"
 )
 
 type Connection struct {
-	ID                 uuid.UUID
+	ws                      *gorillaws.Conn
-	ws                 *gorillaws.Conn
+	wsConnectionEstablished chan bool
-	ctx                context.Context
+	wsWriteLock             sync.Mutex
-	rxBuffer           *MessageBuffer
+	ctx                     context.Context
-	txBuffer           *MessageBuffer
+	buffer                  MessageBuffer
-	disconnectCallback func()
+	disconnectCallback      func()
-	forColor           types.ChessColor
 }
 
 func NewConnection(options ...func(*Connection)) *Connection {
 	connection := Connection{
-		ID:       uuid.New(),
+		buffer:                  *newMessageBuffer(100),
-		rxBuffer: newMessageBuffer(100),
+		wsConnectionEstablished: make(chan bool),
-		txBuffer: newMessageBuffer(100),
 	}
 
 	for _, option := range options {
@@ -53,10 +50,6 @@ func WithDisconnectCallback(cb func()) func(*Connection) {
 	}
 }
 
-func (conn *Connection) SetForColor(color types.ChessColor) {
-	conn.forColor = color
-}
-
 func (conn *Connection) SetDisconnectCallback(cb func()) {
 	conn.disconnectCallback = cb
 }
@@ -65,73 +58,63 @@ func (conn *Connection) HasWebsocketConnection() bool {
 	return conn.ws != nil
 }
 
-func (conn *Connection) readFromRxBuffer() {
-	for {
-		_, msg, err := conn.ws.ReadMessage()
-		if err != nil {
-			conn.logConnection("while reading from websocket: %w", err)
-			conn.Close("")
-			conn.txBuffer.Insert("we do this to make txBuffer.Get() return")
-			return
-		}
-		conn.rxBuffer.Insert(string(msg))
-	}
-}
-
-func (conn *Connection) writeTxBuffer() {
-	for {
-		msg := conn.txBuffer.Get()
-
-		if conn.ws == nil {
-			return
-		}
-
-		err := conn.ws.WriteMessage(gorillaws.TextMessage, []byte(msg))
-		if err != nil {
-			conn.logConnection("while writing to websocket: %w", err)
-			return
-		}
-	}
-}
-
 func (conn *Connection) SetWebsocketConnection(ws *gorillaws.Conn) {
 	if ws == nil {
-		conn.logConnection("ERROR: setting ws = null")
 		return
 	}
 
 	conn.ws = ws
 
-	go conn.readFromRxBuffer()
+	select {
-	go conn.writeTxBuffer()
+	case conn.wsConnectionEstablished <- true:
+	default:
+	}
 
-	defer conn.logConnection("websocket connection set")
+	go func() {
+		for {
+			_, msg, err := conn.ws.ReadMessage()
+			if err != nil {
+				log.Println("while reading from websocket: %w", err)
+
+				conn.unsetWebsocketConnection()
+				if conn.disconnectCallback != nil {
+					conn.disconnectCallback()
+				}
+				return
+			}
+			conn.buffer.Insert(string(msg))
+		}
+	}()
 }
 
 func (conn *Connection) unsetWebsocketConnection() {
-	conn.logConnection("websocket connection unset")
 	conn.ws = nil
 }
 
-func (conn *Connection) Write(msg string) {
+func (conn *Connection) Write(msg []byte) error {
-	conn.logConnection("Writing message: ", string(msg))
+	conn.wsWriteLock.Lock()
-	conn.txBuffer.Insert(msg)
+	defer conn.wsWriteLock.Unlock()
+
+	if conn.ws == nil { //if ws is not yet set, we wait for it
+		<-conn.wsConnectionEstablished
+	}
+
+	log.Printf("Writing message: %s", string(msg))
+	return conn.ws.WriteMessage(gorillaws.TextMessage, msg)
 }
 
-func (conn *Connection) Read() []byte {
+func (conn *Connection) Read() ([]byte, error) {
-	msg := conn.rxBuffer.Get()
+	msg, err := conn.buffer.Get()
+	if err != nil {
+		conn.ws = nil
+		return nil, err // TODO: Tell game-handler that connection was lost
+	}
 
-	return []byte(msg)
+	return []byte(msg), err
 }
 
 func (conn *Connection) Close(msg string) {
-	conn.logConnection("closing websocket connection")
 	conn.ws.WriteMessage(gorillaws.TextMessage, []byte(msg))
 	conn.ws.Close()
 	conn.ws = nil
 }
-
-func (con *Connection) logConnection(v ...any) {
-	log.Println("on connection: ", con.ID)
-	log.Println("for color: ", con.forColor.String(), v)
-}

lobbies/lobby.go

@@ -8,15 +8,17 @@ import (
 )
 
 type Lobby struct {
-	Uuid       uuid.UUID
+	Uuid         uuid.UUID
-	Game       *chess.Game
+	Game         *chess.Game
-	Passphrase utils.Passphrase
+	PlayerJoined chan bool
+	Passphrase   utils.Passphrase
 }
 
 func NewEmptyLobbyWithUUID(uuid uuid.UUID) *Lobby {
 	return &Lobby{
-		Uuid: uuid,
+		Uuid:         uuid,
-		Game: chess.NewGame(),
+		Game:         chess.NewGame(),
+		PlayerJoined: make(chan bool),
 	}
 }
 

lobbies/registry.go

@@ -7,7 +7,7 @@ import (
 )
 
 type LobbyRegistry struct {
-	lobbies map[utils.Passphrase]*Lobby
+	lobbies map[uuid.UUID]*Lobby
 }
 
 var instance *LobbyRegistry
@@ -21,7 +21,7 @@ func GetLobbyRegistry() *LobbyRegistry {
 }
 
 func newLobbyRegistry() *LobbyRegistry {
-	return &LobbyRegistry{lobbies: make(map[utils.Passphrase]*Lobby)}
+	return &LobbyRegistry{lobbies: make(map[uuid.UUID]*Lobby)}
 }
 
 func (r *LobbyRegistry) CreateNewPrivateLobby() *Lobby {
@@ -42,6 +42,10 @@ func (r *LobbyRegistry) GetLobbyForPlayer() *Lobby {
 	return newLobby
 }
 
+func (r *LobbyRegistry) GetLobbyByUUID(uuid uuid.UUID) *Lobby {
+	return r.lobbies[uuid]
+}
+
 func (r *LobbyRegistry) GetLobbyByPassphrase(p utils.Passphrase) *Lobby {
 	for _, lobby := range r.lobbies {
 		if lobby.Passphrase == p {
@@ -52,6 +56,6 @@ func (r *LobbyRegistry) GetLobbyByPassphrase(p utils.Passphrase) *Lobby {
 }
 
 func (r *LobbyRegistry) addNewLobby(lobby *Lobby) uuid.UUID {
-	r.lobbies[lobby.Passphrase] = lobby
+	r.lobbies[lobby.Uuid] = lobby
 	return lobby.Uuid
 }

lobbies/usher.go

@@ -3,6 +3,8 @@ package lobbies
 import (
 	"mchess_server/chess"
 	"mchess_server/utils"
+
+	"github.com/google/uuid"
 )
 
 type Usher struct {
@@ -22,15 +24,25 @@ func GetUsher() *Usher {
 }
 
 func (u *Usher) WelcomeNewPlayer(player *chess.Player) *Lobby {
-	return GetLobbyRegistry().GetLobbyForPlayer()
+	lobby := GetLobbyRegistry().GetLobbyForPlayer()
+	return lobby
 }
 
 func (u *Usher) CreateNewPrivateLobby(player *chess.Player) *Lobby {
-	return GetLobbyRegistry().CreateNewPrivateLobby()
+	lobby := GetLobbyRegistry().CreateNewPrivateLobby()
+	return lobby
 }
 
 func (u *Usher) FindExistingPrivateLobby(p utils.Passphrase) *Lobby {
-	return GetLobbyRegistry().GetLobbyByPassphrase(p)
+	lobby := GetLobbyRegistry().GetLobbyByPassphrase(p)
+	if lobby == nil || lobby.AreBothPlayersConnected() {
+		return nil
+	}
+	return lobby
+}
+
+func (*Usher) GetLobbyByID(id uuid.UUID) *Lobby {
+	return GetLobbyRegistry().GetLobbyByUUID(id)
 }
 
 func (u *Usher) AddPlayerToLobbyAndStartGameIfFull(player *chess.Player, lobby *Lobby) {