fix: play error

Author: kevinjosethomas

src/contexts/PlayControllerContext.ts

@@ -24,7 +24,6 @@ export interface IPlayControllerContext extends BaseTreeControllerContext {
   makePlayerMove: ReturnType<typeof usePlayController>['makePlayerMove']
   updateClock: ReturnType<typeof usePlayController>['updateClock']
   setCurrentNode: ReturnType<typeof usePlayController>['setCurrentNode']
-  addMove: ReturnType<typeof usePlayController>['addMove']
   addMoveWithTime: ReturnType<typeof usePlayController>['addMoveWithTime']
 }
 
@@ -70,6 +69,5 @@ export const PlayControllerContext =
     goToNextNode: fn,
     goToPreviousNode: fn,
     goToRootNode: fn,
-    addMove: fn,
     addMoveWithTime: fn,
   })

src/hooks/usePlayController/usePlayController.ts

@@ -1,11 +1,4 @@
-import {
-  Color,
-  Check,
-  GameNode,
-  GameTree,
-  Termination,
-  PlayGameConfig,
-} from 'src/types'
+import { Color, Check, GameTree, Termination, PlayGameConfig } from 'src/types'
 import { AllStats } from '../useStats'
 import { PlayedGame } from 'src/types/play'
 import { Chess, Piece, SQUARES } from 'chess.ts'
@@ -79,32 +72,36 @@ export const usePlayController = (id: string, config: PlayGameConfig) => {
   const [lastMoveTime, setLastMoveTime] = useState<number>(0)
 
   const moveList = useMemo(
-    () => controller.gameTree.toMoveArray(),
-    [controller.gameTree, treeVersion],
+    () => controller.tree.toMoveArray(),
+    [controller.tree, treeVersion],
   )
 
   const moveTimes = useMemo(
-    () => controller.gameTree.toTimeArray(),
-    [controller.gameTree, treeVersion],
+    () => controller.tree.toTimeArray(),
+    [controller.tree, treeVersion],
   )
 
   const game: PlayedGame = useMemo(() => {
-    const mainLine = controller.gameTree.getMainLine()
+    const mainLine = controller.tree.getMainLine()
+    console.log(mainLine)
     const lastNode = mainLine[mainLine.length - 1]
-    const chess = controller.gameTree.toChess()
+    const turn = lastNode.turn
+    const chess = controller.tree.toChess()
+
+    console.log('gme node', lastNode.fen)
 
     const termination = resigned
       ? Math.min(whiteClock, blackClock) > 0
         ? ({
-            result: chess.turn() == 'w' ? '0-1' : '1-0',
-            winner: chess.turn() == 'w' ? 'black' : 'white',
+            result: turn == 'w' ? '0-1' : '1-0',
+            winner: turn == 'w' ? 'black' : 'white',
             type: 'resign',
           } as Termination)
-        : computeTimeTermination(chess, chess.turn() == 'w' ? 'white' : 'black')
+        : computeTimeTermination(chess, turn == 'w' ? 'white' : 'black')
       : computeTermination(chess)
 
     const moves = []
-    const rootNode = controller.gameTree.getRoot()
+    const rootNode = controller.tree.getRoot()
     const rootChess = new Chess(rootNode.fen)
     moves.push({
       board: rootNode.fen,
@@ -131,12 +128,11 @@ export const usePlayController = (id: string, config: PlayGameConfig) => {
 
     return {
       id,
-      moves,
-      tree: controller.gameTree,
       termination,
-      turn: chess.turn() == 'b' ? 'black' : 'white',
+      tree: controller.tree,
+      turn: turn == 'b' ? 'black' : 'white',
     }
-  }, [controller.gameTree, treeVersion, resigned, whiteClock, blackClock, id])
+  }, [controller.tree, treeVersion, resigned, whiteClock, blackClock, id])
 
   const toPlay: Color | null = game.termination ? null : game.turn
   const playerActive = toPlay == config.player
@@ -228,33 +224,23 @@ export const usePlayController = (id: string, config: PlayGameConfig) => {
     whiteClock,
   ])
 
-  const addMove = useCallback(
-    (moveUci: string) => {
-      const newNode = controller.gameTree.addMoveToMainLine(moveUci)
-      if (newNode) {
-        controller.setCurrentNode(newNode)
-        // Force re-render by incrementing tree version
-        setTreeVersion((prev) => prev + 1)
-      }
-    },
-    [controller.gameTree, controller],
-  )
-
   const addMoveWithTime = useCallback(
     (moveUci: string, moveTime: number) => {
-      const newNode = controller.gameTree.addMoveToMainLine(moveUci, moveTime)
+      const newNode = controller.tree.addMoveToMainLine(moveUci, moveTime)
       if (newNode) {
+        console.log('old node', controller.currentNode.fen)
+        console.log('new move', moveUci)
+        console.log('new node', newNode.fen)
         controller.setCurrentNode(newNode)
-        // Force re-render by incrementing tree version
         setTreeVersion((prev) => prev + 1)
       }
     },
-    [controller.gameTree, controller],
+    [controller.tree, controller],
   )
 
   const reset = () => {
     const newTree = new GameTree(config.startFen || nullFen)
-    controller.gameTree = newTree
+    controller.tree = newTree
     controller.setCurrentNode(newTree.getRoot())
     setResigned(false)
     setLastMoveTime(0)
@@ -278,7 +264,7 @@ export const usePlayController = (id: string, config: PlayGameConfig) => {
 
   return {
     game,
-    gameTree: controller.gameTree,
+    gameTree: controller.tree,
     currentNode: controller.currentNode,
     player: config.player,
     playType: config.playType,
@@ -305,7 +291,6 @@ export const usePlayController = (id: string, config: PlayGameConfig) => {
     orientation: controller.orientation,
     setOrientation: controller.setOrientation,
 
-    addMove,
     addMoveWithTime,
     setResigned,
     reset,

src/hooks/usePlayController/useVsMaiaController.ts

@@ -39,6 +39,7 @@ export const useVsMaiaPlayController = (
         !controller.playerActive &&
         !controller.game.termination
       ) {
+        console.log('node before move', controller.currentNode.fen)
         const maiaClock =
           (controller.player == 'white'
             ? controller.blackClock
@@ -125,10 +126,8 @@ export const useVsMaiaPlayController = (
         },
       )
 
-      // Only update stats after final move submitted
       if (controller.game.termination) {
         const winner = controller.game.termination?.winner
-        // Safely update rating - only if the response contains a valid rating
         safeUpdateRating(response.player_elo, updateRating)
         incrementStats(1, winner == playGameConfig.player ? 1 : 0)
       }

src/hooks/useTreeController/useTreeController.ts

@@ -5,13 +5,14 @@ export const useTreeController = (
   gameTree: GameTree,
   initialOrientation: Color = 'white',
 ) => {
-  const [currentNode, setCurrentNode] = useState<GameNode>(gameTree.getRoot())
+  const [tree, setTree] = useState(gameTree)
+  const [currentNode, setCurrentNode] = useState<GameNode>(tree.getRoot())
   const [orientation, setOrientation] = useState<Color>(initialOrientation)
 
   const plyCount = useMemo(() => {
-    if (!gameTree) return 0
-    return gameTree.getMainLine().length
-  }, [gameTree])
+    if (!tree) return 0
+    return tree.getMainLine().length
+  }, [tree])
 
   const goToNode = useCallback(
     (node: GameNode) => {
@@ -33,17 +34,17 @@ export const useTreeController = (
   }, [currentNode, setCurrentNode])
 
   const goToRootNode = useCallback(() => {
-    if (gameTree) {
-      setCurrentNode(gameTree.getRoot())
+    if (tree) {
+      setCurrentNode(tree.getRoot())
     }
-  }, [gameTree, setCurrentNode])
+  }, [tree, setCurrentNode])
 
   useEffect(() => {
     setOrientation(initialOrientation)
   }, [initialOrientation])
 
   return {
-    gameTree,
+    tree,
     currentNode,
     setCurrentNode,
     orientation,

src/pages/play/maia.tsx

@@ -2,14 +2,14 @@ import Head from 'next/head'
 import { startGame } from 'src/api'
 import { NextPage } from 'next/types'
 import { useRouter } from 'next/router'
+import { tourConfigs } from 'src/constants/tours'
 import { ModalContext, useTour } from 'src/contexts'
-import { useContext, useEffect, useMemo, useState } from 'react'
 import { DelayedLoading, PlayControls } from 'src/components'
 import { Color, TimeControl, PlayGameConfig } from 'src/types'
+import { useContext, useEffect, useMemo, useState } from 'react'
 import { GameplayInterface } from 'src/components/Board/GameplayInterface'
 import { useVsMaiaPlayController } from 'src/hooks/usePlayController/useVsMaiaController'
 import { PlayControllerContext } from 'src/contexts/PlayControllerContext'
-import { tourConfigs } from 'src/constants/tours'
 
 interface Props {
   id: string
@@ -100,7 +100,6 @@ const PlayMaiaPage: NextPage = () => {
     startFen,
   } = router.query
 
-  // simulateMaiaTime can be configured in setup modal, default to true if not specified
   const [simulateMaiaTime, setSimulateMaiaTime] = useState<boolean>(
     simulateMaiaTimeQuery === 'true' || simulateMaiaTimeQuery === undefined
       ? true
@@ -132,7 +131,6 @@ const PlayMaiaPage: NextPage = () => {
   useEffect(() => {
     if (!initialTourCheck) {
       setInitialTourCheck(true)
-      // Always attempt to start the tour - the tour context will handle completion checking
       startTour(tourConfigs.play.id, tourConfigs.play.steps, false)
     }
   }, [initialTourCheck, startTour])

src/types/tree.ts

@@ -119,13 +119,13 @@ export class GameTree {
     const mainLine = this.getMainLine()
     const lastNode = mainLine[mainLine.length - 1]
 
-    const chess = new Chess(lastNode.fen)
-    const result = chess.move(moveUci, { sloppy: true })
+    const board = new Chess(lastNode.fen)
+    const result = board.move(moveUci, { sloppy: true })
 
     if (result) {
       return this.addMainMove(
         lastNode,
-        chess.fen(),
+        board.fen(),
         moveUci,
         result.san,
         undefined,
@@ -260,7 +260,6 @@ export class GameNode {
     return parseInt(parts[5]) - (turn === 'w' ? 1 : 0)
   }
 
-  // Core classification logic - used by both instance and static methods
   private performMoveClassification(
     stockfishEval: StockfishEvaluation,
     maiaEval: { [rating: string]: MaiaEvaluation } | undefined,