Optimized MoveOrdering with Comparator

Author: Shynee1

core/src/com/shynee/main/chess/AI/MoveOrdering.java

@@ -4,18 +4,21 @@
 import com.shynee.main.chess.Move;
 import com.shynee.main.chess.Piece;
 
+import java.util.Comparator;
 import java.util.List;
 
 /**
  * MoveOrdering -- Static class used to order moves by how likely they are to be a good move
  * This should theoretically help the speed of the search and prioritize certain moves in a "quiet" position
  */
-public class MoveOrdering {
+public class MoveOrdering implements Comparator<Move>{
 
     // Increase capture score so that a capture of any kind is always the best move
     private final static int pieceCaptureMultiplier = 10;
     private final static int maxMoveCount = 218;
 
+    private int[] moveScores;
+
     /**
      * Orders moves based on how likely they are to be a good move.
      * Should increase search efficiency and prioritize certain moves in a "quiet" position.
@@ -24,12 +27,14 @@ public class MoveOrdering {
      * @param moves List of moves to be ordered
      * @return New list of moves sorted by how likely each move is to be a good move.
      */
-    public static List<Move> orderMoves(ChessBoard board, List<Move> moves){
-        int[] moveScores = new int[maxMoveCount];
+    public List<Move> orderMoves(ChessBoard board, List<Move> moves){
+        moveScores = new int[maxMoveCount];
 
         for (int i = 0; i < moves.size(); i++){
             int score = 0;
+
             Move move = moves.get(i);
+            move.setSortIndex(i);
 
             Piece movePiece = board.getSquare(move.piecePos).getPiece();
             Piece targetPiece = board.getSquare(move.squarePos).getPiece();
@@ -47,40 +52,13 @@ public static List<Move> orderMoves(ChessBoard board, List<Move> moves){
             moveScores[i] = score;
         }
 
-        return sort(moves, moveScores);
-    }
-
-    /**
-     * Sorts a list of moves by performing a selection sort on an int[].
-     * Since the values of the List<Move> correspond to the values of the int[],
-     * we can swap them when we perform the swap for the selection sort.
-     *
-     * @param moves List of moves we want to be sorted.
-     * @param moveScores Int[] whose values correspond to the values of the List<Move>
-     * @return The list of moves sorted in descending order
-     */
-    private static List<Move> sort(List<Move> moves, int[] moveScores){
-        for (int i = 0; i < moves.size() - 1; i++) {
-            int maxIndex = i;
-            for (int j = i+1; j < moves.size(); j++){
-                if (moveScores[j] > moveScores[maxIndex]){
-                    maxIndex = j;
-                }
-            }
-
-            swap(moves, moveScores, i, maxIndex);
-        }
+        moves.sort(this);
 
         return moves;
     }
 
-    private static void swap(List<Move> moves, int[] moveScores, int posOne, int posTwo){
-        Move tempM = moves.get(posOne);
-        moves.set(posOne, moves.get(posTwo));
-        moves.set(posTwo, tempM);
-
-        int tempI = moveScores[posOne];
-        moveScores[posOne] = moveScores[posTwo];
-        moveScores[posTwo] = tempI;
+    @Override
+    public int compare(Move o1, Move o2) {
+        return Integer.compare(moveScores[o2.getSortIndex()], moveScores[o1.getSortIndex()]);
     }
 }

core/src/com/shynee/main/chess/AI/Search.java

@@ -10,7 +10,10 @@
  */
 public class Search {
 
-    private ChessBoard board;
+    private final ChessBoard board;
+    private final MoveOrdering moveOrdering;
+    private final TranspositionTable tt;
+
     private Move bestMoveInIteration;
     private Move bestMove = null;
 
@@ -26,11 +29,10 @@ public class Search {
     // Uniquely identifiable number that will not conflict with search
     private final int mateScore = 100000;
 
-    private final TranspositionTable tt;
-
     public Search(ChessBoard board){
         this.board = board;
         this.tt = new TranspositionTable(board, 64000);
+        this.moveOrdering = new MoveOrdering();
     }
 
     /**
@@ -127,7 +129,7 @@ private int search(int depth, int alpha, int beta, int plyFromRoot){
             return 0; //Stalemate
         }
 
-        legalMoves = MoveOrdering.orderMoves(board, legalMoves);
+        legalMoves = moveOrdering.orderMoves(board, legalMoves);
         for (Move legalMove : legalMoves) {
             board.makeMove(legalMove, true);
             int eval = -search(depth-1, -beta, -alpha, plyFromRoot+1);
@@ -172,7 +174,7 @@ private int quiescenceSearch(int alpha, int beta){
 
         boolean color = board.colorToMove();
         List<Move> legalCaptures = board.getMoveCalculator().getLegalCaptures(board, color);
-        MoveOrdering.orderMoves(board, legalCaptures);
+        moveOrdering.orderMoves(board, legalCaptures);
 
         for (Move move : legalCaptures) {
 

core/src/com/shynee/main/chess/Move.java

@@ -1,13 +1,15 @@
 package com.shynee.main.chess;
 
-public class Move {
+public class Move{
 
     public int piecePos;
     public int squarePos;
     public int directionOffset;
     public boolean isCastle;
     public boolean isPromotion;
 
+    private int sortIndex;
+
     public Move(int oldSquarePos, int newSquarePos, int directionOffset){
         this.piecePos = oldSquarePos;
         this.squarePos = newSquarePos;
@@ -19,8 +21,17 @@ public Move setCastle(){
         return this;
     }
 
-    public Move setPromotion(){
+    public Move setPromotion() {
         this.isPromotion = true;
         return this;
     }
+
+    public void setSortIndex(int index){
+        this.sortIndex = index;
+    }
+
+    public int getSortIndex(){
+        return sortIndex;
+    }
+
 }

core/src/com/shynee/main/scenes/ChessScene.java

@@ -48,7 +48,7 @@ public void start(){
 
         GameObject aiPlayer = new GameObject("AiPLayer");
         aiPlayer.addComponent(new AIController(!playerColor, board, book));
-        addGameObject(aiPlayer);
+        //addGameObject(aiPlayer);
     }
 
     @Override