From d1c4738796fe0fcb5d4473964ee0da6da12d7729 Mon Sep 17 00:00:00 2001
From: Bel LaPointe <153096461+breel-render@users.noreply.github.com>
Date: Sun, 15 Dec 2024 08:49:43 -0700
Subject: [PATCH] GameState uses GameEvents

---
 cmd/server/games.go | 81 +++++++++++++++++++++------------------------
 1 file changed, 37 insertions(+), 44 deletions(-)

diff --git a/cmd/server/games.go b/cmd/server/games.go
index a547f70..109aa94 100644
--- a/cmd/server/games.go
+++ b/cmd/server/games.go
@@ -142,18 +142,22 @@ type (
 	EventType int
 
 	EventPlayerJoin struct {
-		Type EventType
-		ID   string
+		Type      EventType
+		Timestamp time.Time
+		ID        string
 	}
 	EventPlayerLeave struct {
-		Type EventType
-		ID   string
+		Type      EventType
+		Timestamp time.Time
+		ID        string
 	}
 	EventGameComplete struct {
-		Type EventType
+		Type      EventType
+		Timestamp time.Time
 	}
 	EventAssignmentRotation struct {
 		Type      EventType
+		Timestamp time.Time
 		Killer    string
 		Victim    string
 		KillWord  KillWord
@@ -183,7 +187,7 @@ func (games Games) GameEvents(ctx context.Context, id string, since time.Time) (
 		if err := rows.Scan(&timestamp, &b); err != nil {
 			return err
 		}
-		event, err := parseEvent(b)
+		event, err := parseEvent(b, timestamp)
 		results = append(results, event)
 		return err
 	}, `
@@ -197,7 +201,7 @@ func (games Games) GameEvents(ctx context.Context, id string, since time.Time) (
 	return results, err
 }
 
-func parseEvent(b []byte) (Event, error) {
+func parseEvent(b []byte, timestamp time.Time) (Event, error) {
 	var peek struct {
 		Type EventType
 	}
@@ -206,21 +210,25 @@ func parseEvent(b []byte) (Event, error) {
 	}
 	switch peek.Type {
 	case PlayerJoin:
-		var playerJoin EventPlayerJoin
-		err := json.Unmarshal(b, &playerJoin)
-		return playerJoin, err
+		var v EventPlayerJoin
+		err := json.Unmarshal(b, &v)
+		v.Timestamp = timestamp
+		return v, err
 	case PlayerLeave:
-		var playerLeave EventPlayerLeave
-		err := json.Unmarshal(b, &playerLeave)
-		return playerLeave, err
+		var v EventPlayerLeave
+		err := json.Unmarshal(b, &v)
+		v.Timestamp = timestamp
+		return v, err
 	case GameComplete:
-		var gameComplete EventGameComplete
-		err := json.Unmarshal(b, &gameComplete)
-		return gameComplete, err
+		var v EventGameComplete
+		err := json.Unmarshal(b, &v)
+		v.Timestamp = timestamp
+		return v, err
 	case AssignmentRotation:
-		var assignmentRotation EventAssignmentRotation
-		err := json.Unmarshal(b, &assignmentRotation)
-		return assignmentRotation, err
+		var v EventAssignmentRotation
+		err := json.Unmarshal(b, &v)
+		v.Timestamp = timestamp
+		return v, err
 	}
 	return nil, fmt.Errorf("unknown event type %d: %s", peek.Type, b)
 }
@@ -228,30 +236,22 @@ func parseEvent(b []byte) (Event, error) {
 func (games Games) GameState(ctx context.Context, id string) (GameState, error) {
 	result := GameState{Players: map[string]PlayerState{}}
 
-	err := games.db.Query(ctx, func(rows *sql.Rows) error {
-		var timestamp time.Time
-		var payload []byte
-		if err := rows.Scan(&timestamp, &payload); err != nil {
-			return err
-		}
-
-		event, err := parseEvent(payload)
-		if err != nil {
-			return err
-		}
+	events, err := games.GameEvents(ctx, id, time.Time{})
+	if err != nil {
+		return result, err
+	}
 
+	for _, event := range events {
 		switch event.(type) {
 		case EventPlayerJoin:
 			playerJoin := event.(EventPlayerJoin)
 			result.Players[playerJoin.ID] = PlayerState{}
-			return nil
 		case EventPlayerLeave:
 			playerLeave := event.(EventPlayerLeave)
 			delete(result.Players, playerLeave.ID)
-			return nil
 		case EventGameComplete:
-			result.Completed = timestamp
-			return nil
+			gameComplete := event.(EventGameComplete)
+			result.Completed = gameComplete.Timestamp
 		case EventAssignmentRotation:
 			result.Started = true
 			assignmentRotation := event.(EventAssignmentRotation)
@@ -260,7 +260,7 @@ func (games Games) GameState(ctx context.Context, id string) (GameState, error)
 			} else if _, ok := result.Players[assignmentRotation.Victim]; !ok {
 			} else {
 				killer.Kills = append(killer.Kills, Kill{
-					Timestamp: timestamp,
+					Timestamp: assignmentRotation.Timestamp,
 					Victim:    assignmentRotation.Victim,
 					KillWord:  assignmentRotation.KillWord,
 				})
@@ -277,17 +277,10 @@ func (games Games) GameState(ctx context.Context, id string) (GameState, error)
 				player.KillWords = v
 				result.Players[k] = player
 			}
-			return nil
 		default:
-			return fmt.Errorf("unknown event type %T: %s", event, payload)
+			return GameState{}, fmt.Errorf("unknown event type %T", event)
 		}
-
-		return nil
-	}, `
-		SELECT timestamp, payload
-		FROM events
-		WHERE game_uuid=?
-	`, id)
+	}
 
 	return result, err
 }