Well , Isa , my chess engine is a (weak) classical mailbox engine
It has hashtables, quiescence (MVV LVA) and pvs with nullmove and LMR
Yesterday I decided to apply the henk's idea in Isa , just to see
(henk's idea is : only material in eval )
Here is the result from the start position (tc = 5'+1"):
Code: Select all
1 0 20 0 a2a3
2 0 63 0 a2a3 b8a6
3 0 527 0 a2a3 b8a6 a3a4
4 0 1142 0 a2a3 b8a6 a3a4 a8b8
5 0 1953 0 a2a3 b8a6 a3a4 a8b8 a4a5
6 0 2563 0 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4
7 0 5166 0 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3
8 0 13827 0 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5
9 0 25079 0 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5 a1a2
10 0 42608 0 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5 a1a2 g8h6
11 0 72171 0 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5 a1a2 g8h6 f2f3
12 0 180827 1 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5 a1a2 g8h6 f2f3 b8a8
13 0 283651 3 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5 a1a2 g8h6 f2f3 b8a8 g2g3
14 0 504724 5 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5 a1a2 g8h6 f2f3 b8a8 g2g3 f7f6
15 0 1480829 14 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5 a1a2 g8h6 f2f3 b8a8 g2g3 f7f6 d2d4
16 0 2071862 24 a2a3 b8a6 a3a4 a8b8 a4a5 a6b4 b2b3 b4d5 a1a2 g8h6 f2f3 b8a8 g2g3 f7f6 d2d4 g7g6
Now I just added some pst (for all pieces) in Isa :
Code: Select all
1 50 20 0 b1c3
2 0 60 0 b1c3 b8c6
3 50 534 0 b1c3 b8c6 g1f3
4 0 1270 0 b1c3 b8c6 g1f3 g8f6
5 40 1842 0 b1c3 b8c6 g1f3 g8f6 d2d4
6 0 6588 0 b1c3 b8c6 g1f3 g8f6 d2d4 d7d5
7 20 12428 0 b1c3 b8c6 g1f3 g8f6 d2d4 d7d5 e2e3
8 10 104642 1 e2e4 b8c6 g1f3 g8f6 e4e5 f6e4 d2d3 e4c5
9 20 165613 2 e2e4 b8c6 b1c3 g8f6 g1f3 d7d5 e4d5
10 15 642893 7 e2e4 e7e5 b1c3 b8c6 g1f3 g8f6 d2d4 f8b4 c1g5 b4c3 b2c3
11 15 843620 13 e2e4 e7e5 b1c3 g8f6 g1f3 f8b4 f3e5 d7d6 e5c4 b4c3 d2c3 f6e4
12 10 3363525 39 e2e4 e7e5 b1c3 g8f6 g1f3 b8c6 d2d4 f8b4 d4d5 b4c3
And look at the pv's :
-at depth 9 pv have 7moves
-at depth 12 pv have 10 moves
I don't think it's very logic
I read in the forum " The PV line must be superior or equal to the depth"
Now I'm lost ...
So , I decided to post my horrible PVS function :
Code: Select all
//----------------------------------------------------------------------------------------------------------------
// alpha beta + PVS
//----------------------------------------------------------------------------------------------------------------
int pvs(int alpha, int beta, int depth, MOVE * pBestMove, bool nulmove)
{
int i,j;
int value;
int havemove;
int movecnt;
int hashf = hashfALPHA;
int rep;
bool echec = FAUX;
bool echec2 = FAUX;
bool ext = FAUX;
int ply = 0;
MOVE moveBuf[200];
MOVE tmpMove;
//-----------------------------------------------------------------
// controle temps depasse ou non (jeu au temps)
//-----------------------------------------------------------------
fin_recherche = controle_si_temps_depasse();
if(fin_recherche)
return 0;
//-----------------------------------------------------------------
// longueur pv
//-----------------------------------------------------------------
long_pv[prof] = prof;
//-----------------------------------------------------------------
// profondeur limite ateinte : retourne eval()
//-----------------------------------------------------------------
if(prof >= MAXPLY-1)
return eval();
//-----------------------------------------------------------------
// nulle règle des 50 coups? ?
//-----------------------------------------------------------------
if(cinquante == 100)
{
return 0;
}
//-----------------------------------------------------------------
// nulle règle des triples répétitions ?
//-----------------------------------------------------------------
rep = triple_repetition();
if(prof && rep)
{
return 0;
}
//-----------------------------------------------------------------
// position dans la table de hashage ?
//-----------------------------------------------------------------
if(hash_ok)
{
if(prof)
{
value = probe_hash(depth, alpha, beta);
if(value != valINCONNUE)
{
return value;
}
}
}
//-----------------------------------------------------------------
// on ateint la profondeur en cours , on lance le quiescent search
//-----------------------------------------------------------------
if(depth <= 0)
{
value = quiesce(alpha, beta, &tmpMove);
return value;
}
//-----------------------------------------------------------------
// extension d'une profondeur si la couleur en cours est en échec
//-----------------------------------------------------------------
echec = roi_attaque(pos_roi[side], side);
if(echec)
{
depth++;
}
//-----------------------------------------------------------------
// test si on peut lancer le nulmove
// conditions : pas de finale de pion
// pas en échec
// profondeur > 4
//-----------------------------------------------------------------
if(nm_ok)
{
if((!echec) && (ok_pour_nul_move()) && (depth >= 2) && (nulmove) && (!follow_pv))
{
++ctr_nm;
jouer_coup_nul();
nodes++;
value = -pvs(-beta, -(beta-1), depth - NULL_DEPTH - 1, &tmpMove, NO_NULL);
dejouer_coup_nul();
if (value >= beta)
{
return beta;
}
}
}
//-----------------------------------------------------------------
// init du pointeur et flag "au moins un coup jouable"
//-----------------------------------------------------------------
havemove = 0;
pBestMove->type = COUP_VIDE;
//-----------------------------------------------------------------
// génération des coups pseudo-légaux
//-----------------------------------------------------------------
movecnt = gen_coups(side, moveBuf);
if(follow_pv)
tri_pv(moveBuf, movecnt);
//-----------------------------------------------------------------
// boucle coups normaux
//-----------------------------------------------------------------
for (i = 0; i < movecnt; ++i)
{
ext = FAUX;
meilleur_coup_suivant(moveBuf, movecnt, i);
if (jouer_coup(moveBuf[i]))
{
continue;
}
havemove++;
nodes++;
//extension si pion avance a la 7eme rangée (et coup non réduit lmr)
if(moveBuf[i].piece_from == PION && (ROW(moveBuf[i].dest) <= 1 || ROW(moveBuf[i].dest) >= 6))
{
ext = VRAI;
}
if(havemove == 1)
{
value = -pvs(-beta, -alpha, depth - 1, &tmpMove, OK_NULL);
}
else
{
//------------------------------------------------------
// lmr possible?
//------------------------------------------------------
echec2 = roi_attaque(pos_roi[side], side);
if(lmr_ok)
{
if((prof >= START_PROF) && (!echec) && (!echec2) && (!ext) &&
(!follow_pv) && (moveBuf[i].type == NORMAL))
{
if(havemove > 5)
value = -pvs(-(alpha+1), -alpha, (depth - 2) , &tmpMove, OK_NULL);
else
value = -pvs(-(alpha+1), -alpha, (depth - 1) , &tmpMove, OK_NULL);
}
else
{
value = alpha + 1;
}
if(value > alpha)
{
++ctr_pvs;
value = -pvs(-(alpha+1), -alpha, depth - 1, &tmpMove, NO_NULL);
if(value > alpha && value < beta)
{
value = -pvs(-beta, -alpha, depth - 1, &tmpMove, OK_NULL);
}
}
}
else
{
++ctr_pvs;
value = -pvs(-(alpha+1), -alpha, depth - 1, &tmpMove, NO_NULL);
if(value > alpha && value < beta)
{
value = -pvs(-beta, -alpha, depth - 1, &tmpMove, OK_NULL);
}
}
}
dejouer_coup();
if (value > alpha)
{
history[moveBuf[i].from][moveBuf[i].dest] += (prof * prof);
if(history[moveBuf[i].from][moveBuf[i].dest] >= 999999)
history[moveBuf[i].from][moveBuf[i].dest] = 999999;
if(max_hh < history[moveBuf[i].from][moveBuf[i].dest])
{
max_hh = history[moveBuf[i].from][moveBuf[i].dest];
}
*pBestMove = moveBuf[i];
if (value >= beta) //" cutoff "
{
save_hash(depth, beta, hashfBETA, pBestMove);
if(moveBuf[i].type < PROMO_CAVALIER)
{
killer2[prof] = killer1[prof];
killer1[prof] = moveBuf[i];
}
return beta;
}
hashf = hashfEXACT;
alpha = value;
//-----------------------------------------------------------------
// mise a jour pv
//-----------------------------------------------------------------
pv[prof][prof] = *pBestMove;
for (j = prof + 1; j < long_pv[prof + 1]; ++j)
{
pv[prof][j] = pv[prof + 1][j];
}
long_pv[prof] = long_pv[prof + 1];
}
}
//-----------------------------------------------------------------
// si aucun coups , situation de MAT ou de PAT
//-----------------------------------------------------------------
if (!havemove)
{
if (roi_attaque(pos_roi[side], side))
{
save_hash(depth, -MATE + prof, hashf, pBestMove);
return -MATE + prof;
}
else
{
save_hash(depth, 0, hashf, pBestMove);
return 0;
}
}
save_hash(depth, alpha, hashf, pBestMove);
return alpha;
}
bests
dany
