fix: prevent rebuilding of game node/tree on new move

Author: kevinjosethomas

src/hooks/useBroadcastController.ts

@@ -193,6 +193,10 @@ export const useBroadcastController = (): BroadcastStreamController => {
       if (roundData) {
         const game = roundData.games.get(gameId)
         if (game) {
+          console.log(
+            'Manual game selection:',
+            game.white + ' vs ' + game.black,
+          )
           setCurrentGame(game)
         }
       }
@@ -226,46 +230,99 @@ export const useBroadcastController = (): BroadcastStreamController => {
       const startingFen =
         'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'
 
-      // Build game tree from moves
-      const tree = new GameTree(startingFen)
-      const chess = new Chess(startingFen)
-      let currentNode = tree.getRoot()
-
-      const gameStates = [
-        {
-          board: startingFen,
-          lastMove: undefined as [string, string] | undefined,
-          san: undefined as string | undefined,
-          check: false,
-          maia_values: {},
-        },
-      ]
+      // Check if we have an existing game state to build upon
+      const existingLiveGame = gameStates.current.get(broadcastGame.id)
+
+      let tree: GameTree
+      let movesList: any[]
+      let existingMoveCount = 0
+
+      if (existingLiveGame && existingLiveGame.tree) {
+        // Reuse existing tree and states - preserve all analysis and variations
+        tree = existingLiveGame.tree
+        movesList = [...existingLiveGame.moves]
+        existingMoveCount = movesList.length - 1 // Subtract 1 for initial position
+        console.log(
+          `Reusing existing tree with ${existingMoveCount} moves, adding ${broadcastGame.moves.length - existingMoveCount} new moves`,
+        )
+      } else {
+        // Create new tree only for new games
+        tree = new GameTree(startingFen)
+        movesList = [
+          {
+            board: startingFen,
+            lastMove: undefined as [string, string] | undefined,
+            san: undefined as string | undefined,
+            check: false,
+            maia_values: {},
+          },
+        ]
+        console.log(
+          `Creating new tree for ${broadcastGame.white} vs ${broadcastGame.black}`,
+        )
+      }
 
-      // Process each move
-      for (const moveStr of broadcastGame.moves) {
-        try {
-          const move = chess.move(moveStr)
-          if (move) {
-            const newFen = chess.fen()
-            const uci =
-              move.from + move.to + (move.promotion ? move.promotion : '')
-
-            gameStates.push({
-              board: newFen,
-              lastMove: [move.from, move.to],
-              san: move.san,
-              check: chess.inCheck(),
-              maia_values: {},
-            })
-
-            currentNode = tree.addMainMove(currentNode, newFen, uci, move.san)
+      // Only process new moves that we don't already have
+      if (broadcastGame.moves.length > existingMoveCount) {
+        const chess = new Chess(startingFen)
+        let currentNode = tree.getRoot()
+
+        // Replay existing moves to get to the current position
+        for (let i = 0; i < existingMoveCount; i++) {
+          try {
+            const move = chess.move(broadcastGame.moves[i])
+            if (move && currentNode.mainChild) {
+              currentNode = currentNode.mainChild
+            }
+          } catch (error) {
+            console.warn(
+              `Error replaying existing move ${broadcastGame.moves[i]}:`,
+              error,
+            )
+            break
+          }
+        }
+
+        // Add only the new moves
+        for (let i = existingMoveCount; i < broadcastGame.moves.length; i++) {
+          try {
+            const moveStr = broadcastGame.moves[i]
+            const move = chess.move(moveStr)
+            if (move) {
+              const newFen = chess.fen()
+              const uci =
+                move.from + move.to + (move.promotion ? move.promotion : '')
+
+              movesList.push({
+                board: newFen,
+                lastMove: [move.from, move.to],
+                san: move.san,
+                check: chess.inCheck(),
+                maia_values: {},
+              })
+
+              currentNode = tree.addMainMove(currentNode, newFen, uci, move.san)
+              console.log(`Added new move: ${move.san}`)
+            }
+          } catch (error) {
+            console.warn(
+              `Error processing new move ${broadcastGame.moves[i]}:`,
+              error,
+            )
+            break
           }
-        } catch (error) {
-          console.warn(`Error processing move ${moveStr}:`, error)
-          break
         }
       }
 
+      // Preserve existing availableMoves array (legacy) and extend if needed
+      const availableMoves =
+        existingLiveGame?.availableMoves || new Array(movesList.length).fill({})
+
+      // Extend availableMoves array if we have new moves
+      while (availableMoves.length < movesList.length) {
+        availableMoves.push({})
+      }
+
       return {
         id: broadcastGame.id,
         blackPlayer: {
@@ -278,10 +335,8 @@ export const useBroadcastController = (): BroadcastStreamController => {
         },
         gameType: 'broadcast',
         type: 'stream' as const,
-        moves: gameStates,
-        availableMoves: new Array(gameStates.length).fill(
-          {},
-        ) as AvailableMoves[],
+        moves: movesList,
+        availableMoves: availableMoves as AvailableMoves[],
         termination:
           broadcastGame.result === '*'
             ? undefined
@@ -294,8 +349,8 @@ export const useBroadcastController = (): BroadcastStreamController => {
                       ? 'black'
                       : 'none',
               },
-        maiaEvaluations: [],
-        stockfishEvaluations: [],
+        maiaEvaluations: existingLiveGame?.maiaEvaluations || [],
+        stockfishEvaluations: existingLiveGame?.stockfishEvaluations || [],
         loadedFen: broadcastGame.fen,
         loaded: true,
         tree,
@@ -366,15 +421,30 @@ export const useBroadcastController = (): BroadcastStreamController => {
 
       // Update current game data if it's in the update, but don't switch to a different game
       if (currentGame) {
+        console.log(
+          'Current game selected:',
+          currentGame.white + ' vs ' + currentGame.black,
+        )
         const updatedCurrentGame = parseResult.games.find(
           (g) => g.id === currentGame.id,
         )
         if (updatedCurrentGame) {
+          console.log('Updating current game with new data')
           // Update the currently selected game with new data (including clocks)
           setCurrentGame(updatedCurrentGame)
+        } else {
+          console.log(
+            'Current game not in update - keeping selection unchanged',
+          )
         }
+        // Important: Do NOT change game selection if current game is not in the update
       } else if (parseResult.games.length > 0) {
         // Auto-select first game only if no game is currently selected
+        console.log('No game selected - auto-selecting first game')
+        console.log(
+          'Auto-selecting:',
+          parseResult.games[0].white + ' vs ' + parseResult.games[0].black,
+        )
         setCurrentGame(parseResult.games[0])
       }
 

src/pages/broadcast/[broadcastId]/[roundId].tsx

@@ -121,31 +121,45 @@ const BroadcastAnalysisPage: NextPage = () => {
 
   useEffect(() => {
     const currentLiveGame = (broadcastController as any).currentLiveGame
-    if (currentLiveGame?.tree && analysisController) {
+    if (
+      currentLiveGame?.tree &&
+      analysisController &&
+      analysisController.currentNode
+    ) {
       try {
         const mainLine = currentLiveGame.tree.getMainLine()
         const currentMoveCount = mainLine.length
 
         // If new moves have been added to the game
         if (currentMoveCount > lastGameMoveCount.current) {
-          lastGameMoveCount.current = currentMoveCount
+          console.log(
+            `New move detected: ${lastGameMoveCount.current} -> ${currentMoveCount}`,
+          )
 
           // Find the last node in the main line
-          let lastNode = currentLiveGame.tree.getRoot()
-          while (lastNode.mainChild) {
-            lastNode = lastNode.mainChild
-          }
+          const lastNode = mainLine[mainLine.length - 1]
 
-          // Only auto-follow if user is currently at the previous last node
-          if (
-            analysisController.currentNode &&
-            lastNode.parent === analysisController.currentNode
-          ) {
+          // Only auto-follow if user is currently at the previous last node (or close to it)
+          const isAtLatestPosition =
+            lastNode.parent === analysisController.currentNode ||
+            lastNode === analysisController.currentNode
+
+          console.log('Auto-follow check:', {
+            isAtLatestPosition,
+            currentNodeId: analysisController.currentNode.id,
+            lastNodeParentId: lastNode.parent?.id,
+            lastNodeId: lastNode.id,
+          })
+
+          if (isAtLatestPosition) {
+            console.log('Auto-following to new move')
             analysisController.setCurrentNode(lastNode)
           }
+
+          lastGameMoveCount.current = currentMoveCount
         }
       } catch (error) {
-        console.error('Error setting current node:', error)
+        console.error('Error in auto-follow logic:', error)
       }
     }
   }, [(broadcastController as any).currentLiveGame, analysisController])
@@ -157,6 +171,11 @@ const BroadcastAnalysisPage: NextPage = () => {
       const mainLine = currentLiveGame.tree.getMainLine()
       if (mainLine.length > 0) {
         analysisController.setCurrentNode(mainLine[mainLine.length - 1])
+        // Update the move count tracker for the new game
+        lastGameMoveCount.current = mainLine.length
+      } else {
+        // Reset move count for games with no moves
+        lastGameMoveCount.current = 0
       }
     }
   }, [broadcastController.currentGame?.id])