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
@@ -1,9 +1,11 @@
 package client

 import (
+	"errors"
 	"fmt"
 	"io"
-	"sshpong/internal/netwrk"
+	"log/slog"
+	"sshpong/internal/lobby"
 	"strings"
 )

@@ -14,113 +16,197 @@ type InterrupterMessage struct {

 var help = fmt.Errorf("use invite <player name> to invite a player\nchat or / to send a message to the lobby\nq or quit to leave the game")

-func HandleUserInput(args []string) (*netwrk.LobbyMessage, error) {
+var red = "\x1b[31m"
+var normal = "\033[0m"
+
+func HandleUserInput(args []string, username string) (lobby.LobbyMessage, error) {
 	if len(args) == 0 {
-		return nil, help
+		return lobby.LobbyMessage{}, help
 	}
 	switch args[0] {
 	case "invite":
 		if args[1] != "" {
-			return &netwrk.LobbyMessage{
-				Type:    "invite",
-				Content: args[1],
-			}, nil
+			return lobby.LobbyMessage{
+				MessageType: "invite",
+				Message:     lobby.Invite{From: username, To: args[1]}}, nil
 		} else {
 			fmt.Println("Please provide a player to invite ")
 		}
 	case "chat":
 		if args[1] != "" {
-			return &netwrk.LobbyMessage{
-				Type:    "chat",
-				Content: strings.Join(args[1:], " "),
+			return lobby.LobbyMessage{
+				MessageType: "chat",
+				Message: lobby.Chat{
+					From:    username,
+					Message: args[1],
+				},
 			}, nil
 		}
 	case "/":
 		if args[1] != "" {
-			return &netwrk.LobbyMessage{
-				Type:    "chat",
-				Content: strings.Join(args[1:], " "),
+			return lobby.LobbyMessage{
+				MessageType: "chat",
+				Message: lobby.Chat{
+					From:    username,
+					Message: args[1],
+				},
 			}, nil
 		}
 	case "quit":
-		return nil, io.EOF
+		return lobby.LobbyMessage{}, io.EOF
 	case "q":
-		return nil, io.EOF
+		return lobby.LobbyMessage{}, io.EOF
 	case "help":
-		return nil, help
+		return lobby.LobbyMessage{}, help
 	case "h":
-		return nil, help
+		return lobby.LobbyMessage{}, help
 	default:
 		if strings.Index(args[0], "/") == 0 {
-			return &netwrk.LobbyMessage{
-				Type:    "chat",
-				Content: strings.Join(args, " ")[1:],
+			return lobby.LobbyMessage{
+				MessageType: "chat",
+				Message: lobby.Chat{
+					From:    username,
+					Message: args[1],
+				},
 			}, nil
 		}
-		return nil, help
+		return lobby.LobbyMessage{}, help
 	}
-	return nil, nil
+	return lobby.LobbyMessage{}, nil
 }

-func HandleInterruptInput(incoming InterrupterMessage, args []string) (*netwrk.LobbyMessage, error) {
+func HandleInterruptInput(incoming InterrupterMessage, args []string, username string) (lobby.LobbyMessage, error) {

 	switch incoming.InterruptType {
 	case "invite":
 		if len(args) < 1 {
-			return &netwrk.LobbyMessage{
-				Type:    "decline",
-				Content: incoming.Content,
+			return lobby.LobbyMessage{
+				MessageType: "decline",
+				Message: lobby.Decline{
+					From: username,
+					To:   incoming.Content,
+				},
 			}, nil
 		} else {
 			if strings.ToLower(args[0]) == "y" || strings.ToLower(args[0]) == "yes" {
-				return &netwrk.LobbyMessage{Type: "accept", Content: incoming.Content}, nil
+				return lobby.LobbyMessage{MessageType: "accept", Message: lobby.Accept{
+					From: username,
+					To:   incoming.Content,
+				},
+				}, nil
 			}
 		}

-	// Cancel waiting for invite?
-	case "decline":
-
+	// // Cancel waiting for invite? we aren't doing this I guess.
+	// case "decline":
+	// 	return nil,
 	// Disconnect and connect to game
 	case "accepted":
-		return &netwrk.LobbyMessage{
-			Type:    "disconnect",
-			Content: "",
+		return lobby.LobbyMessage{
+			MessageType: "disconnect",
+			Message: lobby.Disconnect{
+				From: incoming.Content,
+			},
+		}, nil
+	case "start_game":
+		return lobby.LobbyMessage{
+			MessageType: "start_game",
+			Message:     lobby.StartGame{GameID: incoming.Content},
 		}, nil
-	default:
-		return nil, fmt.Errorf("received a interrupt message that could not be handled %v", incoming)
 	}

-	return nil, nil
+	return lobby.LobbyMessage{}, fmt.Errorf("received a interrupt message that could not be handled %v", incoming)
 }

-func HandleServerMessage(message *netwrk.LobbyMessage) (InterrupterMessage, error) {
-	switch message.Type {
+func HandleServerMessage(message lobby.LobbyMessage) (InterrupterMessage, error) {
+
+	msg := message.Message
+	switch message.MessageType {
 	case "name":
-		fmt.Printf("Current Players\n%s\n", message.Content)
+
+		nmsg, ok := msg.(lobby.Name)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a properly formatted name message")
+		}
+
+		fmt.Printf("Current Players\n%s\n", nmsg)
 	case "invite":
-		fmt.Println(message.PlayerId, "is inviting you to a game\nType y to accept...")
+
+		imsg, ok := msg.(lobby.Invite)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a propertly formatted invite message")
+		}
+		fmt.Println(imsg.From, "is inviting you to a game\nType y to accept...")
 		return InterrupterMessage{
 			InterruptType: "invite",
-			Content:       message.PlayerId,
+			Content:       imsg.From,
 		}, nil
 	case "pending_invite":
-		fmt.Println("Invite sent to", message.Content, "\nWaiting for response...")
+
+		pimsg, ok := msg.(lobby.PendingInvite)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a properly formatted pending invite message")
+		}
+		fmt.Println("Invite sent to", pimsg.Recipient, "\nWaiting for response...")
 	case "accepted":
-		fmt.Println(message.PlayerId, "accepted your invite.\n", "Starting game...")
-	case "game_start":
-		fmt.Println("Invited accepted\n", "Starting game...")
-	case "text":
-		fmt.Println(message.PlayerId, ":", message.Content)
-	case "decline_game":
-		fmt.Println(message.Content, "declined your game invite")
+
+		amsg, ok := msg.(lobby.Accepted)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a properly formatted accepted message")
+		}
+		fmt.Println(amsg.Accepter, "accepted your invite.", "Press Enter to connect to game...")
+		return InterrupterMessage{
+			InterruptType: "start_game",
+			Content:       amsg.GameID,
+		}, nil
+	case "start_game":
+
+		sgmsg, ok := msg.(lobby.StartGame)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a properly formatted start game message")
+		}
+		return InterrupterMessage{
+			InterruptType: "start_game",
+			Content:       sgmsg.GameID,
+		}, nil
+	case "chat":
+		cmsg, ok := msg.(lobby.Chat)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a properly formatted chat message")
+		}
+		fmt.Println(cmsg.From, ":", cmsg.Message)
+	case "decline":
+		dmsg, ok := msg.(lobby.Decline)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a properly formatted decline message")
+		}
+
+		fmt.Println(dmsg.From, "declined your game invite")
 	case "disconnect":
-		fmt.Println(message.Content, "has disconnected")
+
+		dmsg, ok := msg.(lobby.Disconnect)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a properly formatted disconnect message")
+		}
+
+		fmt.Println(dmsg.From, "has disconnected")
 	case "connect":
-		fmt.Println(message.Content, "has connected")
+
+		cmsg, ok := msg.(lobby.Connect)
+		if !ok {
+			return InterrupterMessage{}, errors.New("Not a properly formated connect message")
+		}
+		fmt.Println(cmsg.From, "has connected")
 	case "pong":
-		fmt.Println("Received", message.Content)
+		fmt.Println("Received pong")
+	case "error":
+		em, ok := msg.(lobby.Error)
+		if !ok {
+			slog.Debug("Received an indecipherable error message...", slog.Any("msg", msg))
+		}
+		fmt.Println(red, em.Message, normal)
 	default:
-		fmt.Println("Received", message.Content)
+		fmt.Println("Received", message.MessageType, message.Message)
 	}
 	return InterrupterMessage{}, nil
 }