Source Code Ippolit

[Shadowrun]

Hombre, ese código que has puesto no es ningún lenguaje de programacion. :))

Deben ser palabras en inglés tipo "for" … "if"

[lforos]

@Shadowrun:

Hombre, ese código que has puesto no es ningún lenguaje de programacion.

Es que estos rusos son muy suyos …

[jordiqui]

Hola
Link del site. Traducido al inglés. Se puede descargar el cçodigo fuente. IPPOLIT - IPPOLIT.C

[jordiqui]

code

#define wOutpost 0x00007e7e7e000000
#define bOutpost 0x0000007e7e7e0000

#define Bitboard2(x,y) (((uint64) 1)<<(x))|(((uint64) 1)<<(y))
static const uint64 RookTrapped[64] =
{ 0, Bitboard2 (A1, A2), Bitboard2 (A1, A2) | Bitboard2 (B1, B2), 0,
0, Bitboard2 (H1, H2) | Bitboard2 (G1, G2), Bitboard2 (H1, H2), 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, Bitboard2 (A8, A7), Bitboard2 (A8, A7) | Bitboard2 (B8, B7), 0,
0, Bitboard2 (H8, H7) | Bitboard2 (G8, G7), Bitboard2 (H8, H7), 0
};

#define SCORE(x,y) (( (x) << 16) + (y))

#define PawnAntiMobility SCORE(3, 10)
#define MobQ(Y) SCORE(2, 2) * POPCNT(Y)
#define MobB(Y, Z) SCORE (5, 5) * POPCNT( Y & Z)
#define MobR(Y) SCORE(2, 3) * POPCNT(Y)
#define MobN(Y, Z) SCORE (6, * POPCNT(Y & Z)

#define xrayB0 SCORE(0, 0)
#define xrayBmP SCORE(3, 5)
#define xrayBmN SCORE(3, 5)
#define xrayBmK SCORE(3, 5)
#define xrayBmB SCORE(0, 0)
#define xrayBmR SCORE(3, 5)
#define xrayBmQ SCORE(0, 0)

#define xrayBoP SCORE(2, 5)
#define xrayBoN SCORE(2, 5)
#define xrayBoK SCORE(0, 0)
#define xrayBoB SCORE(0, 0)
#define xrayBoR SCORE(15, 25)
#define xrayBoQ SCORE(10, 20)

#define xrayR0 SCORE(0, 0)
#define xrayRmP SCORE(0, 0)
#define xrayRmN SCORE(3, 5)
#define xrayRmK SCORE(3, 5)
#define xrayRmB SCORE(3, 5)
#define xrayRmR SCORE(0, 0)
#define xrayRmQ SCORE(0, 0)

#define xrayRoP SCORE(2, 5)
#define xrayRoN SCORE(2, 5)
#define xrayRoK SCORE(0, 0)
#define xrayRoB SCORE(2, 5)
#define xrayRoR SCORE(0, 0)
#define xrayRoQ SCORE(10, 20)

static const uint32 wBxray[16] =
{ xrayB0, xrayBmP, xrayBmN, xrayBmK, xrayBmB, xrayBmB, xrayBmR, xrayBmQ,
xrayB0, xrayBoP, xrayBoN, xrayBoK, xrayBoB, xrayBoB, xrayBoR, xrayBoQ };

static const uint32 bBxray[16] =
{ xrayB0, xrayBoP, xrayBoN, xrayBoK, xrayBoB, xrayBoB, xrayBoR, xrayBoQ,
xrayB0, xrayBmP, xrayBmN, xrayBmK, xrayBmB, xrayBmB, xrayBmR, xrayBmQ };

static const uint32 wRxray[16] =
{ xrayR0, xrayRmP, xrayRmN, xrayRmK, xrayRmB, xrayRmB, xrayRmR, xrayRmQ,
xrayR0, xrayRoP, xrayRoN, xrayRoK, xrayRoB, xrayRoB, xrayRoR, xrayRoQ };

static const uint32 bRxray[16] =
{ xrayR0, xrayRoP, xrayRoN, xrayRoK, xrayRoB, xrayRoB, xrayRoR, xrayRoQ,
xrayR0, xrayRmP, xrayRmN, xrayRmK, xrayRmB, xrayRmB, xrayRmR, xrayRmQ };

#define xQ0d SCORE(0, 0)
#define xQmPd SCORE(1, 2)
#define xQmNd SCORE(2, 4)
#define xQmKd SCORE(2, 4)
#define xQmBd SCORE(0, 0)
#define xQmRd SCORE(2, 4)
#define xQmQd SCORE(0, 0)

#define xQoPd SCORE(0, 0)
#define xQoNd SCORE(2, 5)
#define xQoKd SCORE(0, 0)
#define xQoBd SCORE(0, 0)
#define xQoRd SCORE(2, 5)
#define xQoQd SCORE(0, 0)

#define xQ0hv SCORE(0, 0)
#define xQmPhv SCORE(0, 0)
#define xQmNhv SCORE(2, 4)
#define xQmKhv SCORE(2, 4)
#define xQmBhv SCORE(2, 4)
#define xQmRhv SCORE(0, 0)
#define xQmQhv SCORE(0, 0)

#define xQoPhv SCORE(0, 0)
#define xQoNhv SCORE(2, 5)
#define xQoKhv SCORE(0, 0)
#define xQoBhv SCORE(2, 5)
#define xQoRhv SCORE(0, 0)
#define xQoQhv SCORE(0, 0)

static const uint32 wQxrayD[16] =
{ xQ0d, xQmPd, xQmNd, xQmKd, xQmBd, xQmBd, xQmRd, xQmQd,
xQ0d, xQoPd, xQoNd, xQoKd, xQoBd, xQoBd, xQoRd, xQoQd };

static const uint32 bQxrayD[16] =
{ xQ0d, xQoPd, xQoNd, xQoKd, xQoBd, xQoBd, xQoRd, xQoQd,
xQ0d, xQmPd, xQmNd, xQmKd, xQmBd, xQmBd, xQmRd, xQmQd };

static const uint32 wQxrayO[16] =
{ xQ0hv, xQmPhv, xQmNhv, xQmKhv, xQmBhv, xQmBhv, xQmRhv, xQmQhv,
xQ0hv, xQoPhv, xQoNhv, xQoKhv, xQoBhv, xQoBhv, xQoRhv, xQoQhv };

static const uint32 bQxrayO[16] =
{ xQ0hv, xQoPhv, xQoNhv, xQoKhv, xQoBhv, xQoBhv, xQoRhv, xQoQhv,
xQ0hv, xQmPhv, xQmNhv, xQmKhv, xQmBhv, xQmBhv, xQmRhv, xQmQhv };

static const uint8 BishopTrapSq[64] =
{ 0x00, C2, 0x00, 0x00, 0x00, 0x00, F2, 0x00,
B3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, G3,
B4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, G4,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
B5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, G5,
B6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, G6,
0x00, C7, 0x00, 0x00, 0x00, 0x00, F7, 0x00 };

#define BishopTrapValue SCORE(40, 40)
#define BishopTrapGuardValu SCORE(40, 40)
static const uint8 GoodBishopTrapSq[64] =
{ 0x00, D1, 0x00, 0x00, 0x00, 0x00, E1, 0x00,
C2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, F2,
C3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, F3,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
C6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, F6,
C7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, F7,
0x00, D8, 0x00, 0x00, 0x00, 0x00, E8, 0x00 };

static const uint32 PassedPawnMeClear[8] =
{ 0, 0, 0, SCORE (0, 0), SCORE (0, 0), SCORE (3, 5), SCORE (5, 10), 0 };
static const uint32 PassedPawnOppClear[8] =
{ 0, 0, 0, SCORE (0, 0), SCORE (5, 10), SCORE (15, 30), SCORE (25, 50) };
static const uint32 PassedPawnCanMove[8] =
{ 0, 0, 0, SCORE (1, 2), SCORE (2, 3), SCORE (3, 5), SCORE (5, 10), 0 };
static const uint32 PassedPawnIsFree[8] =
{ 0, 0, 0, SCORE (0, 0), SCORE (5, 10), SCORE (10, 20), SCORE (20, 40) };

#define QguardK SCORE(5, 2)
#define RguardK SCORE(3, 1)
#define BguardK SCORE(2, 1)
#define NguardK SCORE(4, 2)

#define DoubQueen7th SCORE(10, 15)
#define DoubRook7thKingPawn SCORE(10, 20)
#define MultipleAtt SCORE(15, 25)
#define Queen7th SCORE(5, 25)
#define KingAttUnguardedPawn SCORE(0, 5)

#define PattQ SCORE(8, 12)
#define RattQ SCORE(5, 5)
#define NattRQ SCORE(7, 10)
#define BattRQ SCORE(7, 10)
#define PattR SCORE(7, 10)
#define PattN SCORE(5, 7)
#define PattB SCORE(5, 7)
#define BattN SCORE(5, 5)
#define NattB SCORE(5, 5)
#define Qatt SCORE(4, 4)
#define RattBN SCORE(4, 5)
#define RattP SCORE(2, 3)
#define NattP SCORE(3, 4)
#define BattP SCORE(3, 4)

#define RookHalfOpen SCORE(3, 6)

#define RookOpenFile SCORE(20, 10)
#define RookOpenFixedMinor SCORE(10, 0)
#define RookOpenMinor SCORE(15, 5)

#define RookHalfOpenPawn SCORE(5, 5)
#define RookHalfOpenKing SCORE(15, 0)
#define RookKing8th SCORE(5, 10)
#define Rook7thKingPawn SCORE(10, 30)
#define Rook6thKingPawn SCORE(5, 15)

#define OutputBishop SCORE(1, 2)
#define OutputBishopGuarded SCORE(3, 4)
#define OutpostRook SCORE(1, 2)
#define OutpostRookGuarded SCORE(3, 4)

#define OutpostKnight SCORE(2, 3)
#define OutpostKnightPawn SCORE(2, 3)
#define OutpostKnightGuarded SCORE(5, 5)
#define OutpostKnight5th SCORE(2, 2)
#define OutputKnightONde SCORE(3, 3)

static const uint32 KingSafetyMult[16] =
{ 0, 1, 4, 9, 16, 25, 36, 49, 50, 50, 50, 50, 50, 50, 50, 50 };
#define Hit(x,y) ( (x) << 16) + (y)
#define HitP Hit(1, 0)
#define HitQ Hit(1, 40)
#define HitR Hit(1, 25)
#define HitN Hit(1, 15)
#define HitB Hit(1, 15)
#define HitK Hit(0, 0)
#define KingSafetyDivider 8

static const uint32 RankQueenEnd[8] =
{ 0, 0, 0, SCORE (5, 5), SCORE (10, 10), SCORE (20, 20), SCORE (40, 40), 0 };

#if 0
#define Rook7thEnd SCORE(20, 50)
#define Rook6thEnd SCORE(0, 15)
#define Queen7thEnd SCORE(0, 10)
#else
#define Rook7thEnd SCORE(100, 100)
#define Rook6thEnd SCORE(25, 25)
#define Queen7thEnd SCORE(10, 10)
#endif

static const uint64 CrampFile[8] =
{ FILEb, 0, 0, 0, 0, 0, 0, FILEg };

---

UINT8 left_90[0100] = {
7, 15, 23, 31, 39, 47, 55, 63,
6, 14, 22, 30, 38, 46, 54, 62,
5, 13, 21, 29, 37, 45, 53, 61,
4, 12, 20, 28, 36, 44, 52, 60,
3, 11, 19, 27, 35, 43, 51, 59,
2, 10, 18, 26, 34, 42, 50, 58,
1, 9, 17, 25, 33, 41, 49, 57,
0, 8, 16, 24, 32, 40, 48, 56
};

UINT64 attackeds_knight[0100], attackeds_king[0100],
attackeds_pawn_white[0100], attackeds_pawn_black[0100];
UINT64 bitboard_massive[4][0100][0100];
int bitboard_flicking[4][0100];

UINT8 xray_table[0100];

UINT64 table_horizontals[8] = {
0x00000000000000ff,
0x000000000000ff00,
0x0000000000ff0000,
0x00000000ff000000,
0x000000ff00000000,
0x0000ff0000000000,
0x00ff000000000000,
0xff00000000000000
};

UINT64 table_verticals[8] = {
0x0101010101010101,
0x0202020202020202,
0x0404040404040404,
0x0808080808080808,
0x1010101010101010,
0x2020202020202020,
0x4040404040404040,
0x8080808080808080
};

UINT32 evaluation_material_64bits[16] = {
0, ((0 & 0xff) | (0x1440 << 8)), ((1 & 0xff) | (0x240 << 8)), 0,
((1 & 0xff) | (0x24 << 8)), ((1 & 0xff) | (0x48 << 8)),
((3 & 0xff) | (0x04 << 8)), ((6 & 0xff) | (0x1 << 8)),
0, ((0 & 0xff) | (0xb640 << 8)), ((1 & 0xff) | (0x6c0 << 8)), 0,
((1 & 0xff) | (0x90 << 8)), ((1 & 0xff) | (0x120 << 8)),
((3 & 0xff) | (0xc << 8)), ((6 & 0xff) | (0x2 << 8))
};

static int
openings_king_static (int square)
{
int G[8] = {
4, 1, -2, -5, -10, -15, -25, -35
};
int V[8] = {
40, 45, 15, -5, -5, 15, 45, 40
};
int horizontal = ((square) >> 3), vertical = ((square) & 7);
return G[horizontal] + V[vertical];
}

static int
endings_king_static (int square)
{
int W[8] = {
2, 0, -2, -5, -8, -12, -20, -30
};
int G[8] = {
-30, -5, 0, 5, 10, 5, 0, -10
};
int V[8] = {
-15, 0, 10, 15, 15, 10, 0, -15
};
int horizontal = ((square) >> 3), vertical = ((square) & 7);
int d =
(((vertical - horizontal) >=
0) ? (vertical - horizontal) : -(vertical - horizontal)), e =
(((vertical + horizontal - 7) >=
0) ? (vertical + horizontal - 7) : -(vertical + horizontal - 7));
return W[d] + W[e] + G[horizontal] + V[vertical];
}

static int left_54[0100], right_54[0100], left_09[0100];
static int shifts[0100] = {
1,
2, 2,
4, 4, 4,
7, 7, 7, 7,
11, 11, 11, 11, 11,
16, 16, 16, 16, 16, 16,
22, 22, 22, 22, 22, 22, 22,
29, 29, 29, 29, 29, 29, 29, 29,
37, 37, 37, 37, 37, 37, 37,
44, 44, 44, 44, 44, 44,
50, 50, 50, 50, 50,
55, 55, 55, 55,
59, 59, 59,
62, 62,
64
};

static int breadth[0100], whereat[0100];
static int hoppings[8] = {
6, 10, 15, 17, -6, -10, -15, -17
};

const UINT64 castling_table[0100] = {
Kkf, KFkf, KFkf, KFkf, kf, KFkf, KFkf, Fkf,
KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf,
KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf,
KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf,
KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf,
KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf,
KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf, KFkf,
KFk, KFkf, KFkf, KFkf, KF, KFkf, KFkf, KFf
};

const UINT64 white_en_passant_table[8] = {
(((UINT64) 1) << (B4)) | (((UINT64) 1) << (B4)),
(((UINT64) 1) << (A4)) | (((UINT64) 1) << (C4)),
(((UINT64) 1) << (B4)) | (((UINT64) 1) << (D4)),
(((UINT64) 1) << (C4)) | (((UINT64) 1) << (E4)),
(((UINT64) 1) << (D4)) | (((UINT64) 1) << (F4)),
(((UINT64) 1) << (E4)) | (((UINT64) 1) << (G4)),
(((UINT64) 1) << (F4)) | (((UINT64) 1) << (H4)),
(((UINT64) 1) << (G4)) | (((UINT64) 1) << (G4))
};

const UINT64 black_en_passant_table[8] = {
(((UINT64) 1) << (B5)) | (((UINT64) 1) << (B5)),
(((UINT64) 1) << (A5)) | (((UINT64) 1) << (C5)),
(((UINT64) 1) << (B5)) | (((UINT64) 1) << (D5)),
(((UINT64) 1) << (C5)) | (((UINT64) 1) << (E5)),
(((UINT64) 1) << (D5)) | (((UINT64) 1) << (F5)),
(((UINT64) 1) << (E5)) | (((UINT64) 1) << (G5)),
(((UINT64) 1) << (F5)) | (((UINT64) 1) << (H5)),
(((UINT64) 1) << (G5)) | (((UINT64) 1) << (G5))
};

static const UINT8 pawn_block[0100] = {
0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 2, 2, 2, 2, 1, 1,
1, 2, 3, 3, 3, 3, 2, 1,
1, 2, 3, 5, 5, 3, 2, 1,
1, 2, 3, 5, 5, 3, 2, 1,
1, 2, 3, 3, 3, 3, 2, 1,
1, 1, 2, 2, 2, 2, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0
};

static const SINT32 myself_king_pawn_distancing[8] = {
0, 0, 0, 1, 2, 3, 5, 0
};

static const SINT32 opponent_king_pawn_distancing[8] = {
0, 0, 0, 2, 4, 6, 10, 0
};

static const SINT32 passed_pawn_dry_value[8] = {
(((0) << 16) + (0)), (((0) << 16) + (0)), (((0) << 16) + (0)),
(((10) << 16) + (10)), (((20) << 16) + (25)), (((40) << 16) + (50)),
(((60) << 16) + (75)), (((0) << 16) + (0))
};

static const SINT32 passed_pawn_outside_value[8] = {
(((0) << 16) + (0)), (((0) << 16) + (0)), (((0) << 16) + (0)),
(((0) << 16) + (0)), (((2) << 16) + (5)), (((5) << 16) + (10)),
(((10) << 16) + (20)), (((0) << 16) + (0))
};

´Version Muoltiproceso

Ahora con esta compilación del código fuente de robbolito e Ivanhoe, dos motores de ajedrez, se podría iniciar una nueva mejora cambiando algunos parámetros respecto a las evaluaciones de las distinas piezas. Como software libre que es, linux es libre, pero algunas compilaciones se comercializan, si hay algún programador interesado en realizar una mejora de este código fuente, podré ayudarle con los conocimientos que tengo en ajedrez. Despues de una batería de test el autor de la compilación podría registrar el programa con su nombre siguiendo unos pasos que exige la FIDE y la asociación de programadores de ajedrez. Mi papel sería el de operador del programa, realiza test en los servidores de ajedrez y en las competiciones mueve las piezas en el trablero, cuando se enfrenta a otros motores de ajedrez.

jordi

[jordiqui]

El programa puede ser mejorado o modificado a nivel de compliador. Es una información que se me había olvidado dar.

un saloudo

[Shadowrun]

Jordiqui, ¿¿de verdad que no hay otra forma de jugar al ajedrez online??

[jordiqui]

@Shadowrun:

Jordiqui, ¿¿de verdad que no hay otra forma de jugar al ajedrez online??

Por supuesto, ´tres de los más importantes servidores de ajedrez son Figcs, ICC y playchess. En los tres tienes la posibilidad de jugar a ajedrez clásico, ajedrez avanzado, a la ciega randow fischer, atómico, etc
Pero aquí lo que propongo es mejorar esa compilación y luego pasarla a un motor UCI. Estoy bajándome un compilador de GNU y por otro lado el visual basic C++2008. No obstante podré editarlo, pero no mejorar porque no tengo ni idea de C++. La propuesta puede ser interesante en el sentido de que si el motor funciona estable en multiproceso ( en single ya lo es estable) se podría montar incluso un proyecto desde hardlimit. Si una vez consultada las bases de registro y validado el código fuente, el resto podría ser más que interesante.
Un saludo.

[Shadowrun]

Ok. Pero viendo las respuestas de la gente, pienso que aquí no hay ningún programador.

Si no sabes nada de C++ no hace falta que te bajes ni el VStudio ni ná.

Y las líneas que has puesto, en realidad no es el programa en sí, sino simplemente una introaducción en la que se inicializan las variables que más tarde va a usar el programa en sí.

[jordiqui]

bueno es que el código completo es el que está en ruso, y hay que traducirlo. El que hay en el post, es como bien dices una introducción para el uso en multiprocesador. Cuando tenga el códgo fuente completo lo publico. No obstante, ya le he enviado una copia a un programador que hizo una version de Crafty, y el sabrá como finalizarlo a nivel de compilador.

[jordiqui]

@Shadowrun:

Ok. Pero viendo las respuestas de la gente, pienso que aquí no hay ningún programador.

Si no sabes nada de C++ no hace falta que te bajes ni el VStudio ni ná.

Y las líneas que has puesto, en realidad no es el programa en sí, sino simplemente una introaducción en la que se inicializan las variables que más tarde va a usar el programa en sí.

Bueno entonces algo entiendes de programación, porque en sí eso lo tenía claro desde el principio, porque ahora todos los compiladores están con mucho secretismo. No obstante, tengo un amigo americano que ha hecho varias compilaciones, intentaré tener alguna de ellas para poder publicarlo y a ver si hay alguien interesado en desarrollar el programa desde esas variables. De hecho haré unas cuantas revisiones por los foros para ver varias varaibles más.
Un saludo.

PD: no hay programadores en España? sí que los hay…. venga animaros.