//-----------------------------------------------------------------------------------------------
public factor KRPKB(cPosicion pos)
{
if ((pos.GetNumPiezas(cPieza.PEON) & (cBitBoard.A | cBitBoard.H)) != 0)
{
sq ksq = pos.GetRey(m_cDebil);
sq bsq = pos.GetList(m_cDebil, cPieza.ALFIL)[0];
sq nCasillaPeon = pos.GetList(m_cFuerte, cPieza.PEON)[0];
fila rk = cTypes.FilaProxima(m_cFuerte, nCasillaPeon);
sq push = cTypes.AtaquePeon(m_cFuerte);
if (rk == FILA.F5 && !cTypes.IsColorContrario(bsq, nCasillaPeon))
{
int d = cBitBoard.Distancia(nCasillaPeon + 3 * push, ksq);
if (d <= 2 && !(d == 0 && ksq == pos.GetRey(m_cFuerte) + 2 * push))
return (24);
else
return (48);
}
if (rk == FILA.F6
&& cBitBoard.Distancia(nCasillaPeon + 2 * push, ksq) <= 1
&& (cBitBoard.m_PseudoAtaques[cPieza.ALFIL][bsq] & cBitBoard.m_nCasillas[(nCasillaPeon + push)]) != 0
&& cBitBoard.ColumDistancia(bsq, nCasillaPeon) >= 2)
return (8);
}
return cFactorEscala.NAN;
}
//-----------------------------------------------------------------------------------------------
public val KRKN(cPosicion pos)
{
sq nCasillaReyNegro = pos.GetRey(m_cDebil);
sq nCasillaCaballo = pos.GetList(m_cDebil, cPieza.CABALLO)[0];
val result = (m_lstValorBorde[nCasillaReyNegro] + m_lstValorLejania[cBitBoard.Distancia(nCasillaReyNegro, nCasillaCaballo)]);
return m_cFuerte == pos.ColorMueve() ? result : -result;
}
//-----------------------------------------------------------------------------------------------
public val KRKP(cPosicion pos)
{
val result = 0;
sq nCasillaReyBlanco = cTypes.CasillaProxima(m_cFuerte, pos.GetRey(m_cFuerte));
sq nCasillaReyNegro = cTypes.CasillaProxima(m_cFuerte, pos.GetRey(m_cDebil));
sq nCasillaTorre = cTypes.CasillaProxima(m_cFuerte, pos.GetList(m_cFuerte, cPieza.TORRE)[0]);
sq nCasillaPeon = cTypes.CasillaProxima(m_cFuerte, pos.GetList(m_cDebil, cPieza.PEON)[0]);
sq nCasillaCoronacion = cTypes.CreaCasilla(cTypes.Columna(nCasillaPeon), FILA.F1);
if (nCasillaReyBlanco < nCasillaPeon && cTypes.Columna(nCasillaReyBlanco) == cTypes.Columna(nCasillaPeon))
result = cValoresJuego.TORRE_FINAL - (cBitBoard.Distancia(nCasillaReyBlanco, nCasillaPeon));
else if (cBitBoard.Distancia(nCasillaReyNegro, nCasillaPeon) >= 3 + ((pos.ColorMueve() == m_cDebil) ? 1 : 0)
&& cBitBoard.Distancia(nCasillaReyNegro, nCasillaTorre) >= 3)
result = cValoresJuego.TORRE_FINAL - (cBitBoard.Distancia(nCasillaReyBlanco, nCasillaPeon));
else if (cTypes.Fila(nCasillaReyNegro) <= FILA.F3
&& cBitBoard.Distancia(nCasillaReyNegro, nCasillaPeon) == 1
&& cTypes.Fila(nCasillaReyBlanco) >= FILA.F4
&& cBitBoard.Distancia(nCasillaReyBlanco, nCasillaPeon) > 2 + ((pos.ColorMueve() == m_cFuerte) ? 1 : 0))
result = 80 - 8 * cBitBoard.Distancia(nCasillaReyBlanco, nCasillaPeon);
else
result = (val)(200) - 8 * (cBitBoard.Distancia(nCasillaReyBlanco, nCasillaPeon + cCasilla.SUR)
- cBitBoard.Distancia(nCasillaReyNegro, nCasillaPeon + cCasilla.SUR)
- cBitBoard.Distancia(nCasillaPeon, nCasillaCoronacion));
return m_cFuerte == pos.ColorMueve() ? result : -result;
}
//-----------------------------------------------------------------------------------------------
public val KQKP(cPosicion pos)
{
sq nCasillaReyGanador = pos.GetRey(m_cFuerte);
sq nCasillaReyPerdedor = pos.GetRey(m_cDebil);
sq nCasillaPeon = pos.GetList(m_cDebil, cPieza.PEON)[0];
val result = (m_lstValorCerrado[cBitBoard.Distancia(nCasillaReyGanador, nCasillaReyPerdedor)]);
if (cTypes.FilaProxima(m_cDebil, nCasillaPeon) != FILA.F7 || cBitBoard.Distancia(nCasillaReyPerdedor, nCasillaPeon) != 1
|| 0 == ((cBitBoard.A | cBitBoard.C | cBitBoard.F | cBitBoard.H) & cBitBoard.m_nCasillas[nCasillaPeon]))
result += cValoresJuego.DAMA_FINAL - cValoresJuego.PEON_FINAL;
return m_cFuerte == pos.ColorMueve() ? result : -result;
}
//-----------------------------------------------------------------------------------------------
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 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 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 KNPK(cPosicion pos)
{
sq sqPeon = Normalizar(pos, m_cFuerte, pos.GetList(m_cFuerte, cPieza.PEON)[0]);
sq weakKingSq = Normalizar(pos, m_cFuerte, pos.GetRey(m_cDebil));
if (sqPeon == cCasilla.A7 && cBitBoard.Distancia(cCasilla.A8, weakKingSq) <= 1)
return cFactorEscala.TABLAS;
return cFactorEscala.NAN;
}
//-----------------------------------------------------------------------------------------------
public factor KBPKN(cPosicion pos)
{
sq sqPeon = pos.GetList(m_cFuerte, cPieza.PEON)[0];
sq strongerBishonCasillaPeon = pos.GetList(m_cFuerte, 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;
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 bool SetConjuntoPiezasPosicion(cPosicion pos)
{
whitePieceSquares.Clear();
whiteTypesSquares.Clear();
blackPieceSquares.Clear();
blackTypesSquares.Clear();
for(type pt = cPieza.PEON; pt<=cPieza.REY; ++pt)
{
for(int i = 0; i<pos.GetNum(cColor.BLANCO, pt); i++)
{
whitePieceSquares.Add(pos.GetList(cColor.BLANCO, pt)[i]);
whiteTypesSquares.Add(pt);
}
for(int i = 0; i<pos.GetNum(cColor.NEGRO, pt); i++)
{
blackPieceSquares.Add(pos.GetList(cColor.NEGRO, pt)[i]);
blackTypesSquares.Add(pt);
}
}
enPassantSquare=pos.CasillaEnPaso();
whosTurn=pos.ColorMueve();
return true;
}
//-----------------------------------------------------------------------------------------------
public sq Normalizar(cPosicion posicion, color fuerte, sq escaque)
{
if (cTypes.Columna(posicion.GetList(fuerte, cPieza.PEON)[0]) >= COLUMNA.E)
escaque = (sq)(escaque ^ 7);
if (fuerte == cColor.NEGRO)
escaque = cTypes.CasillaVS(escaque);
return escaque;
}
//-----------------------------------------------------------------------------------------------
public factor KRPKR(cPosicion pos)
{
sq nCasillaReyBlanco = Normalizar(pos, m_cFuerte, pos.GetRey(m_cFuerte));
sq nCasillaReyNegro = Normalizar(pos, m_cFuerte, pos.GetRey(m_cDebil));
sq wnCasillaTorre = Normalizar(pos, m_cFuerte, pos.GetList(m_cFuerte, cPieza.TORRE)[0]);
sq wnCasillaPeon = Normalizar(pos, m_cFuerte, pos.GetList(m_cFuerte, cPieza.PEON)[0]);
sq bnCasillaTorre = Normalizar(pos, m_cFuerte, pos.GetList(m_cDebil, cPieza.TORRE)[0]);
colum f = cTypes.Columna(wnCasillaPeon);
fila r = cTypes.Fila(wnCasillaPeon);
sq queeningSq = cTypes.CreaCasilla(f, FILA.F8);
int tempo = (pos.ColorMueve() == m_cFuerte ? 1 : 0);
if (r <= FILA.F5 && cBitBoard.Distancia(nCasillaReyNegro, queeningSq) <= 1
&& nCasillaReyBlanco <= cCasilla.H5 && (cTypes.Fila(bnCasillaTorre) == FILA.F6 || (r <= FILA.F3 && cTypes.Fila(wnCasillaTorre) != FILA.F6)))
return cFactorEscala.TABLAS;
if (r == FILA.F6 && cBitBoard.Distancia(nCasillaReyNegro, queeningSq) <= 1
&& cTypes.Fila(nCasillaReyBlanco) + tempo <= FILA.F6 && (cTypes.Fila(bnCasillaTorre) == FILA.F1 || (0 == tempo && Math.Abs(cTypes.Columna(bnCasillaTorre) - f) >= 3)))
return cFactorEscala.TABLAS;
if (r >= FILA.F6 && nCasillaReyNegro == queeningSq
&& cTypes.Fila(bnCasillaTorre) == FILA.F1
&& (0 == tempo || cBitBoard.Distancia(nCasillaReyBlanco, wnCasillaPeon) >= 2))
return cFactorEscala.TABLAS;
if (wnCasillaPeon == cCasilla.A7 && wnCasillaTorre == cCasilla.A8
&& (nCasillaReyNegro == cCasilla.H7 || nCasillaReyNegro == cCasilla.G7)
&& cTypes.Columna(bnCasillaTorre) == COLUMNA.A
&& (cTypes.Fila(bnCasillaTorre) <= FILA.F3 || cTypes.Columna(nCasillaReyBlanco) >= COLUMNA.D || cTypes.Fila(nCasillaReyBlanco) <= FILA.F5))
return cFactorEscala.TABLAS;
if (r <= FILA.F5 && nCasillaReyNegro == wnCasillaPeon + cCasilla.NORTE
&& cBitBoard.Distancia(nCasillaReyBlanco, wnCasillaPeon) - tempo >= 2
&& cBitBoard.Distancia(nCasillaReyBlanco, bnCasillaTorre) - tempo >= 2)
return cFactorEscala.TABLAS;
if (r == FILA.F7 && f != COLUMNA.A
&& cTypes.Columna(wnCasillaTorre) == f
&& wnCasillaTorre != queeningSq
&& (cBitBoard.Distancia(nCasillaReyBlanco, queeningSq) < cBitBoard.Distancia(nCasillaReyNegro, queeningSq) - 2 + tempo)
&& (cBitBoard.Distancia(nCasillaReyBlanco, queeningSq) < cBitBoard.Distancia(nCasillaReyNegro, wnCasillaTorre) + tempo))
return (factor)(cFactorEscala.MAXIMO - 2 * cBitBoard.Distancia(nCasillaReyBlanco, queeningSq));
if (f != COLUMNA.A && cTypes.Columna(wnCasillaTorre) == f
&& wnCasillaTorre < wnCasillaPeon
&& (cBitBoard.Distancia(nCasillaReyBlanco, queeningSq) < cBitBoard.Distancia(nCasillaReyNegro, queeningSq) - 2 + tempo)
&& (cBitBoard.Distancia(nCasillaReyBlanco, wnCasillaPeon + cCasilla.NORTE) < cBitBoard.Distancia(nCasillaReyNegro, wnCasillaPeon + cCasilla.NORTE) - 2 + tempo)
&& (cBitBoard.Distancia(nCasillaReyNegro, wnCasillaTorre) + tempo >= 3
|| (cBitBoard.Distancia(nCasillaReyBlanco, queeningSq) < cBitBoard.Distancia(nCasillaReyNegro, wnCasillaTorre) + tempo
&& (cBitBoard.Distancia(nCasillaReyBlanco, wnCasillaPeon + cCasilla.NORTE) < cBitBoard.Distancia(nCasillaReyNegro, wnCasillaTorre) + tempo))))
return (factor)(cFactorEscala.MAXIMO
- 8 * cBitBoard.Distancia(wnCasillaPeon, queeningSq)
- 2 * cBitBoard.Distancia(nCasillaReyBlanco, queeningSq));
if (r <= FILA.F4 && nCasillaReyNegro > wnCasillaPeon)
{
if (cTypes.Columna(nCasillaReyNegro) == cTypes.Columna(wnCasillaPeon))
return 10;
if (Math.Abs(cTypes.Columna(nCasillaReyNegro) - cTypes.Columna(wnCasillaPeon)) == 1
&& cBitBoard.Distancia(nCasillaReyBlanco, nCasillaReyNegro) > 2)
return (24 - 2 * cBitBoard.Distancia(nCasillaReyBlanco, nCasillaReyNegro));
}
return cFactorEscala.NAN;
}
//-----------------------------------------------------------------------------------------------
public factor KNPKB(cPosicion pos)
{
sq sqPeon = pos.GetList(m_cFuerte, cPieza.PEON)[0];
sq alfilCasillaPeon = pos.GetList(m_cDebil, cPieza.ALFIL)[0];
sq weakerKingSq = pos.GetRey(m_cDebil);
if ((cBitBoard.Atras(m_cFuerte, sqPeon) & pos.attacks_from_square_piecetype(alfilCasillaPeon, cPieza.ALFIL)) != 0)
return cBitBoard.Distancia(weakerKingSq, sqPeon);
return cFactorEscala.NAN;
}
//-----------------------------------------------------------------------------------------------
public factor KRPPKRP(cPosicion pos)
{
sq wnCasillaPeon1 = pos.GetList(m_cFuerte, cPieza.PEON)[0];
sq wnCasillaPeon2 = pos.GetList(m_cFuerte, cPieza.PEON)[1];
sq nCasillaReyNegro = pos.GetRey(m_cDebil);
if (pos.IsPeonPasado(m_cFuerte, wnCasillaPeon1) || pos.IsPeonPasado(m_cFuerte, wnCasillaPeon2))
return cFactorEscala.NAN;
fila r = Math.Max(cTypes.FilaProxima(m_cFuerte, wnCasillaPeon1), cTypes.FilaProxima(m_cFuerte, wnCasillaPeon2));
if (cBitBoard.ColumDistancia(nCasillaReyNegro, wnCasillaPeon1) <= 1
&& cBitBoard.ColumDistancia(nCasillaReyNegro, wnCasillaPeon2) <= 1
&& cTypes.FilaProxima(m_cFuerte, nCasillaReyNegro) > r)
{
switch (r)
{
case FILA.F2: return (10);
case FILA.F3: return (10);
case FILA.F4: return (15);
case FILA.F5: return (20);
case FILA.F6: return (40);
default: break;
}
}
return cFactorEscala.NAN;
}
//----------------------------------------------------------------------------------------
public static int Piezas(cPosicion pos, cMov[] mlist, int mPos, color us, bitbrd target, cInfoJaque ci, type Pt, bool Checks)
{
sq[] pieceList = pos.GetList(us, Pt);
int pl = 0;
for(sq from = pieceList[pl]; from!=cCasilla.NONE; from=pieceList[++pl])
{
if(Checks)
{
if((Pt==cPieza.ALFIL||Pt==cPieza.TORRE||Pt==cPieza.DAMA)
&&0==(cBitBoard.m_PseudoAtaques[Pt][from]&target&ci.m_Jaque[Pt]))
continue;
if(ci.m_Candidatas!=0&&(ci.m_Candidatas&cBitBoard.m_nCasillas[from])!=0)
continue;
}
bitbrd b = pos.attacks_from_square_piecetype(from, Pt)⌖
if(Checks)
b&=ci.m_Jaque[Pt];
while(b!=0)
mlist[mPos++].m=cTypes.CreaMov(from, cBitBoard.GetLSB(ref b));
}
return mPos;
}
