middle of the re-work

2024-09-26 19:49:59 -06:00
parent e31dbef6ef
commit f2d488ef51
15 changed files with 1347 additions and 754 deletions
@@ -0,0 +1,290 @@
+package lobby
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"log/slog"
+	"net"
+	"sync"
+
+	"github.com/google/uuid"
+)
+
+type Lobby struct {
+	lobbyMembers           sync.Map
+	ExternalMessageChannel chan ExternalMessage
+}
+
+type Client struct {
+	Username string
+	Conn     net.Conn
+}
+
+type ExternalMessage struct {
+	From    string
+	Target  string
+	Message LobbyMessage
+}
+
+func CreateLobby() *Lobby {
+	externalMessageChan := make(chan ExternalMessage)
+
+	l := Lobby{
+		lobbyMembers:           sync.Map{},
+		ExternalMessageChannel: externalMessageChan,
+	}
+
+	go func(lm *sync.Map) {
+		for {
+			msg := <-externalMessageChan
+
+			tc, ok := lm.Load(msg.Target)
+			if !ok {
+				slog.Debug("Target not found in lobby map")
+				sc, ok := lm.Load(msg.From)
+				if !ok {
+					slog.Debug("Sender was also not found in lobby map and cannot send error message")
+					continue
+				}
+				c, ok := sc.(Client)
+				if !ok {
+					slog.Debug("Item that was not a client found in the lobby map...", slog.Any("key", msg.From))
+				}
+				go func() {
+					em := LobbyMessage{
+						MessageType: "error",
+						Message: Error{
+							Message: fmt.Sprintf("Sorry, player %s is not available...", msg.Target),
+						},
+					}
+					b, err := Marshal(em)
+					if err != nil {
+						slog.Debug("Could not marshall error message for missing player", slog.Any("error", err))
+					}
+					c.Conn.Write(b)
+				}()
+				continue
+			}
+			c, ok := tc.(Client)
+			if !ok {
+
+				slog.Debug("Item that was not a client found in the lobby map...", slog.Any("key", msg.From))
+				continue
+			}
+			go func() {
+				b, err := Marshal(msg.Message)
+				if err != nil {
+					slog.Debug("Could not marshal external message...", slog.Any("error", err))
+				}
+				c.Conn.Write(b)
+			}()
+
+		}
+	}(&l.lobbyMembers)
+
+	return &l
+}
+
+func (l *Lobby) HandleLobbyConnection(conn net.Conn) {
+	messageBytes := make([]byte, 4096)
+
+	ingress := make(chan LobbyMessage)
+	egress := make(chan LobbyMessage)
+
+	// Network Reader
+	go func() {
+		for {
+			n, err := conn.Read(messageBytes)
+			if err == io.EOF {
+				conn.Close()
+				return
+			}
+			if err != nil {
+				conn.Close()
+				log.Printf("Error reading message %v", err)
+				return
+			}
+
+			message := LobbyMessage{}
+
+			message, err = Unmarshal(messageBytes[:n])
+			if err != nil {
+				log.Println("Invalid message received from client", err)
+			}
+			ingress <- message
+		}
+	}()
+
+	// Network Writer
+	go func() {
+		for {
+			msg := <-egress
+			bytes, err := Marshal(msg)
+			if err != nil {
+				log.Println("Error marshalling message to send to user...", err)
+			}
+			_, err = conn.Write(bytes)
+			if err == io.EOF {
+				conn.Close()
+				log.Println("User has disconnected", err)
+
+				// TODO: write message for disconnect to everyone?
+				slog.Debug("Sending bad disconnect message")
+				ingress <- LobbyMessage{MessageType: "disconnect", Message: Disconnect{}}
+			}
+			if err != nil {
+				log.Println("Error writing to user...", err)
+			}
+		}
+	}()
+
+	// Client message handler
+	go func() {
+		for {
+			msg := <-ingress
+			serverMsg, err := l.handleClientLobbyMessage(&msg, conn)
+			if err != nil {
+				log.Println("Error handling client lobby message...", err)
+			}
+			if serverMsg.MessageType != "" {
+				egress <- serverMsg
+			}
+		}
+	}()
+}
+
+// Returns a bool of whether the player has disconnected from the lobby and an error
+func (l *Lobby) handleClientLobbyMessage(message *LobbyMessage, conn net.Conn) (LobbyMessage, error) {
+	switch message.MessageType {
+	// Handle an name/login message from a player
+	// Store the new player in the l.lobbyMembers
+	// Send a connection message for each of the l.lobbyMembers to the new player
+	// Send a connection message to all members in the lobby
+	case "name":
+		_, ok := l.lobbyMembers.Load(message.Message)
+		if ok {
+			return LobbyMessage{MessageType: "error", Message: Error{Message: "Sorry, that name is already taken, please try a different name"}}, nil
+		}
+
+		nm, ok := message.Message.(Name)
+		if !ok {
+			return LobbyMessage{MessageType: "error", Message: Error{Message: "Sorry the message value and type were not matching for name"}}, nil
+		}
+
+		l.lobbyMembers.Store(nm.Name, Client{Username: nm.Name, Conn: conn})
+
+		// Build current lobby list
+		var lobby []string
+		l.lobbyMembers.Range(func(lobbyUsername any, client any) bool {
+			usernameString, _ := lobbyUsername.(string)
+			lobby = append(lobby, usernameString)
+			return true
+		})
+
+		l.broadcastToLobby(LobbyMessage{MessageType: "connect", Message: Name{Name: nm.Name}})
+
+		return LobbyMessage{MessageType: "name", Message: Name{
+			Name: nm.Name,
+		},
+		}, nil
+
+	// Handle an invite message by sending a message to the target player
+	// Send an invite message to the invitee: message.Content
+	// Send an ack message to the inviter: message.PlayerId
+	case "invite":
+
+		i, ok := message.Message.(Invite)
+		if !ok {
+			return LobbyMessage{MessageType: "error", Message: Error{Message: "Sorry the message value and type were not matching for invite"}}, nil
+		}
+		// TODO: figure out this shit
+		l.ExternalMessageChannel <- ExternalMessage{
+			From:    i.From,
+			Target:  i.To,
+			Message: LobbyMessage{},
+		}
+
+		return LobbyMessage{MessageType: "pending_invite", Message: PendingInvite{
+			Recipient: i.To,
+		}}, nil
+
+	// Handle a accept message from a player that was invited
+	// Send a game_start message back to the player: message.Content
+	// Send an accepted message back to the inviter: message.PlayerId
+	case "accept":
+		gameID := uuid.NewString()
+
+		am, ok := message.Message.(Accept)
+		if !ok {
+			return LobbyMessage{MessageType: "error", Message: Error{Message: "Sorry the message value and type were not matching for accept"}}, nil
+		}
+
+		slog.Debug("incoming accept message", slog.Any("From", am.From), slog.Any("To", am.To))
+		l.ExternalMessageChannel <- ExternalMessage{
+			Target: am.To,
+			Message: LobbyMessage{MessageType: "accepted", Message: Accepted{
+				Accepter: am.From,
+				GameID:   gameID,
+			},
+			}}
+
+		return LobbyMessage{MessageType: "start_game", Message: StartGame{To: am.From, GameID: gameID}}, nil
+	// Handle a chat message from a player with PlayerId
+	case "chat":
+		c, ok := message.Message.(Chat)
+		if !ok {
+			return LobbyMessage{MessageType: "error", Message: Error{Message: "Sorry the message value and type were not matching for chat"}}, nil
+		}
+		l.broadcastToLobby(LobbyMessage{MessageType: "text", Message: Chat{
+			From:    c.From,
+			Message: c.Message,
+		}})
+		return LobbyMessage{}, nil
+
+	// Handle a quit message from a player that was connected
+	// broadcast the player quit to the lobby
+	case "quit":
+		q, ok := message.Message.(Disconnect)
+		if !ok {
+			return LobbyMessage{MessageType: "error", Message: Error{Message: "Sorry the message value and type were not matching for quit"}}, nil
+		}
+		l.lobbyMembers.Delete(q.From)
+		l.broadcastToLobby(LobbyMessage{MessageType: "disconnect", Message: Disconnect{
+			From: q.From,
+		}})
+		return LobbyMessage{}, nil
+
+	// Ping and pong
+	case "ping":
+		return LobbyMessage{MessageType: "pong", Message: "pong"}, nil
+
+	// Ping and pong
+	default:
+		return LobbyMessage{MessageType: "pong", Message: "pong"}, nil
+
+	}
+}
+
+func (l *Lobby) broadcastToLobby(message LobbyMessage) {
+	var disconnectedUsers []string
+	l.lobbyMembers.Range(func(playerId, player interface{}) bool {
+		bytes, err := Marshal(message)
+		if err != nil {
+			log.Println("Error marshalling broadcast message", err)
+		}
+
+		client := player.(Client)
+		_, err = client.Conn.Write(bytes)
+		if err != nil {
+			log.Println("Error broadcasting to clients...", err)
+			disconnectedUsers = append(disconnectedUsers, playerId.(string))
+
+		}
+		return true
+	})
+
+	for _, player := range disconnectedUsers {
+		l.lobbyMembers.Delete(player)
+	}
+}
@@ -0,0 +1,244 @@
+package lobby
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"reflect"
+	"strings"
+)
+
+type LobbyMessage struct {
+	MessageType string `json:"message_type"`
+	Message     any    `json:"message"`
+}
+
+type Name struct {
+	Name string `json:"name"`
+}
+
+type Chat struct {
+	From    string `json:"from"`
+	Message string `json:"message"`
+}
+
+type Invite struct {
+	From string `json:"from"`
+	To   string `json:"to"`
+}
+
+type PendingInvite struct {
+	Recipient string `json:"recipient"`
+}
+
+type Accept struct {
+	From string `json:"from"`
+	To   string `json:"to"`
+}
+
+type Accepted struct {
+	Accepter string `json:"accepter"`
+	GameID   string `json:"game_id"`
+}
+
+type StartGame struct {
+	To     string `json:"to"`
+	GameID string `json:"game_id"`
+}
+
+type Decline struct {
+	From string `json:"from"`
+	To   string `json:"to"`
+}
+
+type Disconnect struct {
+	From string `json:"from"`
+}
+
+type Connect struct {
+	From string `json:"from"`
+}
+
+type Error struct {
+	Message string `json:"message"`
+}
+
+func Marshal(a LobbyMessage) ([]byte, error) {
+	slog.Debug("Marshalling message", slog.Any("message type", a.MessageType))
+	bm, err := json.Marshal(a.Message)
+	if err != nil {
+		return nil, err
+	}
+
+	a.Message = bm
+	return json.Marshal(a)
+}
+
+// Use this to get the appropriate message type into the message field then assert the
+// right struct accordingly to safely access the fields you need.
+func Unmarshal(b []byte) (LobbyMessage, error) {
+	lm := LobbyMessage{}
+	err := json.Unmarshal(b, &lm)
+	if err != nil {
+		return lm, err
+	}
+
+	smsg, ok := lm.Message.(string)
+	if !ok {
+		slog.Debug("error asserting message to string")
+	}
+	slog.Debug("type of message", slog.Any("type of message", reflect.TypeOf(smsg)), slog.String("message", smsg))
+
+	jsonBytes, err := base64.StdEncoding.DecodeString(smsg)
+	lm.Message = jsonBytes
+
+	switch strings.ToLower(lm.MessageType) {
+	case "name":
+		n := Name{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+
+		err := json.Unmarshal(bs, &n)
+		if err != nil {
+			slog.Debug("Error", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = n
+		return lm, nil
+	case "chat":
+		c := Chat{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &c)
+		if err != nil {
+			slog.Debug("chat", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = c
+		return lm, nil
+	case "invite":
+		i := Invite{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &i)
+		if err != nil {
+			slog.Debug("invite", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = i
+		return lm, nil
+	case "pending_invite":
+		pi := PendingInvite{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &pi)
+		if err != nil {
+			slog.Debug("pending_invite", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = pi
+	case "accept":
+		a := Accept{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &a)
+		if err != nil {
+			slog.Debug("accept", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = a
+		return lm, nil
+	case "accepted":
+		a := Accepted{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &a)
+		if err != nil {
+			slog.Debug("accepted", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = a
+		return lm, nil
+	case "start_game":
+		sg := StartGame{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &sg)
+		if err != nil {
+			slog.Debug("start_game", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = sg
+		return lm, nil
+	case "decline":
+		d := Decline{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &d)
+		if err != nil {
+			slog.Debug("decline", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = d
+		return lm, nil
+	case "disconnect":
+		di := Disconnect{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &di)
+		if err != nil {
+			slog.Debug("disconnect", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = di
+		return lm, nil
+	case "connect":
+		co := Connect{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &co)
+		if err != nil {
+			slog.Debug("connect", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = co
+		return lm, nil
+	case "error":
+		e := Error{}
+		bs, ok := lm.Message.([]byte)
+		if !ok {
+			return lm, err
+		}
+		err := json.Unmarshal(bs, &e)
+		if err != nil {
+			slog.Debug("error", slog.Any("error", err))
+			return lm, err
+		}
+		lm.Message = e
+		return lm, nil
+	default:
+		return lm, errors.New("unknown message type")
+	}
+	return lm, errors.New("unknown message type")
+}