public unsafe static void RecordHash(int val, Player.enmColour colour)
{
ulong HashCodeA = Board.HashCodeA;
ulong HashCodeB = Board.HashCodeB;
if (colour == Player.enmColour.Black)
{
HashCodeA |= 0x1;
HashCodeB |= 0x1;
}
else
{
HashCodeA &= 0xFFFFFFFFFFFFFFFE;
HashCodeB &= 0xFFFFFFFFFFFFFFFE;
}
fixed(HashEntry *phashBase = &m_arrHashEntry[0])
{
HashEntry *phashEntry = phashBase;
phashEntry += ((uint)(HashCodeA % HASH_TABLE_SIZE));
phashEntry->HashCodeA = HashCodeA;
phashEntry->HashCodeB = HashCodeB;
phashEntry->Points = val;
}
m_intWrites++;
}
public unsafe static int ProbeHash(Player.enmColour colour)
{
ulong HashCodeA = Board.HashCodeA;
ulong HashCodeB = Board.HashCodeB;
if (colour == Player.enmColour.Black)
{
HashCodeA |= 0x1;
HashCodeB |= 0x1;
}
else
{
HashCodeA &= 0xFFFFFFFFFFFFFFFE;
HashCodeB &= 0xFFFFFFFFFFFFFFFE;
}
m_intProbes++;
fixed(HashEntry *phashBase = &m_arrHashEntry[0])
{
HashEntry *phashEntry = phashBase;
phashEntry += ((uint)(HashCodeA % HASH_TABLE_SIZE));
if (phashEntry->HashCodeA == HashCodeA && phashEntry->HashCodeB == HashCodeB)
{
m_intHits++;
return(phashEntry->Points);
}
}
return(UNKNOWN);
}
public static Piece LinesFirstPiece(Player.enmColour colour, Piece.enmName PieceName, Square squareStart, int Offset)
{
int intOrdinal = squareStart.Ordinal;
Square square;
intOrdinal += Offset;
while ((square = Board.GetSquare(intOrdinal)) != null)
{
if (square.Piece == null)
{
}
else if (square.Piece.Player.Colour != colour)
{
return(null);
}
else if (square.Piece.Name == PieceName || square.Piece.Name == Piece.enmName.Queen)
{
return(square.Piece);
}
else
{
return(null);
}
intOrdinal += Offset;
}
return(null);
}
private Move.enmName MoveName(Player.enmColour colourPlayer, Square squareTo)
{
if (colourPlayer == Player.enmColour.White && squareTo.Rank == 7 || colourPlayer == Player.enmColour.Black && squareTo.Rank == 0)
{
return(Move.enmName.PawnPromotion);
}
else
{
return(Move.enmName.Standard);
}
}
static public void Record(Player.enmColour colour, int OrdinalFrom, int OrdinalTo, int Increase, int Value)
{
if (colour == Player.enmColour.White)
{
aHistoryEntryWhite[OrdinalFrom, OrdinalTo] += Value;
}
else
{
aHistoryEntryBlack[OrdinalFrom, OrdinalTo] += Value;
}
}
public unsafe static Move ProbeForBestMove(Player.enmColour colour)
{
fixed(HashEntry *phashBase = &m_arrHashEntry[0])
{
ulong HashCodeA = Board.HashCodeA;
ulong HashCodeB = Board.HashCodeB;
HashEntry *phashEntry = phashBase;
phashEntry += ((uint)(HashCodeA % HASH_TABLE_SIZE));
int intAttempt = 0;
while (phashEntry >= phashBase && (phashEntry->HashCodeA != HashCodeA || phashEntry->HashCodeB != HashCodeB))
{
phashEntry--;
intAttempt++;
if (intAttempt == HASH_TABLE_SLOT_DEPTH)
{
break;
}
}
if (phashEntry < phashBase)
{
phashEntry = phashBase;
}
if (phashEntry->HashCodeA == HashCodeA && phashEntry->HashCodeB == HashCodeB)
{
if (colour == Player.enmColour.White)
{
if (phashEntry->WhiteFrom >= 0)
{
return(new Move(0, 0, phashEntry->WhiteMoveName, Board.GetPiece(phashEntry->WhiteFrom), Board.GetSquare(phashEntry->WhiteFrom), Board.GetSquare(phashEntry->WhiteTo), null, 0, phashEntry->Result));
}
}
else
{
if (phashEntry->BlackFrom >= 0)
{
return(new Move(0, 0, phashEntry->BlackMoveName, Board.GetPiece(phashEntry->BlackFrom), Board.GetSquare(phashEntry->BlackFrom), Board.GetSquare(phashEntry->BlackTo), null, 0, phashEntry->Result));
}
}
}
}
return(null);
}
public static int LineIsOpen(Player.enmColour colour, Square squareStart, int Offset)
{
int intOrdinal = squareStart.Ordinal;
int intSquareCount = 0;
int intPenalty = 0;
Square square;
intOrdinal += Offset;
while (intSquareCount <= 2 && ((square = Board.GetSquare(intOrdinal)) != null && (square.Piece == null || (square.Piece.Name != Piece.enmName.Pawn && square.Piece.Name != Piece.enmName.Rook) || square.Piece.Player.Colour != colour)))
{
intPenalty += 75;
intSquareCount++;
intOrdinal += Offset;
}
return(intPenalty);
}
public unsafe static void RecordHash(ulong HashCodeA, ulong HashCodeB, int depth, int val, enmHashType type, int From, int To, Move.enmName MoveName, Player.enmColour colour)
{
m_intWrites++;
fixed(HashEntry *phashBase = &m_arrHashEntry[0])
{
int intAttempt;
HashEntry *phashEntry = phashBase;
phashEntry += ((uint)(HashCodeA % HASH_TABLE_SIZE));
HashEntry *phashFirst = phashEntry;
intAttempt = 0;
while (phashEntry >= phashBase && phashEntry->HashCodeA != 0 && phashEntry->Depth > depth)
{
phashEntry--;
intAttempt++;
if (intAttempt == HASH_TABLE_SLOT_DEPTH)
{
break;
}
}
if (phashEntry < phashBase)
{
phashEntry = phashBase;
}
if (phashEntry->HashCodeA != 0)
{
m_intCollisions++;
if (phashEntry->HashCodeA != HashCodeA || phashEntry->HashCodeB != HashCodeB)
{
m_intOverwrites++;
phashEntry->WhiteFrom = -1;
phashEntry->BlackFrom = -1;
}
}
phashEntry->HashCodeA = HashCodeA;
phashEntry->HashCodeB = HashCodeB;
phashEntry->Result = val;
phashEntry->Type = type;
phashEntry->Depth = (sbyte)depth;
phashEntry->Colour = colour;
if (From > -1)
{
if (colour == Player.enmColour.White)
{
phashEntry->WhiteMoveName = MoveName;
phashEntry->WhiteFrom = (sbyte)From;
phashEntry->WhiteTo = (sbyte)To;
}
else
{
phashEntry->BlackMoveName = MoveName;
phashEntry->BlackFrom = (sbyte)From;
phashEntry->BlackTo = (sbyte)To;
}
}
}
}
public unsafe static int ProbeHash(ulong HashCodeA, ulong HashCodeB, int depth, int alpha, int beta, Player.enmColour colour)
{
m_intProbes++;
fixed(HashEntry *phashBase = &m_arrHashEntry[0])
{
HashEntry *phashEntry = phashBase;
phashEntry += ((uint)(HashCodeA % HASH_TABLE_SIZE));
int intAttempt = 0;
while (phashEntry >= phashBase && (phashEntry->HashCodeA != HashCodeA || phashEntry->HashCodeB != HashCodeB || phashEntry->Depth < depth))
{
phashEntry--;
intAttempt++;
if (intAttempt == HASH_TABLE_SLOT_DEPTH)
{
break;
}
}
if (phashEntry < phashBase)
{
phashEntry = phashBase;
}
if (phashEntry->HashCodeA == HashCodeA && phashEntry->HashCodeB == HashCodeB && phashEntry->Depth >= depth)
{
if (phashEntry->Colour == colour)
{
if (phashEntry->Type == enmHashType.Exact)
{
m_intHits++;
return(phashEntry->Result);
}
if ((phashEntry->Type == enmHashType.Alpha) && (phashEntry->Result <= alpha))
{
m_intHits++;
return(alpha);
}
if ((phashEntry->Type == enmHashType.Beta) && (phashEntry->Result >= beta))
{
m_intHits++;
return(beta);
}
}
}
}
return(UNKNOWN);
}
static public int Retrieve(Player.enmColour colour, int OrdinalFrom, int OrdinalTo)
{
return(colour == Player.enmColour.White ? aHistoryEntryWhite[OrdinalFrom, OrdinalTo] : aHistoryEntryBlack[OrdinalFrom, OrdinalTo]);
}
