refactor out ws.inProgressMsgItem

cmd/server/ws.go

@@ -139,51 +139,85 @@ func (ws WS) inProgressMsg(ctx context.Context, ugs *UserGameServer, gameState G
 	msg["page"] = "B"
 	msg["event"] = "A"
 
-	items := []map[string]any{}
+	items, err := ws.inProgressMsgItems(ctx, ugs, gameState)
-	for k, v := range gameState.Players {
+	if err != nil {
-		if k == ugs.Session.ID {
+		return nil, err
+	}
+	msg["items"] = items
+
+	return nil, io.EOF
+}
+
+type inProgressMsgItem struct {
+	Name  string                 `json:"name"`
+	Title string                 `json:"title"`
+	Tags  []inProgressMsgItemTag `json:"tags"`
+}
+
+type inProgressMsgItemTag struct {
+	K string `json:"k"`
+	V string `json:"v"`
+}
+
+func (ws WS) inProgressMsgItems(ctx context.Context, ugs *UserGameServer, gameState GameState) ([]inProgressMsgItem, error) {
+	items := []inProgressMsgItem{}
+	for k := range gameState.Players {
+		item, err := ws.inProgressMsgItem(ctx, ugs, gameState, k)
+		if err != nil {
+			return nil, err
+		}
+		if item == nil {
 			continue
 		}
+		items = append(items, *item)
+	}
+	slices.SortFunc(items, func(a, b inProgressMsgItem) int {
+		an, _ := strconv.Atoi(a.Title)
+		bn, _ := strconv.Atoi(b.Title)
+		return an - bn
+	})
+	return items, nil
+}
 
-		name, err := ws.games.UserName(ctx, k)
+func (ws WS) inProgressMsgItem(ctx context.Context, ugs *UserGameServer, gameState GameState, uid string) (*inProgressMsgItem, error) {
+	v := gameState.Players[uid]
+
+	if uid == ugs.Session.ID {
+		return nil, nil
+	}
+
+	name, err := ws.games.UserName(ctx, uid)
 	if err != nil {
 		return nil, err
 	}
 
-		tags := []map[string]any{}
+	tags := []inProgressMsgItemTag{}
-		if self := gameState.Players[ugs.Session.ID]; self.KillWords.Assignee == k {
+	if self := gameState.Players[ugs.Session.ID]; self.KillWords.Assignee == uid {
 		for _, private := range v.KillWords.Assignment.Private {
-				tags = append(tags, map[string]any{
+			tags = append(tags, inProgressMsgItemTag{
-					"k": private.Word,
+				K: private.Word,
-					"v": private.Points,
+				V: strconv.Itoa(private.Points),
 			})
 		}
 	}
 	for _, public := range v.KillWords.Assignment.Public {
-			tags = append(tags, map[string]any{
+		tags = append(tags, inProgressMsgItemTag{
-				"k": public.Word,
+			K: public.Word,
-				"v": public.Points,
+			V: strconv.Itoa(public.Points),
 		})
 	}
 	if self := gameState.Players[ugs.Session.ID]; !slices.ContainsFunc(self.Kills, func(a Kill) bool {
-			return a.Victim == k
+		return a.Victim == uid
 	}) {
-			tags = append(tags, map[string]any{
+		tags = append(tags, inProgressMsgItemTag{
-				"k": self.KillWords.Global.Word,
+			K: self.KillWords.Global.Word,
-				"v": self.KillWords.Global.Points,
+			V: strconv.Itoa(self.KillWords.Global.Points),
 		})
 	}
 
-		items = append(items, map[string]any{
+	return &inProgressMsgItem{
-			"name":  name,
+		Name:  name,
-			"title": strconv.Itoa(v.Points()),
+		Title: strconv.Itoa(v.Points()),
-			"tags":  tags,
+		Tags:  tags,
-		})
+	}, nil
-	}
-	slices.SortFunc(items, func(a, b map[string]any) int {
-		an, _ := strconv.Atoi(fmt.Sprint(a["title"]))
-		bn, _ := strconv.Atoi(fmt.Sprint(b["title"]))
-		return an - bn
-	})
-	return nil, io.EOF
 }