Source Code Ippolit


  • 0

    Hola existe alguien interesado en desarrollar el código fuente de este programa de ajedrez ( totalmente con el código fuente abierto)
    IPPOLIT - Translation (trial)
    Link donde aparece el código fuente. Se han desarrollado versiones para adaptarse a las plataformas multiproceso. C++ es el más utilizado para desarrollar este código fuente.
    En breve publicaré el código fuente de la versión más actual del código fuente de Igorrit. programa de ajedrez sucesor de robbolito y cuya legalidad, así como la de su predecesor no se ha puesto en duda.

    Un saludo



  • 1

    Code

    • корень(ниже,над,глубин)&двигасписок(корень)^история(корень)
      < &распоряжаться |
      < || основа |
      [ [ %% ] + [ глубин > 2 ] ]
      %резать/низкого#(-ниже,глубин-2+&шах)^{ битва + !просто } ^
      %пв(-ниже-1,-ниже,глубин-2+&шах,&шах) ^ %пв(-над,-ниже,глубин-2+&шах,&шах)
      \ %пв(-над,-ниже,глубин-2+&шах,&шах) |
      [ (&) > %% ]# ![ [ %% ] + [ (&) <= ниже ] ] [ обновлять | [ (&) >= предыдущий-25 ] годный \ плохой ] |
      [ (&) > ниже ]# \ [ !счет ] плохой |
      [ (&) >= над ] %%! | счет > |
      распоряжаться |

    Code Eval

    пешка мобильность 3 10
    ферзь мобильность 2 2
    ладья мобильность 2 3 Рентген
    ладья ловушка 50 0 гнить
    слон мобильность 5 5 вперед
    слон цвет 2 1 половина 0 2 после
    слон ловушка 40 40 блюсти удваивать
    конь мобильность 6 8 вперед

    Рентген слон/ладья 3 5
    Рентген ферзь 2 4 пешкадиагональ половина
    связка слабый 2 5
    связка слон/ладья 15 25
    связка ферзь 10 20

    ферзь блюсти 5 2
    ладья блюсти 3 1
    слон блюсти 2 1
    конь блюсти 4 2

    пешка атака ферзь 8 12
    пешка атака ладья 7 10
    пешка атака легкой 5 7
    легкой атака 7 10
    легкой атака легкой 5 5
    легкой атака пешка 3 4
    ладья атака ферзь 5 5
    ладья атака легкой 4 5
    ладья атака пешка 2 3
    ферзь атака 4 4
    король атака пешка 0 5 !блюсти
    многие атака 15 25

    слон/ладья твердый 1 2 отличный 3 4
    конь твердый 2 3 пешка 2 3 отличный 5 5 вперед 2 2 центр 3 3

    ладья открытой 20 10 легкой 15 5 твердый 10 0
    ладья половинаоткрытой 3 6 пешка 5 5 король 15 0
    ладья 8м 5 10 7м 10 30 дуэт 10 20 6м 5 15
    ферзь 7м/8м 5 25 дуэт 10 15

    пешка колоть 1 0
    легкой колоть 1 15
    ладья колоть 1 25
    ферзь колоть 1 40
    король колоть 0 0

    стеснять 0 5 открытой 5 15 проходная 0 1 сдвигать
    проходная мобильный 4м 1 2 5м 2 3 6м 3 5 7м 5 10
    проходная стритсам 6м 3 5 7м 5 10
    проходная стритоппонент 5м 5 10 6м 15 30 7м 25 50
    проходная Ясный 5м 5 10 6м 10 20 7м 20 40
    проходная ферзь 4м 5 5 сдвигать
    проходная ладьязасорять 7м 20 50
    проходная ладьязасорять 6м 0 15
    проходная ферзьзасорять 7м 0 10

    Codde Eval Pawn

    пешка щепка 0 3
    пешка пустой 1 2
    пешка Сдвоенные 2 4 открытой 4 8 Изолированная 2 4 открытой 6 10
    пешка Изолированная 5 8 открытой 15 20
    пешка коротышка 5 5 открытой 10 15
    король атака пешка 0 5
    король рокировка 5 0
    пешка кандидат 4м 5 5 5м 10 12 6м 20 25
    пешка проходная 4м 10 10 5м 20 25 6м 40 50 7м 60 75
    пешка проходная далеко 5м 2 5 6м 5 10 7м 10 20
    пешка проходная охраняемый 5м 5 10 6м 10 15 7м 15 25
    пешка проходная Связанные 5м 5 10 6м 10 15 7м 20 30
    пешка кров край 5 15 20 25 30
    пешка кров между 15 40 50 55 55
    пешка кров центр 10 20 25 30 30
    пешка кров диагональ a 2 4 6 8 10 b 2 4 6 7 8 c 2 3 4 5 6 d 1 2 3 4 4
    пешка молния край 5 15 35
    пешка молния между центр 10 20 50

    Code Search

    PV (пв):

    • пв(ниже,над,глубин,шах)^история#
      < [ глубин <= 1 ] *%пвмолч#шах! | Хэш[пв]_читать&транс&Хэшглубин |
      [ [ !транс ] + [ глубин >= 6] ]
      *%пв глубин >= 10^транс ^
      *%пв(ниже-глубин,над+глубин,глубин-4,шах)^транс
      \ [ [ глубин >= 10 ] + [ глубин >= Хэшглубин + 8] ]
      *%пв(ниже-глубин,над+глубин,глубин-8,шах)^транс ^
      %пв(ниже-глубин,над+глубин,глубин-4,шах)^транс |
      [ шах ] [ @уклонение() | [ #двига# < 2 ] особый
      [ #двига# ] ] |
      [ глубин >= 16 ] + [ ок(транс) ] + [ особый < 2 ]
      [ || основа ! %пв(-над,-ниже,глубин-10,&шах) @!
      *%исключать[шах]#((&)-глубин/2,глубин-мин(12,глубин/2),транс)^особый ^
      *%исключать[шах]#((&)-глубин,глубин-мин(12,глубин/2),транс)^особый ] |
      << [ повторение# ] %макс(%%,0)% + счет! || основа !
      [проходная(6м)] вытягивание + вытягивание
      \ [ !взять ] вытягивание \ [ & шах ] вытягивание \ [ шах ] + [ рано ] вытягивание
      \ [ проходная(4м) ] вытягивание |
      [ транс ] + [ глубин-2+макс(вытягивание,особый) > 1 ]
      %резать/низкого#(-ниже,&левый)^%пв(-над,-ниже,&левый,&шах)
      \ %пв(-над,-ниже,глубин-2+макс(вытягивание,особый),&шах) >>
      [ !%% ] [ [ шах ] (0)! \ ступень! ]

    More search functions

    • молч(зарубка,глубин)
      < | Хэш_читать&транс | %оценить+5% |
      [ %% >= зарубка ] (&левый)! |
      #цель + разница[ пешка:#160* | минор:500 | ладья:800 ] |
      @сила(цель)^транс |
      сорт< [ !торговать ] + [ !транс ] + [ !рентген ] ! ||
      основа(150) ! %молч#(1-зарубка,глубин-1) > |
      [ глубин >= -1 ] + [ ниже <= (100+12_{глубин+4}) ]
      @шах(цель) + < || основа(150) ! %%молч(1-зарубка,глубин-1) >
    • молч+(зарубка,глубин)
      < | Хэш_читать&транс | %ступень% | ##цель |
      [ ниже < 10 ] %(оценить+10)% + #цель + разница[ пешка:200* | минор:500 ] |
      @уклонение(цель)^транс |
      сорт< [ вмешиваться ] + [ !взятьпревращение ] + [ !транс ] + [ нуль ] + [ !мат ]
    • [ возможный + вперед < 25 ] счет! ||
      основа(150) ! %молч#(1-зарубка,глубин) > |
      [ счет ] + [ %% < -мат ] %зарубка-1%
    • низкого(зарубка,глубин)^история
      < [ ниже > 1125 ] (зарубка-1)! | Хэш_читать&транс |
      [ вперед >= 70+10глубин ] (&основа)! | %мин(оценить,зарубка-1)% |
      [ вперед ] + [ нуль ] |! %молч(1-зарубка,0) |
      #цель + разница[ транс2^(50+8
      глубин) | пешка^(75+32глубин):#125 |
      минор^(400+32глубин)+[глубин<=3]:+300 | ладья^(600+32глубин):+200 ]
      \ [ глубин<=3 ] + [ ниже > 4глубин ] транс3 + маржа[ниже+4*глубин+5]
      << [ повторение ] %макс(%%,0)% + счет! |
      [ счет >= глубин ] + [ $знак$ ] + [ !взятьшах ] + [ !рентген ] + [ фигура ]
    • [ 2глубин + возможный + вперед < 40 + 2счет ] счет! |
      [ взять += [ [ глубин <= 5 ] + [ !торговать# ] ] ]
    • [ !рентген ] + [ !корольход ] + [ !транс ] + [ !торговать ] счет! ||
      основа(150) !! %%низкого(1-зарубка,глубин-1) %+
      [ [ счет >= глубин ] + [ 2*глубин + вперед# < счет ] ] !счет!
      \ %низкого/молч(1-зарубка,глубин-2) | счет >> |
      [ !счет ] + [ $транс2$>= ] (0)!
    • низкого+(зарубка,глубин)
      < | Хэш_читать&транс# | %ступень% | ##цель |
      @транс@уклонение(цель) |
      @сорт< [ повторение ] %макс(%%,0)% + ! |
      [ вмешиваться ] + [ !мат ] + [ !транс ] + [ !торговать ] счет! ||
      основа(150) ! %резать/низкого/молч#(1-зарубка,глубин-2+рано+&шах) > |
      [ счет ] + [ %% < -мат ] %зарубка-1%
    • исключать(зарубка,глубин,двига)^история
      < | Хэш#_читать(нуль,прош!)&транс | #цель |
      [ вперед ] + [ нуль ] [ |! %резать/низкого/молч(1-зарубка,глубин-8-макс(вперед/32,3)) ] |
      [ глубин < 20 ] + [ ниже >= 48*(глубин-4) ]
      транс2 + счет + разница[ пешка:48*(глубин-2) ] |
      << (двига) ! | [ повторение ] %макс(%%,0)% + счет! |
      [ счет > 5 ] + [ $знак$ ] + [ !взятьшах ] + [ !рентген ]
    • [ 6_{глубин-6}{20} + возможный + вперед < 30 + 2*счет ] счет! |
      [ глубин < 20 ] + [ 2_{глубин-6} + вперед < 125 ] + [ $знак$ ] + [ !корольход ]
    • [ !рентген ] + [ !шах ] + [ !торговать ] счет! ||
      основа(300) ! %%резать(1-зарубка,глубин-1) %+
      [ счет > 5 ] + [ !взять ] + [ 2_{глубин-6}{20}+вперед# < счет - 15 ] !счет! |
      %$ [ $знак$ ] + [ счет >= 3 ] $BSR(1+счет)$
      %резать/низкого/молч(1-зарубка,глубин-2+проходная(6м)) $% | счет >> |
      %зарубка-1%
    • исключать+(зарубка,глубин,двига)
      < | Хэш#_читать(прош)&транс | %ступень% |
      @транс@уклонение(цель) |
      @сорт < (двига) ! | [ повторение ] %макс(%%,0)% + счет! ||
      основа(300) ! %%резать/низкого(1-зарубка,глубин-1) %+
      %$ [ счет >= 1 ] $мин(2,счет)$ %резать/низкого(1-зарубка,глубин-2+рано) $% | счет >
    • все(зарубка,глубин)^история
      < | Хэш[все]_читать(нуль,прош)&транс | #цель |
      [ вперед ] + [ нуль ] [ |! %резать/низкого/молч(1-зарубка,глубин-8-макс(вперед/32,3)) ] |
      [ глубин < 20 ] + [ ниже >= 48*(глубин-4) ]
      транс2 + счет + разница[ пешка:48*(глубин-2) ] |
      << [ повторение ] %макс(%%,0)% + счет! |
      [ счет > 5 ] + [ $знак$ ] + [ !взятьшах ] + [ !рентген ]
    • [ 5_{глубин-6}{20} + возможный + вперед < 35 + 2*счет ] счет! |
      [ глубин < 20 ] + [ 2_{глубин-6} + вперед < 125 ] + [ $знак$ ] + [ !корольход ]
    • [ !рентген ] + [ !шах ] + [ !торговать ] счет! ||
      основа(300) ! %%резать(глубин-1) %+
      [ счет > 5 ] + [ !взять ] + [ 2_{глубин-6}{20} + вперед# < счет - 15 ] !счет! %+
      %$ [ $знак$ ] + [ счет >= 3 ] $BSR(1+счет)$
      %резать/низкого/молч(1-зарубка,глубин-2+проходная(6м)) $% | счет >> |
      [ !счет ] + [ $транс2$>= ] (0)! | %зарубка-1%
    • все+(зарубка,глубин)
      < | Хэш[все]_читать(прош)&транс# | %ступень%
      @транс@уклонение(цель) |
      @сорт< [ повторение ] %макс(%%,0)% + счет! ||
      основа(300) ! %%резать/низкого(1-зарубка,глубин-1) %+
      %$ [ счет >= 1 ] $мин(2,счет)$
      %резать/низкого(1-зарубка,глубин-2+рано) $% | счет >


  • 2

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

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



  • 3

    @Shadowrun:

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

    Es que estos rusos son muy suyos …



  • 4

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



  • 5

    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, 8) * 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) >=

    1. ? (vertical - horizontal) : -(vertical - horizontal)), e =
      (((vertical + horizontal - 7) >=
    2. ? (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



  • 6

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

    un saloudo



  • 7

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



  • 8

    @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.



  • 9

    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í. ;)



  • 10

    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.



  • 11

    @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.





Has perdido la conexión. Reconectando a Hardlimit.