starting new structure

src/useScore/useScore.ts

@@ -1,107 +1,96 @@
-import { useEffect, useState } from "react";
-import { useTimer } from "./hooks/useTimer";
-import { useScoreTime } from "./useScoreTime";
-import type { GameStatus } from "../types";
+import { useState, useEffect, useCallback } from 'react';
+import type { BoardManager } from '../useBoard/types';
+import type { GameStatusManager } from '../useGameStatus/types';
+import type { ScoreManager, UseScoreProps } from './types';
+import { useTimer } from './useTimer';
 
-const TIME_LIMIT_MS = Infinity; // No time limit by default
-const KEYSTROKE_LIMIT = Infinity; // No keystroke limit by default
-
-type GameScoreContext = {
-  gameStatus: GameStatus;
-  setGameStatus: (status: GameStatus) => void;
-};
-
-type UseScoreParams = {
-  gameContext: GameScoreContext;
-  keystrokeCount: number;
-  board: string;
-  isComplete: (board: string) => boolean;
-  isFullyValid: (board: string) => boolean;
-  initialBoard: string;
-};
-
-export function useScore({
-  gameContext,
-  keystrokeCount,
-  board,
-  isComplete,
-  isFullyValid,
-  initialBoard
-}: UseScoreParams) {
+export function useScore({ board, gameStatusManager, keystrokeCount }: UseScoreProps): ScoreManager {
   const timer = useTimer();
-  const { gameStatus, setGameStatus } = gameContext;
-  const { timeValue, startTimer, stopTimer, resetTimer } = timer;
+  const [mistakes, setMistakes] = useState<number>(0);
+  const [hints, setHints] = useState<number>(0);
 
-  const [finalScore, setFinalScore] = useState<number | null>(null);
+  const addMistake = useCallback(() => {
+    setMistakes(prev => prev + 1);
+  }, []);
 
-  const minMovesRequired = initialBoard.split("").filter(c => c === ".").length;
-  const actualMoves = keystrokeCount;
-  const efficiency = minMovesRequired > 0
-    ? Math.round((actualMoves / minMovesRequired) * 100)
-    : 0;
+  const addHint = useCallback(() => {
+    setHints(prev => prev + 1);
+  }, []);
 
-  useScoreTime({ gameStatus, timer });
+  const calculateEfficiency = useCallback((): number => {
+    const boardString = board.boardRef.current.map(row => 
+      row.map(cell => cell.value || '.').join('')
+    ).join('');
+
+    const filledCells = boardString.replace(/\./g, '').length;
+    const totalCells = 81;
+    const givenCells = board.initialBoardRef.current.replace(/\./g, '').length;
+    const userFilledCells = filledCells - givenCells;
+
+    if (userFilledCells === 0) return 100;
+
+    const optimalMoves = userFilledCells;
+    const actualMoves = keystrokeCount;
+
+    const efficiency = Math.round((optimalMoves / actualMoves) * 100);
+    return Math.max(0, Math.min(100, efficiency));
+  }, [board, keystrokeCount]);
+
+  const calculateFinalScore = useCallback((): number | null => {
+    const { gameStatus } = gameStatusManager;
+    
+    if (gameStatus !== 'game-won') return null;
+
+    const efficiency = calculateEfficiency();
+    const timeInSeconds = timer.timeValue / 1000;
+    const timeBonus = Math.max(0, 3600 - timeInSeconds) * 10;
+    const mistakePenalty = mistakes * 100;
+    const hintPenalty = hints * 200;
+
+    const baseScore = 10000;
+    const efficiencyBonus = efficiency * 50;
+    
+    const finalScore = baseScore + efficiencyBonus + timeBonus - mistakePenalty - hintPenalty;
+    return Math.max(0, Math.round(finalScore));
+  }, [gameStatusManager, calculateEfficiency, timer.timeValue, mistakes, hints]);
 
   useEffect(() => {
-    if (gameStatus !== "started") return;
+    const { gameStatus } = gameStatusManager;
 
-    if (isComplete(board) && isFullyValid(board)) {
-      setGameStatus("game-won");
-      return;
+    if (gameStatus === 'started') {
+      timer.startTimer();
+    } else if (gameStatus === 'paused' || gameStatus === 'game-over' || gameStatus === 'game-won') {
+      timer.stopTimer();
     }
 
-    if (timeValue >= TIME_LIMIT_MS) {
-      setGameStatus("game-over");
-      return;
+    if (gameStatus === 'waiting') {
+      timer.resetTimer();
+      setMistakes(0);
+      setHints(0);
     }
-
-    if (keystrokeCount >= KEYSTROKE_LIMIT) {
-      setGameStatus("game-over");
-      return;
-    }
-
-    // TODO: Enable efficiency-based game-over in future
-    // if (efficiency > 200) {
-    //   setGameStatus("game-over");
-    //   return;
-    // }
-  }, [gameStatus, timeValue, keystrokeCount, board, setGameStatus, isComplete, isFullyValid, efficiency]);
+  }, [gameStatusManager.gameStatus, timer]);
 
   useEffect(() => {
-    const handleWin = () => {
-      if (gameStatus === "started") {
-        setGameStatus("game-won");
-      }
-    };
-    window.addEventListener("sudoku-game-won", handleWin);
-    return () => window.removeEventListener("sudoku-game-won", handleWin);
-  }, [gameStatus, setGameStatus]);
+    const { gameStatus, setGameStatus } = gameStatusManager;
 
-  useEffect(() => {
-    if (gameStatus !== "game-won") return;
-
-    const timeInSeconds = timeValue / 1000;
-    const baseScore = 100000;
-    const timePenalty = Math.floor(timeInSeconds * 10);
-    const extraMoves = Math.max(0, actualMoves - minMovesRequired);
-    const movePenalty = extraMoves * 50;
-    const score = Math.max(0, baseScore - timePenalty - movePenalty);
-
-    setFinalScore(score);
-  }, [gameStatus, timeValue, actualMoves, minMovesRequired]);
+    if (gameStatus === 'started' && board.isComplete() && board.isFullyValid()) {
+      setGameStatus('game-won');
+    }
+  }, [board, gameStatusManager]);
 
   return {
-    timeValue,
-    startTimer,
-    stopTimer,
-    resetTimer,
-    finalScore,
-    timeLimit: TIME_LIMIT_MS,
-    keystrokeLimit: KEYSTROKE_LIMIT,
-    minMovesRequired,
-    actualMoves,
-    efficiency,
+    timeValue: timer.timeValue,
+    keystrokes: keystrokeCount,
+    mistakes,
+    hints,
+    efficiency: calculateEfficiency(),
+    finalScore: calculateFinalScore(),
+    startTimer: timer.startTimer,
+    stopTimer: timer.stopTimer,
+    resetTimer: timer.resetTimer,
+    addMistake,
+    addHint,
+    calculateEfficiency,
+    calculateFinalScore
   };
-}
-
-export type UseScoreType = ReturnType<typeof useScore>;
+}