tome_client/client2/backend.go

package main

import (
	"flag"
	"log"
	"os"
	"os/signal"
	"strconv"
	"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
var matchID uuid.UUID

func receiveHandler(connection *websocket.Conn, container *UIContainer) {
	defer close(done)
	for {
		var resp coordinator.SessionCommandResult
		err := connection.ReadJSON(&resp)
		if err != nil {
			log.Println("Error in receive:", err)
			break
		}
		switch resp.Result {
		case coordinator.SessionRespJoined1:
			pid = game.SentinalID
			container.Output <- "joined as sentinal"
		case coordinator.SessionRespJoined2:
			pid = game.ScourgeID
			container.Output <- "joined as scourge"
		case coordinator.SessionRespFound:
			matchID = resp.MatchID
			container.Output <- "game found"
		case coordinator.SessionRespPlayed:
			if resp.GameResult != nil {
				switch resp.GameResult.ResultType {
				case game.ActCmd:
					container.Output <- resp.GameResult.ActionResult.String()
				case game.StateCmd:
					container.State = resp.GameResult.StateResult
					container.Updated <- true
				case game.DebugCmd:
					container.Output <- resp.GameResult.DebugResult.String()
				}
			} else {
				container.Output <- "error playing"
			}
		case coordinator.SessionRespLeft:
			container.Output <- "game left"
			matchID = uuid.Nil
			return
		case coordinator.SessionRespBroadcastSenTurn:
			container.Output <- "Sentinal may take their turn"
		case coordinator.SessionRespBroadcastScoTrun:
			container.Output <- "Scourge may take their turn"
		case coordinator.SessionRespBroadcastSenWin:
			container.Output <- "Sentinal wins!"
		case coordinator.SessionRespBroadcastScoWin:
			container.Output <- "Scourge wins!"
		case coordinator.SessionRespBroadcastUpdate:
			container.GetUpdate <- true
		case coordinator.SessionRespBroadcastScoJoin:
			container.Output <- "Scourge has joined the game"
		case coordinator.SessionRespBroadcastSenJoin:
			container.Output <- "Sentinal has joined the game"
		case coordinator.SessionRespBroadcastScoLeft:
			container.Output <- "Scourge has left the game"
		case coordinator.SessionRespBroadcastSenLeft:
			container.Output <- "Sentinal has left the game"
		case coordinator.SessionRespBroadcastSenReady:
			container.Output <- "Sentinal is ready"
		case coordinator.SessionRespBroadcastScoReady:
			container.Output <- "scourge is ready"
		case coordinator.SessionRespBroadcastNone:

		case coordinator.SessionRespError:
			container.Output <- "generic error"

		default:
			container.Output <- "Received a server response we don't know how to handle"
		}
	}
}

func backend(container *UIContainer) {
	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)

	signal.Notify(interrupt, os.Interrupt) // Notify the interrupt channel for SIGINT
	hostname := flag.String("host", "localhost", "server hostname to connect to")
	port := flag.Int("port", 7636, "port to connect to")

	flag.Parse()
	port_s := strconv.Itoa(*port)
	socketUrl := "ws://" + *hostname + ":" + port_s + "/ws"
	id := uuid.New()
	conn, _, err := websocket.DefaultDialer.Dial(socketUrl, nil)

	if err != nil {
		log.Fatal("Error connecting to Websocket Server:", err)
	}
	defer conn.Close()
	go receiveHandler(conn, container)
	go GetCommand(id, cmd, container)
	ticker := time.NewTicker(2 * time.Second)
	// Our main loop for the client
	// We send our relevant packets here
	for {
		var c coordinator.SessionCommand
		select {
		case c = <-cmd:
			err := conn.WriteJSON(c)
			if err != nil {
				log.Println("Error during writing to websocket:", err)
				return
			}
			if c.Command == coordinator.SessionCmdLeave {
				break
			}
		case <-container.GetUpdate:
			if container.State != nil {
				err = conn.WriteJSON(&coordinator.SessionCommand{
					ID:      id,
					MatchID: matchID,
					Command: coordinator.SessionCmdPlay,
					GameCommand: &game.Command{
						PlayerID: pid,
						Type:     game.StateCmd,
						Cmd:      "g",
					},
				})
				if err != nil {
					log.Println("Error during writing to websocker:", err)
					return
				}
				container.Updated <- true
			}

		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
		case <-ticker.C:
			select {
			case <-done:
				return
			default:
				if matchID != uuid.Nil {
					err := conn.WriteJSON(coordinator.SessionCommand{
						ID:      id,
						MatchID: matchID,
						Command: coordinator.SessionCmdPoll,
					})
					if err != nil {
						log.Println("Error writing to websocket:", err)
						return
					}
				}
			}
		}
	}
}

func GetCommand(uid uuid.UUID, resp chan coordinator.SessionCommand, container *UIContainer) {
	for {
		var cmd string
		var t int
		input := <-container.Input
		input_s := strings.Split(input, " ")
		t, err := strconv.Atoi(input_s[0])
		if err != nil {
			continue
		}
		cmd = trimFirstRune(input)

		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,
					MatchID: matchID,
					Command: coordinator.SessionCmdJoin,
				}
			case coordinator.SessionCmdLeave:
				resp <- coordinator.SessionCommand{
					ID:      uid,
					MatchID: matchID,
					Command: coordinator.SessionCmdLeave,
				}
			default:
				break
			}
		case 1:
			//state
			resp <- coordinator.SessionCommand{
				ID:      uid,
				MatchID: matchID,
				Command: coordinator.SessionCmdPlay,
				GameCommand: &game.Command{
					PlayerID: pid,
					Type:     game.StateCmd,
					Cmd:      cmd,
				},
			}
		case 2:
			//action
			resp <- coordinator.SessionCommand{
				ID:      uid,
				MatchID: matchID,
				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:]
}