private static void sort(ref LightList children, ref int[] h)
{
int count = children.Count;
bool swapped;
do
{
swapped = false;
for (int j = 1; j < count; ++j)
{
if (h[j - 1] < h[j])
{
int temp;
char[] tempBoard;
temp = h[j];
tempBoard = children[j];
h[j] = h[j - 1];
h[j - 1] = temp;
children.Replace(children[j - 1], j);
children.Replace(tempBoard, j - 1);
swapped = true;
}
}
count--;
} while (swapped);
}
private static void shift(ref LightList children, int indexFound)
{
byte[] tempBest = children[indexFound];
for (int i = indexFound; i > 0; --i)
{
children.Replace(children[i - 1], i);
}
children.Replace(tempBest, 0);
}
private static void shift(ref LightList children, int indexFound)
{
byte[] tempBest = children[indexFound];
for (int i = indexFound; i > 0; --i)
{
children.Replace(children[i - 1], i);
}
children.Replace(tempBest, 0);
}
private static void sort(ref LightList children, ref int[] h)
{
int count = children.Count;
bool swapped;
do
{
swapped = false;
for (int j = 1; j < count; ++j)
{
if (h[j - 1] < h[j])
{
int temp;
char[] tempBoard;
temp = h[j];
tempBoard = children[j];
h[j] = h[j - 1];
h[j - 1] = temp;
children.Replace(children[j - 1], j);
children.Replace(tempBoard, j - 1);
swapped = true;
}
}
count--;
} while (swapped);
}
//This min value version is only called at depth 1 when a previously found best move is used to inform the ordering of moves
public static int minValue(ref char[] board, int depth, bool white, int alpha, int beta, int cutoff, char[] best, ref Stopwatch timer)
{
ChessColor color = (white ? ChessColor.White : ChessColor.Black);
int hValue;
LightList equalMoves = new LightList();
LightList childrenBoard = FEN.GetAvailableMoves(board, color, false);
int count = childrenBoard.Count;
if (count == 0)
{ //no moves available
if (FENExtensions.InCheck(board, white))
{
return(-5000);//checkmate
}
else
{
return(-3000);//stalemate
}
}
//sort array of moves
int[] Hchildren = new int[count];
for (int idx = 0; idx < count; ++idx)
{
Hchildren[idx] = Heuristic.GetHeuristicValue(childrenBoard[idx], color);
}
sort(ref childrenBoard, ref Hchildren);
bool found = false;
int indexFound = 0;
for (int idx = 0; idx < count; ++idx)
{
found = true;
for (int index = 0; index < 71; ++index)
{
if (best[index] != childrenBoard[idx][index])
{
found = false;
break;
}
}
if (found == true)
{
indexFound = idx;
break;
}
}
//prioritize previously found best move
if (indexFound != 0) //swap
{
char[] temp;
temp = childrenBoard[0];
childrenBoard.Replace(childrenBoard[indexFound], 0);
childrenBoard.Replace(temp, indexFound);
}
int minimumValue = 10000;
int i = 0;
char[] tempBoard = null;
while (i < count)
{ //process all the children moves
if (depth != cutoff)
{
tempBoard = childrenBoard[i];
hValue = maxValue(ref tempBoard, depth + 1, !white, alpha, beta, cutoff, ref timer);
}
else //get heuristics value
{
hValue = Hchildren[i];
}
if (depth == 1)
{
if (hValue == -5000)
{
board = childrenBoard[i];
childrenBoard = null;
return(hValue);
}
if (minimumValue == hValue)
{
equalMoves.Add(tempBoard);
}
else if (hValue < minimumValue)
{
minimumValue = hValue;
board = childrenBoard[i];
equalMoves.Empty();
equalMoves.Add(board);
}
if (minimumValue <= alpha)
{
board = getRandomMove(equalMoves);
childrenBoard = null;
return(hValue);
}
beta = Math.Min(beta, minimumValue);
}
else
{
minimumValue = Math.Min(minimumValue, hValue);
if (minimumValue <= alpha)
{
hValue = minimumValue;
childrenBoard = null;
return(hValue);
}
beta = Math.Min(beta, minimumValue);
if (minimumValue == -5000)
{
return(-5000);
}
}
++i;
}
hValue = minimumValue;
if (depth == 1)
{
board = getRandomMove(equalMoves);
}
childrenBoard = null;
return(hValue);
}