Incredible hihg speed

Author: alexobviously

.vscode/launch.json

@@ -13,7 +13,9 @@
             "name": "example",
             "cwd": "example",
             "request": "launch",
-            "type": "dart"
+            "type": "dart",
+            "program": "example.dart",
+            "args": []
         }
     ]
 }

lib/src/game/game.dart

@@ -108,6 +108,7 @@ class Game {
           (target.colour == colour || target.colour == Bishop.neutralPassive)) {
         List<Move> pieceMoves = generatePieceMoves(i, options);
         moves.addAll(pieceMoves);
+        if (options.onlyOne && moves.isNotEmpty) return moves;
       }
     }
     if (variant.handsEnabled && options.quiet && !options.onlyPiece) {
@@ -209,11 +210,40 @@ class Game {
       }
     }
 
+    void addMove(StandardMove m) {
+      final mm = variant.generatePromotionMoves(
+        base: m,
+        state: state,
+        pieceType: pieceType,
+      );
+      if (mm != null) moves.addAll(mm);
+      if (mm == null) moves.add(m);
+      if (variant.gating) {
+        int gRank = size.rank(m.from);
+        if ((gRank == Bishop.rank1 && colour == Bishop.white) ||
+            (gRank == size.maxRank && colour == Bishop.black)) {
+          final gatingMoves = generateGatingMoves(m);
+          moves.addAll(gatingMoves);
+          if (gatingMoves.isNotEmpty &&
+              variant.gatingMode == GatingMode.fixed) {
+            moves.remove(m);
+          }
+        }
+      }
+      if (options.onlySquare != null && m.to == options.onlySquare) {
+        exit = true;
+      }
+    }
+
     // Generate normal moves
     for (MoveDefinition md in pieceType.moves) {
       if (exit) break;
       if (!md.capture && !options.quiet) continue;
       if (!md.quiet && !options.captures) continue;
+      if (options.onlySquare != null &&
+          md.excludeMove(square, options.onlySquare!, dirMult, size)) {
+        continue;
+      }
       if (md is TeleportMoveDefinition) {
         generateTeleportMoves(md);
         continue;
@@ -271,33 +301,6 @@ class Game {
           }
         }
 
-        void addMove(StandardMove m) {
-          final mm = variant.generatePromotionMoves(
-            base: m,
-            state: state,
-            pieceType: pieceType,
-          );
-          if (mm != null) moves.addAll(mm);
-          // bool removeBase = false;
-          if (mm == null) moves.add(m);
-          if (variant.gating) {
-            int gRank = size.rank(m.from);
-            if ((gRank == Bishop.rank1 && colour == Bishop.white) ||
-                (gRank == size.maxRank && colour == Bishop.black)) {
-              final gatingMoves = generateGatingMoves(m);
-              moves.addAll(gatingMoves);
-              if (gatingMoves.isNotEmpty &&
-                  variant.gatingMode == GatingMode.fixed) {
-                moves.remove(m);
-              }
-            }
-          }
-          // if (!addBase) moves.remove(m);
-          if (options.onlySquare != null && m.to == options.onlySquare) {
-            exit = true;
-          }
-        }
-
         if (target.isEmpty) {
           // TODO: prioritise ep? for moves that could be both ep and quiet
           if (md.quiet) {

lib/src/move/move_definition.dart

@@ -25,6 +25,9 @@ abstract class MoveDefinition {
 
   bool get quiet => modality == Modality.both || modality == Modality.quiet;
   bool get capture => modality == Modality.both || modality == Modality.capture;
+
+  /// Used to rapidly exclude moves in cases where we're looking for attacks.
+  bool excludeMove(int from, int to, int dirMult, BoardSize size) => false;
 }
 
 class TeleportMoveDefinition extends MoveDefinition {
@@ -65,6 +68,8 @@ class StandardMoveDefinition extends MoveDefinition {
   final int? lameNormalised;
 
   bool get slider => range != 1;
+  bool get unlimitedSlider => range == 0;
+  bool get limitedSlider => range > 1;
   bool get hopper => slider && hopDistance > -1;
   bool get limitedHopper => slider && hopDistance > 0;
 
@@ -139,6 +144,19 @@ class StandardMoveDefinition extends MoveDefinition {
     );
   }
 
+  @override
+  bool excludeMove(int from, int to, int dirMult, BoardSize size) {
+    if (!slider) {
+      return from + (normalised * dirMult) != to;
+    }
+    final n = normalised * dirMult;
+    if (n > 0 != to > from) return true;
+    if (n == 0) return from == to; // idk could happen
+    // There might be optimisations for limited sliders that
+    // could go here, but this is pretty fast.
+    return (to - from) % n != 0;
+  }
+
   @override
   String toString() {
     String string = '$direction [${modality.name}] [$normalised]';
@@ -168,6 +186,7 @@ class Direction {
   }
 
   static const none = Direction(0, 0);
+  static const unit = Direction(1, 1);
 
   String get simpleString => '$h,$v';
 
@@ -215,6 +234,33 @@ class Direction {
   bool operator ==(Object other) =>
       other is Direction && h == other.h && v == other.v;
 
+  Direction operator +(Direction other) => Direction(h + other.h, v + other.v);
+  Direction operator -(Direction other) => Direction(h - other.h, v - other.v);
+
+  Direction operator *(Object other) {
+    if (other is Direction) {
+      return Direction(h * other.h, v * other.v);
+    }
+    if (other is int) {
+      return other == 1 ? this : Direction(h * other, v * other);
+    }
+    throw Exception('Direction can only be multiplied by an int or another'
+        'Direction (tried to use ${other.runtimeType}).');
+  }
+
+  Direction operator ~/(Object other) {
+    if (other is Direction) {
+      return Direction(h ~/ other.h, v ~/ other.v);
+    }
+    if (other is int) {
+      return other == 1 ? this : Direction(h ~/ other, v ~/ other);
+    }
+    throw Exception('Direction can only be divided by an int or another'
+        'Direction (tried to use ${other.runtimeType}).');
+  }
+
+  Direction operator -() => Direction(-h, -v);
+
   @override
   int get hashCode => (h << 8) + v;
 }

lib/src/move_gen_params.dart

@@ -6,6 +6,7 @@ class MoveGenParams {
   final bool ignorePieces;
   final int? pieceType;
   final int? onlySquare;
+  final bool onlyOne;
 
   bool get onlyPiece => pieceType != null;
 
@@ -17,6 +18,7 @@ class MoveGenParams {
     this.ignorePieces = false,
     this.pieceType,
     this.onlySquare,
+    this.onlyOne = false,
   });
   static const normal = MoveGenParams(
     captures: true,
@@ -49,12 +51,14 @@ class MoveGenParams {
         legal: false,
         pieceType: pieceType,
       );
-  factory MoveGenParams.squareAttacks(int square) => MoveGenParams(
+  factory MoveGenParams.squareAttacks(int square, [bool onlyOne = true]) =>
+      MoveGenParams(
         captures: true,
         quiet: false,
         castling: false,
         legal: false,
         onlySquare: square,
+        onlyOne: onlyOne,
       );
   static const premoves = MoveGenParams(
     captures: true,

lib/src/variant/board_size.dart

@@ -64,6 +64,27 @@ class BoardSize {
   /// Returns true if [a] and [b] are on the same rank.
   bool squaresOnSameRank(int a, int b) => rank(a) == rank(b);
 
+  /// Whether [a] and [b] are connected by a rook move.
+  bool orthogonallyConnected(int a, int b) =>
+      squaresOnSameFile(a, b) || squaresOnSameRank(a, b);
+
+  /// Whether [a] and [b] are connected by a bishop move.
+  bool diagonallyConnected(int a, int b) =>
+      rank(b) - rank(a) == file(b) - file(a);
+
+  /// Whether [a] and [b] are connected by a move in [direction].
+  bool connected(int a, int b, Direction direction) {
+    int fileDiff = file(b) - file(a);
+    if (direction.h == 0 && fileDiff != 0) return false;
+    int rankDiff = rank(b) - rank(a);
+    if (direction.v == 0 && rankDiff != 0) return false;
+    if (direction.h != 0 && fileDiff % direction.h != 0) return false;
+    if (direction.v != 0 && rankDiff % direction.v != 0) return false;
+    return true;
+    return ((file(b) - file(a)).abs() % direction.h == 0) &&
+        (rank(b) - rank(a)).abs() % direction.v == 0;
+  }
+
   /// Get the first rank for player [colour].
   int firstRank(int colour) => colour == Bishop.white ? Bishop.rank1 : maxRank;