mirror of
https://github.com/peterosterlund2/droidfish.git
synced 2025-12-09 23:52:41 +01:00
Fix some Android Studio warnings.
This commit is contained in:
Peter Osterlund
@@ -170,7 +170,7 @@ public class BitBoard {
|
||||
0x000000007efa8146L, 0x0000007ed3e2ef60L, 0x00007f47243adcd6L, 0x007fb65afabfb3b5L
|
||||
};
|
||||
|
||||
private static final long createPattern(int i, long mask) {
|
||||
private static long createPattern(int i, long mask) {
|
||||
long ret = 0L;
|
||||
for (int j = 0; ; j++) {
|
||||
long nextMask = mask & (mask - 1);
|
||||
@@ -184,7 +184,7 @@ public class BitBoard {
|
||||
return ret;
|
||||
}
|
||||
|
||||
private static final long addRookRays(int x, int y, long occupied, boolean inner) {
|
||||
private static long addRookRays(int x, int y, long occupied, boolean inner) {
|
||||
long mask = 0;
|
||||
mask = addRay(mask, x, y, 1, 0, occupied, inner);
|
||||
mask = addRay(mask, x, y, -1, 0, occupied, inner);
|
||||
@@ -192,7 +192,7 @@ public class BitBoard {
|
||||
mask = addRay(mask, x, y, 0, -1, occupied, inner);
|
||||
return mask;
|
||||
}
|
||||
private static final long addBishopRays(int x, int y, long occupied, boolean inner) {
|
||||
private static long addBishopRays(int x, int y, long occupied, boolean inner) {
|
||||
long mask = 0;
|
||||
mask = addRay(mask, x, y, 1, 1, occupied, inner);
|
||||
mask = addRay(mask, x, y, -1, -1, occupied, inner);
|
||||
@@ -201,8 +201,8 @@ public class BitBoard {
|
||||
return mask;
|
||||
}
|
||||
|
||||
private static final long addRay(long mask, int x, int y, int dx, int dy,
|
||||
long occupied, boolean inner) {
|
||||
private static long addRay(long mask, int x, int y, int dx, int dy,
|
||||
long occupied, boolean inner) {
|
||||
int lo = inner ? 1 : 0;
|
||||
int hi = inner ? 6 : 7;
|
||||
while (true) {
|
||||
@@ -270,11 +270,11 @@ public class BitBoard {
|
||||
}
|
||||
}
|
||||
|
||||
public static final long bishopAttacks(int sq, long occupied) {
|
||||
public static long bishopAttacks(int sq, long occupied) {
|
||||
return bTables[sq][(int)(((occupied & bMasks[sq]) * bMagics[sq]) >>> (64 - bBits[sq]))];
|
||||
}
|
||||
|
||||
public static final long rookAttacks(int sq, long occupied) {
|
||||
public static long rookAttacks(int sq, long occupied) {
|
||||
return rTables[sq][(int)(((occupied & rMasks[sq]) * rMagics[sq]) >>> (64 - rBits[sq]))];
|
||||
}
|
||||
|
||||
@@ -346,19 +346,19 @@ public class BitBoard {
|
||||
0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
|
||||
};
|
||||
|
||||
public static final int getDistance(int from, int to) {
|
||||
public static int getDistance(int from, int to) {
|
||||
int offs = to + (to|7) - from - (from|7) + 0x77;
|
||||
return distTable[offs];
|
||||
}
|
||||
|
||||
public static final long southFill(long mask) {
|
||||
public static long southFill(long mask) {
|
||||
mask |= (mask >>> 8);
|
||||
mask |= (mask >>> 16);
|
||||
mask |= (mask >>> 32);
|
||||
return mask;
|
||||
}
|
||||
|
||||
public static final long northFill(long mask) {
|
||||
public static long northFill(long mask) {
|
||||
mask |= (mask << 8);
|
||||
mask |= (mask << 16);
|
||||
mask |= (mask << 32);
|
||||
|
||||
@@ -161,7 +161,7 @@ public class Book {
|
||||
throw new RuntimeException();
|
||||
}
|
||||
|
||||
final private int getWeight(int count) {
|
||||
private int getWeight(int count) {
|
||||
double tmp = Math.sqrt(count);
|
||||
return (int)(tmp * Math.sqrt(tmp) * 100 + 1);
|
||||
}
|
||||
|
||||
@@ -50,97 +50,97 @@ public class Evaluate {
|
||||
}
|
||||
|
||||
/** Piece/square table for king during middle game. */
|
||||
static final int[] kt1b = { -22,-35,-40,-40,-40,-40,-35,-22,
|
||||
-22,-35,-40,-40,-40,-40,-35,-22,
|
||||
-25,-35,-40,-45,-45,-40,-35,-25,
|
||||
-15,-30,-35,-40,-40,-35,-30,-15,
|
||||
-10,-15,-20,-25,-25,-20,-15,-10,
|
||||
4, -2, -5,-15,-15, -5, -2, 4,
|
||||
16, 14, 7, -3, -3, 7, 14, 16,
|
||||
24, 24, 9, 0, 0, 9, 24, 24 };
|
||||
private static final int[] kt1b = { -22,-35,-40,-40,-40,-40,-35,-22,
|
||||
-22,-35,-40,-40,-40,-40,-35,-22,
|
||||
-25,-35,-40,-45,-45,-40,-35,-25,
|
||||
-15,-30,-35,-40,-40,-35,-30,-15,
|
||||
-10,-15,-20,-25,-25,-20,-15,-10,
|
||||
4, -2, -5,-15,-15, -5, -2, 4,
|
||||
16, 14, 7, -3, -3, 7, 14, 16,
|
||||
24, 24, 9, 0, 0, 9, 24, 24 };
|
||||
|
||||
/** Piece/square table for king during end game. */
|
||||
static final int[] kt2b = { 0, 8, 16, 24, 24, 16, 8, 0,
|
||||
8, 16, 24, 32, 32, 24, 16, 8,
|
||||
16, 24, 32, 40, 40, 32, 24, 16,
|
||||
24, 32, 40, 48, 48, 40, 32, 24,
|
||||
24, 32, 40, 48, 48, 40, 32, 24,
|
||||
16, 24, 32, 40, 40, 32, 24, 16,
|
||||
8, 16, 24, 32, 32, 24, 16, 8,
|
||||
0, 8, 16, 24, 24, 16, 8, 0 };
|
||||
private static final int[] kt2b = { 0, 8, 16, 24, 24, 16, 8, 0,
|
||||
8, 16, 24, 32, 32, 24, 16, 8,
|
||||
16, 24, 32, 40, 40, 32, 24, 16,
|
||||
24, 32, 40, 48, 48, 40, 32, 24,
|
||||
24, 32, 40, 48, 48, 40, 32, 24,
|
||||
16, 24, 32, 40, 40, 32, 24, 16,
|
||||
8, 16, 24, 32, 32, 24, 16, 8,
|
||||
0, 8, 16, 24, 24, 16, 8, 0 };
|
||||
|
||||
/** Piece/square table for pawns during middle game. */
|
||||
static final int[] pt1b = { 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
8, 16, 24, 32, 32, 24, 16, 8,
|
||||
3, 12, 20, 28, 28, 20, 12, 3,
|
||||
-5, 4, 10, 20, 20, 10, 4, -5,
|
||||
-6, 4, 5, 16, 16, 5, 4, -6,
|
||||
-6, 4, 2, 5, 5, 2, 4, -6,
|
||||
-6, 4, 4,-15,-15, 4, 4, -6,
|
||||
0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
private static final int[] pt1b = { 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
8, 16, 24, 32, 32, 24, 16, 8,
|
||||
3, 12, 20, 28, 28, 20, 12, 3,
|
||||
-5, 4, 10, 20, 20, 10, 4, -5,
|
||||
-6, 4, 5, 16, 16, 5, 4, -6,
|
||||
-6, 4, 2, 5, 5, 2, 4, -6,
|
||||
-6, 4, 4,-15,-15, 4, 4, -6,
|
||||
0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
/** Piece/square table for pawns during end game. */
|
||||
static final int[] pt2b = { 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
25, 40, 45, 45, 45, 45, 40, 25,
|
||||
17, 32, 35, 35, 35, 35, 32, 17,
|
||||
5, 24, 24, 24, 24, 24, 24, 5,
|
||||
-9, 11, 11, 11, 11, 11, 11, -9,
|
||||
-17, 3, 3, 3, 3, 3, 3,-17,
|
||||
-20, 0, 0, 0, 0, 0, 0,-20,
|
||||
0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
private static final int[] pt2b = { 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
25, 40, 45, 45, 45, 45, 40, 25,
|
||||
17, 32, 35, 35, 35, 35, 32, 17,
|
||||
5, 24, 24, 24, 24, 24, 24, 5,
|
||||
-9, 11, 11, 11, 11, 11, 11, -9,
|
||||
-17, 3, 3, 3, 3, 3, 3,-17,
|
||||
-20, 0, 0, 0, 0, 0, 0,-20,
|
||||
0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
/** Piece/square table for knights during middle game. */
|
||||
static final int[] nt1b = { -53,-42,-32,-21,-21,-32,-42,-53,
|
||||
-42,-32,-10, 0, 0,-10,-32,-42,
|
||||
-21, 5, 10, 16, 16, 10, 5,-21,
|
||||
-18, 0, 10, 21, 21, 10, 0,-18,
|
||||
-18, 0, 3, 21, 21, 3, 0,-18,
|
||||
-21,-10, 0, 0, 0, 0,-10,-21,
|
||||
-42,-32,-10, 0, 0,-10,-32,-42,
|
||||
-53,-42,-32,-21,-21,-32,-42,-53 };
|
||||
private static final int[] nt1b = { -53,-42,-32,-21,-21,-32,-42,-53,
|
||||
-42,-32,-10, 0, 0,-10,-32,-42,
|
||||
-21, 5, 10, 16, 16, 10, 5,-21,
|
||||
-18, 0, 10, 21, 21, 10, 0,-18,
|
||||
-18, 0, 3, 21, 21, 3, 0,-18,
|
||||
-21,-10, 0, 0, 0, 0,-10,-21,
|
||||
-42,-32,-10, 0, 0,-10,-32,-42,
|
||||
-53,-42,-32,-21,-21,-32,-42,-53 };
|
||||
|
||||
/** Piece/square table for knights during end game. */
|
||||
static final int[] nt2b = { -56,-44,-34,-22,-22,-34,-44,-56,
|
||||
-44,-34,-10, 0, 0,-10,-34,-44,
|
||||
-22, 5, 10, 17, 17, 10, 5,-22,
|
||||
-19, 0, 10, 22, 22, 10, 0,-19,
|
||||
-19, 0, 3, 22, 22, 3, 0,-19,
|
||||
-22,-10, 0, 0, 0, 0,-10,-22,
|
||||
-44,-34,-10, 0, 0,-10,-34,-44,
|
||||
-56,-44,-34,-22,-22,-34,-44,-56 };
|
||||
private static final int[] nt2b = { -56,-44,-34,-22,-22,-34,-44,-56,
|
||||
-44,-34,-10, 0, 0,-10,-34,-44,
|
||||
-22, 5, 10, 17, 17, 10, 5,-22,
|
||||
-19, 0, 10, 22, 22, 10, 0,-19,
|
||||
-19, 0, 3, 22, 22, 3, 0,-19,
|
||||
-22,-10, 0, 0, 0, 0,-10,-22,
|
||||
-44,-34,-10, 0, 0,-10,-34,-44,
|
||||
-56,-44,-34,-22,-22,-34,-44,-56 };
|
||||
|
||||
/** Piece/square table for bishops during middle game. */
|
||||
static final int[] bt1b = { 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 4, 2, 2, 2, 2, 4, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 3, 4, 4, 4, 4, 3, 0,
|
||||
0, 4, 2, 2, 2, 2, 4, 0,
|
||||
-5, -5, -7, -5, -5, -7, -5, -5 };
|
||||
private static final int[] bt1b = { 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 4, 2, 2, 2, 2, 4, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 3, 4, 4, 4, 4, 3, 0,
|
||||
0, 4, 2, 2, 2, 2, 4, 0,
|
||||
-5, -5, -7, -5, -5, -7, -5, -5 };
|
||||
|
||||
/** Piece/square table for bishops during middle game. */
|
||||
static final int[] bt2b = { 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 2, 2, 2, 2, 2, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 2, 2, 2, 2, 2, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
private static final int[] bt2b = { 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 2, 2, 2, 2, 2, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 4, 4, 4, 4, 2, 0,
|
||||
0, 2, 2, 2, 2, 2, 2, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
/** Piece/square table for queens during middle game. */
|
||||
static final int[] qt1b = { -10, -5, 0, 0, 0, 0, -5,-10,
|
||||
-5, 0, 5, 5, 5, 5, 0, -5,
|
||||
0, 5, 5, 6, 6, 5, 5, 0,
|
||||
0, 5, 6, 6, 6, 6, 5, 0,
|
||||
0, 5, 6, 6, 6, 6, 5, 0,
|
||||
0, 5, 5, 6, 6, 5, 5, 0,
|
||||
-5, 0, 5, 5, 5, 5, 0, -5,
|
||||
-10, -5, 0, 0, 0, 0, -5,-10 };
|
||||
private static final int[] qt1b = { -10, -5, 0, 0, 0, 0, -5,-10,
|
||||
-5, 0, 5, 5, 5, 5, 0, -5,
|
||||
0, 5, 5, 6, 6, 5, 5, 0,
|
||||
0, 5, 6, 6, 6, 6, 5, 0,
|
||||
0, 5, 6, 6, 6, 6, 5, 0,
|
||||
0, 5, 5, 6, 6, 5, 5, 0,
|
||||
-5, 0, 5, 5, 5, 5, 0, -5,
|
||||
-10, -5, 0, 0, 0, 0, -5,-10 };
|
||||
|
||||
/** Piece/square table for rooks during middle game. */
|
||||
static final int[] rt1b = { 8, 11, 13, 13, 13, 13, 11, 8,
|
||||
private static final int[] rt1b = { 8, 11, 13, 13, 13, 13, 11, 8,
|
||||
22, 27, 27, 27, 27, 27, 27, 22,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
@@ -149,7 +149,7 @@ public class Evaluate {
|
||||
-3, 2, 5, 5, 5, 5, 2, -3,
|
||||
0, 3, 5, 5, 5, 5, 3, 0 };
|
||||
|
||||
static final int[] kt1w, qt1w, rt1w, bt1w, nt1w, pt1w, kt2w, bt2w, nt2w, pt2w;
|
||||
private static final int[] kt1w, qt1w, rt1w, bt1w, nt1w, pt1w, kt2w, bt2w, nt2w, pt2w;
|
||||
static {
|
||||
kt1w = new int[64];
|
||||
qt1w = new int[64];
|
||||
@@ -193,9 +193,9 @@ public class Evaluate {
|
||||
{ 6, 7, 6, 5, 4, 3, 2, 1 },
|
||||
{ 7, 6, 5, 4, 3, 2, 1, 0 } };
|
||||
|
||||
static final int[] rookMobScore = {-10,-7,-4,-1,2,5,7,9,11,12,13,14,14,14,14};
|
||||
static final int[] bishMobScore = {-15,-10,-6,-2,2,6,10,13,16,18,20,22,23,24};
|
||||
static final int[] queenMobScore = {-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,9,10,10,10,10,10,10,10,10,10,10,10,10};
|
||||
private static final int[] rookMobScore = {-10,-7,-4,-1,2,5,7,9,11,12,13,14,14,14,14};
|
||||
private static final int[] bishMobScore = {-15,-10,-6,-2,2,6,10,13,16,18,20,22,23,24};
|
||||
private static final int[] queenMobScore = {-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,9,10,10,10,10,10,10,10,10,10,10,10,10};
|
||||
|
||||
private static final class PawnHashData {
|
||||
long key;
|
||||
@@ -205,7 +205,7 @@ public class Evaluate {
|
||||
long passedPawnsW; // The most advanced passed pawns for each file
|
||||
long passedPawnsB;
|
||||
}
|
||||
static final PawnHashData[] pawnHash;
|
||||
private static final PawnHashData[] pawnHash;
|
||||
static {
|
||||
final int numEntries = 1<<16;
|
||||
pawnHash = new PawnHashData[numEntries];
|
||||
@@ -217,8 +217,8 @@ public class Evaluate {
|
||||
}
|
||||
}
|
||||
|
||||
static byte[] kpkTable = null;
|
||||
static byte[] krkpTable = null;
|
||||
private static byte[] kpkTable = null;
|
||||
private static byte[] krkpTable = null;
|
||||
|
||||
// King safety variables
|
||||
private long wKingZone, bKingZone; // Squares close to king that are worth attacking
|
||||
@@ -1135,7 +1135,7 @@ public class Evaluate {
|
||||
return score;
|
||||
}
|
||||
|
||||
private static final int evalKQKP(int wKing, int wQueen, int bKing, int bPawn, boolean whiteMove) {
|
||||
private static int evalKQKP(int wKing, int wQueen, int bKing, int bPawn, boolean whiteMove) {
|
||||
boolean canWin = false;
|
||||
if (((1L << bKing) & 0xFFFF) == 0) {
|
||||
canWin = true; // King doesn't support pawn
|
||||
@@ -1172,7 +1172,7 @@ public class Evaluate {
|
||||
return score;
|
||||
}
|
||||
|
||||
private static final int kpkEval(int wKing, int bKing, int wPawn, boolean whiteMove) {
|
||||
private static int kpkEval(int wKing, int bKing, int wPawn, boolean whiteMove) {
|
||||
if (Position.getX(wKing) >= 4) { // Mirror X
|
||||
wKing ^= 7;
|
||||
bKing ^= 7;
|
||||
@@ -1191,7 +1191,7 @@ public class Evaluate {
|
||||
return qV - pV / 4 * (7-Position.getY(wPawn));
|
||||
}
|
||||
|
||||
private static final int krkpEval(int wKing, int bKing, int bPawn, boolean whiteMove) {
|
||||
private static int krkpEval(int wKing, int bKing, int bPawn, boolean whiteMove) {
|
||||
if (Position.getX(bKing) >= 4) { // Mirror X
|
||||
wKing ^= 7;
|
||||
bKing ^= 7;
|
||||
@@ -1216,7 +1216,7 @@ public class Evaluate {
|
||||
* Interpolate between (x1,y1) and (x2,y2).
|
||||
* If x < x1, return y1, if x > x2 return y2. Otherwise, use linear interpolation.
|
||||
*/
|
||||
static final int interpolate(int x, int x1, int y1, int x2, int y2) {
|
||||
static int interpolate(int x, int x1, int y1, int x2, int y2) {
|
||||
if (x > x2) {
|
||||
return y2;
|
||||
} else if (x < x1) {
|
||||
|
||||
@@ -545,7 +545,7 @@ public class Game {
|
||||
return false;
|
||||
}
|
||||
|
||||
final static long perfT(MoveGen moveGen, Position pos, int depth) {
|
||||
static long perfT(MoveGen moveGen, Position pos, int depth) {
|
||||
if (depth == 0)
|
||||
return 1;
|
||||
long nodes = 0;
|
||||
|
||||
@@ -28,7 +28,7 @@ public class KillerTable {
|
||||
int move0;
|
||||
int move1;
|
||||
}
|
||||
KTEntry[] ktList;
|
||||
private KTEntry[] ktList;
|
||||
|
||||
/** Create an empty killer table. */
|
||||
public KillerTable() {
|
||||
|
||||
@@ -717,7 +717,7 @@ public final class MoveGen {
|
||||
/**
|
||||
* Return true if the side to move is in check.
|
||||
*/
|
||||
public static final boolean inCheck(Position pos) {
|
||||
public static boolean inCheck(Position pos) {
|
||||
int kingSq = pos.getKingSq(pos.whiteMove);
|
||||
return sqAttacked(pos, kingSq);
|
||||
}
|
||||
@@ -725,7 +725,7 @@ public final class MoveGen {
|
||||
/**
|
||||
* Return the next piece in a given direction, starting from sq.
|
||||
*/
|
||||
private static final int nextPiece(Position pos, int sq, int delta) {
|
||||
private static int nextPiece(Position pos, int sq, int delta) {
|
||||
while (true) {
|
||||
sq += delta;
|
||||
int p = pos.getPiece(sq);
|
||||
@@ -735,7 +735,7 @@ public final class MoveGen {
|
||||
}
|
||||
|
||||
/** Like nextPiece(), but handles board edges. */
|
||||
private static final int nextPieceSafe(Position pos, int sq, int delta) {
|
||||
private static int nextPieceSafe(Position pos, int sq, int delta) {
|
||||
int dx = 0, dy = 0;
|
||||
switch (delta) {
|
||||
case 1: dx=1; dy=0; break;
|
||||
@@ -764,7 +764,7 @@ public final class MoveGen {
|
||||
/**
|
||||
* Return true if making a move delivers check to the opponent
|
||||
*/
|
||||
public static final boolean givesCheck(Position pos, Move m) {
|
||||
public static boolean givesCheck(Position pos, Move m) {
|
||||
boolean wtm = pos.whiteMove;
|
||||
int oKingSq = pos.getKingSq(!wtm);
|
||||
int oKing = wtm ? Piece.BKING : Piece.WKING;
|
||||
@@ -875,7 +875,7 @@ public final class MoveGen {
|
||||
/**
|
||||
* Return true if the side to move can take the opponents king.
|
||||
*/
|
||||
public static final boolean canTakeKing(Position pos) {
|
||||
public static boolean canTakeKing(Position pos) {
|
||||
pos.setWhiteMove(!pos.whiteMove);
|
||||
boolean ret = inCheck(pos);
|
||||
pos.setWhiteMove(!pos.whiteMove);
|
||||
@@ -885,7 +885,7 @@ public final class MoveGen {
|
||||
/**
|
||||
* Return true if a square is attacked by the opposite side.
|
||||
*/
|
||||
public static final boolean sqAttacked(Position pos, int sq) {
|
||||
public static boolean sqAttacked(Position pos, int sq) {
|
||||
if (pos.whiteMove) {
|
||||
if ((BitBoard.knightAttacks[sq] & pos.pieceTypeBB[Piece.BKNIGHT]) != 0)
|
||||
return true;
|
||||
@@ -921,7 +921,7 @@ public final class MoveGen {
|
||||
* "moveList" is assumed to be a list of pseudo-legal moves.
|
||||
* This function removes the moves that don't defend from check threats.
|
||||
*/
|
||||
public static final void removeIllegal(Position pos, MoveList moveList) {
|
||||
public static void removeIllegal(Position pos, MoveList moveList) {
|
||||
int length = 0;
|
||||
UndoInfo ui = new UndoInfo();
|
||||
|
||||
|
||||
@@ -89,7 +89,7 @@ public class Parameters {
|
||||
for (Map.Entry<String, ParamBase> e : params.entrySet())
|
||||
if (e.getValue().visible)
|
||||
parNames.add(e.getKey());
|
||||
return parNames.toArray(new String[parNames.size()]);
|
||||
return parNames.toArray(new String[0]);
|
||||
}
|
||||
|
||||
public final ParamBase getParam(String name) {
|
||||
|
||||
@@ -42,13 +42,13 @@ public class Piece {
|
||||
* Return true if p is a white piece, false otherwise.
|
||||
* Note that if p is EMPTY, an unspecified value is returned.
|
||||
*/
|
||||
public static final boolean isWhite(int pType) {
|
||||
public static boolean isWhite(int pType) {
|
||||
return pType < BKING;
|
||||
}
|
||||
public static final int makeWhite(int pType) {
|
||||
public static int makeWhite(int pType) {
|
||||
return pType < BKING ? pType : pType - (BKING - WKING);
|
||||
}
|
||||
public static final int makeBlack(int pType) {
|
||||
public static int makeBlack(int pType) {
|
||||
return ((pType > EMPTY) && (pType < BKING)) ? pType + (BKING - WKING) : pType;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -188,19 +188,19 @@ public class Position {
|
||||
}
|
||||
}
|
||||
/** Return index in squares[] vector corresponding to (x,y). */
|
||||
public final static int getSquare(int x, int y) {
|
||||
public static int getSquare(int x, int y) {
|
||||
return y * 8 + x;
|
||||
}
|
||||
/** Return x position (file) corresponding to a square. */
|
||||
public final static int getX(int square) {
|
||||
public static int getX(int square) {
|
||||
return square & 7;
|
||||
}
|
||||
/** Return y position (rank) corresponding to a square. */
|
||||
public final static int getY(int square) {
|
||||
public static int getY(int square) {
|
||||
return square >> 3;
|
||||
}
|
||||
/** Return true if (x,y) is a dark square. */
|
||||
public final static boolean darkSquare(int x, int y) {
|
||||
public static boolean darkSquare(int x, int y) {
|
||||
return (x & 1) == (y & 1);
|
||||
}
|
||||
|
||||
|
||||
@@ -28,15 +28,15 @@ public class Search {
|
||||
final static int plyScale = 8; // Fractional ply resolution
|
||||
|
||||
Position pos;
|
||||
MoveGen moveGen;
|
||||
Evaluate eval;
|
||||
KillerTable kt;
|
||||
History ht;
|
||||
long[] posHashList; // List of hashes for previous positions up to the last "zeroing" move.
|
||||
int posHashListSize; // Number of used entries in posHashList
|
||||
int posHashFirstNew; // First entry in posHashList that has not been played OTB.
|
||||
TranspositionTable tt;
|
||||
TreeLogger log = null;
|
||||
private MoveGen moveGen;
|
||||
private Evaluate eval;
|
||||
private KillerTable kt;
|
||||
private History ht;
|
||||
private long[] posHashList; // List of hashes for previous positions up to the last "zeroing" move.
|
||||
private int posHashListSize; // Number of used entries in posHashList
|
||||
private int posHashFirstNew; // First entry in posHashList that has not been played OTB.
|
||||
private TranspositionTable tt;
|
||||
private TreeLogger log = null;
|
||||
|
||||
private static final class SearchTreeInfo {
|
||||
UndoInfo undoInfo;
|
||||
@@ -53,35 +53,35 @@ public class Search {
|
||||
bestMove = new Move(0, 0, 0);
|
||||
}
|
||||
}
|
||||
SearchTreeInfo[] searchTreeInfo;
|
||||
private SearchTreeInfo[] searchTreeInfo;
|
||||
|
||||
// Time management
|
||||
long tStart; // Time when search started
|
||||
long minTimeMillis; // Minimum recommended thinking time
|
||||
long maxTimeMillis; // Maximum allowed thinking time
|
||||
boolean searchNeedMoreTime; // True if negaScout should use up to maxTimeMillis time.
|
||||
private long maxNodes; // Maximum number of nodes to search (approximately)
|
||||
int nodesToGo; // Number of nodes until next time check
|
||||
private long tStart; // Time when search started
|
||||
private long minTimeMillis; // Minimum recommended thinking time
|
||||
long maxTimeMillis; // Maximum allowed thinking time
|
||||
private boolean searchNeedMoreTime; // True if negaScout should use up to maxTimeMillis time.
|
||||
private long maxNodes; // Maximum number of nodes to search (approximately)
|
||||
private int nodesToGo; // Number of nodes until next time check
|
||||
public int nodesBetweenTimeCheck = 5000; // How often to check remaining time
|
||||
|
||||
// Reduced strength variables
|
||||
private int strength = 1000; // Strength (0-1000)
|
||||
boolean weak = false; // Set to strength < 1000
|
||||
long randomSeed = 0;
|
||||
private boolean weak = false; // Set to strength < 1000
|
||||
private long randomSeed = 0;
|
||||
|
||||
// Search statistics stuff
|
||||
long nodes;
|
||||
long qNodes;
|
||||
int[] nodesPlyVec;
|
||||
int[] nodesDepthVec;
|
||||
long totalNodes;
|
||||
long tLastStats; // Time when notifyStats was last called
|
||||
boolean verbose;
|
||||
private long nodes;
|
||||
private long qNodes;
|
||||
private int[] nodesPlyVec;
|
||||
private int[] nodesDepthVec;
|
||||
private long totalNodes;
|
||||
private long tLastStats; // Time when notifyStats was last called
|
||||
private boolean verbose;
|
||||
|
||||
public final static int MATE0 = 32000;
|
||||
|
||||
public final static int UNKNOWN_SCORE = -32767; // Represents unknown static eval score
|
||||
int q0Eval; // Static eval score at first level of quiescence search
|
||||
private int q0Eval; // Static eval score at first level of quiescence search
|
||||
|
||||
public Search(Position pos, long[] posHashList, int posHashListSize, TranspositionTable tt,
|
||||
History ht) {
|
||||
@@ -126,7 +126,7 @@ public class Search {
|
||||
void notifyStats(long nodes, int nps, int time);
|
||||
}
|
||||
|
||||
Listener listener;
|
||||
private Listener listener;
|
||||
public void setListener(Listener listener) {
|
||||
this.listener = listener;
|
||||
}
|
||||
@@ -905,7 +905,7 @@ public class Search {
|
||||
return false;
|
||||
}
|
||||
|
||||
private static final boolean passedPawnPush(Position pos, Move m) {
|
||||
private static boolean passedPawnPush(Position pos, Move m) {
|
||||
int p = pos.getPiece(m.from);
|
||||
if (pos.whiteMove) {
|
||||
if (p != Piece.WPAWN)
|
||||
@@ -925,7 +925,7 @@ public class Search {
|
||||
/**
|
||||
* Quiescence search. Only non-losing captures are searched.
|
||||
*/
|
||||
final private int quiesce(int alpha, int beta, int ply, int depth, final boolean inCheck) {
|
||||
private int quiesce(int alpha, int beta, int ply, int depth, final boolean inCheck) {
|
||||
int score;
|
||||
if (inCheck) {
|
||||
score = -(MATE0 - (ply+1));
|
||||
@@ -1219,7 +1219,7 @@ public class Search {
|
||||
/**
|
||||
* Find move with highest score and move it to the front of the list.
|
||||
*/
|
||||
final static void selectBest(MoveGen.MoveList moves, int startIdx) {
|
||||
static void selectBest(MoveGen.MoveList moves, int startIdx) {
|
||||
int bestIdx = startIdx;
|
||||
int bestScore = moves.m[bestIdx].score;
|
||||
for (int i = startIdx + 1; i < moves.size; i++) {
|
||||
@@ -1237,7 +1237,7 @@ public class Search {
|
||||
}
|
||||
|
||||
/** If hashMove exists in the move list, move the hash move to the front of the list. */
|
||||
final static boolean selectHashMove(MoveGen.MoveList moves, Move hashMove) {
|
||||
static boolean selectHashMove(MoveGen.MoveList moves, Move hashMove) {
|
||||
if (hashMove == null) {
|
||||
return false;
|
||||
}
|
||||
@@ -1253,11 +1253,11 @@ public class Search {
|
||||
return false;
|
||||
}
|
||||
|
||||
public final static boolean canClaimDraw50(Position pos) {
|
||||
public static boolean canClaimDraw50(Position pos) {
|
||||
return (pos.halfMoveClock >= 100);
|
||||
}
|
||||
|
||||
public final static boolean canClaimDrawRep(Position pos, long[] posHashList, int posHashListSize, int posHashFirstNew) {
|
||||
public static boolean canClaimDrawRep(Position pos, long[] posHashList, int posHashListSize, int posHashFirstNew) {
|
||||
int reps = 0;
|
||||
for (int i = posHashListSize - 4; i >= 0; i -= 2) {
|
||||
if (pos.zobristHash() == posHashList[i]) {
|
||||
|
||||
@@ -24,7 +24,7 @@ public class TextIO {
|
||||
static public final String startPosFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
|
||||
|
||||
/** Parse a FEN string and return a chess Position object. */
|
||||
public static final Position readFEN(String fen) throws ChessParseError {
|
||||
public static Position readFEN(String fen) throws ChessParseError {
|
||||
Position pos = new Position();
|
||||
String[] words = fen.split(" ");
|
||||
if (words.length < 2) {
|
||||
@@ -148,7 +148,7 @@ public class TextIO {
|
||||
}
|
||||
|
||||
/** Remove pseudo-legal EP square if it is not legal, ie would leave king in check. */
|
||||
public static final void fixupEPSquare(Position pos) {
|
||||
public static void fixupEPSquare(Position pos) {
|
||||
int epSquare = pos.getEpSquare();
|
||||
if (epSquare >= 0) {
|
||||
MoveGen.MoveList moves = MoveGen.instance.pseudoLegalMoves(pos);
|
||||
@@ -169,7 +169,7 @@ public class TextIO {
|
||||
}
|
||||
}
|
||||
|
||||
private static final void safeSetPiece(Position pos, int col, int row, int p) throws ChessParseError {
|
||||
private static void safeSetPiece(Position pos, int col, int row, int p) throws ChessParseError {
|
||||
if (row < 0) throw new ChessParseError("Too many rows");
|
||||
if (col > 7) throw new ChessParseError("Too many columns");
|
||||
if ((p == Piece.WPAWN) || (p == Piece.BPAWN)) {
|
||||
@@ -180,7 +180,7 @@ public class TextIO {
|
||||
}
|
||||
|
||||
/** Return a FEN string corresponding to a chess Position object. */
|
||||
public static final String toFEN(Position pos) {
|
||||
public static String toFEN(Position pos) {
|
||||
StringBuilder ret = new StringBuilder();
|
||||
// Piece placement
|
||||
for (int r = 7; r >=0; r--) {
|
||||
@@ -271,12 +271,12 @@ public class TextIO {
|
||||
* @param longForm If true, use long notation, eg Ng1-f3.
|
||||
* Otherwise, use short notation, eg Nf3
|
||||
*/
|
||||
public static final String moveToString(Position pos, Move move, boolean longForm) {
|
||||
public static String moveToString(Position pos, Move move, boolean longForm) {
|
||||
MoveGen.MoveList moves = MoveGen.instance.pseudoLegalMoves(pos);
|
||||
MoveGen.removeIllegal(pos, moves);
|
||||
return moveToString(pos, move, longForm, moves);
|
||||
}
|
||||
private static final String moveToString(Position pos, Move move, boolean longForm, MoveGen.MoveList moves) {
|
||||
private static String moveToString(Position pos, Move move, boolean longForm, MoveGen.MoveList moves) {
|
||||
StringBuilder ret = new StringBuilder();
|
||||
int wKingOrigPos = Position.getSquare(4, 0);
|
||||
int bKingOrigPos = Position.getSquare(4, 7);
|
||||
@@ -365,7 +365,7 @@ public class TextIO {
|
||||
}
|
||||
|
||||
/** Convert a move object to UCI string format. */
|
||||
public static final String moveToUCIString(Move m) {
|
||||
public static String moveToUCIString(Move m) {
|
||||
String ret = squareToString(m.from);
|
||||
ret += squareToString(m.to);
|
||||
switch (m.promoteTo) {
|
||||
@@ -395,7 +395,7 @@ public class TextIO {
|
||||
* Convert a string to a Move object.
|
||||
* @return A move object, or null if move has invalid syntax
|
||||
*/
|
||||
public static final Move uciStringToMove(String move) {
|
||||
public static Move uciStringToMove(String move) {
|
||||
Move m = null;
|
||||
if ((move.length() < 4) || (move.length() > 5))
|
||||
return m;
|
||||
@@ -440,7 +440,7 @@ public class TextIO {
|
||||
return m;
|
||||
}
|
||||
|
||||
private static final boolean isCapture(Position pos, Move move) {
|
||||
private static boolean isCapture(Position pos, Move move) {
|
||||
if (pos.getPiece(move.to) == Piece.EMPTY) {
|
||||
int p = pos.getPiece(move.from);
|
||||
if ((p == (pos.whiteMove ? Piece.WPAWN : Piece.BPAWN)) && (move.to == pos.getEpSquare())) {
|
||||
@@ -458,7 +458,7 @@ public class TextIO {
|
||||
* Any prefix of the string representation of a valid move counts as a legal move string,
|
||||
* as long as the string only matches one valid move.
|
||||
*/
|
||||
public static final Move stringToMove(Position pos, String strMove) {
|
||||
public static Move stringToMove(Position pos, String strMove) {
|
||||
strMove = strMove.replaceAll("=", "");
|
||||
Move move = null;
|
||||
if (strMove.length() == 0)
|
||||
@@ -533,7 +533,7 @@ public class TextIO {
|
||||
* Convert a string, such as "e4" to a square number.
|
||||
* @return The square number, or -1 if not a legal square.
|
||||
*/
|
||||
public static final int getSquare(String s) {
|
||||
public static int getSquare(String s) {
|
||||
int x = s.charAt(0) - 'a';
|
||||
int y = s.charAt(1) - '1';
|
||||
if ((x < 0) || (x > 7) || (y < 0) || (y > 7))
|
||||
@@ -544,7 +544,7 @@ public class TextIO {
|
||||
/**
|
||||
* Convert a square number to a string, such as "e4".
|
||||
*/
|
||||
public static final String squareToString(int square) {
|
||||
public static String squareToString(int square) {
|
||||
StringBuilder ret = new StringBuilder();
|
||||
int x = Position.getX(square);
|
||||
int y = Position.getY(square);
|
||||
@@ -556,7 +556,7 @@ public class TextIO {
|
||||
/**
|
||||
* Create an ascii representation of a position.
|
||||
*/
|
||||
public static final String asciiBoard(Position pos) {
|
||||
public static String asciiBoard(Position pos) {
|
||||
StringBuilder ret = new StringBuilder(400);
|
||||
String nl = String.format(Locale.US, "%n");
|
||||
ret.append(" +----+----+----+----+----+----+----+----+"); ret.append(nl);
|
||||
@@ -587,7 +587,7 @@ public class TextIO {
|
||||
/**
|
||||
* Convert move string to lower case and remove special check/mate symbols.
|
||||
*/
|
||||
private static final String normalizeMoveString(String str) {
|
||||
private static String normalizeMoveString(String str) {
|
||||
if (str.length() > 0) {
|
||||
char lastChar = str.charAt(str.length() - 1);
|
||||
if ((lastChar == '#') || (lastChar == '+')) {
|
||||
@@ -597,7 +597,7 @@ public class TextIO {
|
||||
return str;
|
||||
}
|
||||
|
||||
private final static String pieceToChar(int p) {
|
||||
private static String pieceToChar(int p) {
|
||||
switch (p) {
|
||||
case Piece.WQUEEN: case Piece.BQUEEN: return "Q";
|
||||
case Piece.WROOK: case Piece.BROOK: return "R";
|
||||
|
||||
@@ -52,7 +52,7 @@ public final class TreeLogger {
|
||||
}
|
||||
|
||||
/** Get a logger object set up for writing to a log file. */
|
||||
public static final TreeLogger getWriter(String filename, Position pos) {
|
||||
public static TreeLogger getWriter(String filename, Position pos) {
|
||||
try {
|
||||
TreeLogger log = new TreeLogger();
|
||||
log.os = new FileOutputStream(filename);
|
||||
@@ -80,7 +80,7 @@ public final class TreeLogger {
|
||||
}
|
||||
|
||||
/** Get a logger object set up for analyzing a log file. */
|
||||
public static final TreeLogger getAnalyzer(String filename) {
|
||||
public static TreeLogger getAnalyzer(String filename) {
|
||||
RandomAccessFile raf = null;
|
||||
try {
|
||||
TreeLogger log = new TreeLogger();
|
||||
@@ -191,7 +191,7 @@ public final class TreeLogger {
|
||||
// ----------------------------------------------------------------------------
|
||||
// Functions used for tree analyzing
|
||||
|
||||
private static final int indexToFileOffs(int index) {
|
||||
private static int indexToFileOffs(int index) {
|
||||
return 128 + index * 16;
|
||||
}
|
||||
|
||||
@@ -211,7 +211,7 @@ public final class TreeLogger {
|
||||
}
|
||||
mapBuf.put(127, (byte)(1 << 7));
|
||||
mapBuf.force();
|
||||
System.out.printf("Computing forward pointers... done\n");
|
||||
System.out.print("Computing forward pointers... done\n");
|
||||
}
|
||||
|
||||
/** Get FEN string for root node position. */
|
||||
@@ -220,8 +220,7 @@ public final class TreeLogger {
|
||||
byte[] fenB = new byte[len];
|
||||
for (int i = 0; i < len; i++)
|
||||
fenB[i] = mapBuf.get(1+i);
|
||||
String ret = new String(fenB);
|
||||
return ret;
|
||||
return new String(fenB);
|
||||
}
|
||||
|
||||
static final class StartEntry {
|
||||
@@ -271,9 +270,9 @@ public final class TreeLogger {
|
||||
// ----------------------------------------------------------------------------
|
||||
// Functions used for the interactive tree browser
|
||||
|
||||
public static final void main(String[] args) throws IOException {
|
||||
public static void main(String[] args) throws IOException {
|
||||
if (args.length != 1) {
|
||||
System.out.printf("Usage: progname filename\n");
|
||||
System.out.print("Usage: progname filename\n");
|
||||
System.exit(1);
|
||||
}
|
||||
TreeLogger an = getAnalyzer(args[0]);
|
||||
@@ -445,7 +444,7 @@ public final class TreeLogger {
|
||||
}
|
||||
|
||||
/** Get integer parameter from an input string. */
|
||||
private static final int getArg(String s, int defVal) {
|
||||
private static int getArg(String s, int defVal) {
|
||||
try {
|
||||
int idx = s.indexOf(' ');
|
||||
if (idx > 0) {
|
||||
@@ -472,7 +471,7 @@ public final class TreeLogger {
|
||||
}
|
||||
|
||||
/** Get a string parameter from an input string. */
|
||||
private static final String getArgStr(String s, String defVal) {
|
||||
private static String getArgStr(String s, String defVal) {
|
||||
int idx = s.indexOf(' ');
|
||||
if (idx > 0)
|
||||
return s.substring(idx+1);
|
||||
@@ -480,16 +479,16 @@ public final class TreeLogger {
|
||||
}
|
||||
|
||||
private void printHelp() {
|
||||
System.out.printf(" p - Print move sequence\n");
|
||||
System.out.printf(" n - Print node info corresponding to move sequence\n");
|
||||
System.out.printf(" l [move] - List child nodes, optionally only for one move\n");
|
||||
System.out.printf(" d [n1 [n2...]] - Go to child \"n\"\n");
|
||||
System.out.printf(" move - Go to child \"move\", if unique\n");
|
||||
System.out.printf(" u [levels] - Move up\n");
|
||||
System.out.printf(" h [key] - Find nodes with current (or given) hash key\n");
|
||||
System.out.printf(" num - Go to node \"num\"\n");
|
||||
System.out.printf(" q - Quit\n");
|
||||
System.out.printf(" ? - Print this help\n");
|
||||
System.out.print(" p - Print move sequence\n");
|
||||
System.out.print(" n - Print node info corresponding to move sequence\n");
|
||||
System.out.print(" l [move] - List child nodes, optionally only for one move\n");
|
||||
System.out.print(" d [n1 [n2...]] - Go to child \"n\"\n");
|
||||
System.out.print(" move - Go to child \"move\", if unique\n");
|
||||
System.out.print(" u [levels] - Move up\n");
|
||||
System.out.print(" h [key] - Find nodes with current (or given) hash key\n");
|
||||
System.out.print(" num - Go to node \"num\"\n");
|
||||
System.out.print(" q - Quit\n");
|
||||
System.out.print(" ? - Print this help\n");
|
||||
}
|
||||
|
||||
/** Read start/end entries for a tree node. Return true if the end entry exists. */
|
||||
|
||||
@@ -436,7 +436,7 @@ public class ChessController {
|
||||
* Move a piece from one square to another.
|
||||
* @return True if the move was legal, false otherwise.
|
||||
*/
|
||||
final private boolean doMove(Move move) {
|
||||
private boolean doMove(Move move) {
|
||||
Position pos = game.pos;
|
||||
MoveGen.MoveList moves = new MoveGen().pseudoLegalMoves(pos);
|
||||
MoveGen.removeIllegal(pos, moves);
|
||||
@@ -461,14 +461,14 @@ public class ChessController {
|
||||
}
|
||||
|
||||
|
||||
final private void updateGUI() {
|
||||
private void updateGUI() {
|
||||
setStatusString();
|
||||
setMoveList();
|
||||
setThinkingPV();
|
||||
gui.setPosition(game.pos);
|
||||
}
|
||||
|
||||
final private void setStatusString() {
|
||||
private void setStatusString() {
|
||||
String str = game.pos.whiteMove ? "White's move" : "Black's move";
|
||||
if (computerThread != null) str += " (thinking)";
|
||||
if (game.getGameState() != GameState.ALIVE) {
|
||||
@@ -490,7 +490,7 @@ public class ChessController {
|
||||
gui.setThinkingString(str);
|
||||
}
|
||||
|
||||
final private void setSelection() {
|
||||
private void setSelection() {
|
||||
Move m = game.getLastMove();
|
||||
int sq = (m != null) ? m.to : -1;
|
||||
gui.setSelection(sq);
|
||||
|
||||
@@ -99,7 +99,7 @@ public class BitBoardTest {
|
||||
* If there is a piece type that can move from "from" to "to", return the
|
||||
* corresponding direction, 8*dy+dx.
|
||||
*/
|
||||
private static final int computeDirection(int from, int to) {
|
||||
private static int computeDirection(int from, int to) {
|
||||
int dx = Position.getX(to) - Position.getX(from);
|
||||
int dy = Position.getY(to) - Position.getY(from);
|
||||
if (dx == 0) { // Vertical rook direction
|
||||
@@ -125,7 +125,7 @@ public class BitBoardTest {
|
||||
}
|
||||
}
|
||||
|
||||
private static final int computeDistance(int from, int to) {
|
||||
private static int computeDistance(int from, int to) {
|
||||
int dx = Position.getX(to) - Position.getX(from);
|
||||
int dy = Position.getY(to) - Position.getY(from);
|
||||
return Math.max(Math.abs(dx), Math.abs(dy));
|
||||
|
||||
@@ -471,7 +471,7 @@ public class EvaluateTest {
|
||||
}
|
||||
|
||||
/** Return static evaluation score for white, regardless of whose turn it is to move. */
|
||||
final static int evalWhite(Position pos) {
|
||||
static int evalWhite(Position pos) {
|
||||
Evaluate eval = new Evaluate();
|
||||
int ret = eval.evalPos(pos);
|
||||
Position symPos = swapColors(pos);
|
||||
@@ -483,7 +483,7 @@ public class EvaluateTest {
|
||||
return ret;
|
||||
}
|
||||
|
||||
final static Position swapColors(Position pos) {
|
||||
static Position swapColors(Position pos) {
|
||||
Position sym = new Position();
|
||||
sym.whiteMove = !pos.whiteMove;
|
||||
for (int x = 0; x < 8; x++) {
|
||||
|
||||
@@ -26,9 +26,9 @@ import org.junit.Test;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class SearchTest {
|
||||
static final long[] nullHist = new long[200];
|
||||
static TranspositionTable tt = new TranspositionTable(19);
|
||||
static History ht = new History();
|
||||
private static final long[] nullHist = new long[200];
|
||||
private static TranspositionTable tt = new TranspositionTable(19);
|
||||
private static History ht = new History();
|
||||
|
||||
public SearchTest() {
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user