Offline computer fixes and improvements

lib/src/model/common/chess.dart

@@ -26,6 +26,21 @@ sealed class SanMove with _$SanMove {
   // It's sufficient to check for O-O here, because that of course also covers O-O-O.
   bool get isCastles => san.startsWith('O-O');
 
+  /// Normalize UCI to a "king takes rook" UCI notation.
+  ///
+  /// Returns the original notation chess960 variant where this notation is already forced and
+  /// where the normalized notation could conflict with the actual move.
+  UCIMove normalizeUci(Variant variant) {
+    if (variant == Variant.chess960) {
+      return move.uci;
+    }
+    if (isCastles) {
+      return kingTakesRookCastles[move.uci] ?? move.uci;
+    } else {
+      return move.uci;
+    }
+  }
+
   bool isIrreversible(Variant variant) {
     if (isCheck) return true;
     if (variant == Variant.crazyhouse) return false;
@@ -46,9 +61,16 @@ class MoveConverter implements JsonConverter<Move, String> {
   String toJson(Move object) => object.uci;
 }
 
-/// Alternative castling uci notations.
+/// Get alternate castling notations from king takes rook notation, e.g. e1c1 for O-O-O and e1g1 for O-O.
 const altCastles = {'e1a1': 'e1c1', 'e1h1': 'e1g1', 'e8a8': 'e8c8', 'e8h8': 'e8g8'};
 
+/// Get king takes rook castling notations from alternate notation, e.g. e1a1 for O-O-O and e1h1 for O-O.
+const kingTakesRookCastles = {'e1c1': 'e1a1', 'e1g1': 'e1h1', 'e8c8': 'e8a8', 'e8g8': 'e8h8'};
+
+/// Normalizes a UCI move string for comparison by converting alternate castling notations to
+/// standard notation.
+String normalizeUci(String uci) => kingTakesRookCastles[uci] ?? uci;
+
 /// Returns `true` if the move is a pawn promotion move that is not yet promoted.
 bool isPromotionPawnMove(Position position, NormalMove move) {
   return move.promotion == null &&

lib/src/model/common/node.dart

@@ -215,16 +215,11 @@ abstract class Node {
   }) {
     final pos = nodeAt(path).position;
 
-    final potentialAltCastlingMove =
-        move is NormalMove &&
-        pos.board.roleAt(move.from) == Role.king &&
-        pos.board.roleAt(move.to) != Role.rook;
-
-    final convertedMove = potentialAltCastlingMove ? convertAltCastlingMove(move) ?? move : move;
+    final normalizedMove = normalizeMove(pos, move);
 
-    final (newPos, newSan) = pos.makeSan(convertedMove);
+    final (newPos, newSan) = pos.makeSan(normalizedMove);
     final newNode = Branch(
-      sanMove: SanMove(newSan, convertedMove),
+      sanMove: SanMove(newSan, normalizedMove),
       position: newPos,
       comments: (clock != null) ? [PgnComment(clock: clock)] : null,
     );
@@ -239,11 +234,15 @@ abstract class Node {
     return newPath != null ? addMovesAt(newPath, moves.skip(1), prepend: prepend) : null;
   }
 
-  /// The function `convertAltCastlingMove` checks if a move is an alternative
-  /// castling move and converts it to the corresponding standard castling move if so.
-  Move? convertAltCastlingMove(Move move) {
-    return altCastles.containsValue(move.uci)
-        ? Move.parse(altCastles.entries.firstWhere((e) => e.value == move.uci).key)
+  /// Normalizes the move to the king takes rook castling notation if it is an alternate castling move.
+  Move normalizeMove(Position pos, Move move) {
+    final potentialAltCastlingMove =
+        move is NormalMove &&
+        pos.board.roleAt(move.from) == Role.king &&
+        pos.board.roleAt(move.to) != Role.rook;
+    if (!potentialAltCastlingMove) return move;
+    return kingTakesRookCastles[move.uci] != null
+        ? NormalMove.fromUci(kingTakesRookCastles[move.uci]!)
         : move;
   }
 

lib/src/model/engine/evaluation_service.dart

@@ -212,35 +212,36 @@ class EvaluationService {
   /// Returns a [Future] that completes with the evaluation, or `null` if no evaluation
   /// could be obtained (e.g. the engine fails).
   ///
-  /// The [work] must have a [EvalWork.searchTime] set.
-  ///
-  /// If [minDepth] is provided, the evaluation will stop early once this depth is reached.
-  /// Otherwise, it will run for the full [EvalWork.searchTime].
-  Future<LocalEval?> findEval(EvalWork work, {int? minDepth}) async {
-    assert(work.searchTime != Duration.zero, 'searchTime must be set for findEval');
-
-    final stream = evaluate(work);
-    if (stream == null) {
-      // do we have a cached eval?
-      switch (work.evalCache) {
-        case final LocalEval localEval:
-          return localEval;
-        case CloudEval _:
-          return null;
-        case _:
-          return null;
-      }
-    }
+  /// If provided, the evaluation will stop at [depthThreshold], if the [minSearchTime] has passed.
+  /// This allows for better evaluations in high end devices while still providing quick responses in low end devices.
+  /// Even if [depthThreshold] is not reached, the evaluation will still stop at [EvalWork.searchTime].
+  Future<LocalEval?> findEval(EvalWork work, {int? depthThreshold, Duration? minSearchTime}) async {
+    _setEval(null);
+
+    _logger.info(
+      'Finding evaluation at ply ${work.position.ply} with options: '
+      'flavor=${work.stockfishFlavor}, multiPv=${work.multiPv}, cores=${work.threads}, '
+      'searchTime=${work.searchTime.inMilliseconds}ms, threatMode=${work.threatMode}',
+    );
+
+    _startWork(work);
 
     LocalEval? finalEval;
+
     try {
-      await for (final (_, eval) in stream.timeout(
-        work.searchTime + const Duration(milliseconds: 500),
-      )) {
+      await for (final (_, eval)
+          in evalStream
+              .where((result) => result.$1 == work)
+              .timeout(work.searchTime + const Duration(milliseconds: 500))) {
         finalEval = eval;
-        if (minDepth != null && eval.depth >= minDepth) {
+        // if depth threshold is reached quickly, let's still wait min search time (but skip for
+        // higher depths)
+        if ((eval.depth >= 25 || minSearchTime == null || eval.searchTime >= minSearchTime) &&
+            (depthThreshold != null && eval.depth >= depthThreshold)) {
           stop();
           break;
+        } else if (eval.searchTime >= work.searchTime) {
+          break;
         }
       }
     } on TimeoutException {

lib/src/model/engine/uci_protocol.dart

@@ -4,7 +4,6 @@ import 'dart:math' as math;
 import 'package:dartchess/dartchess.dart';
 import 'package:fast_immutable_collections/fast_immutable_collections.dart';
 import 'package:flutter/foundation.dart';
-import 'package:lichess_mobile/src/model/common/chess.dart';
 import 'package:lichess_mobile/src/model/common/eval.dart';
 import 'package:lichess_mobile/src/model/engine/engine.dart';
 import 'package:lichess_mobile/src/model/engine/work.dart';
@@ -241,16 +240,14 @@ class UCIProtocol {
           setOption('Skill Level', '20');
       }
 
-      final positionCommand = switch (_work) {
+      final positionCommand = switch (_work!) {
         final EvalWork evalWork when evalWork.threatMode =>
           'position fen ${evalWork.threatModePosition.fen}',
         _ => [
           'position fen',
           _work!.initialPosition.fen,
           'moves',
-          ..._work!.steps.map(
-            (s) => _work!.variant == Variant.chess960 ? s.sanMove.move.uci : s.castleSafeUCI,
-          ),
+          ..._work!.steps.map((s) => s.sanMove.normalizeUci(_work!.variant)),
         ].join(' '),
       };
 

lib/src/model/engine/work.dart

@@ -129,20 +129,4 @@ sealed class Step with _$Step {
   factory Step.fromNode(Branch node) {
     return Step(position: node.position, sanMove: node.sanMove, eval: node.eval);
   }
-
-  /// Stockfish in chess960 mode always needs a "king takes rook" UCI notation.
-  ///
-  /// Cannot be used in chess960 variant where this notation is already forced and
-  /// where it would conflict with the actual move.
-  UCIMove get castleSafeUCI {
-    if (sanMove.isCastles) {
-      return _castleMoves.containsKey(sanMove.move.uci)
-          ? _castleMoves[sanMove.move.uci]!
-          : sanMove.move.uci;
-    } else {
-      return sanMove.move.uci;
-    }
-  }
 }
-
-const _castleMoves = {'e1c1': 'e1a1', 'e1g1': 'e1h1', 'e8c8': 'e8a8', 'e8g8': 'e8h8'};

lib/src/model/explorer/tablebase.dart

@@ -1,9 +1,24 @@
+import 'package:dartchess/dartchess.dart';
 import 'package:deep_pick/deep_pick.dart';
 import 'package:fast_immutable_collections/fast_immutable_collections.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:lichess_mobile/src/model/common/chess.dart' show Variant;
 
 part 'tablebase.freezed.dart';
 
+int _tablebasePieces(Variant variant) {
+  return switch (variant) {
+    Variant.standard || Variant.fromPosition || Variant.chess960 => 8,
+    Variant.atomic || Variant.antichess => 6,
+    _ => 0,
+  };
+}
+
+bool isTablebaseRelevant(Position pos) {
+  final pieceCount = pos.board.pieces.length;
+  return pieceCount <= _tablebasePieces(Variant.fromRule(pos.rule));
+}
+
 enum TablebaseCategory {
   win,
   unknown,