snengame/cmd/client/main.go

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"os/signal"
	"strings"
	"time"
	"unicode/utf8"

	"git.saintnet.tech/stryan/snengame/internal/coordinator"
	"git.saintnet.tech/stryan/snengame/internal/game"
	"github.com/google/uuid"
	"github.com/gorilla/websocket"
)

var done chan interface{}
var interrupt chan os.Signal
var pid int

func receiveHandler(connection *websocket.Conn, output chan string) {
	defer close(done)
	for {
		var resp coordinator.SessionCommandResult
		err := connection.ReadJSON(&resp)
		if err != nil {
			log.Println("Error in receive:", err)
		}
		if resp.Result == coordinator.SessionRespJoined1 {
			pid = game.SentinalID
			output <- "joined as sentinal"
		} else if resp.Result == coordinator.SessionRespJoined2 {
			pid = game.ScourgeID
			output <- "joined as scourge"
		} else if resp.Result == coordinator.SessionRespFound {
			output <- "game found"
		} else if resp.Result == coordinator.SessionRespPlayed {
			if resp.GameResult != nil {
				switch resp.GameResult.ResultType {
				case game.ActCmd:
					output <- resp.GameResult.ActionResult.String()
				case game.StateCmd:
					output <- resp.GameResult.StateResult.String()
				case game.DebugCmd:
					output <- resp.GameResult.DebugResult.String()
				}
			}
		} else if resp.Result == coordinator.SessionRespLeft {
			output <- "game left"
			break
		} else if resp.Result == coordinator.SessionRespPlayed {
			output <- "played succesfully"
		}
	}
}

func main() {
	done = make(chan interface{})    // Channel to indicate that the receiverHandler is done
	interrupt = make(chan os.Signal) // Channel to listen for interrupt signal to terminate gracefully
	cmd := make(chan coordinator.SessionCommand)
	output := make(chan string)

	signal.Notify(interrupt, os.Interrupt) // Notify the interrupt channel for SIGINT

	socketUrl := "ws://localhost:7636" + "/ws"
	conn, _, err := websocket.DefaultDialer.Dial(socketUrl, nil)
	id := uuid.New()

	if err != nil {
		log.Fatal("Error connecting to Websocket Server:", err)
	}
	defer conn.Close()
	go receiveHandler(conn, output)
	go GetCommand(id, cmd)

	// Our main loop for the client
	// We send our relevant packets here
	for {
		var c coordinator.SessionCommand
		var o string
		select {
		case c = <-cmd:
			err := conn.WriteJSON(c)
			if err != nil {
				log.Println("Error during writing to websocket:", err)
				return
			}
		case o = <-output:
			fmt.Println(o)
		case <-interrupt:
			// We received a SIGINT (Ctrl + C). Terminate gracefully...
			log.Println("Received SIGINT interrupt signal. Closing all pending connections")

			// Close our websocket connection
			err := conn.WriteJSON(coordinator.SessionCommand{
				ID:      id,
				Command: coordinator.SessionCmdLeave,
			})
			if err != nil {
				log.Println("Error during closing websocket:", err)
				return
			}

			select {
			case <-done:
				log.Println("Receiver Channel Closed! Exiting....")
			case <-time.After(time.Duration(1) * time.Second):
				log.Println("Timeout in closing receiving channel. Exiting....")
			}
			return
		}
	}
}

func GetCommand(uid uuid.UUID, resp chan coordinator.SessionCommand) {
	for {
		var cmd string
		var t int
		fmt.Print("> ")
		_, err := fmt.Scanf("%d", &t)
		if err != nil {
			log.Println(err)
		}
		if t == -1 {
			panic("quitting")
		}
		cmd, err = bufio.NewReader(os.Stdin).ReadString('\n')
		if err != nil {
			log.Println(err)
		}
		cmd = strings.TrimSpace(cmd)
		switch t {
		case 0:
			//session
			switch coordinator.SessionCmd(cmd) {
			case coordinator.SessionCmdQuery:
				resp <- coordinator.SessionCommand{
					ID:      uid,
					Command: coordinator.SessionCmdQuery,
				}
			case coordinator.SessionCmdJoin:
				resp <- coordinator.SessionCommand{
					ID:      uid,
					Command: coordinator.SessionCmdJoin,
				}
			case coordinator.SessionCmdLeave:
				resp <- coordinator.SessionCommand{
					ID:      uid,
					Command: coordinator.SessionCmdLeave,
				}
			default:
				break
			}
		case 1:
			//state
			resp <- coordinator.SessionCommand{
				ID:      uid,
				Command: coordinator.SessionCmdPlay,
				GameCommand: &game.Command{
					PlayerID: pid,
					Type:     game.StateCmd,
					Cmd:      cmd,
				},
			}
		case 2:
			//action
			resp <- coordinator.SessionCommand{
				ID:      uid,
				Command: coordinator.SessionCmdPlay,
				GameCommand: &game.Command{
					PlayerID: pid,
					Type:     game.ActCmd,
					Cmd:      cmd,
				},
			}
		}

	}
}

func trimFirstRune(s string) string {
	_, i := utf8.DecodeRuneInString(s)
	return s[i:]
}