Marco
ae3e73f711
1. Implement thread-safe ringbuffer for websocket messages This implements a ringbuffer that is used to decouple the raw websocket connection from the messages that the game handler handles. 2. Change websocket handling With this commit, we stop waiting for the websocket connection to be established before the game starts. Now, the Connection type is responsible for waiting for the websocket connection before writing. Some bugs are still happening: 1. The rejoining client is not told the state of the board 2. Invalid moves are not handled by the client (not sure why though) 3. The still-connected client should be told, that the opponent disconnected. Then the client should show the passphrase again 3. Introduce method to send status of board and player 4. Reconnect works (kind of) With the right changes in the client, the reconnect works (but only for the first time). WARNING: At the moment, we will create a new player whenever connection wants to join a private game. This will also clear all the disconnect callbacks that we set in the player.
142 lines
3.0 KiB
Go
142 lines
3.0 KiB
Go
package chess
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"log"
|
|
"mchess_server/api"
|
|
"mchess_server/connection"
|
|
"mchess_server/types"
|
|
|
|
"github.com/google/uuid"
|
|
"nhooyr.io/websocket"
|
|
)
|
|
|
|
type Player struct {
|
|
Uuid uuid.UUID
|
|
Conn *connection.Connection
|
|
color types.ChessColor
|
|
disconnectCallback func(p *Player)
|
|
}
|
|
|
|
func NewPlayer(uuid uuid.UUID) *Player {
|
|
player := &Player{
|
|
Uuid: uuid,
|
|
Conn: connection.NewConnection(
|
|
connection.WithContext(context.Background())),
|
|
}
|
|
|
|
return player
|
|
}
|
|
|
|
func (p Player) hasWebsocketConnection() bool {
|
|
return p.Conn.HasWebsocketConnection()
|
|
}
|
|
|
|
func (p *Player) SetWebsocketConnection(ctx context.Context, ws *websocket.Conn) {
|
|
p.Conn.SetWebsocketConnection(ws)
|
|
}
|
|
|
|
func (p *Player) SetWebsocketConnectionAndSendBoardState(
|
|
ctx context.Context,
|
|
ws *websocket.Conn,
|
|
boardPosition string,
|
|
turnColor types.ChessColor,
|
|
) {
|
|
p.SetWebsocketConnection(ctx, ws)
|
|
p.SendBoardState(boardPosition, turnColor)
|
|
}
|
|
|
|
func (p *Player) SetDisconnectCallback(cb func(*Player)) {
|
|
// Todo: Fucking complicated
|
|
p.Conn.SetDisconnectCallback(p.PlayerDisconnectedCallback)
|
|
p.disconnectCallback = cb
|
|
}
|
|
|
|
func (p *Player) PlayerDisconnectedCallback() {
|
|
p.disconnectCallback(p)
|
|
}
|
|
|
|
func (p *Player) IsInGame() bool {
|
|
return p.hasWebsocketConnection()
|
|
}
|
|
|
|
func (p *Player) SendBoardState(boardPosition string, turnColor types.ChessColor) error {
|
|
var pColor = p.color
|
|
if p.color == "" { // we default to white if we do not know the color yet
|
|
pColor = types.White
|
|
}
|
|
|
|
messageToSend, err := json.Marshal(api.WebsocketMessage{
|
|
Type: api.BoardStateMessage,
|
|
TurnColor: &turnColor,
|
|
PlayerColor: &pColor,
|
|
Position: &boardPosition,
|
|
})
|
|
if err != nil {
|
|
log.Println("Error while marshalling: ", err)
|
|
return err
|
|
}
|
|
|
|
err = p.writeMessage(messageToSend)
|
|
if err != nil {
|
|
log.Println("Error during message writing:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Player) SendMoveAndPosition(move types.Move, boardPosition string) error {
|
|
messageToSend, err := json.Marshal(api.WebsocketMessage{
|
|
Type: api.MoveMessage,
|
|
Move: &move,
|
|
Position: &boardPosition,
|
|
})
|
|
if err != nil {
|
|
log.Println("Error while marshalling: ", err)
|
|
return err
|
|
}
|
|
|
|
err = p.writeMessage(messageToSend)
|
|
if err != nil {
|
|
log.Println("Error during message writing:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Player) writeMessage(msg []byte) error {
|
|
return p.Conn.Write(msg)
|
|
}
|
|
|
|
func (p *Player) ReadMove() (types.Move, error) {
|
|
receivedMessage, err := p.readMessage()
|
|
if err != nil {
|
|
return types.Move{}, err
|
|
}
|
|
|
|
var msg api.WebsocketMessage
|
|
err = json.Unmarshal(receivedMessage, &msg)
|
|
if err != nil {
|
|
return types.Move{}, err
|
|
}
|
|
|
|
if !msg.IsValid() {
|
|
return types.Move{}, errors.New("not a valid move")
|
|
}
|
|
|
|
return *msg.Move, nil
|
|
}
|
|
|
|
func (p *Player) readMessage() ([]byte, error) {
|
|
msg, err := p.Conn.Read()
|
|
log.Printf("Reading message: %s from player %s", string(msg), p.Uuid.String())
|
|
|
|
return msg, err
|
|
}
|
|
|
|
func (p Player) GetPlayerColor() string {
|
|
return string(p.color)
|
|
}
|