feat: migrate turing to use tree datastructure + clean up type inconsistencies

Author: kevinjosethomas

src/components/Board/BoardController.tsx

@@ -1,3 +1,4 @@
+import { GameNode } from 'src/types'
 import { useWindowSize } from 'src/hooks'
 import { FlipIcon } from 'src/components/Icons/icons'
 import { useCallback, useEffect, useMemo } from 'react'
@@ -6,14 +7,12 @@ interface Props {
   // Controller data
   orientation: 'white' | 'black'
   setOrientation: (orientation: 'white' | 'black') => void
-  currentNode?: any
-  currentIndex?: number
+  currentNode: GameNode
   plyCount: number
-  goToNode?: (node: any) => void
+  goToNode: (node: GameNode) => void
   goToNextNode: () => void
   goToPreviousNode: () => void
   goToRootNode: () => void
-  setCurrentIndex?: (index: number) => void
   gameTree?: any
 
   // Optional event handler
@@ -24,13 +23,11 @@ export const BoardController: React.FC<Props> = ({
   orientation,
   setOrientation,
   currentNode,
-  currentIndex,
   plyCount,
   goToNode,
   goToNextNode,
   goToPreviousNode,
   goToRootNode,
-  setCurrentIndex,
   gameTree,
   setCurrentMove,
 }: Props) => {
@@ -40,26 +37,19 @@ export const BoardController: React.FC<Props> = ({
     setOrientation(orientation === 'white' ? 'black' : 'white')
   }, [orientation, setOrientation])
 
-  // Determine navigation state based on available data
   const hasPrevious = useMemo(() => {
     if (currentNode !== undefined) {
       return !!currentNode?.parent
     }
-    if (currentIndex !== undefined) {
-      return currentIndex > 0
-    }
     return false
-  }, [currentNode, currentIndex])
+  }, [currentNode])
 
   const hasNext = useMemo(() => {
     if (currentNode !== undefined) {
       return !!currentNode?.mainChild
     }
-    if (currentIndex !== undefined) {
-      return currentIndex < plyCount - 1
-    }
     return false
-  }, [currentNode, currentIndex, plyCount])
+  }, [currentNode])
 
   const getFirst = useCallback(() => {
     goToRootNode()
@@ -77,24 +67,16 @@ export const BoardController: React.FC<Props> = ({
   }, [goToNextNode, setCurrentMove])
 
   const getLast = useCallback(() => {
-    if (currentNode && goToNode) {
-      // Node-based navigation (Analysis, Play, Training)
-      let lastNode = currentNode
-      while (lastNode?.mainChild) {
-        lastNode = lastNode.mainChild
-      }
-      if (lastNode) {
-        goToNode(lastNode)
-      }
-    } else if (gameTree && setCurrentIndex) {
-      // Index-based navigation (Turing)
-      const mainLine = gameTree.getMainLine()
-      if (mainLine.length > 0) {
-        setCurrentIndex(mainLine.length - 1)
-      }
+    let lastNode = currentNode
+    while (lastNode?.mainChild) {
+      lastNode = lastNode.mainChild
+    }
+    if (lastNode) {
+      goToNode(lastNode)
     }
+
     setCurrentMove?.(null)
-  }, [currentNode, goToNode, gameTree, setCurrentIndex, setCurrentMove])
+  }, [currentNode, goToNode, gameTree, setCurrentMove])
 
   useEffect(() => {
     if (width <= 670) return

src/components/Misc/ExportGame.tsx

@@ -12,7 +12,7 @@ interface AnalysisProps {
   blackPlayer: string
   event: string
   type: 'analysis'
-  currentNode?: GameNode
+  currentNode: GameNode
 }
 
 interface PlayProps {
@@ -22,7 +22,7 @@ interface PlayProps {
   blackPlayer: string
   event: string
   type: 'play'
-  currentNode?: never
+  currentNode: GameNode
 }
 
 interface TuringProps {
@@ -31,7 +31,7 @@ interface TuringProps {
   blackPlayer: string
   event: string
   type: 'turing'
-  currentNode?: never
+  currentNode: GameNode
 }
 
 type Props = AnalysisProps | PlayProps | TuringProps
@@ -46,7 +46,7 @@ export const ExportGame: React.FC<Props> = (props) => {
   const { currentNode, gameTree } =
     type === 'analysis'
       ? {
-          currentNode: props.currentNode || controller.currentNode,
+          currentNode: props.currentNode,
           gameTree: (props.game as AnalyzedGame).tree,
         }
       : type === 'play'
@@ -60,37 +60,21 @@ export const ExportGame: React.FC<Props> = (props) => {
           }
 
   useEffect(() => {
-    if (gameTree && currentNode) {
-      const tree = new GameTree(gameTree.getRoot().fen)
-      tree.setHeader('ID', game.id)
-      tree.setHeader('Event', event)
-      tree.setHeader('Site', 'https://maiachess.com/')
-      tree.setHeader('White', whitePlayer)
-      tree.setHeader('Black', blackPlayer)
-      if (game.termination) {
-        tree.setHeader('Result', game.termination.result)
-        if (game.termination.condition) {
-          tree.setHeader('Termination', game.termination.condition)
-        }
-      }
-
-      setPgn(gameTree.toPGN())
-      setFen(currentNode.fen)
-    } else {
-      // Fallback to legacy array-based approach
-      const initial = new Chess(game.moves[0]?.board || new Chess().fen())
-      initial.addHeader('ID', game.id)
-      initial.addHeader('Event', event)
-      initial.addHeader('Site', `https://maiachess.com/`)
-      initial.addHeader('White', whitePlayer)
-      initial.addHeader('Black', blackPlayer)
-      if (game.termination) {
-        initial.addHeader('Result', game.termination.result)
-        if (game.termination.condition) {
-          initial.addHeader('Termination', game.termination.condition)
-        }
+    const tree = new GameTree(gameTree.getRoot().fen)
+    tree.setHeader('ID', game.id)
+    tree.setHeader('Event', event)
+    tree.setHeader('Site', 'https://maiachess.com/')
+    tree.setHeader('White', whitePlayer)
+    tree.setHeader('Black', blackPlayer)
+    if (game.termination) {
+      tree.setHeader('Result', game.termination.result)
+      if (game.termination.condition) {
+        tree.setHeader('Termination', game.termination.condition)
       }
     }
+
+    setPgn(gameTree.toPGN())
+    setFen(currentNode.fen)
   }, [
     currentNode,
     game.moves,

src/contexts/BaseTreeControllerContext.ts

@@ -2,13 +2,11 @@ import { GameTree, GameNode } from 'src/types'
 
 export interface BaseTreeControllerContext {
   gameTree: GameTree
-  currentNode?: GameNode
+  currentNode: GameNode
   goToNode: (node: GameNode) => void
   goToNextNode: () => void
   goToPreviousNode: () => void
   goToRootNode: () => void
-  currentIndex: number
-  setCurrentIndex: (index: number) => void
   plyCount: number
   orientation: 'white' | 'black'
   setOrientation: (orientation: 'white' | 'black') => void

src/contexts/PlayControllerContext/PlayControllerContext.ts

@@ -13,16 +13,13 @@ export interface IPlayControllerContext extends BaseTreeControllerContext {
   playerActive: ReturnType<typeof usePlayMaiaController>['playerActive']
   toPlay: ReturnType<typeof usePlayMaiaController>['toPlay']
   moves: ReturnType<typeof usePlayMaiaController>['moves']
-  moveTimes: ReturnType<typeof usePlayMaiaController>['moveTimes']
   availableMoves: ReturnType<typeof usePlayMaiaController>['availableMoves']
   pieces: ReturnType<typeof usePlayMaiaController>['pieces']
   moveList: ReturnType<typeof usePlayMaiaController>['moveList']
   whiteClock: ReturnType<typeof usePlayMaiaController>['whiteClock']
   blackClock: ReturnType<typeof usePlayMaiaController>['blackClock']
   lastMoveTime: ReturnType<typeof usePlayMaiaController>['lastMoveTime']
   stats: ReturnType<typeof usePlayMaiaController>['stats']
-  setMoves: ReturnType<typeof usePlayMaiaController>['setMoves']
-  setMoveTimes: ReturnType<typeof usePlayMaiaController>['setMoveTimes']
   setResigned: ReturnType<typeof usePlayMaiaController>['setResigned']
   reset: ReturnType<typeof usePlayMaiaController>['reset']
   makeMove: ReturnType<typeof usePlayMaiaController>['makeMove']
@@ -48,7 +45,6 @@ export const PlayControllerContext =
     playerActive: false,
     toPlay: 'black',
     moves: [],
-    moveTimes: [],
     availableMoves: [],
     pieces: {},
     moveList: [],
@@ -64,8 +60,6 @@ export const PlayControllerContext =
       lastRating: undefined,
       rating: 0,
     },
-    setMoves: fn,
-    setMoveTimes: fn,
     setResigned: fn,
     reset: fn,
     makeMove: fn,
@@ -77,8 +71,6 @@ export const PlayControllerContext =
     goToNextNode: fn,
     goToPreviousNode: fn,
     goToRootNode: fn,
-    currentIndex: 0,
-    setCurrentIndex: fn,
     addMove: fn,
     addMoveWithTime: fn,
   })

src/contexts/TuringTreeControllerContext/TuringTreeControllerContext.ts

@@ -1,6 +1,6 @@
 import { Chess } from 'chess.ts'
 import { createContext } from 'react'
-import { GameTree, Color } from 'src/types'
+import { GameTree, Color, GameNode } from 'src/types'
 import { TuringGame } from 'src/types/turing'
 import { AllStats } from 'src/hooks/useStats'
 import { BaseTreeControllerContext } from '../BaseTreeControllerContext'
@@ -13,36 +13,19 @@ export interface ITuringControllerContext extends BaseTreeControllerContext {
   stats: AllStats
 
   getNewGame: () => Promise<void>
-  setCurrentId: (id: string | null) => void
+  currentGameId: string
+  setCurrentGameId: (id: string) => void
   submitGuess: (
     guess: Color,
     comment?: string,
     rating?: number,
   ) => Promise<void>
   commentController: [string, (comment: string) => void]
-
-  controller: {
-    plyCount: number
-    currentIndex: number
-    setCurrentIndex: (index: number) => void
-    orientation: 'white' | 'black'
-    setOrientation: (orientation: 'white' | 'black') => void
-  }
 }
 
 const defaultContext: ITuringControllerContext = {
-  game: undefined,
-  games: {},
-  loading: false,
-  gameIds: [],
-  stats: {
-    lifetime: undefined,
-    session: { gamesWon: 0, gamesPlayed: 0 },
-    lastRating: undefined,
-    rating: 0,
-  },
   gameTree: new GameTree(new Chess().fen()),
-  currentNode: undefined,
+  currentNode: new GameTree(new Chess().fen()).getRoot(),
   goToNode: () => {
     /* no-op */
   },
@@ -55,19 +38,26 @@ const defaultContext: ITuringControllerContext = {
   goToRootNode: () => {
     /* no-op */
   },
-  currentIndex: 0,
-  setCurrentIndex: () => {
+  currentGameId: '',
+  setCurrentGameId: () => {
     /* no-op */
   },
   plyCount: 0,
   orientation: 'white',
   setOrientation: () => {
     /* no-op */
   },
-  getNewGame: async () => {
-    /* no-op */
+  game: undefined,
+  games: {},
+  loading: false,
+  gameIds: [],
+  stats: {
+    lifetime: undefined,
+    session: { gamesWon: 0, gamesPlayed: 0 },
+    lastRating: undefined,
+    rating: 0,
   },
-  setCurrentId: () => {
+  getNewGame: async () => {
     /* no-op */
   },
   submitGuess: async () => {
@@ -79,17 +69,6 @@ const defaultContext: ITuringControllerContext = {
       /* no-op */
     },
   ],
-  controller: {
-    plyCount: 0,
-    currentIndex: 0,
-    setCurrentIndex: () => {
-      /* no-op */
-    },
-    orientation: 'white',
-    setOrientation: () => {
-      /* no-op */
-    },
-  },
 }
 
 export const TuringControllerContext =

src/hooks/usePlayController/usePlayMaiaController.ts

@@ -54,9 +54,7 @@ export const usePlayMaiaController = (id: string, config: PlayGameConfig) => {
   const [blackClock, setBlackClock] = useState<number>(initialClockValue)
   const [lastMoveTime, setLastMoveTime] = useState<number>(0)
 
-  const [currentNode, setCurrentNode] = useState<GameNode | undefined>(() =>
-    gameTree.getRoot(),
-  )
+  const [currentNode, setCurrentNode] = useState<GameNode>(gameTree.getRoot())
   const [orientation, setOrientation] = useState<'white' | 'black'>(
     config.player,
   )