//----------------------------------------------------------------------------------------
public static int Capturas(cPosicion pos, cMov[] mlist, int mPos, type Type)
{
color us = pos.ColorMueve();
bitbrd target = Type==cMovType.CAPTURES ? pos.PiezasColor(cTypes.Contrario(us))
: Type==cMovType.QUIETS ? ~pos.Piezas()
: Type==cMovType.NON_EVASIONS ? ~pos.PiezasColor(us) : 0;
return us==cColor.BLANCO ? ToDO(pos, mlist, mPos, target, cColor.BLANCO, Type, null)
: ToDO(pos, mlist, mPos, target, cColor.NEGRO, Type, null);
}
//-----------------------------------------------------------------------------------------------
public factor KQKRPs(cPosicion pos)
{
sq kingSq = pos.GetRey(m_cDebil);
sq nCasillaTorre = pos.GetList(m_cDebil, cPieza.TORRE)[0];
if (cTypes.FilaProxima(m_cDebil, kingSq) <= FILA.F2
&& cTypes.FilaProxima(m_cDebil, pos.GetRey(m_cFuerte)) >= FILA.F4
&& cTypes.FilaProxima(m_cDebil, nCasillaTorre) == FILA.F3
&& (pos.PiezasColor(m_cDebil, cPieza.PEON)
& pos.attacks_from_square_piecetype(kingSq, cPieza.REY)
& pos.AtaquesDePeon(nCasillaTorre, m_cFuerte)) != 0)
return cFactorEscala.TABLAS;
return cFactorEscala.NAN;
}
//-----------------------------------------------------------------------------------------------
public factor KPsK(cPosicion pos)
{
sq ksq = pos.GetRey(m_cDebil);
bitbrd pawns = pos.PiezasColor(m_cFuerte, cPieza.PEON);
sq nCasillaPeon = pos.GetList(m_cFuerte, cPieza.PEON)[0];
if (0 == (pawns & ~cBitBoard.EnFrente(m_cDebil, cTypes.Fila(ksq)))
&& !((pawns & ~cBitBoard.A) != 0 && (pawns & ~cBitBoard.H) != 0)
&& cBitBoard.ColumDistancia(ksq, nCasillaPeon) <= 1)
return cFactorEscala.TABLAS;
return cFactorEscala.NAN;
}
//-----------------------------------------------------------------------------------------------
public factor KBPsK(cPosicion pos)
{
bitbrd pawns = pos.PiezasColor(m_cFuerte, cPieza.PEON);
colum pawnFile = cTypes.Columna(pos.GetList(m_cFuerte, cPieza.PEON)[0]);
if ((pawnFile == COLUMNA.A || pawnFile == COLUMNA.H) && 0 == (pawns & ~cBitBoard.GetColumna(pawnFile)))
{
sq bishonCasillaPeon = pos.GetList(m_cFuerte, cPieza.ALFIL)[0];
sq queeningSq = cTypes.CasillaProxima(m_cFuerte, cTypes.CreaCasilla(pawnFile, FILA.F8));
sq kingSq = pos.GetRey(m_cDebil);
if (cTypes.IsColorContrario(queeningSq, bishonCasillaPeon)
&& cBitBoard.Distancia(queeningSq, kingSq) <= 1)
return cFactorEscala.TABLAS;
}
if ((pawnFile == COLUMNA.B || pawnFile == COLUMNA.G)
&& 0 == (pos.GetNumPiezas(cPieza.PEON) & ~cBitBoard.GetColumna(pawnFile))
&& pos.MaterialPieza(m_cDebil) == 0
&& pos.GetNum(m_cDebil, cPieza.PEON) >= 1)
{
sq weaksqPeon = cBitBoard.backmost_sq(m_cDebil, pos.PiezasColor(m_cDebil, cPieza.PEON));
sq strongKingSq = pos.GetRey(m_cFuerte);
sq weakKingSq = pos.GetRey(m_cDebil);
sq bishonCasillaPeon = pos.GetList(m_cFuerte, cPieza.ALFIL)[0];
if (cTypes.FilaProxima(m_cFuerte, weaksqPeon) == FILA.F7
&& (pos.PiezasColor(m_cFuerte, cPieza.PEON) & cBitBoard.m_nCasillas[(weaksqPeon + cTypes.AtaquePeon(m_cDebil))]) != 0
&& (cTypes.IsColorContrario(bishonCasillaPeon, weaksqPeon) || pos.GetNum(m_cFuerte, cPieza.PEON) == 1))
{
int strongKingDist = cBitBoard.Distancia(weaksqPeon, strongKingSq);
int weakKingDist = cBitBoard.Distancia(weaksqPeon, weakKingSq);
if (cTypes.FilaProxima(m_cFuerte, weakKingSq) >= FILA.F7
&& weakKingDist <= 2
&& weakKingDist <= strongKingDist)
return cFactorEscala.TABLAS;
}
}
return cFactorEscala.NAN;
}
//-----------------------------------------------------------------------------------------------
public factor KBPPKB(cPosicion pos)
{
sq wbsq = pos.GetList(m_cFuerte, cPieza.ALFIL)[0];
sq bbsq = pos.GetList(m_cDebil, cPieza.ALFIL)[0];
if (!cTypes.IsColorContrario(wbsq, bbsq))
return cFactorEscala.NAN;
sq ksq = pos.GetRey(m_cDebil);
sq nCasillaPeon1 = pos.GetList(m_cFuerte, cPieza.PEON)[0];
sq nCasillaPeon2 = pos.GetList(m_cFuerte, cPieza.PEON)[1];
fila r1 = cTypes.Fila(nCasillaPeon1);
fila r2 = cTypes.Fila(nCasillaPeon2);
sq blockSq1, blockSq2;
if (cTypes.FilaProxima(m_cFuerte, nCasillaPeon1) > cTypes.FilaProxima(m_cFuerte, nCasillaPeon2))
{
blockSq1 = nCasillaPeon1 + cTypes.AtaquePeon(m_cFuerte);
blockSq2 = cTypes.CreaCasilla(cTypes.Columna(nCasillaPeon2), cTypes.Fila(nCasillaPeon1));
}
else
{
blockSq1 = nCasillaPeon2 + cTypes.AtaquePeon(m_cFuerte);
blockSq2 = cTypes.CreaCasilla(cTypes.Columna(nCasillaPeon1), cTypes.Fila(nCasillaPeon2));
}
switch (cBitBoard.ColumDistancia(nCasillaPeon1, nCasillaPeon2))
{
case 0:
if (cTypes.Columna(ksq) == cTypes.Columna(blockSq1)
&& cTypes.FilaProxima(m_cFuerte, ksq) >= cTypes.FilaProxima(m_cFuerte, blockSq1)
&& cTypes.IsColorContrario(ksq, wbsq))
return cFactorEscala.TABLAS;
else
return cFactorEscala.NAN;
case 1:
if (ksq == blockSq1
&& cTypes.IsColorContrario(ksq, wbsq)
&& (bbsq == blockSq2
|| (pos.attacks_from_square_piecetype(blockSq2, cPieza.ALFIL) & pos.PiezasColor(m_cDebil, cPieza.ALFIL)) != 0
|| Math.Abs(r1 - r2) >= 2))
return cFactorEscala.TABLAS;
else if (ksq == blockSq2
&& cTypes.IsColorContrario(ksq, wbsq)
&& (bbsq == blockSq1
|| (pos.attacks_from_square_piecetype(blockSq1, cPieza.ALFIL) & pos.PiezasColor(m_cDebil, cPieza.ALFIL)) != 0))
return cFactorEscala.TABLAS;
else
return cFactorEscala.NAN;
default:
return cFactorEscala.NAN;
}
}
//-----------------------------------------------------------------------------------------------
public factor KBPKB(cPosicion pos)
{
sq sqPeon = pos.GetList(m_cFuerte, cPieza.PEON)[0];
sq strongerBishonCasillaPeon = pos.GetList(m_cFuerte, cPieza.ALFIL)[0];
sq weakerBishonCasillaPeon = pos.GetList(m_cDebil, cPieza.ALFIL)[0];
sq weakerKingSq = pos.GetRey(m_cDebil);
if (cTypes.Columna(weakerKingSq) == cTypes.Columna(sqPeon)
&& cTypes.FilaProxima(m_cFuerte, sqPeon) < cTypes.FilaProxima(m_cFuerte, weakerKingSq)
&& (cTypes.IsColorContrario(weakerKingSq, strongerBishonCasillaPeon)
|| cTypes.FilaProxima(m_cFuerte, weakerKingSq) <= FILA.F6))
return cFactorEscala.TABLAS;
if (cTypes.IsColorContrario(strongerBishonCasillaPeon, weakerBishonCasillaPeon))
{
if (cTypes.FilaProxima(m_cFuerte, sqPeon) <= FILA.F5)
return cFactorEscala.TABLAS;
else
{
bitbrd path = cBitBoard.Atras(m_cFuerte, sqPeon);
if ((path & pos.PiezasColor(m_cDebil, cPieza.REY)) != 0)
return cFactorEscala.TABLAS;
if (((pos.attacks_from_square_piecetype(weakerBishonCasillaPeon, cPieza.ALFIL) & path) != 0)
&& cBitBoard.Distancia(weakerBishonCasillaPeon, sqPeon) >= 3)
return cFactorEscala.TABLAS;
}
}
return cFactorEscala.NAN;
}
//----------------------------------------------------------------------------------------------------------
public static pnt evaluate_outposts(cPosicion pos, cEvalInfo ei, sq s, type Pt, color colr)
{
color colorVS = (colr == cColor.BLANCO ? cColor.NEGRO : cColor.BLANCO);
val bonus = m_Avanzado[Pt == cPieza.ALFIL ? 1 : 0][cTypes.CasillaProxima(colr, s)];
if (bonus != 0 && (ei.m_Ataques[colr][cPieza.PEON] & cBitBoard.m_nCasillas[s]) != 0)
{
if (0 == pos.PiezasColor(colorVS, cPieza.CABALLO) && 0 == (cBitBoard.GetColor(s) & pos.PiezasColor(colorVS, cPieza.ALFIL)))
bonus += bonus + bonus / 2;
else
bonus += bonus / 2;
}
return cTypes.Puntua(bonus, bonus);
}
//----------------------------------------------------------------------------------------------------------
public static pnt EvalRey(cPosicion pos, cEvalInfo ei, color colr)
{
color colorVS = (colr == cColor.BLANCO ? cColor.NEGRO : cColor.BLANCO);
bitbrd indefenso, b, b1, b2, safe;
int attackUnits;
sq nCasillaRey = pos.GetRey(colr);
pnt score = 0;
if (ei.m_AtaquesAlRey[colorVS] != 0)
{
indefenso = ei.m_Ataques[colorVS][cPieza.NAN] & ei.m_Ataques[colr][cPieza.REY] & ~(ei.m_Ataques[colr][cPieza.PEON] | ei.m_Ataques[colr][cPieza.CABALLO]
| ei.m_Ataques[colr][cPieza.ALFIL] | ei.m_Ataques[colr][cPieza.TORRE] | ei.m_Ataques[colr][cPieza.DAMA]);
attackUnits = Math.Min(20, (ei.m_AtaquesAlRey[colorVS] * ei.m_PesoAtaquesAlRey[colorVS]) / 2)
+ 3 * (ei.m_ZonaDelRey[colorVS] + cBitBoard.CountMax15(indefenso))
+ 2 * (ei.m_Clavadas[colr] != 0 ? 1 : 0)
- cTypes.GetMedioJuego(score) / 32;
b = indefenso & ei.m_Ataques[colorVS][cPieza.DAMA] & ~pos.PiezasColor(colorVS);
if (b != 0)
{
b &= (ei.m_Ataques[colorVS][cPieza.PEON] | ei.m_Ataques[colorVS][cPieza.CABALLO]
| ei.m_Ataques[colorVS][cPieza.ALFIL] | ei.m_Ataques[colorVS][cPieza.TORRE]);
if (b != 0)
attackUnits += QueenContactCheck
* cBitBoard.CountMax15(b)
* (colorVS == pos.ColorMueve() ? 2 : 1);
}
b = indefenso & ei.m_Ataques[colorVS][cPieza.TORRE] & ~pos.PiezasColor(colorVS);
b &= cBitBoard.m_PseudoAtaques[cPieza.TORRE][nCasillaRey];
if (b != 0)
{
b &= (ei.m_Ataques[colorVS][cPieza.PEON] | ei.m_Ataques[colorVS][cPieza.CABALLO]
| ei.m_Ataques[colorVS][cPieza.ALFIL] | ei.m_Ataques[colorVS][cPieza.DAMA]);
if (b != 0)
attackUnits += RookContactCheck
* cBitBoard.CountMax15(b)
* (colorVS == pos.ColorMueve() ? 2 : 1);
}
safe = ~(pos.PiezasColor(colorVS) | ei.m_Ataques[colr][cPieza.NAN]);
b1 = pos.attacks_from_square_piecetype(nCasillaRey, cPieza.TORRE) & safe;
b2 = pos.attacks_from_square_piecetype(nCasillaRey, cPieza.ALFIL) & safe;
b = (b1 | b2) & ei.m_Ataques[colorVS][cPieza.DAMA];
if (b != 0)
attackUnits += QueenCheck * cBitBoard.CountMax15(b);
b = b1 & ei.m_Ataques[colorVS][cPieza.TORRE];
if (b != 0)
attackUnits += RookCheck * cBitBoard.CountMax15(b);
b = b2 & ei.m_Ataques[colorVS][cPieza.ALFIL];
if (b != 0)
attackUnits += BishopCheck * cBitBoard.CountMax15(b);
b = pos.attacks_from_square_piecetype(nCasillaRey, cPieza.CABALLO) & ei.m_Ataques[colorVS][cPieza.CABALLO] & safe;
if (b != 0)
attackUnits += KnightCheck * cBitBoard.CountMax15(b);
attackUnits = Math.Min(99, Math.Max(0, attackUnits));
score -= m_ReyAmenazado[colr == cSearch.RootColor ? 1 : 0][attackUnits];
}
return score;
}
//----------------------------------------------------------------------------------------------------------
public static pnt EvalPiezas(cPosicion pos, cEvalInfo ei, pnt[] mobility, bitbrd[] mobilityArea, type Pt, color colr)
{
if (colr == cColor.BLANCO && Pt == cPieza.REY)
{
return 0;
}
bitbrd b;
sq s;
pnt nPuntos = 0;
type NextPt = (colr == cColor.BLANCO ? Pt : (Pt + 1));
color colorVS = (colr == cColor.BLANCO ? cColor.NEGRO : cColor.BLANCO);
sq[] pl = pos.GetList(colr, Pt);
int plPos = 0;
ei.m_Ataques[colr][Pt] = 0;
while ((s = pl[plPos++]) != cCasilla.NONE)
{
b = Pt == cPieza.ALFIL ? cBitBoard.AtaquesPieza(s, pos.Piezas() ^ pos.PiezasColor(colr, cPieza.DAMA), cPieza.ALFIL)
: Pt == cPieza.TORRE ? cBitBoard.AtaquesPieza(s, pos.Piezas() ^ pos.PiezasColor(colr, cPieza.TORRE, cPieza.DAMA), cPieza.TORRE)
: pos.attacks_from_square_piecetype(s, Pt);
if ((ei.m_Clavadas[colr] & cBitBoard.m_nCasillas[s]) != 0)
b &= cBitBoard.m_EnLinea[pos.GetRey(colr)][s];
ei.m_Ataques[colr][cPieza.NAN] |= ei.m_Ataques[colr][Pt] |= b;
if ((b & ei.m_ReyAcorralado[colorVS]) != 0)
{
ei.m_AtaquesAlRey[colr]++;
ei.m_PesoAtaquesAlRey[colr] += KingAttackWeights[Pt];
bitbrd bb = (b & ei.m_Ataques[colorVS][cPieza.REY]);
if (bb != 0)
ei.m_ZonaDelRey[colr] += cBitBoard.CountMax15(bb);
}
if (Pt == cPieza.DAMA)
b &= ~(ei.m_Ataques[colorVS][cPieza.CABALLO]
| ei.m_Ataques[colorVS][cPieza.ALFIL]
| ei.m_Ataques[colorVS][cPieza.TORRE]);
int mob = (Pt != cPieza.DAMA ? cBitBoard.CountMax15(b & mobilityArea[colr])
: cBitBoard.Count(b & mobilityArea[colr]));
mobility[colr] += m_Movilidad[Pt][mob];
if ((ei.m_Ataques[colorVS][cPieza.PEON] & cBitBoard.m_nCasillas[s]) != 0)
nPuntos -= ThreatenedByPawn[Pt];
if (Pt == cPieza.ALFIL || Pt == cPieza.CABALLO)
{
if (Pt == cPieza.ALFIL)
nPuntos -= m_AlfilEnPeon * ei.m_Peones.PeonesMismoColor(colr, s);
if (0 == (pos.PiezasColor(colorVS, cPieza.PEON) & cBitBoard.AtaquePeon(colr, s)))
nPuntos += evaluate_outposts(pos, ei, s, Pt, colr);
if (cTypes.FilaProxima(colr, s) < FILA.F5 && (pos.GetNumPiezas(cPieza.PEON) & cBitBoard.m_nCasillas[(s + cTypes.AtaquePeon(colr))]) != 0)
nPuntos += m_CercaDePeon;
}
if (Pt == cPieza.TORRE)
{
if (cTypes.FilaProxima(colr, s) >= FILA.F5)
{
bitbrd pawns = pos.PiezasColor(colorVS, cPieza.PEON) & cBitBoard.m_PseudoAtaques[cPieza.TORRE][s];
if (pawns != 0)
nPuntos += cBitBoard.CountMax15(pawns) * m_TorreEnPeon;
}
if (ei.m_Peones.SemiAbierta(colr, cTypes.Columna(s)) != 0)
nPuntos += ei.m_Peones.SemiAbierta(colorVS, cTypes.Columna(s)) != 0 ? m_TorreColAbierta : m_TorreColumnaSemiAbierta;
if (mob > 3 || ei.m_Peones.SemiAbierta(colr, cTypes.Columna(s)) != 0)
continue;
sq ksq = pos.GetRey(colr);
if (((cTypes.Columna(ksq) < COLUMNA.E) == (cTypes.Columna(s) < cTypes.Columna(ksq)))
&& (cTypes.Fila(ksq) == cTypes.Fila(s) || cTypes.FilaProxima(colr, ksq) == FILA.F1)
&& 0 == ei.m_Peones.SemiAbierta(colr, cTypes.Columna(ksq), cTypes.Columna(s) < cTypes.Columna(ksq)))
nPuntos -= (m_TorreAtrapada - cTypes.Puntua(mob * 8, 0)) * (1 + (pos.CanEnroque(colr) == 0 ? 1 : 0));
}
if (Pt == cPieza.ALFIL
&& pos.IsChess960() != false
&& (s == cTypes.CasillaProxima(colr, cCasilla.A1) || s == cTypes.CasillaProxima(colr, cCasilla.H1)))
{
sq d = cTypes.AtaquePeon(colr) + (cTypes.Columna(s) == COLUMNA.A ? cCasilla.ESTE : cCasilla.OESTE);
if (pos.GetPieza(s + d) == cTypes.CreaPieza(colr, cPieza.PEON))
nPuntos -= !pos.CasillaVacia(s + d + cTypes.AtaquePeon(colr)) ? m_AlfilAtrapado * 4
: pos.GetPieza(s + d + d) == cTypes.CreaPieza(colr, cPieza.PEON) ? m_AlfilAtrapado * 2
: m_AlfilAtrapado;
}
}
return nPuntos - EvalPiezas(pos, ei, mobility, mobilityArea, NextPt, colorVS);
}
//-----------------------------------------------------------------------------------------------------------------------------------
public static pnt EvalPeonesPasados(cPosicion pos, cEvalInfo ei, color colr)
{
color colorVS = (colr == cColor.BLANCO ? cColor.NEGRO : cColor.BLANCO);
bitbrd b, squaresToQueen, defendedSquares, unsafeSquares;
pnt nPuntos = 0;
b = ei.m_Peones.GetPeonesPasados(colr);
while (b != 0)
{
sq casilla = cBitBoard.GetLSB(ref b);
int r = (int)(cTypes.FilaProxima(colr, casilla) - FILA.F2);
int rr = r * (r - 1);
val mbonus = (17 * rr), ebonus = (7 * (rr + r + 1));
if (rr != 0)
{
sq blockSq = casilla + cTypes.AtaquePeon(colr);
ebonus += (cBitBoard.Distancia(pos.GetRey(colorVS), blockSq) * 5 * rr)
- (cBitBoard.Distancia(pos.GetRey(colr), blockSq) * 2 * rr);
if (cTypes.FilaProxima(colr, blockSq) != FILA.F8)
ebonus -= (cBitBoard.Distancia(pos.GetRey(colr), blockSq + cTypes.AtaquePeon(colr)) * rr);
if (pos.CasillaVacia(blockSq))
{
squaresToQueen = cBitBoard.Atras(colr, casilla);
if ((cBitBoard.Atras(colorVS, casilla) & pos.PiezasColor(colorVS, cPieza.TORRE, cPieza.DAMA)) != 0
&& (cBitBoard.Atras(colorVS, casilla) & pos.PiezasColor(colorVS, cPieza.TORRE, cPieza.DAMA) & pos.attacks_from_square_piecetype(casilla, cPieza.TORRE)) != 0)
unsafeSquares = squaresToQueen;
else
unsafeSquares = squaresToQueen & (ei.m_Ataques[colorVS][cPieza.NAN] | pos.PiezasColor(colorVS));
if ((cBitBoard.Atras(colorVS, casilla) & pos.PiezasColor(colr, cPieza.TORRE, cPieza.DAMA)) != 0
&& (cBitBoard.Atras(colorVS, casilla) & pos.PiezasColor(colr, cPieza.TORRE, cPieza.DAMA) & pos.attacks_from_square_piecetype(casilla, cPieza.TORRE)) != 0)
defendedSquares = squaresToQueen;
else
defendedSquares = squaresToQueen & ei.m_Ataques[colr][cPieza.NAN];
int k = 0 == unsafeSquares ? 15 : 0 == (unsafeSquares & cBitBoard.m_nCasillas[blockSq]) ? 9 : 0;
if (defendedSquares == squaresToQueen)
k += 6;
else if ((defendedSquares & cBitBoard.m_nCasillas[blockSq]) != 0)
k += 4;
mbonus += (k * rr); ebonus += (k * rr);
}
} //-- rr != 0
if (pos.GetNum(colr, cPieza.PEON) < pos.GetNum(colorVS, cPieza.PEON))
ebonus += ebonus / 4;
nPuntos += cTypes.Puntua(mbonus, ebonus);
}
return cEval.SetPesos(nPuntos, m_Pesos[cEvalPesos.PEONES_PASADOS]);
}
//-----------------------------------------------------------------------------------------------------------------------------------
public static int EvalEspacio(cPosicion pos, cEvalInfo ei, color colr)
{
color colorVS = (colr == cColor.BLANCO ? cColor.NEGRO : cColor.BLANCO);
bitbrd safe = m_EspacioMasc[colr]
& ~pos.PiezasColor(colr, cPieza.PEON)
& ~ei.m_Ataques[colorVS][cPieza.PEON]
& (ei.m_Ataques[colr][cPieza.NAN] | ~ei.m_Ataques[colorVS][cPieza.NAN]);
bitbrd behind = pos.PiezasColor(colr, cPieza.PEON);
behind |= (colr == cColor.BLANCO ? behind >> 8 : behind << 8);
behind |= (colr == cColor.BLANCO ? behind >> 16 : behind << 16);
return cBitBoard.Count((colr == cColor.BLANCO ? safe << 32 : safe >> 32) | (behind & safe));
}
//-----------------------------------------------------------------------------------------------------------------------------------
public static pnt EvalAmenazas(cPosicion pos, cEvalInfo evalInfo, color colr)
{
color colorVS = (colr == cColor.BLANCO ? cColor.NEGRO : cColor.BLANCO);
bitbrd b, weakEnemies;
pnt nPuntos = 0;
weakEnemies = pos.PiezasColor(colorVS) & ~evalInfo.m_Ataques[colorVS][cPieza.PEON] & evalInfo.m_Ataques[colr][cPieza.NAN];
if (weakEnemies != 0)
{
b = weakEnemies & (evalInfo.m_Ataques[colr][cPieza.PEON] | evalInfo.m_Ataques[colr][cPieza.CABALLO] | evalInfo.m_Ataques[colr][cPieza.ALFIL]);
if (b != 0)
nPuntos += m_Amenazado[0][cTypes.TipoPieza(pos.GetPieza(cBitBoard.LSB(b)))];
b = weakEnemies & (evalInfo.m_Ataques[colr][cPieza.TORRE] | evalInfo.m_Ataques[colr][cPieza.DAMA]);
if (b != 0)
nPuntos += m_Amenazado[1][cTypes.TipoPieza(pos.GetPieza(cBitBoard.LSB(b)))];
b = weakEnemies & ~evalInfo.m_Ataques[colorVS][cPieza.NAN];
if (b != 0)
nPuntos += cBitBoard.MayorQue(b) ? Hanging[colr != pos.ColorMueve() ? 1 : 0] * cBitBoard.CountMax15(b) : Hanging[colr == pos.ColorMueve() ? 1 : 0];
}
return nPuntos;
}
//-----------------------------------------------------------------------------------------------------------------------------------
public static val Eval(cPosicion pos)
{
cEvalInfo eval = new cEvalInfo();
pnt nPuntos;
pnt[] movilidad = new pnt[] { 0, 0 };
cThread thread = pos.ThreadActive();
nPuntos = pos.GetPuntosPeon() + (pos.ColorMueve() == cColor.BLANCO ? m_Tempo : -m_Tempo);
eval.m_Material = cMaterial.Buscar(pos, thread.m_Material, thread.m_Finales);
nPuntos += eval.m_Material.Valor();
if (eval.m_Material.FuncionEvaluacion())
return eval.m_Material.Eval(pos);
eval.m_Peones = cBonusPeones.Buscar(pos, thread.m_TablaPeones);
Init(pos, eval, cColor.BLANCO);
Init(pos, eval, cColor.NEGRO);
nPuntos += SetPesos(eval.m_Peones.GetValue(), m_Pesos[cEvalPesos.ESTRUCTURA_PEONES]);
eval.m_Ataques[cColor.BLANCO][cPieza.NAN] |= eval.m_Ataques[cColor.BLANCO][cPieza.REY];
eval.m_Ataques[cColor.NEGRO][cPieza.NAN] |= eval.m_Ataques[cColor.NEGRO][cPieza.REY];
bitbrd[] areaMovilidad = new bitbrd[]{ ~(eval.m_Ataques[cColor.NEGRO][cPieza.PEON] | pos.PiezasColor(cColor.BLANCO, cPieza.PEON, cPieza.REY)),
~(eval.m_Ataques[cColor.BLANCO][cPieza.PEON] | pos.PiezasColor(cColor.NEGRO, cPieza.PEON, cPieza.REY)) };
nPuntos += EvalPiezas(pos, eval, movilidad, areaMovilidad, cPieza.CABALLO, cColor.BLANCO);
nPuntos += cEval.SetPesos(movilidad[cColor.BLANCO] - movilidad[cColor.NEGRO], m_Pesos[cEvalPesos.MOVILIDAD]);
nPuntos += EvalRey(pos, eval, cColor.BLANCO) - EvalRey(pos, eval, cColor.NEGRO);
nPuntos += EvalAmenazas(pos, eval, cColor.BLANCO) - EvalAmenazas(pos, eval, cColor.NEGRO);
nPuntos += EvalPeonesPasados(pos, eval, cColor.BLANCO) - EvalPeonesPasados(pos, eval, cColor.NEGRO);
if (0 == pos.MaterialPieza(cColor.BLANCO) || 0 == pos.MaterialPieza(cColor.NEGRO))
nPuntos += EvalPeonImparable(pos, cColor.BLANCO, eval) - EvalPeonImparable(pos, cColor.NEGRO, eval);
if (eval.m_Material.Peso() != 0)
{
int s = EvalEspacio(pos, eval, cColor.BLANCO) - EvalEspacio(pos, eval, cColor.NEGRO);
nPuntos += cEval.SetPesos(s * eval.m_Material.Peso(), m_Pesos[cEvalPesos.ESPACIO]);
}
factor sf = cTypes.GetFinalJuego(nPuntos) > cValoresJuego.TABLAS ? eval.m_Material.FactorDeEscala(pos, cColor.BLANCO)
: eval.m_Material.FactorDeEscala(pos, cColor.NEGRO);
if (eval.m_Material.Fase() < cFaseJuego.MEDIO_JUEGO
&& pos.AlfilesOpuestos()
&& (sf == cFactorEscala.NORMAL || sf == cFactorEscala.PEON))
{
if (pos.MaterialPieza(cColor.BLANCO) == cValoresJuego.ALFIL_MJ
&& pos.MaterialPieza(cColor.NEGRO) == cValoresJuego.ALFIL_MJ)
{
bool one_pawn = (pos.GetNum(cColor.BLANCO, cPieza.PEON) + pos.GetNum(cColor.NEGRO, cPieza.PEON) == 1);
sf = one_pawn ? (8) : (32);
}
else
sf = (50 * sf / cFactorEscala.NORMAL);
}
val v = cTypes.GetMedioJuego(nPuntos) * (eval.m_Material.Fase())
+ cTypes.GetFinalJuego(nPuntos) * (cFaseJuego.MEDIO_JUEGO - eval.m_Material.Fase()) * sf / cFactorEscala.NORMAL;
v /= (cFaseJuego.MEDIO_JUEGO);
return pos.ColorMueve() == cColor.BLANCO ? v : -v;
}
//----------------------------------------------------------------------------------------
public static int Enroques(cPosicion pos, cMov[] mlist, int mPos, color us, cInfoJaque ci, enroque Cr, bool Checks, bool Chess960)
{
bool KingSide = (Cr==cEnroque.OO_BLANCAS||Cr==cEnroque.OO_NEGRAS);
if(pos.CanNotEnroque(Cr)||0==pos.PosibleEnrocar(Cr))
return mPos;
sq kfrom = pos.GetRey(us);
sq rfrom = pos.CasillaTorreEnroque(Cr);
sq kto = cTypes.CasillaProxima(us, KingSide ? cCasilla.G1 : cCasilla.C1);
bitbrd enemies = pos.PiezasColor(cTypes.Contrario(us));
sq K = Chess960 ? kto>kfrom ? cCasilla.OESTE : cCasilla.ESTE : KingSide ? cCasilla.OESTE : cCasilla.ESTE;
for(sq s = kto; s!=kfrom; s+=K)
if((pos.AtaquesA(s)&enemies)!=0)
return mPos;
if(Chess960&&(cBitBoard.AtaquesPieza(kto, pos.Piezas()^cBitBoard.m_nCasillas[rfrom], cPieza.TORRE)&pos.PiezasColor(cTypes.Contrario(us), cPieza.TORRE, cPieza.DAMA))!=0)
return mPos;
mov m = cTypes.CreaMov(kfrom, rfrom, cMovType.ENROQUE, cPieza.CABALLO);
if(Checks&&!pos.IsJaque(m, ci))
return mPos;
mlist[mPos++].m=m;
return mPos;
}
//----------------------------------------------------------------------------------------
public static int Peones(cPosicion pos, cMov[] mlist, int mPos, bitbrd target, cInfoJaque ci, color colr, type Type)
{
color colorVS = (colr==cColor.BLANCO ? cColor.NEGRO : cColor.BLANCO);
bitbrd TRank8BB = (colr==cColor.BLANCO ? cBitBoard.F8 : cBitBoard.F1);
bitbrd TRank7BB = (colr==cColor.BLANCO ? cBitBoard.F7 : cBitBoard.F2);
bitbrd TRank3BB = (colr==cColor.BLANCO ? cBitBoard.F3 : cBitBoard.F6);
sq Up = (colr==cColor.BLANCO ? cCasilla.NORTE : cCasilla.SUR);
sq Right = (colr==cColor.BLANCO ? cCasilla.NORTE_ESTE : cCasilla.SUR_OESTE);
sq Left = (colr==cColor.BLANCO ? cCasilla.NORTE_OESTE : cCasilla.SUR_ESTE);
bitbrd b1, b2, dc1, dc2, emptySquares = 0;
bitbrd pawnsOn7 = pos.PiezasColor(colr, cPieza.PEON)&TRank7BB;
bitbrd pawnsNotOn7 = pos.PiezasColor(colr, cPieza.PEON)&~TRank7BB;
bitbrd enemies = (Type==cMovType.EVASIONS ? pos.PiezasColor(colorVS)&target :
Type==cMovType.CAPTURES ? target : pos.PiezasColor(colorVS));
if(Type!=cMovType.CAPTURES)
{
emptySquares=(Type==cMovType.QUIETS||Type==cMovType.QUIET_CHECKS ? target : ~pos.Piezas());
b1=cBitBoard.Desplazamiento(pawnsNotOn7, Up)&emptySquares;
b2=cBitBoard.Desplazamiento(b1&TRank3BB, Up)&emptySquares;
if(Type==cMovType.EVASIONS)
{
b1&=target;
b2&=target;
}
if(Type==cMovType.QUIET_CHECKS)
{
b1&=pos.AtaquesDePeon(ci.m_SqRey, colorVS);
b2&=pos.AtaquesDePeon(ci.m_SqRey, colorVS);
if((pawnsNotOn7&ci.m_Candidatas)!=0)
{
dc1=cBitBoard.Desplazamiento(pawnsNotOn7&ci.m_Candidatas, Up)&emptySquares&~cBitBoard.GetColumnaSq(ci.m_SqRey);
dc2=cBitBoard.Desplazamiento(dc1&TRank3BB, Up)&emptySquares;
b1|=dc1;
b2|=dc2;
}
}
while(b1!=0)
{
sq to = cBitBoard.GetLSB(ref b1);
mlist[mPos++].m=cTypes.CreaMov(to-Up, to);
}
while(b2!=0)
{
sq to = cBitBoard.GetLSB(ref b2);
mlist[mPos++].m=cTypes.CreaMov(to-Up-Up, to);
}
}
if(pawnsOn7!=0&&(Type!=cMovType.EVASIONS||(target&TRank8BB)!=0))
{
if(Type==cMovType.CAPTURES)
emptySquares=~pos.Piezas();
if(Type==cMovType.EVASIONS)
emptySquares&=target;
mPos=Promocion(mlist, mPos, pawnsOn7, enemies, ci, Type, Right);
mPos=Promocion(mlist, mPos, pawnsOn7, enemies, ci, Type, Left);
mPos=Promocion(mlist, mPos, pawnsOn7, emptySquares, ci, Type, Up);
}
if(Type==cMovType.CAPTURES||Type==cMovType.EVASIONS||Type==cMovType.NON_EVASIONS)
{
b1=cBitBoard.Desplazamiento(pawnsNotOn7, Right)&enemies;
b2=cBitBoard.Desplazamiento(pawnsNotOn7, Left)&enemies;
while(b1!=0)
{
sq to = cBitBoard.GetLSB(ref b1);
mlist[mPos++].m=cTypes.CreaMov(to-Right, to);
}
while(b2!=0)
{
sq to = cBitBoard.GetLSB(ref b2);
mlist[mPos++].m=cTypes.CreaMov(to-Left, to);
}
if(pos.CasillaEnPaso()!=cCasilla.NONE)
{
if(Type==cMovType.EVASIONS&&(target&cBitBoard.m_nCasillas[(pos.CasillaEnPaso()-Up)])==0)
return mPos;
b1=pawnsNotOn7&pos.AtaquesDePeon(pos.CasillaEnPaso(), colorVS);
while(b1!=0)
mlist[mPos++].m=cTypes.CreaMov(cBitBoard.GetLSB(ref b1), pos.CasillaEnPaso(), cMovType.ENPASO, cPieza.CABALLO);
}
}
return mPos;
}
//----------------------------------------------------------------------------------------
public static int Evasiones(cPosicion pos, cMov[] mlist, int mPos)
{
color us = pos.ColorMueve();
sq ksq = pos.GetRey(us);
bitbrd sliderAttacks = 0;
bitbrd sliders = pos.Jaques()&~pos.GetNumPiezas(cPieza.CABALLO, cPieza.PEON);
while(sliders!=0)
{
sq checksq = cBitBoard.GetLSB(ref sliders);
sliderAttacks|=cBitBoard.m_EnLinea[checksq][ksq]^cBitBoard.m_nCasillas[checksq];
}
bitbrd b = pos.attacks_from_square_piecetype(ksq, cPieza.REY)&~pos.PiezasColor(us)&~sliderAttacks;
while(b!=0)
mlist[mPos++].m=cTypes.CreaMov(ksq, cBitBoard.GetLSB(ref b));
if(cBitBoard.MayorQue(pos.Jaques()))
return mPos;
sq checksq2 = cBitBoard.LSB(pos.Jaques());
bitbrd target = cBitBoard.Entre(checksq2, ksq)|cBitBoard.m_nCasillas[checksq2];
return us==cColor.BLANCO ? ToDO(pos, mlist, mPos, target, cColor.BLANCO, cMovType.EVASIONS, null) :
ToDO(pos, mlist, mPos, target, cColor.NEGRO, cMovType.EVASIONS, null);
}