Draft: big refactor

plays/base.go

@@ -20,12 +20,14 @@ func Tick(d time.Duration) tea.Cmd {
 }
 
 type Base struct {
-	client *resty.Client
+	client   *resty.Client
+	username string
 }
 
 func NewBase(client *resty.Client) *Base {
 	return &Base{
-		client: client,
+		client:   client,
+		username: "",
 	}
 }
 

plays/game.go

@@ -0,0 +1,128 @@
+package plays
+
+import (
+	"fmt"
+	"net/url"
+	"sync"
+
+	"gitea.konchin.com/ytshih/inp2025/game/server/wordle"
+	"gitea.konchin.com/ytshih/inp2025/game/tracing"
+	"gitea.konchin.com/ytshih/inp2025/game/types"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/gorilla/websocket"
+	"github.com/vmihailenco/msgpack/v5"
+	"go.uber.org/zap"
+)
+
+type Game struct {
+	*Base
+	server *url.URL
+	roomID string
+
+	mutex sync.RWMutex
+	state types.WordleState
+
+	input string
+}
+
+func (m *Game) GetState() {
+	urlStr := m.server.String()
+	tracing.Logger.Info("dialing websocket", zap.String("url", urlStr))
+	c, _, err := websocket.DefaultDialer.Dial(urlStr, m.Base.client.Header)
+	if err != nil {
+		panic(fmt.Errorf("failed to dial, %w", err))
+	}
+	defer c.Close()
+
+	for {
+		_, b, err := c.ReadMessage()
+		switch err.(type) {
+		case nil:
+			var state types.WordleState
+			if err := msgpack.Unmarshal(b, &state); err != nil {
+				panic(fmt.Errorf("failed to unmarshal state, %w", err))
+			}
+
+			m.mutex.Lock()
+			m.state = state
+			m.mutex.Unlock()
+		case *websocket.CloseError:
+			return
+		default:
+			panic(fmt.Errorf("failed to read message, %w", err))
+		}
+	}
+}
+
+func NewGame(base *Base, server *url.URL, roomID string) *Game {
+	m := &Game{
+		Base:   base,
+		server: server,
+		roomID: roomID,
+		state:  types.NewWordleState(),
+		input:  "",
+	}
+
+	go m.GetState()
+	return m
+}
+
+func (m *Game) Init() tea.Cmd {
+	return tea.Batch(tea.ClearScreen)
+}
+
+func (m *Game) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	if _, cmd := m.Base.Update(msg); cmd != nil {
+		return m, cmd
+	}
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch msg.Type {
+		case tea.KeyBackspace:
+			if len(m.input) > 0 {
+				m.input = m.input[:len(m.input)-1]
+			}
+		case tea.KeyEnter:
+			if len(m.input) == types.MaxLength {
+				return m, tea.Quit
+			}
+		case tea.KeyRunes:
+			if len(m.input) < types.MaxLength {
+				m.input = m.input + string(msg.Runes)
+			}
+		}
+	}
+
+	return m, nil
+}
+
+func (m *Game) View() string {
+	m.mutex.RLock()
+	ret := m.state.View()
+	m.mutex.RUnlock()
+	return ret
+}
+
+func (m *Game) Next(queue *[]*tea.Program) error {
+	if len(m.input) == types.MaxLength {
+		b, err := msgpack.Marshal(wordle.Operation{
+			Type:     wordle.OperationTypeGuess,
+			Username: m.username,
+			Guess:    m.input,
+		})
+		if err != nil {
+			return err
+		}
+		_, err = m.Base.client.R().
+			SetBody(b).
+			Post(fmt.Sprintf("/api/rooms/%s/guess", m.roomID))
+		if err != nil {
+			return err
+		}
+
+		*queue = append(*queue,
+			tea.NewProgram(NewGame(m.Base, m.server, m.roomID)))
+	}
+	return nil
+}

plays/joinRoom.go

@@ -0,0 +1,89 @@
+package plays
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"gitea.konchin.com/ytshih/inp2025/game/types"
+	ea "github.com/charmbracelet/bubbletea"
+)
+
+type JoinRoom struct {
+	*Base
+	rooms  []types.Room
+	cursor int
+	choice *types.Room
+}
+
+func NewJoinRoom(base *Base, rooms []types.Room) *JoinRoom {
+	return &JoinRoom{
+		Base:  base,
+		rooms: rooms,
+	}
+}
+
+func (m *JoinRoom) Init() ea.Cmd {
+	return ea.ClearScreen
+}
+
+func (m *JoinRoom) Update(msg ea.Msg) (ea.Model, ea.Cmd) {
+	switch msg := msg.(type) {
+	case ea.KeyMsg:
+		switch msg.String() {
+		case "ctrl+c", "q":
+			return m, ea.Quit
+		case "enter":
+			if m.cursor < len(m.rooms) {
+				m.choice = &m.rooms[m.cursor]
+			}
+			return m, ea.Quit
+		case "up":
+			if m.cursor > 0 {
+				m.cursor--
+			}
+		case "down":
+			if m.cursor < len(m.rooms)-1 {
+				m.cursor++
+			}
+		}
+	}
+	return m, nil
+}
+
+func (m *JoinRoom) View() string {
+	var b strings.Builder
+	b.WriteString("Select a room to join:\n\n")
+
+	for i, room := range m.rooms {
+		if m.cursor == i {
+			b.WriteString("(•) ")
+		} else {
+			b.WriteString("( ) ")
+		}
+		b.WriteString(room.View() + "\n")
+	}
+
+	return b.String()
+}
+
+func (m *JoinRoom) Next(queue *[]*ea.Program) error {
+	if m.choice == nil {
+		*queue = append(*queue, ea.NewProgram(NewLobby(m.Base)))
+		return nil
+	}
+
+	resp, err := m.Base.client.R().
+		SetResult(&types.Room{}).
+		Post(fmt.Sprintf("/api/rooms/%s/join", m.choice.ID))
+
+	if err != nil || resp.StatusCode() != http.StatusOK {
+		*queue = append(*queue, ea.NewProgram(NewRedirect("Failed to join room")))
+		*queue = append(*queue, ea.NewProgram(NewLobby(m.Base)))
+		return nil
+	}
+
+	room := resp.Result().(*types.Room)
+	*queue = append(*queue, ea.NewProgram(NewRoomWaiting(m.Base, room.ID)))
+	return nil
+}

plays/lobby.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
-	"time"
 
 	"gitea.konchin.com/ytshih/inp2025/game/models"
 	"gitea.konchin.com/ytshih/inp2025/game/tracing"
@@ -14,7 +13,7 @@ import (
 )
 
 var (
-	lobbyChoices = []string{"No-op", "Logout"}
+	lobbyChoices = []string{"Create Room", "Join Room", "Refresh", "Logout"}
 )
 
 type Lobby struct {
@@ -23,62 +22,44 @@ type Lobby struct {
 	choice string
 	cursor int
 
-	updateCh chan struct{}
-	users    []models.UserStatus
-	rooms    []models.Room
+	users []models.UserStatus
+	rooms []types.Room
 }
 
 func NewLobby(base *Base) *Lobby {
-	m := Lobby{
-		Base:     base,
-		choice:   "",
-		cursor:   0,
-		updateCh: make(chan struct{}, 1),
+	m := &Lobby{
+		Base:   base,
+		choice: "",
+		cursor: 0,
 	}
-
-	return &m
+	return m
 }
 
-func updateLobbyInfo(m *Lobby) error {
-	for {
-		select {
-		case <-m.updateCh:
-			return nil
-		default:
-			var users []models.UserStatus
-			resp, err := m.Base.client.R().
-				SetResult(&users).
-				ForceContentType("application/json").
-				Get("/api/lobby/users")
-			if resp.StatusCode() != http.StatusOK {
-				tracing.Logger.
-					Error("failed to get lobby users",
-						zap.Error(err))
-				return err
-			}
-			m.users = users
-
-			var rooms []models.Room
-			_, err = m.Base.client.R().
-				SetResult(&rooms).
-				ForceContentType("application/json").
-				Get("/api/lobby/rooms")
-			if err != nil {
-				tracing.Logger.
-					Error("failed to get lobby rooms",
-						zap.Error(err))
-				return err
-			}
-			m.rooms = rooms
-
-			time.Sleep(refetchTick)
-		}
+func (m *Lobby) fetchLobbyInfo() tea.Msg {
+	var users []models.UserStatus
+	resp, err := m.Base.client.R(). 
+		SetResult(&users).
+		Get("/api/lobby/users")
+	if err != nil || resp.StatusCode() != http.StatusOK {
+		tracing.Logger.Error("failed to get lobby users", zap.Error(err))
+		return nil
 	}
+	m.users = users
+
+	var rooms []types.Room
+	resp, err = m.Base.client.R().
+		SetResult(&rooms).
+		Get("/api/lobby/rooms")
+	if err != nil || resp.StatusCode() != http.StatusOK {
+		tracing.Logger.Error("failed to get lobby rooms", zap.Error(err))
+		return nil
+	}
+	m.rooms = rooms
+	return nil
 }
 
 func (m *Lobby) Init() tea.Cmd {
-	go updateLobbyInfo(m)
-	return tea.Sequence(tea.ClearScreen, Tick(refreshTick))
+	return tea.Batch(tea.ClearScreen, m.fetchLobbyInfo)
 }
 
 func (m *Lobby) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
@@ -107,8 +88,6 @@ func (m *Lobby) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				m.cursor = len(lobbyChoices) - 1
 			}
 		}
-	case types.TickMsg:
-		return m, Tick(refreshTick)
 	}
 	return m, nil
 }
@@ -116,19 +95,20 @@ func (m *Lobby) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 func (m *Lobby) View() string {
 	var b strings.Builder
 
-	fmt.Fprintf(&b, "Game lobby\n")
+	fmt.Fprintf(&b, "Game lobby\n\n")
 
-	fmt.Fprintf(&b, "User Status (%d):\n", len(m.users))
+	fmt.Fprintf(&b, "Online Users (%d):\n", len(m.users))
 	for _, user := range m.users {
 		b.WriteString("- " + user.View() + "\n")
 	}
+	b.WriteString("\n")
 
-	fmt.Fprintf(&b, "Room Status (%d):\n", len(m.rooms))
+	fmt.Fprintf(&b, "Game Rooms (%d):\n", len(m.rooms))
 	for _, room := range m.rooms {
 		b.WriteString("- " + room.View() + "\n")
 	}
 
-	b.WriteString("==========\n")
+	b.WriteString("\n==========\n")
 
 	for i := 0; i < len(lobbyChoices); i++ {
 		if m.cursor == i {
@@ -142,11 +122,23 @@ func (m *Lobby) View() string {
 }
 
 func (m *Lobby) Next(queue *[]*tea.Program) error {
-	m.updateCh <- struct{}{}
 	switch m.choice {
-	case "No-op":
+	case "Refresh":
 		*queue = append(*queue,
 			tea.NewProgram(NewLobby(m.Base)))
+	case "Create Room":
+		resp, err := m.Base.client.R().
+			SetResult(&types.Room{}).
+			Post("/api/rooms")
+		if err != nil || resp.StatusCode() != http.StatusOK {
+			return fmt.Errorf("failed to create room")
+		}
+		room := resp.Result().(*types.Room)
+		*queue = append(*queue,
+			tea.NewProgram(NewRoomWaiting(m.Base, room.ID)))
+	case "Join Room":
+		*queue = append(*queue,
+			tea.NewProgram(NewJoinRoom(m.Base, m.rooms)))
 	case "Logout":
 		*queue = append(*queue,
 			tea.NewProgram(NewLogout(m.Base)))

plays/login.go

@@ -125,6 +125,7 @@ func (m *Login) Next(queue *[]*tea.Program) error {
 	if resp.StatusCode() == http.StatusOK {
 		m.Base.client.
 			SetBasicAuth(username, password)
+		m.Base.username = username
 		*queue = append(*queue,
 			tea.NewProgram(NewLobby(m.Base)))
 	} else {

plays/register.go

@@ -123,17 +123,19 @@ func (m *Register) Next(queue *[]*tea.Program) error {
 		}).
 		Post("/auth/register")
 
-	switch resp.StatusCode() {
-	case http.StatusOK:
+	if err == nil && resp.StatusCode() == http.StatusOK {
 		*queue = append(*queue,
 			tea.NewProgram(NewLogin(m.Base)))
-	case http.StatusBadRequest:
-		*queue = append(*queue,
-			tea.NewProgram(NewRedirect("Username already exist")))
-		*queue = append(*queue,
-			tea.NewProgram(NewRegister(m.Base)))
-	case http.StatusInternalServerError:
-		return err
+	} else {
+		switch resp.StatusCode() {
+		case http.StatusBadRequest:
+			*queue = append(*queue,
+				tea.NewProgram(NewRedirect("Username already exist")))
+			*queue = append(*queue,
+				tea.NewProgram(NewRegister(m.Base)))
+		default:
+			return err
+		}
 	}
 
 	return nil

plays/roomWaiting.go

@@ -0,0 +1,90 @@
+package plays
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"gitea.konchin.com/ytshih/inp2025/game/tracing"
+	"gitea.konchin.com/ytshih/inp2025/game/types"
+	tea "github.com/charmbracelet/bubbletea"
+	"go.uber.org/zap"
+)
+
+type RoomWaiting struct {
+	*Base
+	roomID string
+	room   *types.Room
+}
+
+func NewRoomWaiting(base *Base, roomID string) *RoomWaiting {
+	return &RoomWaiting{
+		Base:   base,
+		roomID: roomID,
+	}
+}
+
+func (m *RoomWaiting) checkRoomStatus() tea.Msg {
+	resp, err := m.Base.client.R().
+		SetResult(&types.Room{}).
+		Get(fmt.Sprintf("/api/rooms/%s", m.roomID))
+
+	if err != nil || resp.StatusCode() != http.StatusOK {
+		return types.TickMsg{} // Keep polling
+	}
+
+	room := resp.Result().(*types.Room)
+	if room.Status == types.RoomStatusPlaying {
+		m.room = room
+		return tea.Quit() // Stop polling and proceed
+	}
+
+	return types.TickMsg{} // Keep polling
+}
+
+func (m *RoomWaiting) Init() tea.Cmd {
+	return tea.Batch(tea.ClearScreen, func() tea.Msg {
+		return types.TickMsg(time.Now())
+	})
+}
+
+func (m *RoomWaiting) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case types.TickMsg:
+		time.Sleep(1 * time.Second)
+		return m, m.checkRoomStatus
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "ctrl+c", "q":
+			return m, tea.Quit
+		}
+	}
+	return m, nil
+}
+
+func (m *RoomWaiting) View() string {
+	var b strings.Builder
+	b.WriteString("Waiting for another player to join...\n")
+	b.WriteString(fmt.Sprintf("Room ID: %s\n", m.roomID))
+	return b.String()
+}
+
+func (m *RoomWaiting) Next(queue *[]*tea.Program) error {
+	if m.room != nil && m.room.Status == types.RoomStatusPlaying {
+		hostURL := m.Base.client.HostURL
+		wsHost := strings.Replace(hostURL, "http", "ws", 1)
+		wsURL := fmt.Sprintf("%s/api/rooms/%s/state", wsHost, m.roomID)
+		tracing.Logger.Info("parsing websocket url", zap.String("url", wsURL))
+		u, err := url.Parse(wsURL)
+		if err != nil {
+			return err
+		}
+		*queue = append(*queue, tea.NewProgram(NewGame(m.Base, u, m.roomID)))
+	} else {
+		// If we quit without the room being ready, go back to the lobby.
+		*queue = append(*queue, tea.NewProgram(NewLobby(m.Base)))
+	}
+	return nil
+}